signalium 2.2.3 → 2.3.0

package/dist/esm/production/transform/index.js

@@ -19,53 +19,56 @@ const createTransformedImports = (defaultImports, additionalImports, globalImpor
   return transformedImports;
 };
 function createSignaliumAsyncTransform(api, opts) {
-  const transformedImports = createTransformedImports(
-    [
-      ["callback", ["signalium"]],
-      ["reactive", ["signalium"]],
-      ["reactiveMethod", ["signalium"]],
-      ["relay", ["signalium"]],
-      ["task", ["signalium"]],
-      ["watcher", ["signalium"]]
-    ],
-    opts?.transformedImports,
-    opts?.importPaths
-  );
+  const transformedImports = createTransformedImports([
+    ["callback", ["signalium"]],
+    ["reactive", ["signalium"]],
+    ["reactiveMethod", ["signalium"]],
+    ["relay", ["signalium"]],
+    ["task", ["signalium"]],
+    ["watcher", ["signalium"]]
+  ], opts?.transformedImports, opts?.importPaths);
   const t = api.types;
   const isTrackedImport = (localName, path) => {
     const binding = path.scope.getBinding(localName);
-    if (!binding || !t.isImportSpecifier(binding.path.node)) return false;
+    if (!binding || !t.isImportSpecifier(binding.path.node))
+      return false;
     const importSpec = binding.path.node;
     const importedName = importSpec.imported.name;
     const importDecl = binding.path.parent;
-    if (!t.isImportDeclaration(importDecl)) return false;
+    if (!t.isImportDeclaration(importDecl))
+      return false;
     const importPaths = transformedImports.get(importedName);
-    if (!importPaths) return false;
-    return importPaths.some(
-      (p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value)
-    );
+    if (!importPaths)
+      return false;
+    return importPaths.some((p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value));
   };
   const isReactiveCall = (path) => {
-    if (!t.isCallExpression(path.node)) return false;
+    if (!t.isCallExpression(path.node))
+      return false;
     const callee = path.node.callee;
-    if (!t.isIdentifier(callee)) return false;
+    if (!t.isIdentifier(callee))
+      return false;
     return isTrackedImport(callee.name, path);
   };
   const isWithinTrackedCall = (path) => {
     let current = path.parentPath;
     while (current) {
-      if (current.isCallExpression() && isReactiveCall(current)) return true;
+      if (current.isCallExpression() && isReactiveCall(current))
+        return true;
       current = current.parentPath;
     }
     return false;
   };
   function convertReactiveToGenerator(path) {
-    if (!isWithinTrackedCall(path)) return;
-    if (!path.node.async) return;
+    if (!isWithinTrackedCall(path))
+      return;
+    if (!path.node.async)
+      return;
     path.traverse({
       AwaitExpression(awaitPath) {
         const funcParent = awaitPath.getFunctionParent();
-        if (funcParent?.node !== path.node) return;
+        if (funcParent?.node !== path.node)
+          return;
         awaitPath.replaceWith(t.yieldExpression(awaitPath.node.argument));
       }
     });
@@ -103,37 +106,37 @@ function signaliumAsyncTransform(apiOrOpts, maybeOpts) {
   return (api) => createSignaliumAsyncTransform(api, apiOrOpts);
 }
 function createSignaliumCallbackTransform(api, opts) {
-  const transformedImports = createTransformedImports(
-    [
-      ["component", ["signalium/react"]],
-      ["reactive", ["signalium"]],
-      ["reactiveMethod", ["signalium"]],
-      ["relay", ["signalium"]],
-      ["task", ["signalium"]]
-    ],
-    opts?.transformedImports,
-    opts?.importPaths
-  );
+  const transformedImports = createTransformedImports([
+    ["component", ["signalium/react"]],
+    ["reactive", ["signalium"]],
+    ["reactiveMethod", ["signalium"]],
+    ["relay", ["signalium"]],
+    ["task", ["signalium"]],
+    ["watcher", ["signalium"]]
+  ], opts?.transformedImports, opts?.importPaths);
   const t = api.types;
   const callbackImportPath = opts?.callbackImportPath ?? "signalium";
   const isTrackedImport = (localName, path) => {
     const binding = path.scope.getBinding(localName);
-    if (!binding || !t.isImportSpecifier(binding.path.node)) return false;
+    if (!binding || !t.isImportSpecifier(binding.path.node))
+      return false;
     const importSpec = binding.path.node;
     const importedName = importSpec.imported.name;
     const importDecl = binding.path.parent;
-    if (!t.isImportDeclaration(importDecl)) return false;
+    if (!t.isImportDeclaration(importDecl))
+      return false;
     const importPaths = transformedImports.get(importedName);
-    if (!importPaths) return false;
-    const matches = importPaths.find(
-      (p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value)
-    );
+    if (!importPaths)
+      return false;
+    const matches = importPaths.find((p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value));
     return matches ? typeof matches === "string" ? matches : importDecl.source.value : false;
   };
   const isTargetWrapperCall = (path) => {
-    if (!t.isCallExpression(path.node)) return false;
+    if (!t.isCallExpression(path.node))
+      return false;
     const callee = path.node.callee;
-    if (!t.isIdentifier(callee)) return false;
+    if (!t.isIdentifier(callee))
+      return false;
     return !!isTrackedImport(callee.name, path);
   };
   function isIdentifierInTypePosition(refPath) {
@@ -143,7 +146,8 @@ function createSignaliumCallbackTransform(api, opts) {
       const nodeType = current.node.type;
       if (nodeType && nodeType.startsWith("TS")) {
         if (current.isTSAsExpression() || current.isTSSatisfiesExpression?.() || current.isTSNonNullExpression() || current.isTSInstantiationExpression?.()) {
-          if (child.key === "expression") return false;
+          if (child.key === "expression")
+            return false;
           return true;
         }
         return true;
@@ -155,9 +159,11 @@ function createSignaliumCallbackTransform(api, opts) {
   }
   function ensureCallbackIdentifier(programPath) {
     for (const bodyPath of programPath.get("body")) {
-      if (!bodyPath.isImportDeclaration()) continue;
+      if (!bodyPath.isImportDeclaration())
+        continue;
       const importDecl2 = bodyPath.node;
-      if (importDecl2.source.value !== callbackImportPath) continue;
+      if (importDecl2.source.value !== callbackImportPath)
+        continue;
       for (const spec of importDecl2.specifiers) {
         if (spec.type === "ImportSpecifier") {
           const ispec = spec;
@@ -169,18 +175,17 @@ function createSignaliumCallbackTransform(api, opts) {
       }
     }
     for (const bodyPath of programPath.get("body")) {
-      if (!bodyPath.isImportDeclaration()) continue;
+      if (!bodyPath.isImportDeclaration())
+        continue;
       const node = bodyPath.node;
-      if (node.source.value !== callbackImportPath) continue;
+      if (node.source.value !== callbackImportPath)
+        continue;
       const localName2 = programPath.scope.generateUidIdentifier("callback").name;
       node.specifiers.push(t.importSpecifier(t.identifier(localName2), t.identifier("callback")));
       return localName2;
     }
     const localName = "callback";
-    const importDecl = t.importDeclaration(
-      [t.importSpecifier(t.identifier(localName), t.identifier("callback"))],
-      t.stringLiteral(callbackImportPath)
-    );
+    const importDecl = t.importDeclaration([t.importSpecifier(t.identifier(localName), t.identifier("callback"))], t.stringLiteral(callbackImportPath));
     const [first] = programPath.get("body");
     if (first) {
       first.insertBefore(importDecl);
@@ -196,18 +201,24 @@ function createSignaliumCallbackTransform(api, opts) {
     innerFn.traverse({
       ReferencedIdentifier(refPath) {
         const nearestFn = refPath.getFunctionParent();
-        if (!nearestFn || nearestFn.node !== innerNode) return;
+        if (!nearestFn || nearestFn.node !== innerNode)
+          return;
         const name = refPath.node.name;
         const binding = refPath.scope.getBinding(name);
-        if (!binding) return;
-        if (isIdentifierInTypePosition(refPath)) return;
-        if (binding.scope.path.isProgram()) return;
+        if (!binding)
+          return;
+        if (isIdentifierInTypePosition(refPath))
+          return;
+        if (binding.scope.path.isProgram())
+          return;
         let declScope = binding.scope;
         while (declScope) {
-          if (declScope === innerScope) return;
+          if (declScope === innerScope)
+            return;
           declScope = declScope.parent;
         }
-        if (binding.kind === "param" && binding.scope === innerScope) return;
+        if (binding.kind === "param" && binding.scope === innerScope)
+          return;
         depNames.add(name);
       }
     });
@@ -217,10 +228,13 @@ function createSignaliumCallbackTransform(api, opts) {
     name: "signalium-transform-callback-wrapping",
     visitor: {
       CallExpression(callPath) {
-        if (!isTargetWrapperCall(callPath)) return;
+        if (!isTargetWrapperCall(callPath))
+          return;
         const arg0 = callPath.get("arguments")[0];
-        if (!arg0) return;
-        if (!(arg0.isFunctionExpression() || arg0.isArrowFunctionExpression())) return;
+        if (!arg0)
+          return;
+        if (!(arg0.isFunctionExpression() || arg0.isArrowFunctionExpression()))
+          return;
         const outerFn = arg0;
         const programPath = callPath.findParent((p) => p.isProgram());
         const callbackName = ensureCallbackIdentifier(programPath);
@@ -235,10 +249,12 @@ function createSignaliumCallbackTransform(api, opts) {
           // Initialize counters for any function-like node when first seen
           FunctionExpression: {
             enter(fnPath) {
-              if (!counters.has(fnPath.node)) counters.set(fnPath.node, 0);
+              if (!counters.has(fnPath.node))
+                counters.set(fnPath.node, 0);
             },
             exit(innerFnPath) {
-              if (innerFnPath.node === outerFn.node) return;
+              if (innerFnPath.node === outerFn.node)
+                return;
               const immediateParent = innerFnPath.parentPath;
               if (immediateParent && immediateParent.isCallExpression()) {
                 const callee = immediateParent.node.callee;
@@ -285,10 +301,12 @@ function createSignaliumCallbackTransform(api, opts) {
           },
           ArrowFunctionExpression: {
             enter(fnPath) {
-              if (!counters.has(fnPath.node)) counters.set(fnPath.node, 0);
+              if (!counters.has(fnPath.node))
+                counters.set(fnPath.node, 0);
             },
             exit(innerFnPath) {
-              if (innerFnPath.node === outerFn.node) return;
+              if (innerFnPath.node === outerFn.node)
+                return;
               const immediateParent = innerFnPath.parentPath;
               if (immediateParent && immediateParent.isCallExpression()) {
                 const callee = immediateParent.node.callee;
@@ -335,18 +353,14 @@ function createSignaliumCallbackTransform(api, opts) {
           },
           FunctionDeclaration: {
             enter(fnPath) {
-              if (!counters.has(fnPath.node)) counters.set(fnPath.node, 0);
+              if (!counters.has(fnPath.node))
+                counters.set(fnPath.node, 0);
             },
             exit(innerDeclPath) {
               const id = innerDeclPath.node.id;
-              if (!id) return;
-              const fnExpr = t.functionExpression(
-                id,
-                innerDeclPath.node.params,
-                innerDeclPath.node.body,
-                innerDeclPath.node.generator,
-                innerDeclPath.node.async
-              );
+              if (!id)
+                return;
+              const fnExpr = t.functionExpression(id, innerDeclPath.node.params, innerDeclPath.node.body, innerDeclPath.node.generator, innerDeclPath.node.async);
               const deps = Array.from(collectDeps(innerDeclPath));
               const parentFn = innerDeclPath.parentPath?.getFunctionParent() || outerFn;
               const argIndex = getNextIndexFor(parentFn.node);
@@ -362,17 +376,13 @@ function createSignaliumCallbackTransform(api, opts) {
           },
           ObjectMethod: {
             enter(fnPath) {
-              if (!counters.has(fnPath.node)) counters.set(fnPath.node, 0);
+              if (!counters.has(fnPath.node))
+                counters.set(fnPath.node, 0);
             },
             exit(innerMethodPath) {
-              if (innerMethodPath.node.kind !== "method") return;
-              const fnExpr = t.functionExpression(
-                null,
-                innerMethodPath.node.params,
-                innerMethodPath.node.body,
-                innerMethodPath.node.generator,
-                innerMethodPath.node.async
-              );
+              if (innerMethodPath.node.kind !== "method")
+                return;
+              const fnExpr = t.functionExpression(null, innerMethodPath.node.params, innerMethodPath.node.body, innerMethodPath.node.generator, innerMethodPath.node.async);
               const deps = Array.from(collectDeps(innerMethodPath));
               const parentFn = innerMethodPath.parentPath?.getFunctionParent() || outerFn;
               const argIndex = getNextIndexFor(parentFn.node);
@@ -402,51 +412,54 @@ function signaliumCallbackTransform(apiOrOpts, opts) {
 }
 const PROMISE_STATIC_METHODS = /* @__PURE__ */ new Set(["all", "race", "any", "allSettled", "resolve", "reject", "withResolvers"]);
 function createSignaliumPromiseMethodsTransform(api, opts) {
-  const transformedImports = createTransformedImports(
-    [
-      ["callback", ["signalium"]],
-      ["reactive", ["signalium"]],
-      ["reactiveMethod", ["signalium"]],
-      ["relay", ["signalium"]],
-      ["task", ["signalium"]]
-    ],
-    opts?.transformedImports,
-    opts?.importPaths
-  );
+  const transformedImports = createTransformedImports([
+    ["callback", ["signalium"]],
+    ["reactive", ["signalium"]],
+    ["reactiveMethod", ["signalium"]],
+    ["relay", ["signalium"]],
+    ["task", ["signalium"]],
+    ["watcher", ["signalium"]]
+  ], opts?.transformedImports, opts?.importPaths);
   const t = api.types;
   const promiseImportPath = opts?.promiseImportPath ?? "signalium";
   const isTrackedImport = (localName, path) => {
     const binding = path.scope.getBinding(localName);
-    if (!binding || !t.isImportSpecifier(binding.path.node)) return false;
+    if (!binding || !t.isImportSpecifier(binding.path.node))
+      return false;
     const importSpec = binding.path.node;
     const importedName = importSpec.imported.name;
     const importDecl = binding.path.parent;
-    if (!t.isImportDeclaration(importDecl)) return false;
+    if (!t.isImportDeclaration(importDecl))
+      return false;
     const importPaths = transformedImports.get(importedName);
-    if (!importPaths) return false;
-    return importPaths.some(
-      (p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value)
-    );
+    if (!importPaths)
+      return false;
+    return importPaths.some((p) => typeof p === "string" ? importDecl.source.value === p : p.test(importDecl.source.value));
   };
   const isReactiveCall = (path) => {
-    if (!t.isCallExpression(path.node)) return false;
+    if (!t.isCallExpression(path.node))
+      return false;
     const callee = path.node.callee;
-    if (!t.isIdentifier(callee)) return false;
+    if (!t.isIdentifier(callee))
+      return false;
     return isTrackedImport(callee.name, path);
   };
   const isWithinTrackedCall = (path) => {
     let current = path.parentPath;
     while (current) {
-      if (current.isCallExpression() && isReactiveCall(current)) return true;
+      if (current.isCallExpression() && isReactiveCall(current))
+        return true;
       current = current.parentPath;
     }
     return false;
   };
   function ensureReactivePromiseIdentifier(programPath) {
     for (const bodyPath of programPath.get("body")) {
-      if (!bodyPath.isImportDeclaration()) continue;
+      if (!bodyPath.isImportDeclaration())
+        continue;
       const importDecl2 = bodyPath.node;
-      if (importDecl2.source.value !== promiseImportPath) continue;
+      if (importDecl2.source.value !== promiseImportPath)
+        continue;
       for (const spec of importDecl2.specifiers) {
         if (spec.type === "ImportSpecifier") {
           const ispec = spec;
@@ -458,18 +471,17 @@ function createSignaliumPromiseMethodsTransform(api, opts) {
       }
     }
     for (const bodyPath of programPath.get("body")) {
-      if (!bodyPath.isImportDeclaration()) continue;
+      if (!bodyPath.isImportDeclaration())
+        continue;
       const node = bodyPath.node;
-      if (node.source.value !== promiseImportPath) continue;
+      if (node.source.value !== promiseImportPath)
+        continue;
       const localName2 = "ReactivePromise";
       node.specifiers.push(t.importSpecifier(t.identifier(localName2), t.identifier("ReactivePromise")));
       return localName2;
     }
     const localName = "ReactivePromise";
-    const importDecl = t.importDeclaration(
-      [t.importSpecifier(t.identifier(localName), t.identifier("ReactivePromise"))],
-      t.stringLiteral(promiseImportPath)
-    );
+    const importDecl = t.importDeclaration([t.importSpecifier(t.identifier(localName), t.identifier("ReactivePromise"))], t.stringLiteral(promiseImportPath));
     const [first] = programPath.get("body");
     if (first) {
       first.insertBefore(importDecl);
@@ -482,17 +494,24 @@ function createSignaliumPromiseMethodsTransform(api, opts) {
     name: "signalium-transform-reactive-promise-methods",
     visitor: {
       CallExpression(callPath) {
-        if (!isWithinTrackedCall(callPath)) return;
+        if (!isWithinTrackedCall(callPath))
+          return;
         const callee = callPath.node.callee;
-        if (!t.isMemberExpression(callee)) return;
-        if (callee.computed) return;
+        if (!t.isMemberExpression(callee))
+          return;
+        if (callee.computed)
+          return;
         const object = callee.object;
         const property = callee.property;
-        if (!t.isIdentifier(object, { name: "Promise" })) return;
-        if (callPath.scope.getBinding("Promise")) return;
-        if (!t.isIdentifier(property)) return;
+        if (!t.isIdentifier(object, { name: "Promise" }))
+          return;
+        if (callPath.scope.getBinding("Promise"))
+          return;
+        if (!t.isIdentifier(property))
+          return;
         const methodName = property.name;
-        if (!PROMISE_STATIC_METHODS.has(methodName)) return;
+        if (!PROMISE_STATIC_METHODS.has(methodName))
+          return;
         const programPath = callPath.findParent((p) => p.isProgram());
         const reactivePromiseId = ensureReactivePromiseIdentifier(programPath);
         const newCallee = t.memberExpression(t.identifier(reactivePromiseId), t.identifier(methodName));