rollup-plugin-react-scoped-css 0.8.0 → 0.8.1

package/dist/ast-iterator.js

@@ -1,3 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astIterator = void 0;
 const isNode = (key, value) => {
     if (key === "loc")
         return false;
@@ -6,7 +9,7 @@ const isNode = (key, value) => {
         typeof value?.start === "number" &&
         typeof value?.type === "string");
 };
-export const astIterator = function* (ast) {
+const astIterator = function* (ast) {
     if (!ast) {
         return;
     }
@@ -18,12 +21,13 @@ export const astIterator = function* (ast) {
         // If key value is an array, iterate over it
         if (Array.isArray(ast[key])) {
             for (const nodeIndex in ast[key]) {
-                yield* astIterator(ast[key][nodeIndex]);
+                yield* (0, exports.astIterator)(ast[key][nodeIndex]);
             }
         }
         else if (isNode(key, ast[key])) {
-            yield* astIterator(ast[key]);
+            yield* (0, exports.astIterator)(ast[key]);
         }
     }
     yield ast;
 };
+exports.astIterator = astIterator;

package/dist/ast-program.js

@@ -1,37 +1,41 @@
-import { astIterator } from "./ast-iterator";
-import { astTransformer } from "./ast-transformer";
-import { getSrcFromImportOrRequire, isNodeImportOrRequire } from "./ast.utils";
-import { LegacyJsxParser } from "./parsers/legacy-jsx-parser";
-import { ModernJsxParser } from "./parsers/modern-jsx-parser";
-import { ParserImplementations } from "./parsers/jsx-parser.model";
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addHashAttributesToJsxTagsAst = void 0;
+const ast_iterator_1 = require("./ast-iterator");
+const ast_transformer_1 = require("./ast-transformer");
+const ast_utils_1 = require("./ast.utils");
+const legacy_jsx_parser_1 = require("./parsers/legacy-jsx-parser");
+const modern_jsx_parser_1 = require("./parsers/modern-jsx-parser");
+const jsx_parser_model_1 = require("./parsers/jsx-parser.model");
 global.implementation = null;
-const legacyJsxParser = new LegacyJsxParser();
-const modernJsxParser = new ModernJsxParser();
+const legacyJsxParser = new legacy_jsx_parser_1.LegacyJsxParser();
+const modernJsxParser = new modern_jsx_parser_1.ModernJsxParser();
 let parser = legacyJsxParser;
 const findImplementation = (program) => {
-    const implementation = ParserImplementations.legacy;
-    for (const node of astIterator(program)) {
-        if (!isNodeImportOrRequire(node)) {
+    const implementation = jsx_parser_model_1.ParserImplementations.legacy;
+    for (const node of (0, ast_iterator_1.astIterator)(program)) {
+        if (!(0, ast_utils_1.isNodeImportOrRequire)(node)) {
             continue;
         }
-        const src = getSrcFromImportOrRequire(node);
+        const src = (0, ast_utils_1.getSrcFromImportOrRequire)(node);
         if (["react/jsx-dev-runtime", "react/jsx-runtime"].includes(src)) {
-            return ParserImplementations.modern;
+            return jsx_parser_model_1.ParserImplementations.modern;
         }
     }
     return implementation;
 };
-export function addHashAttributesToJsxTagsAst(program, attr) {
+function addHashAttributesToJsxTagsAst(program, attr) {
     // Once in the program, we can determine which parser to use
     if (global.implementation === null) {
         global.implementation = findImplementation(program);
-        if (global.implementation === ParserImplementations.modern) {
+        if (global.implementation === jsx_parser_model_1.ParserImplementations.modern) {
             parser = modernJsxParser;
         }
     }
-    return astTransformer(program, (node) => {
+    return (0, ast_transformer_1.astTransformer)(program, (node) => {
         if (parser.isNodeReactElement(node) && !parser.isNodeReactFragment(node)) {
             return parser.extendNodeWithAttributes(node, attr);
         }
     });
 }
+exports.addHashAttributesToJsxTagsAst = addHashAttributesToJsxTagsAst;

package/dist/ast-transformer.js

@@ -1,23 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.astTransformer = void 0;
 const isNode = (obj) => {
     return (typeof obj === "object" &&
         typeof obj?.end === "number" &&
         typeof obj?.start === "number" &&
         typeof obj?.type === "string");
 };
-export const astTransformer = (ast, callback) => {
+const astTransformer = (ast, callback) => {
     for (const key of Object.keys(ast)) {
         if (["end", "start", "type"].includes(key)) {
             continue;
         }
         if (Array.isArray(ast[key])) {
             for (const nodeIndex in ast[key]) {
-                ast[key][nodeIndex] = astTransformer(ast[key][nodeIndex], callback);
+                ast[key][nodeIndex] = (0, exports.astTransformer)(ast[key][nodeIndex], callback);
             }
         }
         else if (isNode(ast[key])) {
-            ast[key] = astTransformer(ast[key], callback);
+            ast[key] = (0, exports.astTransformer)(ast[key], callback);
         }
     }
     const result = callback(ast);
     return typeof result !== "undefined" ? result : ast;
 };
+exports.astTransformer = astTransformer;

package/dist/ast.utils.js

@@ -1,4 +1,7 @@
-export const createObjectAssignCallExpressionWithIdentifier = (identifier, objectExpression) => {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSrcFromImportOrRequire = exports.isNodeImportOrRequire = exports.isNodeRequireCallExpression = exports.isNodeImportDeclaration = exports.isNodeIdentifier = exports.isNodeExtender = exports.isNodeObjectExpression = exports.isNodeCallExpression = exports.hackIntoExtenderCallExpression = exports.extendObjectExpression = exports.createObjectExpressionWithAttr = exports.createObjectAssignCallExpressionWithIdentifier = void 0;
+const createObjectAssignCallExpressionWithIdentifier = (identifier, objectExpression) => {
     return {
         type: "CallExpression",
         callee: {
@@ -27,57 +30,69 @@ export const createObjectAssignCallExpressionWithIdentifier = (identifier, objec
         optional: false,
     };
 };
-export const createObjectExpressionWithAttr = (attrNode) => {
+exports.createObjectAssignCallExpressionWithIdentifier = createObjectAssignCallExpressionWithIdentifier;
+const createObjectExpressionWithAttr = (attrNode) => {
     return {
         type: "ObjectExpression",
         properties: [attrNode],
     };
 };
-export const extendObjectExpression = (objectExpression, prop) => {
+exports.createObjectExpressionWithAttr = createObjectExpressionWithAttr;
+const extendObjectExpression = (objectExpression, prop) => {
     return {
         ...objectExpression,
         properties: [...objectExpression.properties, prop],
     };
 };
-export const hackIntoExtenderCallExpression = (callExpression, prop) => {
+exports.extendObjectExpression = extendObjectExpression;
+const hackIntoExtenderCallExpression = (callExpression, prop) => {
     return {
         ...callExpression,
         arguments: [
             ...callExpression.arguments,
-            createObjectExpressionWithAttr(prop),
+            (0, exports.createObjectExpressionWithAttr)(prop),
         ],
     };
 };
-export const isNodeCallExpression = (node) => {
+exports.hackIntoExtenderCallExpression = hackIntoExtenderCallExpression;
+const isNodeCallExpression = (node) => {
     return node.type === "CallExpression";
 };
-export const isNodeObjectExpression = (node) => {
+exports.isNodeCallExpression = isNodeCallExpression;
+const isNodeObjectExpression = (node) => {
     return node.type === "ObjectExpression";
 };
-export const isNodeExtender = (node) => {
-    return (isNodeCallExpression(node) &&
+exports.isNodeObjectExpression = isNodeObjectExpression;
+const isNodeExtender = (node) => {
+    return ((0, exports.isNodeCallExpression)(node) &&
         (node.callee.name === "_objectSpread" || node.callee.name === "_extends"));
 };
-export const isNodeIdentifier = (node) => {
+exports.isNodeExtender = isNodeExtender;
+const isNodeIdentifier = (node) => {
     return node.type === "Identifier";
 };
-export const isNodeImportDeclaration = (node) => {
+exports.isNodeIdentifier = isNodeIdentifier;
+const isNodeImportDeclaration = (node) => {
     return node.type === "ImportDeclaration";
 };
-export const isNodeRequireCallExpression = (node) => {
-    return (isNodeCallExpression(node) &&
+exports.isNodeImportDeclaration = isNodeImportDeclaration;
+const isNodeRequireCallExpression = (node) => {
+    return ((0, exports.isNodeCallExpression)(node) &&
         node.callee.name === "require" &&
         node.arguments.length === 1);
 };
-export const isNodeImportOrRequire = (node) => {
-    return isNodeImportDeclaration(node) || isNodeRequireCallExpression(node);
+exports.isNodeRequireCallExpression = isNodeRequireCallExpression;
+const isNodeImportOrRequire = (node) => {
+    return (0, exports.isNodeImportDeclaration)(node) || (0, exports.isNodeRequireCallExpression)(node);
 };
-export const getSrcFromImportOrRequire = (node) => {
-    if (isNodeImportDeclaration(node)) {
+exports.isNodeImportOrRequire = isNodeImportOrRequire;
+const getSrcFromImportOrRequire = (node) => {
+    if ((0, exports.isNodeImportDeclaration)(node)) {
         return node.source.value;
     }
-    if (isNodeRequireCallExpression(node)) {
+    if ((0, exports.isNodeRequireCallExpression)(node)) {
         return node.arguments[0].value;
     }
     return null;
 };
+exports.getSrcFromImportOrRequire = getSrcFromImportOrRequire;

package/dist/index.js

@@ -1,10 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reactScopedCssPlugin = void 0;
 /* eslint-disable no-useless-escape */
-import { resolve, dirname } from "path";
-import { xxHash32 } from "js-xxhash";
-import { createFilter } from "@rollup/pluginutils";
-import { compileStyle } from "@vue/component-compiler-utils";
-import { generate } from "escodegen";
-import { addHashAttributesToJsxTagsAst } from "./ast-program";
+const path_1 = require("path");
+const js_xxhash_1 = require("js-xxhash");
+const pluginutils_1 = require("@rollup/pluginutils");
+const component_compiler_utils_1 = require("@vue/component-compiler-utils");
+const escodegen_1 = require("escodegen");
+const ast_program_1 = require("./ast-program");
 const getFilenameFromPath = (filePath) => {
     const parts = filePath.split("/");
     return parts[parts.length - 1].split("?")[0];
@@ -15,11 +18,11 @@ const getHashFromPath = (filePath) => {
     return hash;
 };
 const generateHash = (input, seed = 0) => {
-    const hashNum = xxHash32(Buffer.from(input, "utf8"), seed);
+    const hashNum = (0, js_xxhash_1.xxHash32)(Buffer.from(input, "utf8"), seed);
     return hashNum.toString(16);
 };
 const addAttributesToCss = (src, fileName, hash) => {
-    const { code } = compileStyle({
+    const { code } = (0, component_compiler_utils_1.compileStyle)({
         source: src,
         filename: fileName,
         id: hash,
@@ -28,7 +31,7 @@ const addAttributesToCss = (src, fileName, hash) => {
     });
     return code;
 };
-export function reactScopedCssPlugin(optionsIn = {}) {
+function reactScopedCssPlugin(optionsIn = {}) {
     const options = {
         hashPrefix: "v",
         styleFileSuffix: "scoped",
@@ -42,7 +45,7 @@ export function reactScopedCssPlugin(optionsIn = {}) {
     if (!options.jsxFileExtensions || !options.jsxFileExtensions.length) {
         throw new Error("You need to provide at least one jsx file extension");
     }
-    const filter = createFilter(options.include, options.exclude);
+    const filter = (0, pluginutils_1.createFilter)(options.include, options.exclude);
     const scopedCssRegex = options.styleFileSuffix
         ? new RegExp(`\.${options.styleFileSuffix}\.(${options.styleFileExtensions.join("|")})$`)
         : new RegExp(`\.(${options.styleFileExtensions.join("|")})$`);
@@ -59,7 +62,7 @@ export function reactScopedCssPlugin(optionsIn = {}) {
                 }
                 if (scopedCssRegex.test(source) && jsxRegex.test(importer)) {
                     const importerHash = generateHash(importer);
-                    const url = resolve(dirname(importer), `${source}?scope=${importerHash}`);
+                    const url = (0, path_1.resolve)((0, path_1.dirname)(importer), `${source}?scope=${importerHash}`);
                     return url;
                 }
             },
@@ -74,8 +77,8 @@ export function reactScopedCssPlugin(optionsIn = {}) {
                 if (scopedCssInFileRegex.test(code)) {
                     const importerHash = generateHash(id);
                     const program = this.parse(code);
-                    const newAst = addHashAttributesToJsxTagsAst(program, `data-${options.hashPrefix}-${importerHash}`);
-                    return generate(newAst);
+                    const newAst = (0, ast_program_1.addHashAttributesToJsxTagsAst)(program, `data-${options.hashPrefix}-${importerHash}`);
+                    return (0, escodegen_1.generate)(newAst);
                 }
                 if (scopedCssRegex.test(getFilenameFromPath(id))) {
                     const importerHash = getHashFromPath(id);
@@ -85,3 +88,4 @@ export function reactScopedCssPlugin(optionsIn = {}) {
         },
     ];
 }
+exports.reactScopedCssPlugin = reactScopedCssPlugin;

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

@@ -1,5 +1,8 @@
-export var ParserImplementations;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ParserImplementations = void 0;
+var ParserImplementations;
 (function (ParserImplementations) {
     ParserImplementations["modern"] = "modern";
     ParserImplementations["legacy"] = "legacy";
-})(ParserImplementations || (ParserImplementations = {}));
+})(ParserImplementations = exports.ParserImplementations || (exports.ParserImplementations = {}));

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

@@ -1,5 +1,8 @@
-import { createObjectAssignCallExpressionWithIdentifier, createObjectExpressionWithAttr, extendObjectExpression, hackIntoExtenderCallExpression, isNodeExtender, isNodeIdentifier, isNodeObjectExpression, } from "../ast.utils";
-export class LegacyJsxParser {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyJsxParser = void 0;
+const ast_utils_1 = require("../ast.utils");
+class LegacyJsxParser {
     isNodeReactFragment(node) {
         return ((node?.callee?.object?.name === "React" ||
             node?.callee?.object?.object?.name === "_react") &&
@@ -21,19 +24,19 @@ export class LegacyJsxParser {
                 }
                 const attrNode = this.createAttributeNode(attr);
                 // If it's an object expression, extend it
-                if (isNodeObjectExpression(v)) {
-                    return extendObjectExpression(v, attrNode);
+                if ((0, ast_utils_1.isNodeObjectExpression)(v)) {
+                    return (0, ast_utils_1.extendObjectExpression)(v, attrNode);
                 }
                 // If it's an extender, hack into it
-                if (isNodeExtender(v)) {
-                    return hackIntoExtenderCallExpression(v, attrNode);
+                if ((0, ast_utils_1.isNodeExtender)(v)) {
+                    return (0, ast_utils_1.hackIntoExtenderCallExpression)(v, attrNode);
                 }
                 // If it's an identifier, do Object.assign to be safe
-                if (isNodeIdentifier(v)) {
-                    return createObjectAssignCallExpressionWithIdentifier(v, createObjectExpressionWithAttr(attrNode));
+                if ((0, ast_utils_1.isNodeIdentifier)(v)) {
+                    return (0, ast_utils_1.createObjectAssignCallExpressionWithIdentifier)(v, (0, ast_utils_1.createObjectExpressionWithAttr)(attrNode));
                 }
                 // Worst case override with
-                return createObjectExpressionWithAttr(attrNode);
+                return (0, ast_utils_1.createObjectExpressionWithAttr)(attrNode);
             }),
         };
     }
@@ -56,3 +59,4 @@ export class LegacyJsxParser {
         };
     }
 }
+exports.LegacyJsxParser = LegacyJsxParser;

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

@@ -1,5 +1,8 @@
-import { createObjectAssignCallExpressionWithIdentifier, createObjectExpressionWithAttr, extendObjectExpression, hackIntoExtenderCallExpression, isNodeExtender, isNodeIdentifier, isNodeObjectExpression, } from "../ast.utils";
-export class ModernJsxParser {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ModernJsxParser = void 0;
+const ast_utils_1 = require("../ast.utils");
+class ModernJsxParser {
     constructor() {
         this.reactCalleeNames = [
             "_jsxDEV",
@@ -50,19 +53,19 @@ export class ModernJsxParser {
                 }
                 const attrNode = this.createAttributeNode(attr);
                 // If it's an object expression, extend it
-                if (isNodeObjectExpression(v)) {
-                    return extendObjectExpression(v, attrNode);
+                if ((0, ast_utils_1.isNodeObjectExpression)(v)) {
+                    return (0, ast_utils_1.extendObjectExpression)(v, attrNode);
                 }
                 // If it's an extender, hack into it
-                if (isNodeExtender(v)) {
-                    return hackIntoExtenderCallExpression(v, attrNode);
+                if ((0, ast_utils_1.isNodeExtender)(v)) {
+                    return (0, ast_utils_1.hackIntoExtenderCallExpression)(v, attrNode);
                 }
                 // If it's an identifier, do Object.assign to be safe
-                if (isNodeIdentifier(v)) {
-                    return createObjectAssignCallExpressionWithIdentifier(v, createObjectExpressionWithAttr(attrNode));
+                if ((0, ast_utils_1.isNodeIdentifier)(v)) {
+                    return (0, ast_utils_1.createObjectAssignCallExpressionWithIdentifier)(v, (0, ast_utils_1.createObjectExpressionWithAttr)(attrNode));
                 }
                 // Worst case override with
-                return createObjectExpressionWithAttr(attrNode);
+                return (0, ast_utils_1.createObjectExpressionWithAttr)(attrNode);
             }),
         };
     }
@@ -85,3 +88,4 @@ export class ModernJsxParser {
         };
     }
 }
+exports.ModernJsxParser = ModernJsxParser;

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "rollup-plugin-react-scoped-css",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "A rollup plugin designed to allow scoped css to be run in react (Compatible with vite and rollup)",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
-  "type": "module",
   "scripts": {
     "build": "tsc",
     "build:watch": "tsc --watch",

package/tsconfig.json

@@ -1,7 +1,7 @@
 {
   "compilerOptions": {
     "target": "ES2021",
-    "module": "ESNext",
+    "module": "CommonJS",
     "moduleResolution": "node",
     "declaration": true,
     "outDir": "dist",