@plumeria/utils 19.2.13 → 19.2.15

package/dist/parser.d.ts

@@ -43,6 +43,7 @@ export declare function traverse(node: Module | JSXExpression, visitor: {
     }) => void;
 }): void;
 export declare function objectExpressionToObject(node: ObjectExpression, staticTable: StaticTable, keyframesHashTable: KeyframesHashTable, viewTransitionHashTable: ViewTransitionHashTable, createThemeHashTable: CreateThemeHashTable, createThemeObjectTable: CreateThemeObjectTable, createHashTable: CreateHashTable, createStaticHashTable: CreateStaticHashTable, createStaticObjectTable: CreateStaticObjectTable, resolveVariable?: (name: string) => any): CSSObject;
+export declare function collectLocalConstNodes(ast: Module): Map<string, any>;
 export declare function collectLocalConsts(ast: Module): Record<string, any>;
 export declare function resolveThemeSelector(node: Expression, staticTable: StaticTable, createStaticHashTable: CreateStaticHashTable, createStaticObjectTable: CreateStaticObjectTable): string;
 export declare function resolveFileError(actualPath: string, importedName: string): {

package/dist/parser.js

@@ -39,6 +39,7 @@ exports.resolveOriginError = resolveOriginError;
 exports.resolveComponentKey = resolveComponentKey;
 exports.traverse = traverse;
 exports.objectExpressionToObject = objectExpressionToObject;
+exports.collectLocalConstNodes = collectLocalConstNodes;
 exports.collectLocalConsts = collectLocalConsts;
 exports.resolveThemeSelector = resolveThemeSelector;
 exports.resolveFileError = resolveFileError;
@@ -343,8 +344,7 @@ function objectExpressionToObject(node, staticTable, keyframesHashTable, viewTra
     });
     return obj;
 }
-function collectLocalConsts(ast) {
-    const localConsts = {};
+function collectLocalConstNodes(ast) {
     const decls = new Map();
     for (const node of ast.body) {
         let declarations = [];
@@ -363,6 +363,11 @@ function collectLocalConsts(ast) {
             }
         }
     }
+    return decls;
+}
+function collectLocalConsts(ast) {
+    const localConsts = {};
+    const decls = collectLocalConstNodes(ast);
     const visiting = new Set();
     function resolveValue(name) {
         if (localConsts[name] !== undefined)

package/dist/transform.d.ts

@@ -5,6 +5,7 @@ export type TransformEnv = {
     filePath: string;
     root: string;
     styleProp: string;
+    classProp?: string;
     propertyPolicy: PropertyPolicy | undefined;
     isDev: boolean;
     collectOndemandSheets: boolean;

package/dist/transform.js

@@ -38,6 +38,42 @@ const core_1 = require("@swc/core");
 const path = __importStar(require("path"));
 const zss_engine_1 = require("zss-engine");
 const parser_1 = require("./parser");
+const unresolvableValue_1 = require("./unresolvableValue");
+const spreadValues = (tables, constNodes) => {
+    const spread = (prop) => {
+        let values;
+        try {
+            values = (0, parser_1.objectExpressionToObject)({ properties: [prop] }, ...tables);
+        }
+        catch {
+            return null;
+        }
+        const argument = prop.arguments;
+        const declared = argument?.type === 'Identifier'
+            ? constNodes.get(argument.value)
+            : undefined;
+        const source = declared && parser_1.t.isObjectExpression(declared) ? declared : undefined;
+        return { values, source };
+    };
+    const resolvesValue = (value) => {
+        try {
+            const probe = (0, parser_1.objectExpressionToObject)({
+                properties: [
+                    {
+                        type: 'KeyValueProperty',
+                        key: { type: 'Identifier', value: '__probe' },
+                        value,
+                    },
+                ],
+            }, ...tables);
+            return '__probe' in probe;
+        }
+        catch {
+            return false;
+        }
+    };
+    return { spread, resolvesValue };
+};
 const create_1 = require("./create");
 const dynamicKey_1 = require("./dynamicKey");
 const escalation_1 = require("./escalation");
@@ -146,6 +182,7 @@ const foldDynamicVars = (vars) => {
 };
 const transformSource = async (env) => {
     const { source, root, styleProp, propertyPolicy, isDev, collectOndemandSheets, addDependency, } = env;
+    const classProp = env.classProp ?? 'className';
     const id = env.moduleId;
     const resourcePath = env.moduleId;
     const baseId = env.filePath;
@@ -308,6 +345,7 @@ const transformSource = async (env) => {
         return records;
     };
     const localConsts = (0, parser_1.collectLocalConsts)(ast);
+    const localConstNodes = (0, parser_1.collectLocalConstNodes)(ast);
     const importMap = {};
     const keyframesImportMap = {};
     const viewTransitionImportMap = {};
@@ -581,6 +619,16 @@ const transformSource = async (env) => {
             if (propName === 'create' &&
                 parser_1.t.isObjectExpression(init.arguments[0].expression)) {
                 const obj = (0, parser_1.objectExpressionToObject)(init.arguments[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable);
+                (0, unresolvableValue_1.assertNoDroppedValues)(init.arguments[0].expression, obj, spreadValues([
+                    mergedStaticTable,
+                    mergedKeyframesTable,
+                    mergedViewTransitionTable,
+                    mergedCreateThemeHashTable,
+                    scannedTables.createThemeObjectTable,
+                    mergedCreateTable,
+                    mergedCreateStaticHashTable,
+                    scannedTables.createStaticObjectTable,
+                ], localConstNodes));
                 if (obj) {
                     const hashMap = {};
                     Object.entries(obj).forEach(([key, style]) => {
@@ -631,6 +679,16 @@ const transformSource = async (env) => {
                     throwCompilationError(`Plumeria: Unsupported at-rule: "${selector}". createTheme only supports nesting at-rules such as @media, @container, @supports, @layer, and @scope.`, selectorExpr);
                 }
                 const obj = (0, parser_1.objectExpressionToObject)(init.arguments[1].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable);
+                (0, unresolvableValue_1.assertNoDroppedValues)(init.arguments[1].expression, obj, spreadValues([
+                    mergedStaticTable,
+                    mergedKeyframesTable,
+                    mergedViewTransitionTable,
+                    mergedCreateThemeHashTable,
+                    scannedTables.createThemeObjectTable,
+                    mergedCreateTable,
+                    mergedCreateStaticHashTable,
+                    scannedTables.createStaticObjectTable,
+                ], localConstNodes));
                 const hash = (0, createTheme_1.themeHashOf)(selector, obj);
                 if (parser_1.t.isIdentifier(node.id)) {
                     const uniqueKey = `${resourcePath}-${node.id.value}`;
@@ -669,6 +727,16 @@ const transformSource = async (env) => {
                     idSpans.add(node.id.span.start);
                 }
                 const obj = (0, parser_1.objectExpressionToObject)(init.arguments[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable);
+                (0, unresolvableValue_1.assertNoDroppedValues)(init.arguments[0].expression, obj, spreadValues([
+                    mergedStaticTable,
+                    mergedKeyframesTable,
+                    mergedViewTransitionTable,
+                    mergedCreateThemeHashTable,
+                    scannedTables.createThemeObjectTable,
+                    mergedCreateTable,
+                    mergedCreateStaticHashTable,
+                    scannedTables.createStaticObjectTable,
+                ], localConstNodes));
                 const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
                 if (parser_1.t.isIdentifier(node.id)) {
                     const uniqueKey = `${resourcePath}-${node.id.value}`;
@@ -781,6 +849,16 @@ const transformSource = async (env) => {
                     const expr = args[0].expression;
                     if (parser_1.t.isObjectExpression(expr)) {
                         const obj = (0, parser_1.objectExpressionToObject)(expr, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable);
+                        (0, unresolvableValue_1.assertNoDroppedValues)(expr, obj, spreadValues([
+                            mergedStaticTable,
+                            mergedKeyframesTable,
+                            mergedViewTransitionTable,
+                            mergedCreateThemeHashTable,
+                            scannedTables.createThemeObjectTable,
+                            mergedCreateTable,
+                            mergedCreateStaticHashTable,
+                            scannedTables.createStaticObjectTable,
+                        ], localConstNodes));
                         const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
                         scannedTables.keyframesObjectTable[hash] = obj;
                         replacements.push({
@@ -794,6 +872,16 @@ const transformSource = async (env) => {
                     args.length > 0 &&
                     parser_1.t.isObjectExpression(args[0].expression)) {
                     const obj = (0, parser_1.objectExpressionToObject)(args[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable);
+                    (0, unresolvableValue_1.assertNoDroppedValues)(args[0].expression, obj, spreadValues([
+                        mergedStaticTable,
+                        mergedKeyframesTable,
+                        mergedViewTransitionTable,
+                        mergedCreateThemeHashTable,
+                        scannedTables.createThemeObjectTable,
+                        mergedCreateTable,
+                        mergedCreateStaticHashTable,
+                        scannedTables.createStaticObjectTable,
+                    ], localConstNodes));
                     const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
                     scannedTables.viewTransitionObjectTable[hash] = obj;
                     replacements.push({
@@ -815,6 +903,16 @@ const transformSource = async (env) => {
                         throwCompilationError(`Plumeria: Unsupported at-rule: "${selector}". createTheme only supports nesting at-rules such as @media, @container, @supports, @layer, and @scope.`, selectorExpr);
                     }
                     const obj = (0, parser_1.objectExpressionToObject)(args[1].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable);
+                    (0, unresolvableValue_1.assertNoDroppedValues)(args[1].expression, obj, spreadValues([
+                        mergedStaticTable,
+                        mergedKeyframesTable,
+                        mergedViewTransitionTable,
+                        mergedCreateThemeHashTable,
+                        scannedTables.createThemeObjectTable,
+                        mergedCreateTable,
+                        mergedCreateStaticHashTable,
+                        scannedTables.createStaticObjectTable,
+                    ], localConstNodes));
                     const hash = (0, createTheme_1.themeHashOf)(selector, obj);
                     scannedTables.createThemeObjectTable[hash] = obj;
                     if (scannedTables.createThemeSelectorTable) {
@@ -825,6 +923,16 @@ const transformSource = async (env) => {
                     args.length > 0 &&
                     parser_1.t.isObjectExpression(args[0].expression)) {
                     const obj = (0, parser_1.objectExpressionToObject)(args[0].expression, mergedStaticTable, mergedKeyframesTable, mergedViewTransitionTable, mergedCreateThemeHashTable, scannedTables.createThemeObjectTable, mergedCreateTable, mergedCreateStaticHashTable, scannedTables.createStaticObjectTable);
+                    (0, unresolvableValue_1.assertNoDroppedValues)(args[0].expression, obj, spreadValues([
+                        mergedStaticTable,
+                        mergedKeyframesTable,
+                        mergedViewTransitionTable,
+                        mergedCreateThemeHashTable,
+                        scannedTables.createThemeObjectTable,
+                        mergedCreateTable,
+                        mergedCreateStaticHashTable,
+                        scannedTables.createStaticObjectTable,
+                    ], localConstNodes));
                     const hash = (0, zss_engine_1.genBase36Hash)(obj, 1, 8);
                     scannedTables.createStaticObjectTable[hash] = obj;
                 }
@@ -2127,7 +2235,7 @@ const transformSource = async (env) => {
             const attributes = jsxAttributeOwnerMap.get(node.span.start)?.attributes ?? [];
             const classNameAttr = attributes.find((attr) => attr.type === 'JSXAttribute' &&
                 attr.name.type === 'Identifier' &&
-                attr.name.value === 'className');
+                attr.name.value === classProp);
             let existingClassExpr = '';
             if (classNameAttr) {
                 replacements.push({
@@ -2186,12 +2294,12 @@ const transformSource = async (env) => {
                 replacements.push({
                     start: node.span.start - baseByteOffset,
                     end: node.span.end - baseByteOffset,
-                    content: `className={${replacement}}${styleAttr}`,
+                    content: `${classProp}={${replacement}}${styleAttr}`,
                 });
             }
             else {
                 const keptClass = existingClassExpr
-                    ? `className={${existingClassExpr}}`
+                    ? `${classProp}={${existingClassExpr}}`
                     : '';
                 replacements.push({
                     start: node.span.start - baseByteOffset,

package/dist/unresolvableValue.d.ts

@@ -0,0 +1,14 @@
+import type { ObjectExpression, SpreadElement } from '@swc/core';
+type SourceObject = ObjectExpression;
+type StaticValues = Record<string, unknown>;
+type SpreadInfo = {
+    values: StaticValues;
+    source?: SourceObject;
+};
+type ResolveSpread = (prop: SpreadElement) => SpreadInfo | null;
+export type StyleContext = {
+    spread: ResolveSpread;
+    resolvesValue: (value: unknown) => boolean;
+};
+export declare const assertNoDroppedValues: (node: SourceObject, resolved: StaticValues | null | undefined, context?: StyleContext, ignore?: Set<string>) => void;
+export {};

package/dist/unresolvableValue.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertNoDroppedValues = void 0;
+const keyValue = (key) => {
+    if (!key || typeof key !== 'object' || !('value' in key))
+        return;
+    const value = key.value;
+    return typeof value === 'string' || typeof value === 'number'
+        ? value
+        : undefined;
+};
+const unresolvableValue = (key, node) => new Error(`[plumeria] Cannot resolve the value of "${key}" at build time (${node.type}). ` +
+    `Values in css.create must be statically known; pass a runtime value through the ` +
+    `function form, css.create({ name: (value) => ({ ... }) }).`);
+const overwrittenLater = (properties, index, key, context) => {
+    for (let i = index + 1; i < properties.length; i++) {
+        const later = properties[i];
+        if (later.type === 'SpreadElement') {
+            const provided = context?.spread(later);
+            if (!provided)
+                return true;
+            if (String(key) in provided.values)
+                return true;
+            continue;
+        }
+        if (later.type === 'KeyValueProperty' && keyValue(later.key) === key)
+            return true;
+    }
+    return false;
+};
+const RUNTIME_ONLY = new Set([
+    'CallExpression',
+    'NewExpression',
+    'AwaitExpression',
+    'TaggedTemplateExpression',
+    'YieldExpression',
+]);
+const readsAnyOf = (node, names) => {
+    if (!node || typeof node !== 'object')
+        return false;
+    const value = node;
+    if (value.type === 'Identifier' && typeof value.value === 'string')
+        return names.has(value.value);
+    for (const key of Object.keys(value)) {
+        if (key === 'span')
+            continue;
+        const child = value[key];
+        if (Array.isArray(child)) {
+            for (const item of child)
+                if (readsAnyOf(item, names))
+                    return true;
+        }
+        else if (readsAnyOf(child, names))
+            return true;
+    }
+    return false;
+};
+const parameterNames = (func) => {
+    const names = new Set();
+    const add = (pattern) => {
+        if (!pattern || typeof pattern !== 'object')
+            return;
+        if (pattern.type === 'Identifier' && typeof pattern.value === 'string')
+            names.add(pattern.value);
+        for (const key of ['pat', 'left', 'argument', 'value', 'key'])
+            if (pattern[key])
+                add(pattern[key]);
+        for (const key of ['properties', 'elements'])
+            if (Array.isArray(pattern[key]))
+                pattern[key].forEach(add);
+    };
+    (func.params ?? []).forEach((param) => add(param?.pat ?? param));
+    return names;
+};
+const assertStyleFunction = (func, context) => {
+    const params = parameterNames(func);
+    const body = func.body;
+    const returned = body?.type === 'ObjectExpression'
+        ? body
+        : body?.type === 'ParenthesisExpression' &&
+            body.expression?.type === 'ObjectExpression'
+            ? body.expression
+            : null;
+    if (!returned)
+        return;
+    const walk = (object) => {
+        const properties = object.properties ?? [];
+        for (let index = 0; index < properties.length; index++) {
+            const prop = properties[index];
+            if (prop.type !== 'KeyValueProperty')
+                continue;
+            const key = keyValue(prop.key);
+            if ((typeof key === 'string' || typeof key === 'number') &&
+                overwrittenLater(properties, index, key, context))
+                continue;
+            const value = prop.value;
+            if (!value)
+                continue;
+            if (value.type === 'ObjectExpression') {
+                walk(value);
+                continue;
+            }
+            if (RUNTIME_ONLY.has(value.type) && !readsAnyOf(value, params))
+                throw unresolvableValue(key ?? '', value);
+            if ((value.type === 'Identifier' || value.type === 'MemberExpression') &&
+                context &&
+                !readsAnyOf(value, params) &&
+                !context.resolvesValue(value))
+                throw unresolvableValue(key ?? '', value);
+        }
+    };
+    walk(returned);
+};
+const keysSuppliedAfter = (properties, index, context) => {
+    const keys = new Set();
+    for (let i = index + 1; i < properties.length; i++) {
+        const later = properties[i];
+        if (later.type === 'SpreadElement') {
+            const provided = context?.spread(later);
+            if (!provided)
+                return null;
+            for (const name of Object.keys(provided.values))
+                keys.add(name);
+            continue;
+        }
+        if (later.type !== 'KeyValueProperty')
+            continue;
+        const key = keyValue(later.key);
+        if (typeof key !== 'string' && typeof key !== 'number')
+            return null;
+        keys.add(String(key));
+    }
+    return keys;
+};
+const assertNoDroppedValues = (node, resolved, context, ignore) => {
+    if (!resolved)
+        return;
+    for (let index = 0; index < node.properties.length; index++) {
+        const prop = node.properties[index];
+        if (prop.type === 'SpreadElement') {
+            const provided = context?.spread(prop);
+            if (!provided?.source)
+                continue;
+            const replaced = keysSuppliedAfter(node.properties, index, context);
+            if (replaced)
+                (0, exports.assertNoDroppedValues)(provided.source, provided.values, context, replaced);
+            continue;
+        }
+        if (prop.type !== 'KeyValueProperty')
+            continue;
+        const key = keyValue(prop.key);
+        if (typeof key !== 'string' && typeof key !== 'number')
+            continue;
+        if (ignore?.has(String(key)))
+            continue;
+        if (overwrittenLater(node.properties, index, key, context))
+            continue;
+        const value = prop.value;
+        if (!value)
+            continue;
+        if (value.type === 'ArrowFunctionExpression' ||
+            value.type === 'FunctionExpression') {
+            assertStyleFunction(value, context);
+            continue;
+        }
+        if (value.type === 'NullLiteral')
+            continue;
+        if (!(key in resolved))
+            throw unresolvableValue(key, value);
+        if (value.type === 'ObjectExpression') {
+            const nested = resolved[key];
+            if (nested && typeof nested === 'object')
+                (0, exports.assertNoDroppedValues)(value, nested, context);
+        }
+    }
+};
+exports.assertNoDroppedValues = assertNoDroppedValues;

package/package.json

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