@dunx/transform 2.5.0 → 3.0.1

package/dist/ast.d.ts

@@ -47,16 +47,30 @@ export interface ImportDeclaration extends Node {
     readonly specifiers: readonly Node[];
     readonly importKind: 'value' | 'type';
 }
+/**
+ * `ImportSpecifier`, `ImportDefaultSpecifier` and `ImportNamespaceSpecifier`.
+ * Only the first carries its own `importKind`; all three carry `local`, which is
+ * the name the file binds and the only field the erasure map needs.
+ */
 export interface ImportSpecifier extends Node {
-    readonly type: 'ImportSpecifier';
     readonly local: Identifier;
-    readonly importKind: 'value' | 'type';
+    readonly importKind?: 'value' | 'type';
+}
+export interface TSQualifiedName extends Node {
+    readonly type: 'TSQualifiedName';
+    readonly left: Node;
+    readonly right: Identifier;
+}
+export interface AssignmentPattern extends Node {
+    readonly type: 'AssignmentPattern';
+    readonly left: Node;
 }
 export declare const isIdentifier: (node: Node | null | undefined) => node is Identifier;
 export declare const isMethodDefinition: (node: Node | null | undefined) => node is MethodDefinition;
 export declare const isTypeReference: (node: Node | null | undefined) => node is TSTypeReference;
 export declare const isImportDeclaration: (node: Node | null | undefined) => node is ImportDeclaration;
-export declare const isImportSpecifier: (node: Node | null | undefined) => node is ImportSpecifier;
+export declare const isQualifiedName: (node: Node | null | undefined) => node is TSQualifiedName;
+export declare const isAssignmentPattern: (node: Node | null | undefined) => node is AssignmentPattern;
 export declare const isParameterProperty: (node: Node | null | undefined) => node is TSParameterProperty;
 /**
  * Declarations only. A `ClassExpression`'s own name is bound inside the class
@@ -71,3 +85,8 @@ export declare const isClassDeclaration: (node: Node) => node is ClassNode;
  */
 export declare const walk: (root: unknown, visit: (node: Node) => void) => void;
 export declare const nameOf: (node: Node | null | undefined) => string | undefined;
+/**
+ * The leftmost identifier of a type name. In `a.b.C` only `a` has to exist at
+ * runtime, so it is the only part the erasure map can answer for.
+ */
+export declare const rootOfTypeName: (node: Node) => Node;

package/dist/{chunk-41at0m5d.js → chunk-cfmpj4s2.js}

@@ -23,7 +23,8 @@ var isIdentifier = guard("Identifier");
 var isMethodDefinition = guard("MethodDefinition");
 var isTypeReference = guard("TSTypeReference");
 var isImportDeclaration = guard("ImportDeclaration");
-var isImportSpecifier = guard("ImportSpecifier");
+var isQualifiedName = guard("TSQualifiedName");
+var isAssignmentPattern = guard("AssignmentPattern");
 var isParameterProperty = guard("TSParameterProperty");
 var isClassDeclaration = (node) => node.type === "ClassDeclaration";
 var walk = (root, visit) => {
@@ -42,18 +43,33 @@ var walk = (root, visit) => {
     walk(child, visit);
 };
 var nameOf = (node) => isIdentifier(node) ? node.name : undefined;
+var rootOfTypeName = (node) => isQualifiedName(node) ? rootOfTypeName(node.left) : node;
 
 // src/erased.ts
+var mergedClassNames = (program) => {
+  const body = program.body ?? [];
+  const names = new Set;
+  for (const statement of body) {
+    const declaration = statement.declaration ?? statement;
+    if (!isClassDeclaration(declaration))
+      continue;
+    const name = declaration.id?.name;
+    if (name !== undefined)
+      names.add(name);
+  }
+  return names;
+};
 var collectTypeOnlyNames = (program) => {
   const names = new Map;
   walk(program, (node) => {
     if (isImportDeclaration(node)) {
       for (const specifier of node.specifiers) {
-        if (!isImportSpecifier(specifier))
+        const { local, importKind } = specifier;
+        if (node.importKind !== "type" && importKind !== "type")
           continue;
-        if (node.importKind === "type" || specifier.importKind === "type") {
-          names.set(specifier.local.name, "import-type");
-        }
+        const name = nameOf(local);
+        if (name !== undefined)
+          names.set(name, "import-type");
       }
       return;
     }
@@ -64,6 +80,8 @@ var collectTypeOnlyNames = (program) => {
         names.set(name, "declared-type");
     }
   });
+  for (const name of mergedClassNames(program))
+    names.delete(name);
   return names;
 };
 var collectTypeParameters = (klass) => {
@@ -91,23 +109,29 @@ var constructorParams = (klass) => {
   const found = klass.body.body.find((member) => isMethodDefinition(member) && nameOf(member.key) === "constructor");
   return isMethodDefinition(found) ? found.value.params : [];
 };
+var bindingOf = (param) => {
+  const named = isParameterProperty(param) ? param.parameter : param;
+  return isAssignmentPattern(named) ? named.left : named;
+};
 var annotationOf = (param) => {
-  const inner = isParameterProperty(param) ? param.parameter : param;
+  const inner = bindingOf(param);
   if (!isIdentifier(inner))
     return;
   return inner.typeAnnotation?.typeAnnotation;
 };
+var hasDefault = (param) => isAssignmentPattern(isParameterProperty(param) ? param.parameter : param);
 var entryFor = (source, param, erased) => {
   const text = JSON.stringify(slice(source, param));
-  const unresolved = `{ unresolved: ${text} }`;
+  const optional = hasDefault(param) ? ", optional: true" : "";
+  const unresolved = `{ unresolved: ${text}${optional} }`;
   const annotation = annotationOf(param);
   if (!annotation || !isTypeReference(annotation))
     return unresolved;
-  const token = slice(source, annotation.typeName);
-  const cause = erased.get(token);
+  const root = nameOf(rootOfTypeName(annotation.typeName));
+  const cause = root === undefined ? undefined : erased.get(root);
   if (cause === undefined)
-    return token;
-  return cause === "import-type" ? `{ unresolved: ${text}, typeOnly: ${JSON.stringify(token)} }` : unresolved;
+    return slice(source, annotation.typeName);
+  return cause === "import-type" ? `{ unresolved: ${text}${optional}, typeOnly: ${JSON.stringify(root)} }` : unresolved;
 };
 var transform = (source, filename = "input.ts") => {
   const parsed = parseSync(filename, source);
@@ -133,10 +157,7 @@ var transform = (source, filename = "input.ts") => {
       edits.push({
         start: node.end,
         end: node.end,
-        text: `
-Object.defineProperty(${name}, ${DEPS_KEY}, {
-` + `  value: () => [${entries.join(", ")}],
-});`
+        text: `;Object.defineProperty(${name}, ${DEPS_KEY}, ` + `{ value: () => [${entries.join(", ")}] });`
       });
     }
   });

package/dist/edits.d.ts

@@ -5,7 +5,8 @@ export interface Edit {
 }
 /**
  * Splices edits into the original text rather than reprinting the AST, so
- * everything untouched keeps its exact bytes - comments, formatting, and the
- * line numbers stack traces point at.
+ * everything untouched keeps its exact bytes. Line numbers survive too, but only
+ * because every edit this transform makes is a single line appended to one that
+ * already exists - splicing alone does not guarantee it.
  */
 export declare const applyEdits: (source: string, edits: readonly Edit[]) => string;

package/dist/index.js

@@ -3,7 +3,7 @@ import {
   applyEdits,
   depsPlugin,
   transform
-} from "./chunk-41at0m5d.js";
+} from "./chunk-cfmpj4s2.js";
 export {
   applyEdits,
   depsPlugin,

package/dist/preload.js

@@ -1,7 +1,7 @@
 // @bun
 import {
   depsPlugin
-} from "./chunk-41at0m5d.js";
+} from "./chunk-cfmpj4s2.js";
 
 // src/preload.ts
 var {plugin } = globalThis.Bun;

package/package.json

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