true-pg 0.5.0 → 0.5.1

package/lib/kysely/index.js

@@ -1,149 +1,148 @@
 import { Canonical, FunctionReturnTypeKind, } from "../extractor/index.js";
-import { allowed_kind_names, createGenerator, Nodes } from "../types.js";
+import { allowed_kind_names, createGenerator } from "../types.js";
+import { Import } from "../imports.js";
 import { builtins } from "./builtins.js";
 import { toPascalCase, join, quote, quoteI } from "../util.js";
 export const Kysely = createGenerator(opts => {
     const defaultSchema = opts?.defaultSchema ?? "public";
-    const ky = (imports, name) => imports.add(new Nodes.ExternalImport({
-        name,
-        module: "kysely",
-        typeOnly: true,
-        star: false,
-    }));
-    const add = (imports, type) => {
-        if (type.schema === "pg_catalog")
-            return;
-        imports.add(new Nodes.InternalImport({
-            name: generator.formatType(type),
-            canonical_type: type,
+    const ky = (ctx, name) => {
+        ctx.imports.add(new Import({
+            from: "kysely",
+            namedImports: [name],
             typeOnly: true,
-            star: false,
         }));
     };
     const column = (
     /** "this" */
-    generator, 
-    /** @out Append used types to this array */
-    imports, 
+    generator, ctx, 
     /** Information about the column */
     col) => {
-        let base = generator.formatType(col.type);
-        if (col.type.dimensions > 0)
-            base += "[]".repeat(col.type.dimensions);
-        if (col.isNullable)
-            base += " | null";
+        let base = generator.formatType(ctx, col.type, { nullable: col.isNullable });
         let qualified = base;
         if (col.generated === "ALWAYS") {
             qualified = `GeneratedAlways<${qualified}>`;
-            ky(imports, "GeneratedAlways");
+            ky(ctx, "GeneratedAlways");
         }
         else if (col.generated === "BY DEFAULT") {
             qualified = `Generated<${qualified}>`;
-            ky(imports, "Generated");
+            ky(ctx, "Generated");
         }
         else if (col.defaultValue) {
             qualified = `Generated<${qualified}>`;
-            ky(imports, "Generated");
+            ky(ctx, "Generated");
         }
         let out = col.comment ? `/** ${col.comment} */\n\t` : "";
         out += quoteI(col.name);
         // TODO: update imports for non-primitive types
         out += `: ${qualified}`;
-        add(imports, col.type);
         return `\t${out};\n`;
     };
-    const composite_attribute = (generator, imports, attr) => {
+    const composite_attribute = (ctx, generator, attr) => {
         let out = quoteI(attr.name);
         if (attr.isNullable)
             out += "?";
-        out += `: ${generator.formatType(attr.type)}`;
-        add(imports, attr.type);
-        if (attr.type.dimensions > 0)
-            out += "[]".repeat(attr.type.dimensions);
-        if (attr.isNullable)
-            out += " | null";
+        out += ": ";
+        out += generator.formatType(ctx, attr.type, { nullable: attr.isNullable });
         return out;
     };
     const generator = {
-        formatSchema(name) {
+        formatSchemaName(name) {
             return toPascalCase(name) + "Schema";
         },
-        formatSchemaType(type) {
+        formatSchemaMemberName(type) {
             return toPascalCase(type.name);
         },
-        formatType(type) {
+        formatType(ctx, type, attr) {
+            let base;
             if (type.kind === FunctionReturnTypeKind.ExistingTable) {
-                return toPascalCase(type.name);
+                base = toPascalCase(type.name);
             }
             else if (type.schema === "pg_catalog") {
                 const name = type.canonical_name;
                 const format = builtins[name];
                 if (format)
-                    return format;
-                opts?.warnings?.push(`(kysely) Unknown builtin type: ${name}. Pass customBuiltinMap to map this type. Defaulting to "unknown".`);
-                return "unknown";
+                    base = format;
+                else {
+                    opts?.warnings?.add(`(kysely) Unknown builtin type: ${name}. Pass 'kysely.builtinMap' to map this type. Defaulting to "unknown".`);
+                    base = "unknown";
+                }
             }
-            return toPascalCase(type.name);
+            else
+                base = toPascalCase(type.name);
+            if (type.schema !== "pg_catalog") {
+                // before adding modifiers, add the import
+                ctx.imports.add(Import.fromInternal({
+                    source: ctx.source,
+                    type,
+                    withName: base,
+                    typeOnly: true,
+                }));
+            }
+            if ("dimensions" in type)
+                base += "[]".repeat(type.dimensions);
+            if (attr?.nullable)
+                base += " | null";
+            return base;
         },
-        table(imports, table) {
+        table(ctx, table) {
             let out = "";
             if (table.comment)
                 out += `/** ${table.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(table)} {\n`;
+            out += `export interface ${this.formatSchemaMemberName(table)} {\n`;
             for (const col of table.columns)
-                out += column(this, imports, col);
+                out += column(this, ctx, col);
             out += "}";
             return out;
         },
-        view(imports, view) {
+        view(ctx, view) {
             let out = "";
             if (view.comment)
                 out += `/** ${view.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(view)} {\n`;
+            out += `export interface ${this.formatSchemaMemberName(view)} {\n`;
             for (const col of view.columns)
-                out += column(this, imports, col);
+                out += column(this, ctx, col);
             out += "}";
             return out;
         },
-        materializedView(imports, materializedView) {
+        materializedView(ctx, materializedView) {
             let out = "";
             if (materializedView.comment)
                 out += `/** ${materializedView.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(materializedView)} {\n`;
+            out += `export interface ${this.formatSchemaMemberName(materializedView)} {\n`;
             for (const col of materializedView.columns)
-                out += column(this, imports, col);
+                out += column(this, ctx, col);
             out += "}";
             return out;
         },
-        enum(imports, en) {
+        enum(ctx, en) {
             let out = "";
             if (en.comment)
                 out += `/** ${en.comment} */\n`;
-            out += `export type ${this.formatSchemaType(en)} = ${en.values.map(v => `"${v}"`).join(" | ")};`;
+            out += `export type ${this.formatSchemaMemberName(en)} = ${en.values.map(v => `"${v}"`).join(" | ")};`;
             return out;
         },
-        composite(imports, type) {
+        composite(ctx, type) {
             let out = "";
             if (type.comment)
                 out += `/** ${type.comment} */\n`;
-            out += `export interface ${this.formatSchemaType(type)} {\n`;
-            const props = type.canonical.attributes.map(c => composite_attribute(this, imports, c)).map(t => `\t${t};`);
+            out += `export interface ${this.formatSchemaMemberName(type)} {\n`;
+            const props = type.canonical.attributes.map(c => composite_attribute(ctx, this, c)).map(t => `\t${t};`);
             out += props.join("\n");
             out += "\n}";
             return out;
         },
-        domain(imports, type) {
+        domain(ctx, type) {
             let out = "";
-            out += `export type ${this.formatSchemaType(type)} = ${this.formatType(type.canonical.domain_base_type)};`;
+            out += `export type ${this.formatSchemaMemberName(type)} = ${this.formatType(ctx, type.canonical.domain_base_type)};`;
             return out;
         },
-        range(imports, type) {
+        range(ctx, type) {
             let out = "";
             // force this to be string because range has to be passed as a string to Kysely
-            out += `export type ${this.formatSchemaType(type)} = string;`;
+            out += `export type ${this.formatSchemaMemberName(type)} = string;`;
             return out;
         },
-        function(imports, type) {
+        function(ctx, type) {
             let out = "";
             out += "/**\n";
             if (type.comment)
@@ -152,7 +151,7 @@ export const Kysely = createGenerator(opts => {
             out += ` * @parallelSafety ${type.parallelSafety}\n`;
             out += ` * @isStrict ${type.isStrict}\n`;
             out += " */\n";
-            out += `export interface ${this.formatSchemaType(type)} {\n\t`;
+            out += `export interface ${this.formatSchemaMemberName(type)} {\n\t`;
             // Get the input parameters (those that appear in function signature)
             const inputParams = type.parameters.filter(p => p.mode === "IN" || p.mode === "INOUT" || p.mode === "VARIADIC");
             if (inputParams.length === 0) {
@@ -162,10 +161,7 @@ export const Kysely = createGenerator(opts => {
                 out += "(";
                 out += inputParams[0].name;
                 out += ": ";
-                out += this.formatType(inputParams[0].type);
-                add(imports, inputParams[0].type);
-                if (inputParams[0].type.dimensions > 0)
-                    out += "[]".repeat(inputParams[0].type.dimensions);
+                out += this.formatType(ctx, inputParams[0].type);
                 out += "): ";
             }
             else if (inputParams.length > 0) {
@@ -177,10 +173,7 @@ export const Kysely = createGenerator(opts => {
                     out += `\t\t${paramName}`;
                     if (param.hasDefault && !isVariadic)
                         out += "?";
-                    out += `: ${this.formatType(param.type)}`;
-                    add(imports, param.type);
-                    if (param.type.dimensions > 0)
-                        out += "[]".repeat(param.type.dimensions);
+                    out += `: ${this.formatType(ctx, param.type)}`;
                     if (!isVariadic)
                         out += ",";
                     out += "\n";
@@ -194,24 +187,17 @@ export const Kysely = createGenerator(opts => {
                     out += "{\n";
                     for (const col of type.returnType.columns) {
                         out += `\t\t"${col.name}": `;
-                        out += this.formatType(col.type);
-                        add(imports, col.type);
-                        if (col.type.dimensions > 0)
-                            out += "[]".repeat(col.type.dimensions);
+                        out += this.formatType(ctx, col.type);
                         out += `;\n`;
                     }
                     out += "\t}";
                 }
             }
             else if (type.returnType.kind === FunctionReturnTypeKind.ExistingTable) {
-                out += this.formatType(type.returnType);
-                add(imports, type.returnType);
+                out += this.formatType(ctx, type.returnType);
             }
             else {
-                out += this.formatType(type.returnType.type);
-                add(imports, type.returnType.type);
-                if (type.returnType.type.dimensions > 0)
-                    out += "[]".repeat(type.returnType.type.dimensions);
+                out += this.formatType(ctx, type.returnType.type);
             }
             // Add additional array brackets if it returns a set
             if (type.returnType.isSet) {
@@ -220,24 +206,25 @@ export const Kysely = createGenerator(opts => {
             out += ";\n}";
             return out;
         },
-        schemaKindIndex(schema, kind, main_generator) {
+        schemaKindIndex(ctx, schema, kind, main_generator) {
             const generator = main_generator ?? this;
             const imports = schema[kind];
             if (imports.length === 0)
                 return "";
             return imports
                 .map(each => {
-                const name = this.formatSchemaType(each);
-                const file = generator.formatSchemaType(each);
+                const name = generator.formatSchemaMemberName(each);
+                const file = generator.formatSchemaMemberName(each);
                 return `export type { ${name} } from "./${file}.ts";`;
             })
                 .join("\n");
         },
-        schemaIndex(schema) {
+        schemaIndex(ctx, schema) {
             const actual_kinds = allowed_kind_names.filter(kind => schema[kind].length);
+            // we could in theory use the imports from GeneratorContext here, but this works fine
             let out = actual_kinds.map(kind => `import type * as ${kind} from "./${kind}/index.ts";`).join("\n");
             out += "\n\n";
-            out += `export interface ${this.formatSchema(schema.name)} {\n`;
+            out += `export interface ${this.formatSchemaName(schema.name)} {\n`;
             for (const kind of actual_kinds) {
                 const items = schema[kind];
                 if (items.length === 0)
@@ -245,7 +232,7 @@ export const Kysely = createGenerator(opts => {
                 out += `\t${kind}: {\n`;
                 const formatted = items
                     .map(each => {
-                    const formatted = this.formatSchemaType(each);
+                    const formatted = generator.formatSchemaMemberName(each);
                     return { ...each, formatted };
                 })
                     .filter(x => x !== undefined);
@@ -260,10 +247,10 @@ export const Kysely = createGenerator(opts => {
             out += "}";
             return out;
         },
-        fullIndex(schemas) {
+        fullIndex(ctx, schemas) {
             const parts = [];
             parts.push(schemas
-                .map(s => `import type { ${this.formatSchema(s.name)} } from "./${s.name}/index.ts";`)
+                .map(s => `import type { ${generator.formatSchemaName(s.name)} } from "./${s.name}/index.ts";`)
                 .join("\n"));
             {
                 let iface = `export interface Database {\n`;
@@ -275,7 +262,7 @@ export const Kysely = createGenerator(opts => {
                     const seen = new Set();
                     const formatted = tables
                         .map(each => {
-                        const formatted = this.formatSchemaType(each);
+                        const formatted = generator.formatSchemaMemberName(each);
                         // skip clashing names
                         if (seen.has(formatted))
                             return;
@@ -294,7 +281,7 @@ export const Kysely = createGenerator(opts => {
                         else
                             qualified = t.name;
                         qualified = quoteI(qualified);
-                        return `\t${qualified}: ${this.formatSchema(schema.name)}[${quote(t.kind + "s")}][${quote(t.name)}];`;
+                        return `\t${qualified}: ${generator.formatSchemaName(schema.name)}[${quote(t.kind + "s")}][${quote(t.name)}];`;
                     })
                         .join("\n");
                     return out;
@@ -303,7 +290,7 @@ export const Kysely = createGenerator(opts => {
                 iface += "\n}";
                 parts.push(iface);
             }
-            parts.push(schemas.map(s => `export type { ${this.formatSchema(s.name)} };`).join("\n"));
+            parts.push(schemas.map(s => `export type { ${generator.formatSchemaName(s.name)} };`).join("\n"));
             return join(parts);
         },
     };

package/lib/types.d.ts

@@ -1,4 +1,5 @@
 import { Canonical, type TableDetails, type ViewDetails, type MaterializedViewDetails, type EnumDetails, type CompositeTypeDetails, type DomainDetails, type RangeDetails, type FunctionDetails, type SchemaType, type Schema, type FunctionReturnType } from "./extractor/index.ts";
+import type { ImportList } from "./imports.ts";
 export declare const allowed_kind_names: readonly ["tables", "views", "materializedViews", "enums", "composites", "functions", "domains", "ranges"];
 export type allowed_kind_names = (typeof allowed_kind_names)[number];
 export interface FolderStructure {
@@ -23,118 +24,72 @@ export interface FolderStructure {
         };
     };
 }
-export declare namespace Nodes {
-    class ExternalImport {
-        name: string;
-        typeOnly: boolean;
-        star: boolean;
-        external: true;
-        module: string;
-        constructor(args: {
-            name: string;
-            module: string;
-            typeOnly: boolean;
-            star: boolean;
-        });
-    }
-    class InternalImport {
-        name: string;
-        canonical_type: Canonical | FunctionReturnType.ExistingTable;
-        typeOnly: boolean;
-        star: boolean;
-        external: false;
-        constructor(args: {
-            name: string;
-            canonical_type: Canonical | FunctionReturnType.ExistingTable;
-            typeOnly: boolean;
-            star: boolean;
-        });
-    }
-    class ImportList {
-        imports: (ExternalImport | InternalImport)[];
-        constructor(imports: (ExternalImport | InternalImport)[]);
-        static merge(lists: ImportList[]): ImportList;
-        add(item: ExternalImport | InternalImport): void;
-        stringify(context_file: string, files: FolderStructure): string;
-    }
-    interface Export {
-        name: string;
-        kind: SchemaType["kind"];
-        schema: string;
-        star: boolean;
-    }
-}
 export interface CreateGeneratorOpts {
     defaultSchema?: string;
-    warnings: string[];
+    warnings: Set<string>;
 }
 export interface createGenerator {
     (opts?: CreateGeneratorOpts): SchemaGenerator;
 }
 export declare const createGenerator: (generatorCreator: createGenerator) => createGenerator;
+export interface GeneratorContext {
+    /** The source file path */
+    source: string;
+    /** Append types to import */
+    imports: ImportList;
+}
+export interface FormatTypeAttributes {
+    nullable?: boolean;
+    generated?: boolean;
+    identity?: boolean;
+}
 export interface SchemaGenerator {
     /**
      * Use this function to define a name mapping for schema names.
      * This is useful if you want to use a different name for a schema in the generated code.
      * Example: "public" -> "PublicSchema"
      */
-    formatSchema(name: string): string;
+    formatSchemaName(name: string): string;
     /**
-     * Use this function to define a name mapping for schema types.
-     * This is useful if you want to use a different name for a type in the generated code.
+     * Use this function to define a name mapping for schema members.
+     * This is useful if you want to use a different name for a member in the generated code.
      * Example: "users" -> "UsersTable"
      */
-    formatSchemaType(type: SchemaType): string;
+    formatSchemaMemberName(type: SchemaType): string;
     /**
      * Use this function to define a name mapping for type names.
      * This is useful if you want to use a different name for a type in the generated code.
      * Example: "users" -> "UsersTable"
      */
-    formatType(type: Canonical | FunctionReturnType.ExistingTable): string;
-    table(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    formatType(ctx: GeneratorContext, type: Canonical | FunctionReturnType.ExistingTable, attr?: FormatTypeAttributes): string;
+    table(ctx: GeneratorContext, 
     /** Information about the table */
     table: TableDetails): string;
-    view(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    view(ctx: GeneratorContext, 
     /** Information about the view */
     view: ViewDetails): string;
-    materializedView(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    materializedView(ctx: GeneratorContext, 
     /** Information about the materialized view */
     materializedView: MaterializedViewDetails): string;
-    enum(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    enum(ctx: GeneratorContext, 
     /** Information about the enum */
     en: EnumDetails): string;
-    composite(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    composite(ctx: GeneratorContext, 
     /** Information about the composite type */
     type: CompositeTypeDetails): string;
-    domain(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    domain(ctx: GeneratorContext, 
     /** Information about the domain */
     type: DomainDetails): string;
-    range(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    range(ctx: GeneratorContext, 
     /** Information about the range */
     type: RangeDetails): string;
-    function(
-    /** @out Append used types to this array */
-    imports: Nodes.ImportList, 
+    function(ctx: GeneratorContext, 
     /** Information about the function */
     type: FunctionDetails): string;
     /** create the file `$out/$schema.name/$kind/index.ts` */
-    schemaKindIndex(schema: Schema, kind: Exclude<keyof Schema, "name">, main_generator?: SchemaGenerator): string;
+    schemaKindIndex(ctx: GeneratorContext, schema: Schema, kind: Exclude<keyof Schema, "name">, main_generator?: SchemaGenerator): string;
     /** create the file `$out/$schema.name/index.ts` */
-    schemaIndex(schema: Schema, main_generator?: SchemaGenerator): string;
+    schemaIndex(ctx: GeneratorContext, schema: Schema, main_generator?: SchemaGenerator): string;
     /** create the file `$out/index.ts` */
-    fullIndex(schemas: Schema[], main_generator?: SchemaGenerator): string;
+    fullIndex(ctx: GeneratorContext, schemas: Schema[], main_generator?: SchemaGenerator): string;
 }

package/lib/types.js

@@ -1,6 +1,4 @@
 import { Canonical, } from "./extractor/index.js";
-import { dirname, relative } from "node:path/posix";
-import { join } from "./util.js";
 // To be updated when we add support for other kinds
 export const allowed_kind_names = [
     "tables",
@@ -12,168 +10,5 @@ export const allowed_kind_names = [
     "domains",
     "ranges",
 ];
-export var Nodes;
-(function (Nodes) {
-    class ExternalImport {
-        // what to import
-        name;
-        // use `type` syntax?
-        typeOnly;
-        // use `* as` syntax?
-        star;
-        // this is an external import
-        external;
-        // what module to import from
-        module;
-        constructor(args) {
-            this.name = args.name;
-            this.typeOnly = args.typeOnly;
-            this.star = args.star;
-            this.external = true;
-            this.module = args.module;
-        }
-    }
-    Nodes.ExternalImport = ExternalImport;
-    class InternalImport {
-        // what to import
-        name;
-        // underlying type that is being imported
-        canonical_type;
-        // use `type` syntax?
-        typeOnly;
-        // use `* as` syntax?
-        star;
-        // this is an internal import
-        external;
-        constructor(args) {
-            this.name = args.name;
-            this.canonical_type = args.canonical_type;
-            this.star = args.star;
-            this.typeOnly = args.typeOnly;
-            this.external = false;
-        }
-    }
-    Nodes.InternalImport = InternalImport;
-    class ImportList {
-        imports;
-        constructor(imports) {
-            this.imports = imports;
-        }
-        static merge(lists) {
-            return new ImportList(lists.flatMap(l => l.imports));
-        }
-        add(item) {
-            this.imports.push(item);
-        }
-        stringify(context_file, files) {
-            const externals = this.imports.filter(i => i.external);
-            const internals = this.imports.filter(i => !i.external);
-            const modulegroups = {};
-            for (const item of externals) {
-                const group = modulegroups[item.module];
-                if (group)
-                    group.push(item);
-                else
-                    modulegroups[item.module] = [item];
-            }
-            const out = [];
-            // TODO: normalise external and internal imports and handle the stringification of the imports in a single place
-            {
-                // EXTERNAL IMPORTS
-                const imports = [];
-                for (const module in modulegroups) {
-                    const items = modulegroups[module];
-                    const star = items.find(i => i.star);
-                    const unique = items.filter((i, index, arr) => {
-                        if (i.star)
-                            return false;
-                        if (arr.findIndex(i2 => i2.name === i.name) !== index)
-                            return false;
-                        return true;
-                    });
-                    const bits = [];
-                    const typeOnlys = unique.filter(i => i.typeOnly);
-                    const values = unique.filter(i => !i.typeOnly);
-                    // if no values to import, use `import type { ... }` instead of `import { type ... }`
-                    const typeInline = values.length !== 0;
-                    let import_line = `import `;
-                    for (const type of typeOnlys)
-                        bits.push(typeInline ? "type " : "" + type.name);
-                    for (const type of values)
-                        bits.push(type.name);
-                    if (bits.length)
-                        import_line += (typeInline ? "" : "type ") + "{ " + bits.join(", ") + " }";
-                    if (bits.length && star)
-                        import_line += `, `;
-                    if (star)
-                        import_line += `* as ${star.name}`;
-                    if (bits.length || star)
-                        import_line += ` from `;
-                    import_line += `"${module}";`;
-                    imports.push(import_line);
-                }
-                out.push(join(imports, "\n"));
-            }
-            {
-                // INTERNAL IMPORTS
-                const imports = [];
-                const unique_types = internals
-                    .filter(({ name: name1, canonical_type: int }, index, arr) => {
-                    return (arr.findIndex(({ name: name2, canonical_type: int2 }) => {
-                        return (
-                        // adapter-assigned name
-                        name2 === name1 &&
-                            // canonical type details
-                            int2.name === int.name &&
-                            int2.schema === int.schema &&
-                            int2.kind === int.kind);
-                    }) === index);
-                })
-                    .filter(imp => imp.canonical_type.kind === Canonical.Kind.Base ||
-                    allowed_kind_names.includes(`${imp.canonical_type.kind}s`))
-                    .map(imp => {
-                    const t = imp.canonical_type;
-                    const schema = files.children[t.schema];
-                    const kind = schema.children[`${t.kind}s`];
-                    const type = kind.children[t.name];
-                    const located_file = `${files.name}/${schema.name}/${kind.kind}/${type.name}.ts`;
-                    return { ...imp, located_file };
-                });
-                const group_by_file = {};
-                for (const type of unique_types) {
-                    const file = group_by_file[type.located_file] || [];
-                    file.push(type);
-                    group_by_file[type.located_file] = file;
-                }
-                for (const group in group_by_file) {
-                    let relative_path = relative(dirname(context_file), group);
-                    if (/^[^\.+\/]/.test(relative_path))
-                        relative_path = "./" + relative_path;
-                    const items = group_by_file[group];
-                    const typeOnlys = items.filter(i => i.typeOnly);
-                    const values = items.filter(i => !i.typeOnly);
-                    const star = values.find(i => i.star);
-                    let import_line = "import ";
-                    const bits = [];
-                    // if no values to import, use `import type { ... }` instead of `import { type ... }`
-                    const typeInline = values.length !== 0;
-                    for (const type of typeOnlys)
-                        bits.push((typeInline ? "type " : "") + type.name);
-                    for (const type of values)
-                        bits.push(type.name);
-                    if (bits.length)
-                        import_line += (typeInline ? "" : "type ") + "{ " + bits.join(", ") + " }";
-                    if (star)
-                        import_line += `* as ${star.name}`;
-                    import_line += ` from "${relative_path}";`;
-                    imports.push(import_line);
-                }
-                out.push(join(imports, "\n"));
-            }
-            return join(out);
-        }
-    }
-    Nodes.ImportList = ImportList;
-})(Nodes || (Nodes = {}));
 /* convenience function to create a generator with type inference */
 export const createGenerator = (generatorCreator) => generatorCreator;