@plumeria/utils 7.0.2 → 7.1.1

package/dist/index.d.ts

@@ -1,7 +1,8 @@
-export type { CSSObject, FileStyles, StaticTable, KeyframesHashTable, KeyframesObjectTable, ViewTransitionHashTable, ViewTransitionObjectTable, CreateThemeObjectTable, CreateHashTable, CreateObjectTable, VariantsHashTable, VariantsObjectTable, CreateThemeHashTable, CreateStaticHashTable, CreateStaticObjectTable, } from './types';
+export type { CSSObject, FileStyles, StaticTable, KeyframesHashTable, ViewTransitionHashTable, CreateHashTable, VariantsHashTable, CreateThemeHashTable, CreateStaticHashTable, } from './types';
 export { objectExpressionToObject, collectLocalConsts, traverse, t, extractOndemandStyles, deepMerge, scanAll, } from './parser';
 export type { StyleRecord } from './create';
 export { getStyleRecords } from './create';
 export { createTheme } from './createTheme';
 export { resolveImportPath } from './resolver';
 export { optimizer } from './optimizer';
+export { processVariants } from './variants';

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.optimizer = exports.resolveImportPath = exports.createTheme = exports.getStyleRecords = exports.scanAll = exports.deepMerge = exports.extractOndemandStyles = exports.t = exports.traverse = exports.collectLocalConsts = exports.objectExpressionToObject = void 0;
+exports.processVariants = exports.optimizer = exports.resolveImportPath = exports.createTheme = exports.getStyleRecords = exports.scanAll = exports.deepMerge = exports.extractOndemandStyles = exports.t = exports.traverse = exports.collectLocalConsts = exports.objectExpressionToObject = void 0;
 var parser_1 = require("./parser");
 Object.defineProperty(exports, "objectExpressionToObject", { enumerable: true, get: function () { return parser_1.objectExpressionToObject; } });
 Object.defineProperty(exports, "collectLocalConsts", { enumerable: true, get: function () { return parser_1.collectLocalConsts; } });
@@ -17,3 +17,5 @@ var resolver_1 = require("./resolver");
 Object.defineProperty(exports, "resolveImportPath", { enumerable: true, get: function () { return resolver_1.resolveImportPath; } });
 var optimizer_1 = require("./optimizer");
 Object.defineProperty(exports, "optimizer", { enumerable: true, get: function () { return optimizer_1.optimizer; } });
+var variants_1 = require("./variants");
+Object.defineProperty(exports, "processVariants", { enumerable: true, get: function () { return variants_1.processVariants; } });

package/dist/variants.d.ts

@@ -0,0 +1,4 @@
+export declare function processVariants(variants: Record<string, Record<string, any>>): {
+    hashMap: Record<string, any>;
+    sheets: string[];
+};

package/dist/variants.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processVariants = processVariants;
+const parser_1 = require("./parser");
+const create_1 = require("./create");
+function processVariants(variants) {
+    const sheets = [];
+    const variantKeys = Object.keys(variants);
+    const variantProperties = {};
+    variantKeys.forEach((key) => {
+        variantProperties[key] = new Set();
+        Object.values(variants[key]).forEach((style) => {
+            Object.keys(style).forEach((prop) => variantProperties[key].add(prop));
+        });
+    });
+    const conflicts = {};
+    variantKeys.forEach((key) => (conflicts[key] = new Set()));
+    for (let i = 0; i < variantKeys.length; i++) {
+        for (let j = i + 1; j < variantKeys.length; j++) {
+            const keyA = variantKeys[i];
+            const keyB = variantKeys[j];
+            let hasConflict = false;
+            for (const prop of variantProperties[keyA]) {
+                if (variantProperties[keyB].has(prop)) {
+                    hasConflict = true;
+                    break;
+                }
+            }
+            if (hasConflict) {
+                conflicts[keyA].add(keyB);
+                conflicts[keyB].add(keyA);
+            }
+        }
+    }
+    const visited = new Set();
+    const independentKeys = [];
+    const compoundGroups = [];
+    variantKeys.forEach((key) => {
+        if (visited.has(key))
+            return;
+        const queue = [key];
+        const component = new Set();
+        while (queue.length > 0) {
+            const curr = queue.shift();
+            if (component.has(curr))
+                continue;
+            component.add(curr);
+            visited.add(curr);
+            conflicts[curr].forEach((neighbor) => {
+                if (!visited.has(neighbor)) {
+                    queue.push(neighbor);
+                }
+                else if (!component.has(neighbor)) {
+                }
+            });
+        }
+        if (component.size === 1) {
+            independentKeys.push(key);
+        }
+        else {
+            compoundGroups.push(Array.from(component));
+        }
+    });
+    const hashMap = {};
+    independentKeys.forEach((key) => {
+        const optionMap = {};
+        Object.entries(variants[key]).forEach(([optKey, style]) => {
+            const records = (0, create_1.getStyleRecords)(style);
+            records.forEach((r) => {
+                if (!sheets.includes(r.sheet))
+                    sheets.push(r.sheet);
+            });
+            optionMap[optKey] = records.map((r) => r.hash).join(' ');
+        });
+        hashMap[key] = optionMap;
+    });
+    if (compoundGroups.length > 0) {
+        hashMap._compound = compoundGroups.map((groupKeys) => {
+            const compoundMap = {};
+            const generateCombinations = (depth, currentCombo) => {
+                if (depth === groupKeys.length) {
+                    let mergedStyle = {};
+                    const comboKeyParts = [];
+                    groupKeys.forEach((k) => {
+                        const opt = currentCombo[k];
+                        comboKeyParts.push(opt || 'default');
+                        if (opt && variants[k][opt]) {
+                            mergedStyle = (0, parser_1.deepMerge)(mergedStyle, variants[k][opt]);
+                        }
+                    });
+                    const records = (0, create_1.getStyleRecords)(mergedStyle);
+                    records.forEach((r) => {
+                        if (!sheets.includes(r.sheet))
+                            sheets.push(r.sheet);
+                    });
+                    const className = records.map((r) => r.hash).join(' ');
+                    if (className) {
+                        compoundMap[comboKeyParts.join(':')] = className;
+                    }
+                    return;
+                }
+                const key = groupKeys[depth];
+                const options = Object.keys(variants[key]);
+                const effectiveOptions = new Set(options);
+                effectiveOptions.add('default');
+                effectiveOptions.forEach((opt) => {
+                    generateCombinations(depth + 1, { ...currentCombo, [key]: opt });
+                });
+            };
+            generateCombinations(0, {});
+            return {
+                keys: groupKeys,
+                map: compoundMap,
+            };
+        });
+    }
+    return {
+        hashMap,
+        sheets,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/utils",
-  "version": "7.0.2",
+  "version": "7.1.1",
   "description": "Plumeria Utils",
   "author": "Refirst 11",
   "license": "MIT",
@@ -22,7 +22,7 @@
   ],
   "dependencies": {
     "@swc/core": "1.15.8",
-    "zss-engine": "2.2.3",
+    "zss-engine": "2.2.4",
     "postcss": "8.5.6",
     "postcss-combine-media-query": "^2.1.0",
     "lightningcss": "^1.30.2"