@litsx/babel-preset-litsx 0.8.1 → 0.9.0

package/dist/index.cjs

@@ -10,16 +10,17 @@ require('@litsx/babel-plugin-transform-litsx-scoped-elements');
 require('./internal/transform-litsx-dom-refs.cjs');
 require('@litsx/babel-plugin-shared-hooks');
 require('./internal/transform-litsx-hooks.cjs');
+require('node:fs');
+require('node:path');
+require('@babel/traverse');
+require('@litsx/babel-parser');
 require('./internal/transform-litsx-renderer-props.cjs');
 require('@babel/plugin-syntax-jsx');
 require('@litsx/authoring');
-require('./shared/transform-litsx-element-candidates-JMFlPFXK.cjs');
+require('./shared/transform-litsx-element-candidates-D8pSZxpL.cjs');
 require('@babel/helper-plugin-utils');
-require('@babel/traverse');
-require('@litsx/babel-parser');
-require('node:fs');
-require('node:path');
 require('@litsx/typescript-session');
+require('./internal/transform-litsx-static-ir.cjs');
 require('module');
 
 function litsxPreset(api, options = {}) {

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":["../src/index.js"],"sourcesContent":["import { createLitsxPresetPlugins } from \"./pipeline.js\";\n\nexport { createLitsxPresetPlugins, detectLitsxSourceFeatures } from \"./pipeline.js\";\nexport {\n  createTransformLitsxComponentsPlugin,\n  setTypescriptModule,\n} from \"./pipeline.js\";\n\nexport default function litsxPreset(api, options = {}) {\n  api.assertVersion?.(7);\n\n  return {\n    plugins: createLitsxPresetPlugins(options),\n  };\n}\n"],"names":["createLitsxPresetPlugins"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAQe,SAAS,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,EAAE,EAAE;AACvD,EAAE,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC;;AAExB,EAAE,OAAO;AACT,IAAI,OAAO,EAAEA,iCAAwB,CAAC,OAAO,CAAC;AAC9C,GAAG;AACH;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":["../src/index.js"],"sourcesContent":["import { createLitsxPresetPlugins } from \"./pipeline.js\";\n\nexport { createLitsxPresetPlugins, detectLitsxSourceFeatures } from \"./pipeline.js\";\nexport {\n  createTransformLitsxComponentsPlugin,\n  setTypescriptModule,\n} from \"./pipeline.js\";\n\nexport default function litsxPreset(api, options = {}) {\n  api.assertVersion?.(7);\n\n  return {\n    plugins: createLitsxPresetPlugins(options),\n  };\n}\n"],"names":["createLitsxPresetPlugins"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAQe,SAAS,WAAW,CAAC,GAAG,EAAE,OAAO,GAAG,EAAE,EAAE;AACvD,EAAE,GAAG,CAAC,aAAa,GAAG,CAAC,CAAC;;AAExB,EAAE,OAAO;AACT,IAAI,OAAO,EAAEA,iCAAwB,CAAC,OAAO,CAAC;AAC9C,GAAG;AACH;;;;;;;;"}

package/dist/internal/transform-litsx-components.cjs

@@ -4,7 +4,8 @@ Object.defineProperty(exports, '__esModule', { value: true });
 
 var jsxSyntaxPlugin = require('@babel/plugin-syntax-jsx');
 var internal_transformLitsxProperties = require('./transform-litsx-properties.cjs');
-var transformLitsxElementCandidates = require('../shared/transform-litsx-element-candidates-JMFlPFXK.cjs');
+var transformLitsxElementCandidates = require('../shared/transform-litsx-element-candidates-D8pSZxpL.cjs');
+var internal_transformLitsxStaticIr = require('./transform-litsx-static-ir.cjs');
 var authoring = require('@litsx/authoring');
 require('module');
 require('@litsx/typescript-session');
@@ -248,6 +249,46 @@ function mergeStaticPropsIntoProperties(propertiesStatic, staticProps) {
   });
 }
 
+function normalizePropertiesIr(staticIr, renderStatements) {
+  const properties = {
+    inferred: (staticIr?.properties?.inferred || []).map((entry, index) => ({
+      index: entry.index ?? index,
+      expression: entry.expression ? t$9.cloneNode(entry.expression) : null,
+    })),
+    authored: (staticIr?.properties?.authored || []).map((entry, index) => ({
+      index: entry.index ?? index,
+      expression: entry.expression ? t$9.cloneNode(entry.expression) : null,
+    })),
+    legacy: (staticIr?.properties?.legacy || []).map((entry, index) => ({
+      index: entry.index ?? index,
+      expression: entry.expression ? t$9.cloneNode(entry.expression) : null,
+    })),
+  };
+
+  if (!staticIr && Array.isArray(renderStatements)) {
+    renderStatements.forEach((statement, index) => {
+      const propertyOptions = getStaticPropsExpression(statement);
+      if (!propertyOptions) return;
+
+      if (propertyOptions.__litsxHoistedProperties) {
+        properties.authored.push({
+          index,
+          expression: propertyOptions.expression,
+        });
+      } else {
+        properties.legacy.push({
+          index,
+          expression: propertyOptions,
+        });
+      }
+    });
+  }
+
+  properties.authored.sort((left, right) => left.index - right.index);
+  properties.legacy.sort((left, right) => left.index - right.index);
+  return properties;
+}
+
 function normalizeStylesTemplate(argument, functionPath) {
   if (t$9.isTemplateLiteral(argument)) {
     if (
@@ -625,28 +666,30 @@ function processStaticHoists({
   node,
   renderStatements,
   programPath,
-  propertiesStatic,
+  staticIr = null,
   classMembers,
   options = {},
   getOrCreateModuleStaticHoistSymbol,
 }) {
   const staticStyles = [];
-  const staticProps = [];
-  const staticHoists = [];
+  const propertiesIr = normalizePropertiesIr(staticIr, renderStatements);
+  const effectivePropertiesStatic = propertiesIr.inferred
+    .map((entry) => entry.expression)
+    .filter(Boolean);
+  const staticProps = propertiesIr.legacy
+    .map((entry) => entry.expression)
+    .filter(Boolean);
+  const staticHoists = propertiesIr.authored
+    .map((entry) => ({
+      name: "properties",
+      expression: entry.expression,
+    }));
   let lightDomRequested = options.defaultDomMode === "light";
 
   if (t$9.isBlockStatement(node.body)) {
     for (let index = renderStatements.length - 1; index >= 0; index -= 1) {
       const propertyOptions = getStaticPropsExpression(renderStatements[index]);
       if (propertyOptions) {
-        if (propertyOptions.__litsxHoistedProperties) {
-          staticHoists.unshift({
-            name: "properties",
-            expression: propertyOptions.expression,
-          });
-        } else {
-          staticProps.unshift(propertyOptions);
-        }
         renderStatements.splice(index, 1);
         continue;
       }
@@ -688,14 +731,14 @@ function processStaticHoists({
   }
 
   if (staticProps.length > 0) {
-    mergeStaticPropsIntoProperties(propertiesStatic, staticProps);
+    mergeStaticPropsIntoProperties(effectivePropertiesStatic, staticProps);
   }
 
   const hasHoistedProperties = staticHoists.some((entry) => entry.name === "properties");
-  if (propertiesStatic.length > 0 && !hasHoistedProperties) {
+  if (effectivePropertiesStatic.length > 0 && !hasHoistedProperties) {
     const classProperties = t$9.classProperty(
       t$9.identifier("properties"),
-      t$9.objectExpression(propertiesStatic),
+      t$9.objectExpression(effectivePropertiesStatic),
       null,
       [],
       false
@@ -739,7 +782,7 @@ function processStaticHoists({
       return createStaticHoistGetter(
         "properties",
         symbolId,
-        createPropertiesHoistResolver(propertiesStatic, staticProps, hoist.expression)
+        createPropertiesHoistResolver(effectivePropertiesStatic, staticProps, hoist.expression)
       );
     }
 
@@ -1605,7 +1648,6 @@ function createComponentClass({
 
   classNode._needsCss = needsCss;
   classNode._needsUnsafeCss = needsUnsafeCss;
-  classNode._litsxLightDom = lightDomRequested;
   classNode._needsCallbackRef = needsCallbackRef;
   return classNode;
 }
@@ -1693,6 +1735,42 @@ function createThisMemberExpression$2(propName) {
   return t$4.memberExpression(t$4.thisExpression(), t$4.identifier(propName));
 }
 
+function createPropsObjectExpression(bindingInfo, propertyMap = new Map()) {
+  if (
+    bindingInfo &&
+    typeof bindingInfo !== "object" &&
+    bindingInfo !== "props"
+  ) {
+    return null;
+  }
+
+  const propNames = new Set([
+    ...(bindingInfo && typeof bindingInfo === "object" && bindingInfo.kind === "alias"
+      ? Array.from(bindingInfo.properties?.keys?.() || [])
+      : []),
+    ...Array.from(propertyMap.keys?.() || []),
+  ]);
+  const properties = Array.from(propNames)
+    .filter((propName) => typeof propName === "string" && propName.length > 0)
+    .sort()
+    .map((propName) =>
+      t$4.objectProperty(
+        t$4.isValidIdentifier(propName) ? t$4.identifier(propName) : t$4.stringLiteral(propName),
+        createThisMemberExpression$2(propName)
+      )
+    );
+
+  return t$4.objectExpression(properties);
+}
+
+function isObjectDestructuringInitializer(refPath) {
+  return (
+    refPath.parentPath?.isVariableDeclarator() &&
+    refPath.parentKey === "init" &&
+    t$4.isObjectPattern(refPath.parentPath.node.id)
+  );
+}
+
 function transformJSXExpressions(jsxPath, bindings, state = null) {
   const localNames = Array.from(bindings.keys());
 
@@ -1830,10 +1908,20 @@ function replaceParamReferences(functionPath, bindings, propertyMap = new Map(),
           refPath.parentPath.isObjectProperty({ shorthand: true }) &&
           refPath.parentKey === "value"
         ) {
+          const propsObject = createPropsObjectExpression(bindingInfo, propertyMap);
+          if (propsObject) {
+            refPath.parentPath.node.shorthand = false;
+            refPath.replaceWith(propsObject);
+            return;
+          }
           return;
         }
 
-        refPath.replaceWith(t$4.thisExpression());
+        refPath.replaceWith(
+          isObjectDestructuringInitializer(refPath)
+            ? t$4.thisExpression()
+            : createPropsObjectExpression(bindingInfo, propertyMap) ?? t$4.thisExpression()
+        );
         return;
       }
 
@@ -1915,6 +2003,14 @@ function replaceParamReferences(functionPath, bindings, propertyMap = new Map(),
         }
       }
 
+      if (localName === "props") {
+        const propsObject = createPropsObjectExpression(bindingInfo, propertyMap);
+        if (propsObject) {
+          refPath.replaceWith(propsObject);
+          return;
+        }
+      }
+
       refPath.replaceWith(getReplacementForProp(targetProp || localName, refPath));
     });
   });
@@ -2442,6 +2538,7 @@ function createTransformFunctionToClassPlugin(defaultPluginOptions = {}) {
     setParamRewriteBabelTypes(t);
     setRendererCallsBabelTypes(t);
     transformLitsxElementCandidates.setElementCandidatesBabelTypes(t);
+    internal_transformLitsxStaticIr.setStaticIrBabelTypes(t);
     setRenderBodyBabelTypes(t);
     setProgramBabelTypes(t);
     const resolvedPluginOptions = {
@@ -2745,6 +2842,11 @@ function transformFunction(functionPath, programPath, className, options = {}) {
   const { node } = functionPath;
   const elementCandidates = transformLitsxElementCandidates.getAnnotatedElementCandidates(functionPath, programPath, options);
   const importedElementCandidates = transformLitsxElementCandidates.getAnnotatedImportedElementCandidates(functionPath, programPath, options);
+  const staticIr = internal_transformLitsxStaticIr.collectStaticIr({
+    functionPath,
+    elementCandidates,
+    importedElementCandidates,
+  });
   let resolvedName = className;
   if (!resolvedName && node && node.id && t.isIdentifier(node.id)) {
     resolvedName = node.id.name;
@@ -2766,6 +2868,7 @@ function transformFunction(functionPath, programPath, className, options = {}) {
     programPath,
     options
   );
+  internal_transformLitsxStaticIr.setStaticIrInferredProperties(staticIr, propertiesStatic);
 
   assertStaticHoistsStayTopLevel(functionPath);
   collectNativeClassNameWarnings(functionPath, options.warn, options);
@@ -2816,7 +2919,7 @@ function transformFunction(functionPath, programPath, className, options = {}) {
     node,
     renderStatements,
     programPath,
-    propertiesStatic,
+    staticIr,
     classMembers,
     options,
     getOrCreateModuleStaticHoistSymbol,
@@ -2842,25 +2945,10 @@ function transformFunction(functionPath, programPath, className, options = {}) {
     needsCallbackRef,
   });
 
-  if (classNode && elementCandidates.size) {
-    classNode._litsxElementCandidates &&= new Set(classNode._litsxElementCandidates);
-    const elementSet = classNode._litsxElementCandidates ||= new Set();
-    elementCandidates.forEach((candidate) => elementSet.add(candidate));
-  }
-
-  if (classNode && importedElementCandidates.length > 0) {
-    classNode._litsxImportedElementCandidates ||= [];
-    importedElementCandidates.forEach((candidate) => {
-      if (!classNode._litsxImportedElementCandidates.some(
-        (entry) =>
-          entry.sourceFile === candidate.sourceFile &&
-          entry.importedName === candidate.importedName &&
-          entry.tagName === candidate.tagName
-      )) {
-        classNode._litsxImportedElementCandidates.push(candidate);
-      }
-    });
-  }
+  internal_transformLitsxStaticIr.attachStaticIr(classNode, {
+    ...staticIr,
+    lightDom: lightDomRequested,
+  });
 
   return classNode;
 }