@esportsplus/typescript 0.29.5 → 0.29.6

package/build/compiler/coordinator.js

@@ -92,7 +92,8 @@ function modify(code, file, pkg, options) {
     for (let i = 0, n = found.length; i < n; i++) {
         for (let [name, alias] of found[i].specifiers) {
             if (!remove || (!remove.has(name) && !remove.has(alias))) {
-                specifiers.add(name === alias ? name : `${name} as ${alias}`);
+                let base = name === alias ? name : `${name} as ${alias}`;
+                specifiers.add(found[i].typeOnly.has(name) ? `type ${base}` : base);
             }
         }
     }

package/build/compiler/imports.d.ts

@@ -2,6 +2,7 @@ import { ts } from '../index.js';
 type ImportInfo = {
     end: number;
     specifiers: Map<string, string>;
+    typeOnly: Set<string>;
     start: number;
 };
 type ModifyOptions = {

package/build/compiler/imports.js

@@ -15,14 +15,17 @@ const all = (file, pkg) => {
         if (!ts.isStringLiteral(moduleSpecifier) || moduleSpecifier.text !== pkg) {
             continue;
         }
-        let bindings = stmt.importClause?.namedBindings, specifiers = new Map();
+        let bindings = stmt.importClause?.namedBindings, declTypeOnly = stmt.importClause?.isTypeOnly ?? false, specifiers = new Map(), typeOnly = new Set();
         if (bindings && ts.isNamedImports(bindings)) {
             for (let j = 0, m = bindings.elements.length; j < m; j++) {
                 let element = bindings.elements[j], name = element.name.text, propertyName = element.propertyName?.text || name;
                 specifiers.set(propertyName, name);
+                if (declTypeOnly || element.isTypeOnly) {
+                    typeOnly.add(propertyName);
+                }
             }
         }
-        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(file) });
+        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(file), typeOnly });
     }
     return imports;
 };

package/package.json

@@ -43,7 +43,7 @@
   },
   "type": "module",
   "types": "build/index.d.ts",
-  "version": "0.29.5",
+  "version": "0.29.6",
   "scripts": {
     "bench:run": "vitest bench --run",
     "build": "tsc && tsc-alias",

package/pnpm-workspace.yaml

@@ -0,0 +1,6 @@
+# Approve dependency build scripts (pnpm errors on unapproved ones during install/publish) and trust
+# our own scope so freshly published first-party deps bypass the minimumReleaseAge gate.
+allowBuilds:
+  esbuild: true
+minimumReleaseAgeExclude:
+  - '@esportsplus/*'

package/src/compiler/coordinator.ts

@@ -136,7 +136,12 @@ function modify(code: string, file: ts.SourceFile, pkg: string, options: ModifyO
     for (let i = 0, n = found.length; i < n; i++) {
         for (let [name, alias] of found[i].specifiers) {
             if (!remove || (!remove.has(name) && !remove.has(alias))) {
-                specifiers.add(name === alias ? name : `${name} as ${alias}`);
+                let base = name === alias ? name : `${name} as ${alias}`;
+
+                // Preserve type-only specifiers with an inline `type` modifier so the merged import
+                // stays erasable — otherwise `import type { X }` re-emits as a runtime `import { X }`
+                // and fails at load time when X has no runtime export.
+                specifiers.add(found[i].typeOnly.has(name) ? `type ${base}` : base);
             }
         }
     }

package/src/compiler/imports.ts

@@ -4,6 +4,10 @@ import { ts } from '~/index';
 type ImportInfo = {
     end: number;
     specifiers: Map<string, string>;
+    // propertyName keys that were imported type-only, whether via a type-only clause
+    // (`import type { A }`) or an inline specifier (`import { type A }`). Preserved so a rewrite
+    // re-emits them as type imports instead of runtime imports.
+    typeOnly: Set<string>;
     start: number;
 };
 
@@ -43,7 +47,9 @@ const all = (file: ts.SourceFile, pkg: string): ImportInfo[] => {
         }
 
         let bindings = stmt.importClause?.namedBindings,
-            specifiers = new Map<string, string>();
+            declTypeOnly = stmt.importClause?.isTypeOnly ?? false,
+            specifiers = new Map<string, string>(),
+            typeOnly = new Set<string>();
 
         if (bindings && ts.isNamedImports(bindings)) {
             for (let j = 0, m = bindings.elements.length; j < m; j++) {
@@ -52,10 +58,14 @@ const all = (file: ts.SourceFile, pkg: string): ImportInfo[] => {
                     propertyName = element.propertyName?.text || name;
 
                 specifiers.set(propertyName, name);
+
+                if (declTypeOnly || element.isTypeOnly) {
+                    typeOnly.add(propertyName);
+                }
             }
         }
 
-        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(file) });
+        imports.push({ end: stmt.end, specifiers, start: stmt.getStart(file), typeOnly });
     }
 
     return imports;

package/tests/compiler/coordinator.test.ts

@@ -346,6 +346,23 @@ describe('coordinator.transform', () => {
         expect(result.code).not.toMatch(/import\s*\{[^}]*reactive[^}]*\}\s*from\s*'my-pkg'/);
     });
 
+    it('preserves a type-only import when rewriting a package\'s imports', () => {
+        let code = "import { html } from 'my-pkg';\nimport type { Renderable } from 'my-pkg';\nlet x = 1;",
+            file = parse(code),
+            program = makeProgram(file),
+            plugin = makePlugin(() => ({
+                imports: [{ namespace: 'NS', package: 'my-pkg', remove: ['html'] }]
+            })),
+            result = coordinator.transform([plugin], code, file, program, '/root', new Map());
+
+        expect(result.changed).toBe(true);
+        expect(result.code).toContain("import * as NS from 'my-pkg';");
+        // Renderable must stay type-only (import type { ... } or inline `type Renderable`) so it is
+        // erased at runtime — a runtime `import { Renderable }` fails when it has no runtime export.
+        expect(result.code).toMatch(/import\s+type\s*\{[^}]*Renderable|import\s*\{[^}]*type\s+Renderable/);
+        expect(result.code).not.toMatch(/import\s*\{\s*Renderable\s*\}\s*from\s*'my-pkg'/);
+    });
+
     // F-TEST-003: Import manipulation integration tests
 
     it('adds specifiers to existing import', () => {