@plumeria/utils 19.1.10 → 19.2.1

package/dist/parser.js

@@ -996,6 +996,7 @@ function resolveFileError(actualPath, importedName) {
     return undefined;
 }
 const fileCache = {};
+const receiverKeysByFile = new Map();
 const dependentsMap = new Map();
 let knownFiles = new Set();
 function updateDependencyEdges(filePath, oldDeps, newDeps) {
@@ -1031,6 +1032,7 @@ const globalAgregatedTables = {
     createStaticHashTable: {},
     createStaticObjectTable: {},
     componentPropsTable: {},
+    styleReceiverTable: {},
 };
 let hasComputedOnce = false;
 let resolutionConfigStamp;
@@ -1040,7 +1042,7 @@ const fileObjectContributions = new Map();
 function snapshotTables() {
     return Object.fromEntries(Object.entries(globalAgregatedTables).map(([key, value]) => [
         key,
-        { ...value },
+        key === 'styleReceiverTable' ? value : { ...value },
     ]));
 }
 function releaseFileObjects(filePath) {
@@ -1082,11 +1084,18 @@ function releaseObjectOwner(tableName, hash, filePath, table) {
 }
 function stripFileContributions(filePath, cached) {
     releaseFileObjects(filePath);
+    const receiverKeys = receiverKeysByFile.get(filePath);
+    if (receiverKeys) {
+        for (const key of receiverKeys)
+            delete globalAgregatedTables.styleReceiverTable[key];
+        receiverKeysByFile.delete(filePath);
+    }
     for (const [name, table] of Object.entries(globalAgregatedTables)) {
         if (name.endsWith('ObjectTable') ||
             name === 'createAtomicMapTable' ||
             name === 'createThemeSelectorTable' ||
-            name === 'componentPropsTable')
+            name === 'componentPropsTable' ||
+            name === 'styleReceiverTable')
             continue;
         for (const key of Object.keys(table))
             if (key.startsWith(`${filePath}-`))
@@ -2006,6 +2015,57 @@ function scanAll(scanCwd = process.cwd()) {
                     list.push(entry);
                 }
             };
+            const receiverTable = localTables.styleReceiverTable;
+            const registerReceiver = (name, fn) => {
+                if (name[0] !== name[0].toUpperCase())
+                    return;
+                const first = fn?.params?.[0];
+                const pattern = first?.pat ?? first;
+                const inner = pattern?.type === 'AssignmentPattern' ? pattern.left : pattern;
+                if (inner?.type !== 'ObjectPattern')
+                    return;
+                for (const property of inner.properties ?? []) {
+                    const key = property.type === 'AssignmentPatternProperty'
+                        ? property.key
+                        : property.type === 'KeyValuePatternProperty'
+                            ? property.key
+                            : undefined;
+                    if (!exports.t.isIdentifier(key))
+                        continue;
+                    const compKey = `${filePath}-${name}`;
+                    if (!receiverTable[compKey]) {
+                        receiverTable[compKey] = [];
+                        const owned = receiverKeysByFile.get(filePath);
+                        if (owned)
+                            owned.push(compKey);
+                        else
+                            receiverKeysByFile.set(filePath, [compKey]);
+                    }
+                    const props = receiverTable[compKey];
+                    if (!props.includes(key.value))
+                        props.push(key.value);
+                }
+            };
+            for (const statement of ast.body) {
+                const declaration = statement.type === 'ExportDeclaration'
+                    ? statement.declaration
+                    : statement;
+                if (declaration.type === 'FunctionDeclaration') {
+                    if (declaration.identifier)
+                        registerReceiver(declaration.identifier.value, declaration);
+                    continue;
+                }
+                if (declaration.type !== 'VariableDeclaration')
+                    continue;
+                for (const declarator of declaration.declarations) {
+                    const init = declarator.init;
+                    if (!exports.t.isIdentifier(declarator.id) || !init)
+                        continue;
+                    if (init.type === 'ArrowFunctionExpression' ||
+                        init.type === 'FunctionExpression')
+                        registerReceiver(declarator.id.value, init);
+                }
+            }
             traverse(ast, {
                 JSXOpeningElement({ node }) {
                     const compKey = resolveComponentKey(node.name, filePath, localImports);

package/dist/transform.js

@@ -2010,17 +2010,20 @@ const transformSource = async (env) => {
             if (node.name.type !== 'Identifier')
                 return;
             const attrName = node.name.value;
-            if (attrName !== styleProp) {
-                let compKey = null;
-                for (const [, val] of jsxOpeningElementMap) {
-                    const found = val.attributes
-                        .filter((a) => a.type === 'JSXAttribute')
-                        .find((a) => a.span.start === node.span.start);
-                    if (found) {
-                        compKey = val.compKey;
-                        break;
-                    }
+            let compKey = null;
+            for (const [, val] of jsxOpeningElementMap) {
+                const found = val.attributes
+                    .filter((a) => a.type === 'JSXAttribute')
+                    .find((a) => a.span.start === node.span.start);
+                if (found) {
+                    compKey = val.compKey;
+                    break;
                 }
+            }
+            const receivesStyleProp = Boolean(compKey &&
+                scannedTables.styleReceiverTable?.[compKey]?.includes(attrName));
+            let relayed = false;
+            if (attrName !== styleProp || receivesStyleProp) {
                 if (compKey) {
                     if (node.value?.type === 'JSXExpressionContainer')
                         assertNoStyleArraySpread(node.value.expression);
@@ -2081,23 +2084,27 @@ const transformSource = async (env) => {
                         (0, parser_1.traverse)(expr, {
                             MemberExpression({ node: subNode }) {
                                 if (replaceWithKey(subNode)) {
+                                    relayed = true;
                                     excludeSubtreeSpans(subNode);
                                 }
                             },
                             ArrayExpression({ node: subNode }) {
                                 if (replaceWithKey(subNode)) {
+                                    relayed = true;
                                     excludeSubtreeSpans(subNode);
                                 }
                             },
                             CallExpression({ node: subNode }) {
                                 if (replaceWithKey(subNode)) {
+                                    relayed = true;
                                     excludeSubtreeSpans(subNode);
                                 }
                             },
                         });
                     }
                 }
-                return;
+                if (attrName !== styleProp || relayed)
+                    return;
             }
             if (!node.value || node.value.type !== 'JSXExpressionContainer')
                 return;

package/dist/types.d.ts

@@ -48,6 +48,7 @@ export interface Tables {
     createStaticHashTable: CreateStaticHashTable;
     createStaticObjectTable: CreateStaticObjectTable;
     componentPropsTable?: Record<string, Record<string, TableEntry[]>>;
+    styleReceiverTable?: Record<string, string[]>;
 }
 export type CreateTheme = {
     [key: string]: {

package/package.json

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