@dunx/transform 3.8.2 → 3.8.3

package/dist/{chunk-x4mcmdwj.js → chunk-9qq1p8f7.js}

@@ -84,6 +84,35 @@ var collectTypeOnlyNames = (program) => {
     names.delete(name);
   return names;
 };
+var boundNames = (program) => {
+  const names = new Set;
+  const bind = (node) => {
+    const name = nameOf(node);
+    if (name !== undefined)
+      names.add(name);
+  };
+  for (const statement of program.body ?? []) {
+    if (isImportDeclaration(statement)) {
+      for (const specifier of statement.specifiers) {
+        bind(specifier.local);
+      }
+      continue;
+    }
+    const declaration = statement.declaration ?? statement;
+    if (declaration.declare === true)
+      continue;
+    if (declaration.type === "VariableDeclaration") {
+      for (const declarator of declaration.declarations ?? []) {
+        bind(declarator.id);
+      }
+      continue;
+    }
+    if (isClassDeclaration(declaration) || declaration.type === "FunctionDeclaration" || declaration.type === "TSEnumDeclaration" || declaration.type === "TSModuleDeclaration") {
+      bind(declaration.id);
+    }
+  }
+  return names;
+};
 var collectTypeParameters = (klass) => {
   const names = new Set;
   if (klass.typeParameters === null)
@@ -120,7 +149,7 @@ var annotationOf = (param) => {
   return inner.typeAnnotation?.typeAnnotation;
 };
 var hasDefault = (param) => isAssignmentPattern(isParameterProperty(param) ? param.parameter : param);
-var entryFor = (source, param, erased) => {
+var entryFor = (source, param, erased, bound) => {
   const text = JSON.stringify(slice(source, param));
   const optional = hasDefault(param) ? ", optional: true" : "";
   const unresolved = `{ unresolved: ${text}${optional} }`;
@@ -129,8 +158,13 @@ var entryFor = (source, param, erased) => {
     return unresolved;
   const root = nameOf(rootOfTypeName(annotation.typeName));
   const cause = root === undefined ? undefined : erased.get(root);
-  if (cause === undefined)
-    return slice(source, annotation.typeName);
+  if (cause === undefined) {
+    const named = slice(source, annotation.typeName);
+    if (root === undefined || bound.has(root))
+      return named;
+    const missing = named === root ? `typeof ${root} === 'undefined'` : `typeof ${root} === 'undefined' || ${named} === undefined`;
+    return `${missing} ? ${unresolved} : ${named}`;
+  }
   return cause === "import-type" ? `{ unresolved: ${text}${optional}, typeOnly: ${JSON.stringify(root)} }` : unresolved;
 };
 var transform2 = (source, filename = "input.ts") => {
@@ -141,6 +175,7 @@ var transform2 = (source, filename = "input.ts") => {
   }
   const program = parsed.program;
   const typeOnly = collectTypeOnlyNames(program);
+  const bound = boundNames(program);
   const edits = [];
   const annotated = [];
   walk(program, (node) => {
@@ -152,7 +187,7 @@ var transform2 = (source, filename = "input.ts") => {
     const erased = erasedNames(typeOnly, node);
     const params = constructorParams(node);
     if (params.length > 0) {
-      const entries = params.map((param) => entryFor(source, param, erased));
+      const entries = params.map((param) => entryFor(source, param, erased, bound));
       annotated.push(name);
       edits.push({
         start: node.end,

package/dist/erased.d.ts

@@ -13,5 +13,16 @@ export type ErasureCause = 'import-type' | 'declared-type';
  * inline `type` specifiers, local interfaces and type aliases.
  */
 export declare const collectTypeOnlyNames: (program: Node) => ReadonlyMap<string, ErasureCause>;
+/**
+ * Every name this file binds **at runtime**: imported, or declared at the top
+ * level. Anything else a constructor annotation names is ambient.
+ *
+ * Two ways a name looks bound and is not, each of which would suppress
+ * `entryFor`'s guard and bring the `ReferenceError` back: a `declare`, which
+ * promises a runtime value this file does not create, and a binding nested in a
+ * function, which is not in scope at a constructor signature. Top-level
+ * statements only, for the second - a `walk` would collect it.
+ */
+export declare const boundNames: (program: Node) => ReadonlySet<string>;
 /** Every name in this file that a value position cannot use. */
 export declare const erasedNames: (typeOnly: ReadonlyMap<string, ErasureCause>, klass: ClassNode) => ReadonlyMap<string, ErasureCause>;

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   applyEdits2,
   transform2,
   depsPlugin2
-} from "./chunk-x4mcmdwj.js";
+} from "./chunk-9qq1p8f7.js";
 export {
   applyEdits2 as applyEdits,
   depsPlugin2 as depsPlugin,

package/dist/preload.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   depsPlugin2
-} from "./chunk-x4mcmdwj.js";
+} from "./chunk-9qq1p8f7.js";
 
 // src/preload.ts
 var {plugin } = globalThis.Bun;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dunx/transform",
-  "version": "3.8.2",
+  "version": "3.8.3",
   "description": "Load-time transform that records constructor dependencies for the dunx container",
   "keywords": [
     "bun",