rollup-plugin-react-scoped-css 0.4.1 → 0.6.0

package/src/parsers/new-parser.ts

@@ -0,0 +1,74 @@
+import { JsxParser } from "./jsx-parser.model";
+
+export class NewJsxParser implements JsxParser {
+  isNodeReactFragment(node: any) {
+    return (
+      node.arguments?.[0]?.type === "Identifier" &&
+      ["_Fragment", "Fragment"].includes(node.arguments?.[0]?.name)
+    );
+  }
+
+  isNodeReactElement(node: any) {
+    return (
+      node?.type === "CallExpression" &&
+      ["_jsxDEV", "_jsx", "_jsxs", "jsxDev", "jsx", "jsxs"].includes(
+        node?.callee?.name
+      )
+    );
+  }
+
+  public extendNodeWithAttributes(node: any, attr: string) {
+    const arg = node?.arguments?.[1];
+    return {
+      ...node,
+      arguments: node?.arguments.map((v: any, i: number) => {
+        if (i === 1) {
+          if (v.type === "ObjectExpression") {
+            return {
+              ...v,
+              properties: [...arg.properties, this.createAttributeNode(attr)],
+            };
+          } else if (
+            v.type === "CallExpression" &&
+            v.callee.name === "_objectSpread"
+          ) {
+            const args = [...v.arguments];
+            args[0].properties = [
+              ...args[0].properties,
+              this.createAttributeNode(attr),
+            ];
+            return {
+              ...v,
+              arguments: args,
+            };
+          } else {
+            return {
+              type: "ObjectExpression",
+              properties: [this.createAttributeNode(attr)],
+            };
+          }
+        }
+        return v;
+      }),
+    };
+  }
+
+  private createAttributeNode(attr: string) {
+    return {
+      type: "Property",
+      method: false,
+      shorthand: false,
+      computed: false,
+      key: {
+        type: "Identifier",
+        name: `"${attr}"`,
+      },
+      value: {
+        type: "Literal",
+        value: true,
+        raw: "true",
+      },
+      kind: "init",
+    };
+  }
+}

package/tsconfig.json

@@ -6,7 +6,8 @@
     "declaration": true,
     "outDir": "dist",
     "strict": true,
-    "esModuleInterop": true
+    "esModuleInterop": true,
+    "downlevelIteration": true
   },
   "exclude": [
     "node_modules",

package/dist/parsers/base-parser.d.ts

@@ -1,15 +0,0 @@
-import { JsxParser, ParserImplementations } from "./jsx-parser.model";
-export declare class BaseParser implements Pick<JsxParser, 'isNode' & 'traverse'> {
-    isNode(obj: any): boolean;
-    /**
-     * Traverses the AST tree and calls callback for each node.
-     * -
-     * @param ast The ast tree
-     * @param callback Callback function to be called for each node
-     * @returns
-     */
-    traverse(ast: any, callback: Function): any;
-    findImplementation(ast: any): ParserImplementations.classic;
-    extendNodeWithAttributes(node: any, attr: string): any;
-    private createAttributeNode;
-}

package/dist/parsers/base-parser.js

@@ -1,109 +0,0 @@
-"use strict";
-var __assign = (this && this.__assign) || function () {
-    __assign = Object.assign || function(t) {
-        for (var s, i = 1, n = arguments.length; i < n; i++) {
-            s = arguments[i];
-            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
-                t[p] = s[p];
-        }
-        return t;
-    };
-    return __assign.apply(this, arguments);
-};
-var __spreadArray = (this && this.__spreadArray) || function (to, from) {
-    for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-        to[j] = from[i];
-    return to;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseParser = void 0;
-var jsx_parser_model_1 = require("./jsx-parser.model");
-var BaseParser = /** @class */ (function () {
-    function BaseParser() {
-    }
-    BaseParser.prototype.isNode = function (obj) {
-        var _a, _b, _c;
-        return typeof obj === 'object' &&
-            typeof ((_a = obj) === null || _a === void 0 ? void 0 : _a.end) === 'number' &&
-            typeof ((_b = obj) === null || _b === void 0 ? void 0 : _b.start) === 'number' &&
-            typeof ((_c = obj) === null || _c === void 0 ? void 0 : _c.type) === 'string';
-    };
-    /**
-     * Traverses the AST tree and calls callback for each node.
-     * -
-     * @param ast The ast tree
-     * @param callback Callback function to be called for each node
-     * @returns
-     */
-    BaseParser.prototype.traverse = function (ast, callback) {
-        for (var _i = 0, _a = Object.keys(ast); _i < _a.length; _i++) {
-            var key = _a[_i];
-            if (['end', 'start', 'type'].includes(key)) {
-                continue;
-            }
-            if (Array.isArray(ast[key])) {
-                for (var nodeIndex in ast[key]) {
-                    ast[key][nodeIndex] = this.traverse(ast[key][nodeIndex], callback);
-                }
-            }
-            else if (this.isNode(ast[key])) {
-                ast[key] = this.traverse(ast[key], callback);
-            }
-        }
-        var result = callback(ast);
-        return typeof result !== 'undefined' ? result : ast;
-    };
-    BaseParser.prototype.findImplementation = function (ast) {
-        var implementation = jsx_parser_model_1.ParserImplementations.classic;
-        this.traverse(ast, function (node) {
-            if (node.type !== 'ImportDeclaration') {
-                return;
-            }
-            if (node.source.value === 'react/jsx-runtime') {
-                implementation = jsx_parser_model_1.ParserImplementations.new;
-            }
-        });
-        return implementation;
-    };
-    BaseParser.prototype.extendNodeWithAttributes = function (node, attr) {
-        var _this = this;
-        var _a;
-        var arg = (_a = node === null || node === void 0 ? void 0 : node.arguments) === null || _a === void 0 ? void 0 : _a[1];
-        return __assign(__assign({}, node), { arguments: node === null || node === void 0 ? void 0 : node.arguments.map(function (v, i) {
-                if (i === 1) {
-                    if (v.type === 'ObjectExpression') {
-                        return __assign(__assign({}, v), { properties: __spreadArray(__spreadArray([], arg.properties), [
-                                _this.createAttributeNode(attr)
-                            ]) });
-                    }
-                    else {
-                        return {
-                            type: 'ObjectExpression',
-                            properties: [_this.createAttributeNode(attr)]
-                        };
-                    }
-                }
-                return v;
-            }) });
-    };
-    BaseParser.prototype.createAttributeNode = function (attr) {
-        return {
-            type: 'Property',
-            method: false,
-            shorthand: false,
-            computed: false,
-            key: {
-                type: 'Identifier',
-                name: "\"" + attr + "\""
-            },
-            value: {
-                type: 'Literal',
-                value: true,
-                raw: "true"
-            },
-            kind: 'init'
-        };
-    };
-    return BaseParser;
-}());
-exports.BaseParser = BaseParser;

package/dist/parsers/jsx-parser.interface.d.ts

@@ -1,6 +0,0 @@
-export interface JsxParser {
-    isNode: (node: any) => boolean;
-    isNodeReactElement: (node: any) => boolean;
-    isNodeReactFragment: (node: any) => boolean;
-    traverse: (ast: any, callback: (ast: any) => void) => void;
-}

package/dist/parsers/jsx-parser.interface.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });