@vobs/compiler 1.2.2 → 1.3.1

package/dist/compile.cjs

@@ -93,7 +93,8 @@ function compileWithSourceMap(code, options = {}) {
     sourceLocation: options.sourceLocation ?? true,
     stateAliases: collectStateAliases(sourceFile),
     localBindings: collectLocallyDeclaredNames(sourceFile),
-    diagnostics: []
+    diagnostics: [],
+    hmrModuleId: options.hmrModuleId ?? null
   };
   const cleanFilename = filename.split(/[?#]/u, 1)[0] || filename;
   const diagnostics = import_typescript.default.transpileModule(code, {
@@ -119,14 +120,15 @@ function compileWithSourceMap(code, options = {}) {
   }
   for (const plugin of plugins) sourceFile = transformPluginNodes(sourceFile, plugin, context);
   const statements = sourceFile.statements.map(
-    (statement) => import_typescript.default.isImportDeclaration(statement) ? rebuildImport(state, statement) : transformStatement(state, statement)
+    (statement) => import_typescript.default.isImportDeclaration(statement) ? rebuildImport(state, statement) : transformStatement(state, statement, true)
   );
   const templateDeclarations = createTemplateDeclarations(state);
-  const resultFile = import_typescript.default.factory.updateSourceFile(sourceFile, [
+  let resultFile = import_typescript.default.factory.updateSourceFile(sourceFile, [
     ...createRuntimeImports(state),
     ...templateDeclarations,
     ...statements
   ]);
+  resultFile = transformResidualJsx(state, resultFile);
   const generated = import_typescript.default.createPrinter().printFile(resultFile);
   return {
     code: generated,
@@ -408,7 +410,7 @@ function rebuildImport(state, node) {
   ), node);
 }
 __name(rebuildImport, "rebuildImport");
-function transformStatement(state, node) {
+function transformStatement(state, node, moduleScope = false) {
   if (import_typescript.default.isFunctionDeclaration(node) && node.body) {
     return tagStatement(state, import_typescript.default.factory.updateFunctionDeclaration(
       node,
@@ -421,7 +423,7 @@ function transformStatement(state, node) {
       transformBlock(state, node.body)
     ), node);
   }
-  if (import_typescript.default.isVariableStatement(node)) return transformVariableStatement(state, node);
+  if (import_typescript.default.isVariableStatement(node)) return transformVariableStatement(state, node, moduleScope);
   if (import_typescript.default.isExportAssignment(node) && containsJsx(node.expression)) {
     return tagStatement(state, import_typescript.default.factory.updateExportAssignment(node, node.modifiers, transformEmbeddedExpression(state, node.expression)), node);
   }
@@ -434,7 +436,7 @@ function transformStatement(state, node) {
   return node;
 }
 __name(transformStatement, "transformStatement");
-function transformVariableStatement(state, node) {
+function transformVariableStatement(state, node, moduleScope = false) {
   let changed = false;
   const declarations = node.declarationList.declarations.map((declaration) => {
     const initializer = declaration.initializer;
@@ -442,6 +444,8 @@ function transformVariableStatement(state, node) {
     let nextInitializer = inferStateDebugName(state, declaration, initializer) ?? initializer;
     if (containsJsx(nextInitializer)) {
       nextInitializer = transformEmbeddedExpression(state, nextInitializer);
+    } else if (moduleScope && state.hmrModuleId !== null) {
+      nextInitializer = wrapStateWithHmrRef(state, declaration, nextInitializer) ?? nextInitializer;
     }
     if (nextInitializer === initializer) return declaration;
     changed = true;
@@ -479,6 +483,29 @@ function inferStateDebugName(state, declaration, initializer) {
   ]);
 }
 __name(inferStateDebugName, "inferStateDebugName");
+function wrapStateWithHmrRef(state, declaration, initializer) {
+  let call = initializer;
+  while (import_typescript.default.isParenthesizedExpression(call) || import_typescript.default.isAsExpression(call) || import_typescript.default.isTypeAssertionExpression(call) || import_typescript.default.isSatisfiesExpression(call)) {
+    call = call.expression;
+  }
+  if (!import_typescript.default.isCallExpression(call)) return void 0;
+  const callee = call.expression;
+  if (!import_typescript.default.isIdentifier(callee) || !state.stateAliases.has(callee.text)) return void 0;
+  if (state.localBindings.has(callee.text)) return void 0;
+  if (!import_typescript.default.isIdentifier(declaration.name)) return void 0;
+  return import_typescript.default.factory.createCallExpression(helperRef(state, "hmrStateRef"), void 0, [
+    import_typescript.default.factory.createStringLiteral(`${state.hmrModuleId}#${declaration.name.text}`),
+    import_typescript.default.factory.createArrowFunction(
+      void 0,
+      void 0,
+      [],
+      void 0,
+      import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.EqualsGreaterThanToken),
+      initializer
+    )
+  ]);
+}
+__name(wrapStateWithHmrRef, "wrapStateWithHmrRef");
 function containsJsx(expression) {
   let found = false;
   const visit = /* @__PURE__ */ __name((node) => {
@@ -739,6 +766,27 @@ function transformEmbeddedExpression(state, expression) {
   }
 }
 __name(transformEmbeddedExpression, "transformEmbeddedExpression");
+function transformResidualJsx(state, sourceFile) {
+  if (!containsJsx(sourceFile)) return sourceFile;
+  const result = import_typescript.default.transform(sourceFile, [(context) => (root) => {
+    const visit = /* @__PURE__ */ __name((node) => {
+      if (import_typescript.default.isReturnStatement(node) && node.expression && containsJsx(node.expression)) {
+        return import_typescript.default.factory.updateReturnStatement(node, transformEmbeddedExpression(state, node.expression));
+      }
+      if (isJsxExpression(node)) {
+        return transformJsxExpression(state, node);
+      }
+      return import_typescript.default.visitEachChild(node, visit, context);
+    }, "visit");
+    return import_typescript.default.visitNode(root, visit);
+  }]);
+  try {
+    return result.transformed[0];
+  } finally {
+    result.dispose();
+  }
+}
+__name(transformResidualJsx, "transformResidualJsx");
 function isStaticElement(tagName, attributes, children) {
   if (!import_typescript.default.isIdentifier(tagName) || !/^[a-z]/.test(tagName.text)) return false;
   for (const attribute of attributes.properties) {
@@ -991,36 +1039,52 @@ function createSourceLocation(node) {
 }
 __name(createSourceLocation, "createSourceLocation");
 function transformDynamicExpression(state, expression) {
+  const converted = convertDynamicNodeExpression(state, expression);
+  return converted ? createGetter(converted) : null;
+}
+__name(transformDynamicExpression, "transformDynamicExpression");
+function convertDynamicNodeExpression(state, expression) {
   if (import_typescript.default.isBinaryExpression(expression) && expression.operatorToken.kind === import_typescript.default.SyntaxKind.AmpersandAmpersandToken) {
     const right = unwrapExpression(expression.right);
-    if (!isJsxExpression(right)) return null;
-    return createGetter(import_typescript.default.factory.createConditionalExpression(
-      expression.left,
-      import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.QuestionToken),
-      transformJsxExpression(state, right),
-      import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.ColonToken),
-      import_typescript.default.factory.createNull()
-    ));
+    if (isJsxExpression(right)) {
+      return createNodeConditional(expression.left, transformJsxExpression(state, right), null);
+    }
+    const convertedRight = convertDynamicNodeExpression(state, right);
+    if (convertedRight) return createNodeConditional(expression.left, convertedRight, null);
+    return null;
   }
   if (import_typescript.default.isConditionalExpression(expression)) {
     const whenTrue = transformDynamicBranch(state, expression.whenTrue);
     const whenFalse = transformDynamicBranch(state, expression.whenFalse);
     if (!whenTrue && !whenFalse) return null;
-    return createGetter(import_typescript.default.factory.createConditionalExpression(
+    return import_typescript.default.factory.createConditionalExpression(
       expression.condition,
       import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.QuestionToken),
       whenTrue ?? import_typescript.default.factory.createNull(),
       import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.ColonToken),
       whenFalse ?? import_typescript.default.factory.createNull()
-    ));
+    );
   }
   return null;
 }
-__name(transformDynamicExpression, "transformDynamicExpression");
+__name(convertDynamicNodeExpression, "convertDynamicNodeExpression");
+function createNodeConditional(condition, whenTrue, whenFalse) {
+  return import_typescript.default.factory.createConditionalExpression(
+    condition,
+    import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.QuestionToken),
+    whenTrue,
+    import_typescript.default.factory.createToken(import_typescript.default.SyntaxKind.ColonToken),
+    whenFalse ?? import_typescript.default.factory.createNull()
+  );
+}
+__name(createNodeConditional, "createNodeConditional");
 function transformDynamicBranch(state, expression) {
   const branch = unwrapExpression(expression);
   if (isJsxExpression(branch)) return transformJsxExpression(state, branch);
   if (branch.kind === import_typescript.default.SyntaxKind.NullKeyword || branch.kind === import_typescript.default.SyntaxKind.FalseKeyword) return branch;
+  if (import_typescript.default.isConditionalExpression(branch) || import_typescript.default.isBinaryExpression(branch) && branch.operatorToken.kind === import_typescript.default.SyntaxKind.AmpersandAmpersandToken) {
+    return convertDynamicNodeExpression(state, branch);
+  }
   return null;
 }
 __name(transformDynamicBranch, "transformDynamicBranch");