@amritk/generate-parsers 0.12.3 → 0.14.0

package/dist/helpers/collect-imports.js

@@ -2,11 +2,12 @@ import { refToFilename } from '@amritk/helpers/ref-to-filename';
 import { refToName } from '@amritk/helpers/ref-to-name';
 import { resolveRef } from '@amritk/helpers/resolve-ref';
 import { hasAdditionalProperties, hasAllOf, hasAnyOf, hasItems, hasOneOf, hasRef } from '@amritk/helpers/schema-guards';
-// Emit an explicit `.js` extension on the relative specifier. Node's ESM resolver
-// requires it (extensionless relative imports only work under a bundler or Bun),
-// and `./x.js` pointing at a sibling `x.ts` is the standard TS NodeNext form —
-// accepted by Bun, esbuild, webpack, and tsc alike.
-const getImportPathForFilename = (filename) => `./${filename}.js`;
+// Emit an explicit extension on the relative specifier. Node's ESM resolver
+// requires one (extensionless relative imports only work under a bundler or
+// Bun). `./x.js` pointing at a sibling `x.ts` is the standard TS NodeNext form
+// — accepted by Bun, esbuild, webpack, and tsc alike — while `./x.ts` is the
+// literal on-disk path Node's type stripping needs to run the sources directly.
+const getImportPathForFilename = (filename, ext) => `./${filename}.${ext}`;
 /**
  * Collects all import statements needed for a schema by finding $ref references
  * that are directly used in the type definition (from properties, items, etc.).
@@ -48,6 +49,32 @@ const getImportPathForFilename = (filename) => `./${filename}.js`;
  */
 export const collectImports = (schema, options) => {
     const typesOnly = options?.typesOnly === true;
+    const importExt = options?.importExt ?? 'js';
+    const importMap = new Map();
+    for (const [filename, typeName] of collectImportTargets(schema, options)) {
+        const importPath = getImportPathForFilename(filename, importExt);
+        // In types-only mode, omit the parser function import since there is no parser to call
+        const importStatement = typesOnly
+            ? `import type { ${typeName} } from '${importPath}';`
+            : `import { type ${typeName}, parse${typeName}, validate${typeName}Shape } from '${importPath}';`;
+        importMap.set(filename, importStatement);
+    }
+    return Array.from(importMap.values()).sort();
+};
+/**
+ * The type names a generated file will import for its `$ref`s — the same
+ * dedup/skip rules as {@link collectImports}. Generators seed their private
+ * sub-type naming with this set so a synthesized name (e.g. a root array's
+ * `FooItem`) can never shadow an imported identifier.
+ */
+export const collectImportTypeNames = (schema, options) => {
+    const names = new Set();
+    for (const [, typeName] of collectImportTargets(schema, options))
+        names.add(typeName);
+    return names;
+};
+/** Shared `$ref` walk: filename → derived type name for every import target. */
+const collectImportTargets = (schema, options) => {
     const selfFilename = options?.selfRef ? refToFilename(options.selfRef) : undefined;
     const rootSchema = options?.rootSchema;
     const typeSuffix = options?.typeSuffix;
@@ -194,8 +221,8 @@ export const collectImports = (schema, options) => {
     if (typeof schema === 'object' && schema !== null && 'else' in schema) {
         collectRefsFromValue(schema.else);
     }
-    // Convert refs to combined import statements, deduplicating by filename
-    const importMap = new Map();
+    // Convert refs to import targets, deduplicating by filename.
+    const targets = new Map();
     for (const ref of refs) {
         // For URI refs, skip if the base URI is not resolvable in the root schema.
         // This prevents generating imports for external schemas that were never generated as files.
@@ -209,12 +236,7 @@ export const collectImports = (schema, options) => {
         if (selfFilename !== undefined && filename === selfFilename) {
             continue;
         }
-        const importPath = getImportPathForFilename(filename);
-        // In types-only mode, omit the parser function import since there is no parser to call
-        const importStatement = typesOnly
-            ? `import type { ${typeName} } from '${importPath}';`
-            : `import { type ${typeName}, parse${typeName}, validate${typeName}Shape } from '${importPath}';`;
-        importMap.set(filename, importStatement);
+        targets.set(filename, typeName);
     }
-    return Array.from(importMap.values()).sort();
+    return targets;
 };

package/dist/index.d.ts

@@ -1 +1,2 @@
 export { buildSchema, type GeneratedFile } from './generators/build-schema.js';
+export type { ImportExtension } from './helpers/collect-imports.js';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amritk/generate-parsers",
-  "version": "0.12.3",
+  "version": "0.14.0",
   "description": "Generate TypeScript parsers and type definitions from JSON Schemas.",
   "module": "./dist/index.js",
   "type": "module",
@@ -48,7 +48,7 @@
   },
   "dependencies": {
     "json-schema-typed": "^8.0.1",
-    "@amritk/helpers": "0.10.2",
+    "@amritk/helpers": "0.11.0",
     "@amritk/generate-markdown": "0.4.1"
   },
   "devDependencies": {