Remove circular dependency between rules and atrules parsers

Author: elchininet

src/@types/index.ts

@@ -1,4 +1,6 @@
 import {
+    Container,
+    Root,
     Rule,
     AtRule,
     Declaration
@@ -144,4 +146,37 @@ export type DeclarationHashMapProp = {
 export type DeclarationHashMap = Record<
     string,
     DeclarationHashMapProp
->;
+>;
+
+export type RuleParser = (
+    parsers: Parsers,
+    container: Container,
+    parentSourceDirective?: string,
+    hasParentRule?: boolean
+) => void;
+
+export type AtRuleParser = (
+    parsers: Parsers,
+    container: Container,
+    parentSourceDirective?: string,
+    hasParentRule?: boolean
+) => void;
+
+export type KeyframeParser = (
+    css: Root
+) => void;
+
+export type DeclarationParser = (
+    container: DeclarationContainer,
+    hasParentRule: boolean,
+    ruleSourceDirectiveValue: string,
+    processRule: boolean,
+    rename: boolean
+) => void;
+
+export type Parsers = {
+    parseRules: RuleParser;
+    parseAtRules: AtRuleParser;
+    parseKeyFrames: KeyframeParser;
+    parseDeclarations: DeclarationParser;
+};

src/data/store.ts

@@ -233,7 +233,11 @@ const normalizeOptions = (options: PluginOptions): PluginOptionsNormalized => {
     }
     if (isAcceptedProcessDeclarationPlugins(options.processDeclarationPlugins)) {
         returnOptions.plugins = options.processDeclarationPlugins.map(plugin => ({
-            ...plugin, directives: {control: {}, value: []},
+            ...plugin,
+            directives: {
+                control: {},
+                value: [] as object[]
+            },
         }));
     }
     if (options.aliases && isObjectWithStringKeys(options.aliases)) {

src/index.ts

@@ -1,23 +1,32 @@
 import { Root, Plugin } from 'postcss';
-import { PluginOptions } from '@types';
+import { PluginOptions, Parsers } from '@types';
 import { initStore } from '@data/store';
-import { parseKeyFrames, parseAtRules } from '@parsers/atrules';
+import { parseAtRules } from '@parsers/atrules';
 import { parseRules } from '@parsers/rules';
+import { parseKeyFrames } from '@parsers/keyframes';
+import { parseDeclarations } from '@parsers/declarations';
 import {
     appendRules,
     appendKeyFrames,
     parseRuleNames
 } from '@utilities/rules';
 import { clean } from '@utilities/clean';
 
+const parsers: Parsers = {
+    parseRules,
+    parseAtRules,
+    parseKeyFrames,
+    parseDeclarations
+};
+
 function postcssRTLCSS (options: PluginOptions = {}): Plugin {
     return ({
         postcssPlugin: 'postcss-rtlcss',
         Once(css: Root): void {
             initStore(options);
             parseKeyFrames(css);
-            parseAtRules(css);
-            parseRules(css);
+            parseAtRules(parsers, css);
+            parseRules(parsers, css);
             parseRuleNames();
             appendRules();
             appendKeyFrames();

src/parsers/atrules.ts

@@ -1,25 +1,14 @@
-import postcss, {
-    Root,
+import{
     Container,
     Node,
-    AtRule,
     Comment
 } from 'postcss';
-import rtlcss from 'rtlcss';
-import {
-    Source,
-    ControlDirective,
-    Mode
-} from '@types';
+import { ControlDirective, Parsers } from '@types';
 import {
     TYPE,
     KEYFRAMES_NAME,
     CONTROL_DIRECTIVE
 } from '@constants';
-import {
-    store,
-    initKeyframesData
-} from '@data/store';
 import { walkContainer } from '@utilities/containers';
 import {
     isIgnoreDirectiveInsideAnIgnoreBlock,
@@ -28,10 +17,9 @@ import {
 } from '@utilities/directives';
 import { isAtRule } from '@utilities/predicates';
 import { vendor } from '@utilities/vendor';
-import { parseRules } from '@parsers/rules';
-import { parseDeclarations } from './declarations';
 
 export const parseAtRules = (
+    parsers: Parsers,
     container: Container,
     parentSourceDirective: string = undefined,
     hasParentRule = false
@@ -70,7 +58,7 @@ export const parseAtRules = (
                 hasParentRule &&
                 node.nodes
             ) {
-                parseDeclarations(
+                parsers.parseDeclarations(
                     node,
                     hasParentRule,
                     sourceDirectiveValue,
@@ -79,13 +67,15 @@ export const parseAtRules = (
                 );
             }
 
-            parseAtRules(
+            parsers.parseAtRules(
+                parsers,
                 node,
                 parentSourceDirective,
                 hasParentRule
             );
 
-            parseRules(
+            parsers.parseRules(
+                parsers,
                 node,
                 sourceDirectiveValue,
                 hasParentRule
@@ -95,108 +85,3 @@ export const parseAtRules = (
     );
 
 };
-
-const addToIgnoreKeyframesInDiffMode = (node: AtRule): void => {
-    if (store.options.mode === Mode.diff) {
-        store.keyframesToRemove.push(node);
-    }
-};
-
-export const parseKeyFrames = (css: Root): void => {
-
-    const { source, processUrls, useCalc, stringMap, processKeyFrames } = store.options;
-
-    if (!processKeyFrames) {
-        return;
-    }
-
-    const controlDirectives: Record<string, ControlDirective> = {};
-
-    walkContainer(
-        css,
-        [ TYPE.AT_RULE, TYPE.RULE ],
-        (_comment: Comment, controlDirective: ControlDirective): void => {
-
-            if (isIgnoreDirectiveInsideAnIgnoreBlock(controlDirective, controlDirectives)) {
-                return;
-            }
-
-            controlDirectives[controlDirective.directive] = controlDirective;
-
-        },
-        (node: Node): void => {
-
-            if ( checkDirective(controlDirectives, CONTROL_DIRECTIVE.IGNORE) ) {
-                addToIgnoreKeyframesInDiffMode(node as AtRule);
-                return;
-            }
-
-            if (!isAtRule(node)) {
-                return;
-            }
-            
-            if (vendor.unprefixed(node.name) !== KEYFRAMES_NAME) {
-                return;
-            }
-            
-            const atRuleString = node.toString();
-            const atRuleFlippedString = rtlcss.process(atRuleString, { processUrls, useCalc, stringMap });
-            
-            if (atRuleString === atRuleFlippedString) {
-                addToIgnoreKeyframesInDiffMode(node);
-                return;
-            }
-
-            /* the source could be undefined in certain cases but not during the tests */
-            /* istanbul ignore next */
-            const rootFlipped = postcss.parse(
-                atRuleFlippedString,
-                {
-                    from: node.source?.input?.from
-                }
-            );
-            const atRuleFlipped = rootFlipped.first as AtRule;
-
-            const atRuleParams = node.params;
-            const ltr = `${atRuleParams}-${Source.ltr}`;
-            const rtl = `${atRuleParams}-${Source.rtl}`;
-            const sourceDirectiveValue = getSourceDirectiveValue(controlDirectives);
-            
-            node.params = (
-                (
-                    !sourceDirectiveValue &&
-                    source === Source.ltr
-                ) ||
-                (
-                    sourceDirectiveValue &&
-                    sourceDirectiveValue === Source.ltr
-                )
-            )
-                ? ltr
-                : rtl;
-            
-            atRuleFlipped.params = (
-                (
-                    !sourceDirectiveValue &&
-                    source === Source.ltr
-                ) ||
-                (
-                    sourceDirectiveValue &&
-                    sourceDirectiveValue === Source.ltr
-                )
-            )
-                ? rtl
-                : ltr;
-
-            store.keyframes.push({
-                atRuleParams,
-                atRule: node,
-                atRuleFlipped
-            });
-        
-        }
-    );
-
-    initKeyframesData();
-
-};