@plumeria/turbopack-loader 0.29.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+import type { LoaderContext } from 'webpack';
+export default function loader(this: LoaderContext<unknown>, source: string): void;

package/dist/index.js

@@ -0,0 +1,144 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = loader;
+const core_1 = require("@swc/core");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+const zss_engine_1 = require("zss-engine");
+const utils_1 = require("@plumeria/utils");
+const VIRTUAL_FILE_PATH = path_1.default.resolve(__dirname, '..', 'zero-virtual.css');
+fs_1.default.writeFileSync(VIRTUAL_FILE_PATH, '');
+function loader(source) {
+    const callback = this.async();
+    if (this.resourcePath.includes('node_modules')) {
+        return callback(null, source);
+    }
+    this.clearDependencies();
+    this.addDependency(this.resourcePath);
+    utils_1.tables.constTable = (0, utils_1.scanForDefineConsts)((path) => this.addDependency(path));
+    const { keyframesHashTableLocal, keyframesObjectTableLocal } = (0, utils_1.scanForKeyframes)((path) => this.addDependency(path));
+    utils_1.tables.keyframesHashTable = keyframesHashTableLocal;
+    utils_1.tables.keyframesObjectTable = keyframesObjectTableLocal;
+    const { viewTransitionHashTableLocal, viewTransitionObjectTableLocal } = (0, utils_1.scanForViewTransition)((path) => this.addDependency(path));
+    utils_1.tables.viewTransitionHashTable = viewTransitionHashTableLocal;
+    utils_1.tables.viewTransitionObjectTable = viewTransitionObjectTableLocal;
+    const { tokensTableLocal, defineTokensObjectTableLocal } = (0, utils_1.scanForDefineTokens)((path) => this.addDependency(path));
+    utils_1.tables.tokensTable = tokensTableLocal;
+    utils_1.tables.defineTokensObjectTable = defineTokensObjectTableLocal;
+    const extractedObjects = [];
+    let ast;
+    try {
+        ast = (0, core_1.parseSync)(source, {
+            syntax: 'typescript',
+            tsx: true,
+            target: 'es2022',
+        });
+    }
+    catch (err) {
+        console.log(err);
+        callback(null, source);
+        return;
+    }
+    const localConsts = (0, utils_1.collectLocalConsts)(ast);
+    Object.assign(utils_1.tables.constTable, localConsts);
+    (0, utils_1.traverse)(ast, {
+        CallExpression({ node }) {
+            const callee = node.callee;
+            if (utils_1.t.isMemberExpression(callee) &&
+                utils_1.t.isIdentifier(callee.object, { name: 'css' }) &&
+                utils_1.t.isIdentifier(callee.property)) {
+                const args = node.arguments;
+                if (callee.property.value === 'create' &&
+                    args.length === 1 &&
+                    utils_1.t.isObjectExpression(args[0].expression)) {
+                    const obj = (0, utils_1.objectExpressionToObject)(args[0].expression, utils_1.tables.constTable, utils_1.tables.keyframesHashTable, utils_1.tables.viewTransitionHashTable, utils_1.tables.tokensTable);
+                    if (obj) {
+                        extractedObjects.push(obj);
+                    }
+                }
+            }
+        },
+    });
+    const fileStyles = {};
+    if (extractedObjects.length > 0) {
+        const combinedStyles = extractedObjects.reduce((acc, obj) => Object.assign(acc, obj), {});
+        const base = (0, utils_1.createCSS)(combinedStyles);
+        if (base) {
+            fileStyles.baseStyles = base;
+        }
+    }
+    if (Object.keys(utils_1.tables.keyframesObjectTable).length > 0) {
+        fileStyles.keyframeStyles = Object.entries(utils_1.tables.keyframesObjectTable)
+            .map(([hash, obj]) => (0, zss_engine_1.transpile)({ [`@keyframes kf-${hash}`]: obj }, undefined, '--global')
+            .styleSheet)
+            .join('\n');
+    }
+    if (Object.keys(utils_1.tables.viewTransitionObjectTable).length > 0) {
+        fileStyles.viewTransitionStyles = Object.entries(utils_1.tables.viewTransitionObjectTable)
+            .map(([hash, obj]) => (0, zss_engine_1.transpile)({
+            [`::view-transition-group(vt-${hash})`]: obj.group,
+            [`::view-transition-image-pair(vt-${hash})`]: obj.imagePair,
+            [`::view-transition-old(vt-${hash})`]: obj.old,
+            [`::view-transition-new(vt-${hash})`]: obj.new,
+        }, undefined, '--global').styleSheet)
+            .join('\n');
+    }
+    if (Object.keys(utils_1.tables.defineTokensObjectTable).length > 0) {
+        fileStyles.tokenStyles = Object.values(utils_1.tables.defineTokensObjectTable)
+            .map((obj) => (0, zss_engine_1.transpile)((0, utils_1.createTokens)(obj), undefined, '--global')
+            .styleSheet)
+            .join('\n');
+    }
+    const VIRTUAL_CSS_PATH = require.resolve(VIRTUAL_FILE_PATH);
+    function stringifyRequest(loaderContext, request) {
+        const context = loaderContext.context || loaderContext.rootContext;
+        const relativePath = path_1.default.relative(context, request);
+        const requestPath = relativePath.startsWith('.')
+            ? relativePath
+            : './' + relativePath;
+        return JSON.stringify(requestPath);
+    }
+    const virtualCssImportPath = path_1.default.posix.join(path_1.default.posix.relative(path_1.default.dirname(this.resourcePath), path_1.default.resolve(__dirname, '..', VIRTUAL_CSS_PATH)));
+    let importPath = virtualCssImportPath;
+    if (!importPath.startsWith('.')) {
+        importPath = './' + importPath;
+    }
+    const virtualCssRequest = stringifyRequest(this, `${VIRTUAL_CSS_PATH}`);
+    const postfix = `\nimport ${virtualCssRequest};`;
+    let css = '';
+    try {
+        css = fs_1.default.readFileSync(VIRTUAL_FILE_PATH, 'utf-8');
+    }
+    catch (e) {
+        e;
+    }
+    function generateOrderedCSS(styles) {
+        const sections = [];
+        if (styles.keyframeStyles?.trim()) {
+            if (!css.includes(styles.keyframeStyles))
+                sections.push(styles.keyframeStyles);
+        }
+        if (styles.viewTransitionStyles?.trim()) {
+            if (!css.includes(styles.viewTransitionStyles))
+                sections.push(styles.viewTransitionStyles);
+        }
+        if (styles.tokenStyles?.trim()) {
+            if (!css.includes(styles.tokenStyles))
+                sections.push(styles.tokenStyles);
+        }
+        if (styles.baseStyles?.trim()) {
+            if (!css.includes(styles.baseStyles))
+                sections.push(styles.baseStyles);
+        }
+        return sections.join('\n');
+    }
+    const orderedCSS = generateOrderedCSS(fileStyles);
+    if (orderedCSS) {
+        if (!css.includes(orderedCSS))
+            fs_1.default.appendFileSync(VIRTUAL_FILE_PATH, orderedCSS + '\n');
+    }
+    callback(null, source + postfix);
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@plumeria/turbopack-loader",
+  "version": "0.29.0",
+  "description": "Plumeria Turbopack-loader",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zss-in-js/plumeria.git",
+    "directory": "packages/turbopack-loader"
+  },
+  "license": "MIT",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist/",
+    "zero-virtual.css"
+  ],
+  "scripts": {
+    "build": "rimraf dist && pnpm cjs",
+    "cjs": "tsc --project tsconfig.cjs.json"
+  },
+  "dependencies": {
+    "@plumeria/utils": "workspace:^"
+  },
+  "devDependencies": {
+    "@swc/core": "1.15.2",
+    "webpack": "^5.101.0",
+    "zss-engine": "^0.2.102"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/zero-virtual.css

@@ -0,0 +1 @@
+/** Placeholder file */