@plumeria/utils 18.2.12 → 18.2.13

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-export type { CSSObject, StaticTable, KeyframesHashTable, ViewTransitionHashTable, CreateHashTable, VariantsHashTable, CreateThemeHashTable, CreateStaticHashTable, } from './types';
+export type { CSSObject, StaticTable, KeyframesHashTable, ViewTransitionHashTable, CreateHashTable, CreateFunctionTable, VariantsHashTable, CreateThemeHashTable, CreateStaticHashTable, } from './types';
 export { objectExpressionToObject, collectLocalConsts, traverse, t, getRootIdentifier, extractOndemandStyles, deepMerge, scanAll, getFileDependencies, resolveExport, resolveComponentKey, } from './parser';
 export type { StyleRecord } from './create';
 export { getStyleRecords } from './create';

package/dist/parser.js

@@ -358,6 +358,202 @@ function collectLocalConsts(ast) {
     }
     return localConsts;
 }
+function paramNames(func) {
+    const names = new Set();
+    const add = (pattern) => {
+        if (!pattern)
+            return;
+        if (exports.t.isIdentifier(pattern)) {
+            names.add(pattern.value);
+        }
+        else if (pattern.type === 'ObjectPattern') {
+            for (const item of pattern.properties ?? []) {
+                if (item.type === 'AssignmentPatternProperty')
+                    add(item.key);
+                else if (item.type === 'KeyValuePatternProperty')
+                    add(item.value);
+                else if (item.type === 'RestElement')
+                    add(item.argument);
+            }
+        }
+        else if (pattern.type === 'ArrayPattern') {
+            (pattern.elements ?? []).forEach(add);
+        }
+        else if (pattern.type === 'AssignmentPattern') {
+            add(pattern.left);
+        }
+        else if (pattern.type === 'RestElement') {
+            add(pattern.argument);
+        }
+    };
+    func.params.forEach((param) => add(param?.pat ?? param));
+    return names;
+}
+function readsParams(node, params) {
+    if (Array.isArray(node))
+        return node.some((item) => readsParams(item, params));
+    if (!node || typeof node !== 'object')
+        return false;
+    if (node.type === 'Identifier')
+        return params.has(node.value);
+    if (node.type === 'KeyValueProperty')
+        return readsParams(node.value, params);
+    if (node.type === 'MemberExpression')
+        return (readsParams(node.object, params) ||
+            (node.property?.type === 'Computed' && readsParams(node.property, params)));
+    return Object.entries(node).some(([key, child]) => key !== 'span' && readsParams(child, params));
+}
+function literalFromValue(value, span) {
+    if (typeof value === 'string')
+        return { type: 'StringLiteral', span, value };
+    if (typeof value === 'number')
+        return { type: 'NumericLiteral', span, value };
+    if (typeof value === 'boolean')
+        return { type: 'BooleanLiteral', span, value };
+    if (typeof value !== 'object' || value === null)
+        return undefined;
+    const properties = [];
+    for (const [key, entry] of Object.entries(value)) {
+        const node = literalFromValue(entry, span);
+        if (!node)
+            return undefined;
+        properties.push({
+            type: 'KeyValueProperty',
+            key: { type: 'StringLiteral', span, value: key },
+            value: node,
+        });
+    }
+    return { type: 'ObjectExpression', span, properties };
+}
+function inlineOuterScope(objExpression, resolveProperty) {
+    const rewriteProperty = (prop, params) => {
+        if (prop.type === 'KeyValueProperty') {
+            const val = prop.value;
+            if (val.type === 'ObjectExpression') {
+                const rewritten = rewriteObject(val, params);
+                return rewritten === val ? prop : { ...prop, value: rewritten };
+            }
+            if (exports.t.isStringLiteral(val) ||
+                exports.t.isNumericLiteral(val) ||
+                exports.t.isBooleanLiteral(val))
+                return prop;
+        }
+        else if (prop.type !== 'SpreadElement' && !exports.t.isIdentifier(prop)) {
+            return prop;
+        }
+        if (readsParams(prop, params)) {
+            if (prop.type !== 'KeyValueProperty')
+                return prop;
+            const value = rewriteExpression(prop.value, params);
+            return value === prop.value ? prop : { ...prop, value };
+        }
+        const entries = Object.entries(resolveProperty(prop));
+        if (entries.length === 0)
+            return prop;
+        const span = (prop.value ?? prop).span;
+        if (prop.type === 'KeyValueProperty') {
+            const value = literalFromValue(entries[0][1], span);
+            return value ? { ...prop, value } : prop;
+        }
+        const properties = [];
+        for (const [key, entry] of entries) {
+            const value = literalFromValue(entry, span);
+            if (!value)
+                return prop;
+            properties.push({
+                type: 'KeyValueProperty',
+                key: { type: 'StringLiteral', span, value: key },
+                value,
+            });
+        }
+        return properties;
+    };
+    const rewriteExpression = (node, params) => {
+        if (!node || typeof node !== 'object')
+            return node;
+        if (!readsParams(node, params)) {
+            const entries = Object.entries(resolveProperty({
+                type: 'KeyValueProperty',
+                key: { type: 'Identifier', span: node.span, value: 'value' },
+                value: node,
+            }));
+            if (entries.length !== 1)
+                return node;
+            return literalFromValue(entries[0][1], node.span) ?? node;
+        }
+        if (node.type === 'ObjectExpression')
+            return rewriteObject(node, params);
+        if (node.type === 'ParenthesisExpression') {
+            const inner = rewriteExpression(node.expression, params);
+            return inner === node.expression ? node : { ...node, expression: inner };
+        }
+        if (node.type === 'TemplateLiteral') {
+            let changed = false;
+            const expressions = node.expressions.map((expr) => {
+                const rewritten = rewriteExpression(expr, params);
+                if (rewritten !== expr)
+                    changed = true;
+                return rewritten;
+            });
+            return changed ? { ...node, expressions } : node;
+        }
+        if (node.type === 'BinaryExpression') {
+            const left = rewriteExpression(node.left, params);
+            const right = rewriteExpression(node.right, params);
+            return left === node.left && right === node.right
+                ? node
+                : { ...node, left, right };
+        }
+        return node;
+    };
+    const rewriteObject = (node, params) => {
+        let changed = false;
+        const properties = [];
+        for (const prop of node.properties) {
+            const rewritten = rewriteProperty(prop, params);
+            if (rewritten !== prop)
+                changed = true;
+            if (Array.isArray(rewritten))
+                properties.push(...rewritten);
+            else
+                properties.push(rewritten);
+        }
+        return changed ? { ...node, properties } : node;
+    };
+    const rewriteBody = (node, params) => {
+        if (node?.type === 'ParenthesisExpression') {
+            const inner = rewriteBody(node.expression, params);
+            return inner === node.expression ? node : { ...node, expression: inner };
+        }
+        if (node?.type === 'BlockStatement') {
+            const first = node.stmts?.[0];
+            if (first?.type !== 'ReturnStatement' || !first.argument)
+                return node;
+            const inner = rewriteBody(first.argument, params);
+            if (inner === first.argument)
+                return node;
+            const stmts = [{ ...first, argument: inner }, ...node.stmts.slice(1)];
+            return { ...node, stmts };
+        }
+        if (node?.type === 'ObjectExpression')
+            return rewriteObject(node, params);
+        return node;
+    };
+    let changed = false;
+    const properties = objExpression.properties.map((prop) => {
+        if (prop.type !== 'KeyValueProperty' ||
+            (prop.value.type !== 'ArrowFunctionExpression' &&
+                prop.value.type !== 'FunctionExpression'))
+            return prop;
+        const func = prop.value;
+        const body = rewriteBody(func.body, paramNames(func));
+        if (body === func.body)
+            return prop;
+        changed = true;
+        return { ...prop, value: { ...func, body } };
+    });
+    return changed ? { ...objExpression, properties } : objExpression;
+}
 function getPropertyKey(node, staticTable, keyframesHashTable, viewTransitionHashTable, createThemeHashTable, createThemeObjectTable, createStaticHashTable, createStaticObjectTable) {
     if (exports.t.isIdentifier(node)) {
         return node.value;
@@ -714,6 +910,7 @@ const globalAgregatedTables = {
     createThemeSelectorTable: {},
     createHashTable: {},
     createObjectTable: {},
+    createFunctionTable: {},
     createAtomicMapTable: {},
     variantsHashTable: {},
     variantsObjectTable: {},
@@ -765,6 +962,7 @@ function stripFileContributions(filePath, cached) {
     }
     for (const key of Object.keys(cached.createHashTable)) {
         delete localTables.createHashTable[`${filePath}-${key}`];
+        delete localTables.createFunctionTable[`${filePath}-${key}`];
     }
     for (const key of Object.keys(cached.variantsHashTable)) {
         delete localTables.variantsHashTable[`${filePath}-${key}`];
@@ -921,6 +1119,7 @@ function scanAll() {
         const isFirstPass = passNumber === 1;
         for (const { filePath, ast, mtimeMs } of parsedFiles) {
             try {
+                let localConsts;
                 const localDependencies = new Set();
                 const localStaticTable = {};
                 const localKeyframesHashTable = {};
@@ -1098,6 +1297,10 @@ function scanAll() {
                                     }
                                     return undefined;
                                 };
+                                const scopedStaticTable = {
+                                    ...(localConsts ??= collectLocalConsts(ast)),
+                                    ...localStaticTable,
+                                };
                                 const isPassOneMethod = method === 'createStatic' ||
                                     method === 'createTheme' ||
                                     method === 'keyframes' ||
@@ -1107,7 +1310,7 @@ function scanAll() {
                                 const objExpression = isCreateTheme
                                     ? init.arguments[1].expression
                                     : init.arguments[0].expression;
-                                const obj = objectExpressionToObject(objExpression, localStaticTable, localKeyframesHashTable, localViewTransitionHashTable, localCreateThemeHashTable, localCreateThemeObjectTable, localCreateHashTable, localCreateStaticHashTable, localCreateStaticObjectTable, localVariantsHashTable, resolveVariable);
+                                const obj = objectExpressionToObject(objExpression, scopedStaticTable, localKeyframesHashTable, localViewTransitionHashTable, localCreateThemeHashTable, localCreateThemeObjectTable, localCreateHashTable, localCreateStaticHashTable, localCreateStaticObjectTable, localVariantsHashTable, resolveVariable);
                                 const uniqueKey = `${filePath}-${name}`;
                                 if (method === 'createStatic') {
                                     localStaticTable[name] = obj;
@@ -1167,6 +1370,15 @@ function scanAll() {
                                     localTables.createObjectTable[hash] = obj;
                                     localCreateObjectTable[hash] = obj;
                                     registerObjectOwner('createObjectTable', hash, filePath);
+                                    const hasFunctionKey = objExpression.properties.some((prop) => prop.type === 'KeyValueProperty' &&
+                                        (prop.value.type === 'ArrowFunctionExpression' ||
+                                            prop.value.type === 'FunctionExpression'));
+                                    if (hasFunctionKey)
+                                        localTables.createFunctionTable[uniqueKey] =
+                                            inlineOuterScope(objExpression, (property) => objectExpressionToObject({
+                                                ...objExpression,
+                                                properties: [property],
+                                            }, scopedStaticTable, localKeyframesHashTable, localViewTransitionHashTable, localCreateThemeHashTable, localCreateThemeObjectTable, localCreateHashTable, localCreateStaticHashTable, localCreateStaticObjectTable, localVariantsHashTable, resolveVariable));
                                     const hashMap = {};
                                     Object.entries(obj).forEach(([key, style]) => {
                                         const records = (0, create_1.getStyleRecords)(style);

package/dist/types.d.ts

@@ -1,4 +1,5 @@
 import { CSSProperties } from 'zss-engine';
+import type { ObjectExpression } from '@swc/core';
 type CSSPrimitive = string | number | boolean;
 export type CSSValue = CSSPrimitive | CSSObject;
 export type CSSObject = {
@@ -12,6 +13,7 @@ export type ViewTransitionObjectTable = Record<string, CSSObject>;
 export type CreateThemeObjectTable = Record<string, CSSObject>;
 export type CreateHashTable = Record<string, string>;
 export type CreateObjectTable = Record<string, CSSObject>;
+export type CreateFunctionTable = Record<string, ObjectExpression>;
 export type VariantsHashTable = Record<string, string>;
 export type VariantsObjectTable = Record<string, CSSObject>;
 export type CreateAtomicMapTable = Record<string, Record<string, Record<string, string>>>;
@@ -37,6 +39,7 @@ export interface Tables {
     createThemeObjectTable: CreateThemeObjectTable;
     createHashTable: CreateHashTable;
     createObjectTable: CreateObjectTable;
+    createFunctionTable: CreateFunctionTable;
     createAtomicMapTable: CreateAtomicMapTable;
     createStaticHashTable: CreateStaticHashTable;
     createStaticObjectTable: CreateStaticObjectTable;

package/package.json

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