@plumeria/utils 19.1.5 → 19.1.6

package/dist/transform.js

@@ -1702,11 +1702,13 @@ const transformSource = async (env) => {
             Object.keys(conflictVarGroups).forEach((id) => {
                 const groupId = Number(id);
                 const opts = conflictVarGroups[groupId];
-                if (opts.some((c) => c.valueName === ''))
-                    return;
-                const off = conditionals.find((c) => c.groupId === groupId && c.valueName === '');
-                if (off)
-                    opts.push({ ...off, truthy: {}, falsy: {} });
+                const present = new Set(opts.map((c) => c.valueName));
+                conditionals.forEach((c) => {
+                    if (c.groupId !== groupId || present.has(c.valueName))
+                        return;
+                    present.add(c.valueName);
+                    opts.push({ ...c, truthy: {}, falsy: {} });
+                });
             });
             Object.entries(conflictVarGroups).forEach(([, opts]) => {
                 ordered.push({
@@ -1725,45 +1727,98 @@ const transformSource = async (env) => {
             });
             ordered.sort((a, b) => a.order - b.order);
             const dimensions = ordered.map((o) => o.dimension);
-            const joined = dimensions.filter((dim) => dim.type !== 'const').length > 1;
-            dimensions.forEach((dim) => {
-                if (!joined || dim.type !== 'var' || !dim.ownKeys)
-                    return;
-                const numbers = {};
-                dim.options.forEach((opt, index) => {
-                    numbers[String(opt.value)] = String(index);
-                    opt.value = String(index);
+            const keysOf = (dim) => {
+                const keys = new Set();
+                dim.options.forEach((opt) => Object.keys(opt.style).forEach((key) => {
+                    if (conflictingKeys.has(key))
+                        keys.add(key);
+                }));
+                return keys;
+            };
+            const dimensionKeys = dimensions.map(keysOf);
+            const parent = dimensions.map((_, index) => index);
+            const find = (index) => parent[index] === index ? index : (parent[index] = find(parent[index]));
+            const ownerByKey = new Map();
+            dimensionKeys.forEach((keys, index) => {
+                keys.forEach((key) => {
+                    const owner = ownerByKey.get(key);
+                    if (owner === undefined) {
+                        ownerByKey.set(key, index);
+                        return;
+                    }
+                    const a = find(owner);
+                    const b = find(index);
+                    if (a !== b)
+                        parent[b] = a;
                 });
-                dim.testExpr = `(${JSON.stringify(numbers)}[${dim.testExpr}] || "")`;
             });
-            const results = {};
-            const recurse = (dimIndex, currentStyle, keyParts) => {
-                if (dimIndex >= dimensions.length) {
-                    const className = processStyleRecords(currentStyle, stateWeights)
-                        .map((r) => r.hash)
-                        .join(' ');
-                    if (className)
-                        results[keyParts.join('__')] = className;
+            const components = new Map();
+            dimensions.forEach((_, index) => {
+                const root = find(index);
+                const group = components.get(root);
+                if (group)
+                    group.push(index);
+                else
+                    components.set(root, [index]);
+            });
+            const emitComponent = (indexes) => {
+                const dims = indexes.map((index) => dimensions[index]);
+                const variables = dims.filter((dim) => dim.type !== 'const');
+                const joined = variables.length > 1;
+                dims.forEach((dim) => {
+                    if (!joined || dim.type !== 'var' || !dim.ownKeys)
+                        return;
+                    const numbers = {};
+                    dim.options.forEach((opt, index) => {
+                        numbers[String(opt.value)] = String(index);
+                        opt.value = String(index);
+                    });
+                    dim.testExpr = `(${JSON.stringify(numbers)}[${dim.testExpr}] || "")`;
+                });
+                const results = {};
+                const recurse = (dimIndex, currentStyle, keyParts) => {
+                    if (dimIndex >= dims.length) {
+                        const className = processStyleRecords(currentStyle, stateWeights)
+                            .map((r) => r.hash)
+                            .join(' ');
+                        if (className)
+                            results[keyParts.join('__')] = className;
+                        return;
+                    }
+                    const dimension = dims[dimIndex];
+                    dimension.options.forEach((opt) => recurse(dimIndex + 1, (0, parser_1.deepMerge)(currentStyle, opt.style), dimension.type === 'const'
+                        ? keyParts
+                        : [...keyParts, String(opt.value)]));
+                };
+                recurse(0, {}, []);
+                if (variables.length === 0) {
+                    const only = results[''];
+                    if (only)
+                        classParts.push(JSON.stringify(only));
                     return;
                 }
-                const dimension = dimensions[dimIndex];
-                dimension.options.forEach((opt) => recurse(dimIndex + 1, (0, parser_1.deepMerge)(currentStyle, opt.style), dimension.type === 'const'
-                    ? keyParts
-                    : [...keyParts, String(opt.value)]));
+                const componentKeys = new Set();
+                indexes.forEach((index) => dimensionKeys[index].forEach((key) => componentKeys.add(key)));
+                const componentBase = {};
+                Object.entries(baseConflict).forEach(([key, value]) => {
+                    if (componentKeys.has(key))
+                        componentBase[key] = value;
+                });
+                const baseConflictClass = Object.keys(componentBase).length > 0
+                    ? processStyleRecords(componentBase, stateWeights)
+                        .map((r) => r.hash)
+                        .join(' ')
+                    : '';
+                const masterKeyExpr = variables
+                    .map((dim) => dim.type === 'std'
+                    ? `(${dim.testExpr} ? "1" : "0")`
+                    : dim.testExpr || '""')
+                    .join(' + "__" + ');
+                classParts.push(`(${JSON.stringify(results)}[${masterKeyExpr}] || ${baseConflictClass ? JSON.stringify(baseConflictClass) : '""'})`);
             };
-            recurse(0, {}, []);
-            const baseConflictClass = Object.keys(baseConflict).length > 0
-                ? processStyleRecords(baseConflict, stateWeights)
-                    .map((r) => r.hash)
-                    .join(' ')
-                : '';
-            const masterKeyExpr = dimensions
-                .filter((dim) => dim.type !== 'const')
-                .map((dim) => dim.type === 'std'
-                ? `(${dim.testExpr} ? "1" : "0")`
-                : dim.testExpr || '""')
-                .join(' + "__" + ');
-            classParts.push(`(${JSON.stringify(results)}[${masterKeyExpr || '""'}] || ${baseConflictClass ? JSON.stringify(baseConflictClass) : '""'})`);
+            [...components.values()]
+                .sort((a, b) => a[0] - b[0])
+                .forEach(emitComponent);
         }
         classParts.push(...dynamicClassParts);
         return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@plumeria/utils",
-  "version": "19.1.5",
+  "version": "19.1.6",
   "description": "Plumeria Utils",
   "author": "Refirst 11",
   "license": "MIT",