@solidjs/babel-plugin 2.0.0-rc.17 → 2.0.0-rc.19

package/.turbo/turbo-build.log

@@ -7,4 +7,4 @@ src/shared/transform.ts -> src/dom/element.ts -> src/universal/element.ts -> src
 src/shared/transform.ts -> src/ssr/element.ts -> src/shared/transform.ts
 src/shared/transform.ts -> src/shared/component.ts -> src/shared/transform.ts
 src/shared/transform.ts -> src/shared/fragment.ts -> src/shared/transform.ts
-created index.js in 2.3s
+created index.js in 2.2s

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # @solidjs/babel-plugin
 
+## 2.0.0-rc.19
+
+### Patch Changes
+
+- 8cff139: Evaluated negative and non-finite numbers (`c={-1}`, `d={NaN}`) are static again. Since Babel 8 support, `evaluateAndInline` built them with `t.valueToNode`, which gives `-1` / `0 / 0` expressions rather than numeric literals, so they stopped being inlined into templates (SSR emitted `ssrAttribute("c", -1)` instead of `c="-1"`) and diverged from `@solidjs/compiler` (the parity probes' "exotic literal holes"). They are now NumericLiteral nodes again, built directly where @babel/types 8's builder would reject the value; both Babel majors print them as before.
+- 55c7329: Support `@babel/core` 8 alongside 7: the peer range is now `^7.20.12 || ^8.0.0`. SSR no longer reads `Scope#uids` (removed in Babel 8), evaluated negative or non-finite numbers are built with `valueToNode`, `import()` parsed as `ImportExpression` stays dynamic, and TSRX emits the AST shape of the running Babel major (type arguments, type parameter names, `import()`, enums, heritage). TSRX also keeps `import()` options and class method type parameters, which it dropped before.
+- 9e1edbc: A lone dynamic spread on an SSR element (`<label {...props()} />`) now defers behind a thunk like a spread beside other attributes, so it runs after the element's hydration key. A spread that created a memo shifted the element's key on the server only, and hydration missed the element (#4240).
+
+## 2.0.0-rc.18
+
 ## 2.0.0-rc.17
 
 ### Patch Changes

package/index.js

@@ -329,6 +329,13 @@ path)
   return hasStaticMarker(object.expression, path);
 }
 
+/** `import()`: an `ImportExpression` on Babel 8 (and 7 with
+ * `createImportExpressions`), a `CallExpression` with an `Import` callee
+ * otherwise. Checked by type so older `@babel/types` builds still match. */
+function isImportExpression(node) {
+  return node.type === "ImportExpression";
+}
+
 function isDynamic(
 path,
 { checkMember, checkTags, checkCallExpressions = true })
@@ -348,7 +355,8 @@ path,
   checkCallExpressions && (
   t__namespace.isCallExpression(expr) ||
   t__namespace.isOptionalCallExpression(expr) ||
-  t__namespace.isTaggedTemplateExpression(expr)))
+  t__namespace.isTaggedTemplateExpression(expr) ||
+  isImportExpression(expr)))
   {
     return true;
   }
@@ -391,6 +399,11 @@ path,
 
   let dynamic;
   const visitor = {
+    // `ImportExpression` is matched by type rather than visitor key: a Babel
+    // core older than 7.23 rejects visitors for node types it doesn't know.
+    enter(p) {
+      checkCallExpressions && isImportExpression(p.node) && (dynamic = true) && p.stop();
+    },
     Function(p) {
       if (t__namespace.isObjectMethod(p.node) && p.node.computed) {
         dynamic = isDynamic(p.get("key"), { checkMember, checkTags, checkCallExpressions });
@@ -945,6 +958,18 @@ const templateEscapes = new Map([
 ["\u2029", "\\u2029"]]
 );
 
+// A NumericLiteral for any evaluated number, so `-1` and `NaN` stay static
+// literals downstream. @babel/types 8's builder rejects negative and
+// non-finite values (`t.valueToNode` builds `-1` / `0 / 0` expressions
+// instead), so those are built as plain nodes; generators print them as
+// `-1` / `NaN` / `Infinity`, as Babel 7's builder did.
+function numberLiteral(value) {
+  if (value >= 0 && Number.isFinite(value) && !Object.is(value, -0)) return t__namespace.numericLiteral(value);
+  const node = { type: "NumericLiteral", value };
+  if (Object.is(value, -0)) node.extra = { raw: "-0", rawValue: -0 };
+  return node;
+}
+
 function evaluateAndInline(
 value,
 valueNode)
@@ -969,7 +994,7 @@ valueNode)
       if (typeof r.value === "string") {
         valueNode.replaceWith(t__namespace.stringLiteral(r.value));
       } else if (typeof r.value === "number") {
-        valueNode.replaceWith(t__namespace.numericLiteral(r.value));
+        valueNode.replaceWith(numberLiteral(r.value));
       } else if (typeof r.value === "boolean") {
         valueNode.replaceWith(t__namespace.booleanLiteral(r.value));
       }
@@ -2116,7 +2141,7 @@ info = {})
         }
         if (value)
         a.get("value").replaceWith(
-          t$1.jSXExpressionContainer(t$1.callExpression(t$1.arrowFunctionExpression([], value), []))
+          t$1.jsxExpressionContainer(t$1.callExpression(t$1.arrowFunctionExpression([], value), []))
         );
       }
     });
@@ -2868,7 +2893,7 @@ results)
       (type = typeof evaluated) === "string" || type === "number" || type === "boolean"))
       {
         if (type === "number" && key.startsWith("prop:")) {
-          value = t$1.jsxExpressionContainer(t$1.numericLiteral(evaluated));
+          value = t$1.jsxExpressionContainer(numberLiteral(evaluated));
         } else if (type === "boolean") {
           value = t$1.jsxExpressionContainer(t$1.booleanLiteral(evaluated));
         } else value = t$1.stringLiteral(String(evaluated));
@@ -4306,8 +4331,10 @@ function hoistProps(program, config) {
   // program scope's `uids` (the names generateUid handed out — `hasUid` is
   // how a compiler temp is told from user code below) and `data` (imports,
   // templates, events — what postprocess is about to place); both survive.
-  const uids = program.scope.uids;
+  const scope = program.scope;
+  const uids = scope.uidsSet ? new Set(scope.uidsSet) : scope.uids;
   program.scope.crawl();
+  if (uids instanceof Set) for (const name of uids) scope.uidsSet.add(name);else
   Object.assign(program.scope.uids, uids);
   program.scope.data = data;
 
@@ -5780,7 +5807,15 @@ path,
     refs.push(node.value.expression);
   }
   if (propAttributes.length === 1 && t.isJSXSpreadAttribute(propAttributes[0].node)) {
-    props = [propAttributes[0].node.argument];
+    // A lone dynamic spread defers behind a thunk too (#4240): see the
+    // source loop below. `ssrElement` calls a function props argument after
+    // allocating the key.
+    const argument = propAttributes[0].node.argument;
+    props = [
+    isDynamic(propAttributes[0].get("argument"), { checkMember: true }) ?
+    inlineCallExpression(argument) :
+    argument];
+
   } else {
     props = [];
     let runningObject = [],
@@ -5929,7 +5964,8 @@ function callsOutsideFunctions(node) {
   t.isCallExpression(node) ||
   t.isOptionalCallExpression(node) ||
   t.isNewExpression(node) ||
-  t.isTaggedTemplateExpression(node))
+  t.isTaggedTemplateExpression(node) ||
+  isImportExpression(node))
 
   return true;
   if (t.isFunction(node)) return false;
@@ -16375,6 +16411,16 @@ const STRIP_KEYS = new Set([
 "directive"]
 );
 
+/** Which Babel AST shape to emit. Babel 8 keeps `typeArguments`,
+ * `ImportExpression`, Identifier type-parameter names and `TSEnumBody`;
+ * Babel 7 wants the older forms. Set for the length of one `toBabelFile`. */
+let babel8 = false;
+
+/** The key Babel expects for a node's type arguments. */
+function typeArgsKey() {
+  return babel8 ? "typeArguments" : "typeParameters";
+}
+
 function isNode$2(value) {
   return (
     typeof value === "object" &&
@@ -16401,19 +16447,32 @@ function convertValue(value) {
 }
 
 /** Shallow-map every kept key, renaming typescript-eslint's `typeArguments`
- * to Babel 7's `typeParameters` along the way. */
+ * to Babel 7's `typeParameters` along the way (Babel 8 keeps the name). */
 function convertGeneric(node, overrideType) {
   const out = { type: overrideType ?? node.type };
   copyLoc(node, out);
   for (const key of Object.keys(node)) {
     if (STRIP_KEYS.has(key)) continue;
     const outKey =
-    key === "typeArguments" && node.typeParameters === undefined ? "typeParameters" : key;
+    !babel8 && key === "typeArguments" && node.typeParameters === undefined ?
+    "typeParameters" :
+    key;
     out[outKey] = convertValue(node[key]);
   }
   return out;
 }
 
+/** Convert a node whose type arguments typescript-eslint spells
+ * `typeParameters`, moving them to the key the target Babel expects. */
+function convertTypeArgsHolder(node, type) {
+  const out = convertGeneric(node, type);
+  const args = out.typeParameters ?? out.typeArguments;
+  delete out.typeParameters;
+  delete out.typeArguments;
+  if (args !== undefined) out[typeArgsKey()] = args;
+  return out;
+}
+
 function convertLiteral(node) {
   const out = {};
   copyLoc(node, out);
@@ -16506,7 +16565,7 @@ function convertChainLink(node) {
         };
         copyLoc(node, out);
         if (node.typeParameters !== undefined || node.typeArguments !== undefined) {
-          out.typeParameters = convertValue(node.typeParameters ?? node.typeArguments);
+          out[typeArgsKey()] = convertValue(node.typeParameters ?? node.typeArguments);
         }
         return out;
       }
@@ -16589,6 +16648,9 @@ function convertNode(node) {
         };
         copyLoc(node, out);
         convertFunctionParts(fn, out);
+        if (node.typeParameters != null && out.typeParameters === undefined) {
+          out.typeParameters = convertValue(node.typeParameters);
+        }
         if (node.accessibility !== undefined) out.accessibility = node.accessibility;
         if (node.override !== undefined) out.override = node.override;
         if (node.optional !== undefined) out.optional = node.optional;
@@ -16631,10 +16693,22 @@ function convertNode(node) {
       return convertChainLink(node.expression);
 
     case "ImportExpression":{
+        // `@tsrx/core` puts the options object in `arguments[0]`; acorn uses `options`.
+        const options = node.options ?? node.arguments?.[0];
+        if (babel8) {
+          const out = {
+            type: "ImportExpression",
+            source: convertValue(node.source),
+            options: options != null ? convertValue(options) : null
+          };
+          if (node.phase != null) out.phase = node.phase;
+          copyLoc(node, out);
+          return out;
+        }
         const importCallee = { type: "Import" };
         copyLoc(node, importCallee);
         const args = [convertValue(node.source)];
-        if (node.options != null) args.push(convertValue(node.options));
+        if (options != null) args.push(convertValue(options));
         const out = {
           type: "CallExpression",
           callee: importCallee,
@@ -16653,12 +16727,71 @@ function convertNode(node) {
 
     case "TSTypeParameter":{
         const out = convertGeneric(node);
-        if (isNode$2(out.name)) out.name = out.name.name;
+        if (babel8) {
+          if (typeof out.name === "string") {
+            const id = { type: "Identifier", name: out.name };
+            copyLoc(node, id);
+            out.name = id;
+          }
+        } else if (isNode$2(out.name)) out.name = out.name.name;
         return out;
       }
 
     case "TSInterfaceHeritage":
-      return convertGeneric(node, "TSExpressionWithTypeArguments");
+      return convertTypeArgsHolder(
+        node,
+        babel8 ? "TSInterfaceHeritage" : "TSExpressionWithTypeArguments"
+      );
+
+    // `implements` entries arrive in the pre-split typescript-eslint shape.
+    case "TSExpressionWithTypeArguments":
+    case "TSClassImplements":
+      return convertTypeArgsHolder(
+        node,
+        babel8 ? "TSClassImplements" : "TSExpressionWithTypeArguments"
+      );
+
+    case "ClassDeclaration":
+    case "ClassExpression":{
+        const out = convertGeneric(node);
+        const superArgs = out.superTypeParameters ?? out.superTypeArguments;
+        delete out.superTypeParameters;
+        delete out.superTypeArguments;
+        if (superArgs !== undefined) {
+          out[babel8 ? "superTypeArguments" : "superTypeParameters"] = superArgs;
+        }
+        return out;
+      }
+
+    case "TSInterfaceDeclaration":{
+        const out = convertGeneric(node);
+        // Interface heritage can arrive in the class-implements shape.
+        if (babel8 && Array.isArray(out.extends)) {
+          for (const heritage of out.extends) {
+            heritage.type = "TSInterfaceHeritage";
+          }
+        }
+        return out;
+      }
+
+    case "TSImportType":{
+        const out = convertGeneric(node);
+        if (babel8 && out.argument !== undefined) {
+          out.source = out.argument;
+          delete out.argument;
+        }
+        return out;
+      }
+
+    case "TSEnumDeclaration":{
+        const out = convertGeneric(node);
+        if (babel8 && out.body === undefined) {
+          const body = { type: "TSEnumBody", members: out.members };
+          delete out.members;
+          out.body = body;
+        }
+        return out;
+      }
 
     case "TSAbstractMethodDefinition":
     case "TSAbstractPropertyDefinition":
@@ -16681,15 +16814,20 @@ function convertNode(node) {
   }
 }
 
-function toBabelFile(program) {
-  const file = {
-    type: "File",
-    program: convertNode(program),
-    comments: [],
-    tokens: []
-  };
-  copyLoc(program, file);
-  return file;
+function toBabelFile(program, babelMajor = 7) {
+  babel8 = babelMajor >= 8;
+  try {
+    const file = {
+      type: "File",
+      program: convertNode(program),
+      comments: [],
+      tokens: []
+    };
+    copyLoc(program, file);
+    return file;
+  } finally {
+    babel8 = false;
+  }
 }
 
 /**
@@ -17256,7 +17394,7 @@ function isTsrxSource(syntax, filename) {
 
 /** Parse TSRX source text into a Babel `File` with all TSRX constructs
  * lowered to Solid builtIn JSX. */
-function parseTsrx(code, filename) {
+function parseTsrx(code, filename, babelMajor = 7) {
   const tsrx = loadTsrxCore();
   const program = tsrx.parseModule(code, filename ?? "module.tsrx");
   rejectAuthoredLazyDestructuring(program);
@@ -17266,7 +17404,7 @@ function parseTsrx(code, filename) {
 
   desugarProgram(program);
 
-  const file = toBabelFile(program);
+  const file = toBabelFile(program, babelMajor);
   // Babel's default AST clone preserves enumerable string keys. Program.enter
   // lifts this temporary payload into transform metadata and removes it from
   // the AST, avoiding mutable plugin-factory state (and concurrent-run races).
@@ -17275,7 +17413,7 @@ function parseTsrx(code, filename) {
 }
 
 var index = (
-_api,
+api,
 options = {}) =>
 
 
@@ -17283,12 +17421,14 @@ options = {}) =>
 
 
 {
+  // TSRX builds its own AST, so it has to match the running core's shape.
+  const babelMajor = parseInt(api?.version ?? "7", 10) || 7;
   return {
     name: "@solidjs/babel-plugin",
     inherits: SyntaxJSX.default,
     parserOverride(code, parserOpts, parse) {
       if (isTsrxSource(options.syntax, parserOpts?.sourceFileName)) {
-        return parseTsrx(code, parserOpts?.sourceFileName);
+        return parseTsrx(code, parserOpts?.sourceFileName, babelMajor);
       }
       return parse(code, parserOpts);
     },

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@solidjs/babel-plugin",
   "description": "Babel compiler plugin for Solid templates",
-  "version": "2.0.0-rc.17",
+  "version": "2.0.0-rc.19",
   "author": "Ryan Carniato",
   "license": "MIT",
   "repository": {
@@ -27,7 +27,7 @@
     "parse5": "^7.1.2"
   },
   "peerDependencies": {
-    "@babel/core": "^7.20.12",
+    "@babel/core": "^7.20.12 || ^8.0.0",
     "@tsrx/core": "0.1.63"
   },
   "peerDependenciesMeta": {