chore: clean up renderer

Author: mrlubos

.vscode/launch.json

@@ -18,7 +18,7 @@
       "runtimeArgs": ["-r", "ts-node/register/transpile-only"],
       "program": "${workspaceFolder}/packages/openapi-ts/src/run.ts",
       "env": {
-        "DEBUG": "heyapi:*"
+        "DEBUG": "false"
       }
     }
   ]

dev/openapi-ts.config.ts

@@ -43,7 +43,7 @@ export default defineConfig(() => {
             // 'invalid',
             // 'full.yaml',
             // 'object-property-names.yaml',
-            // 'openai.yaml',
+            'openai.yaml',
             // 'opencode.yaml',
             // 'pagination-ref.yaml',
             // 'sdk-instance.yaml',
@@ -53,7 +53,7 @@ export default defineConfig(() => {
             // 'validators.yaml',
             // 'validators-circular-ref.json',
             // 'validators-circular-ref-2.yaml',
-            'zoom-video-sdk.json',
+            // 'zoom-video-sdk.json',
           ),
           // path: 'https://get.heyapi.dev/hey-api/backend?branch=main&version=1.0.0',
           // path: 'http://localhost:4000/',
@@ -237,6 +237,7 @@ export default defineConfig(() => {
           //   error: '他們_error_{{name}}',
           //   name: '你們_errors_{{name}}',
           // },
+          // exportFromIndex: false,
           name: '@hey-api/typescript',
           // requests: '我們_data_{{name}}',
           // responses: {
@@ -263,7 +264,7 @@ export default defineConfig(() => {
           // },
           // include...
           // instance: true,
-          // name: '@hey-api/sdk',
+          name: '@hey-api/sdk',
           // operationId: false,
           // paramsStructure: 'flat',
           // responseStyle: 'data',
@@ -272,7 +273,7 @@ export default defineConfig(() => {
           // signature: 'object',
           // transformer: '@hey-api/transformers',
           // transformer: true,
-          validator: 'valibot',
+          validator: 'zod',
           // validator: {
           //   request: 'zod',
           //   response: 'zod',
@@ -371,18 +372,18 @@ export default defineConfig(() => {
         {
           // case: 'SCREAMING_SNAKE_CASE',
           // comments: false,
-          // definitions: 'z{{name}}Definition',
+          definitions: 'z{{name}}',
           exportFromIndex: true,
           // metadata: true,
-          // name: 'valibot',
+          name: 'valibot',
           // requests: {
           //   case: 'PascalCase',
           //   name: '{{name}}Data',
           // },
-          // responses: {
-          //   // case: 'snake_case',
-          //   name: 'z{{name}}TestResponse',
-          // },
+          responses: {
+            // case: 'snake_case',
+            name: 'z{{name}}TestResponse',
+          },
           // webhooks: {
           //   name: 'q{{name}}CoolWebhook',
           // },
@@ -425,10 +426,7 @@ export default defineConfig(() => {
             validator({ $, schema, v }) {
               return [
                 $.const('parsed').assign(
-                  $(v.placeholder)
-                    .attr('safeParseAsync')
-                    .call(schema.placeholder, 'data')
-                    .await(),
+                  $(v).attr('safeParseAsync').call(schema, 'data').await(),
                 ),
                 $('parsed').return(),
               ];
@@ -449,9 +447,9 @@ export default defineConfig(() => {
             //     infer: 'D{{name}}ZodType',
             //   },
           },
-          // exportFromIndex: true,
+          exportFromIndex: true,
           metadata: true,
-          // name: 'zod',
+          name: 'zod',
           // requests: {
           //   // case: 'SCREAMING_SNAKE_CASE',
           //   // name: 'z{{name}}TestData',
@@ -505,10 +503,7 @@ export default defineConfig(() => {
             validator({ $, schema }) {
               return [
                 $.const('parsed').assign(
-                  $(schema.placeholder)
-                    .attr('safeParseAsync')
-                    .call('data')
-                    .await(),
+                  $(schema).attr('safeParseAsync').call('data').await(),
                 ),
                 $('parsed').return(),
               ];

packages/codegen-core/src/__tests__/symbols.test.ts

@@ -1,6 +1,7 @@
 import { describe, expect, it } from 'vitest';
 
 import { SymbolRegistry } from '../symbols/registry';
+import { isSymbol } from '../symbols/symbol';
 
 describe('SymbolRegistry', () => {
   it('covers the full public interface', () => {
@@ -260,4 +261,88 @@ describe('SymbolRegistry', () => {
     const newQuery = registry.query({ something: 'else' });
     expect(newQuery).toEqual([]);
   });
+
+  it('isSymbol covers various inputs', () => {
+    const registry = new SymbolRegistry();
+
+    // real registered symbol
+    const sym = registry.register({ meta: { a: 1 }, name: 'A' });
+    expect(isSymbol(sym)).toBe(true);
+
+    // stub reference (unregistered)
+    const stub = registry.reference({ b: 2 });
+    expect(isSymbol(stub)).toBe(true);
+
+    // primitives
+    expect(isSymbol(null)).toBe(false);
+    expect(isSymbol(undefined)).toBe(false);
+    expect(isSymbol(123)).toBe(false);
+    expect(isSymbol('foo')).toBe(false);
+    expect(isSymbol(true)).toBe(false);
+
+    // arrays and plain objects
+    expect(isSymbol([])).toBe(false);
+    expect(isSymbol({})).toBe(false);
+
+    // object with different tag
+    expect(isSymbol({ '~tag': 'not-a-symbol' })).toBe(false);
+
+    // object masquerading as a symbol (matches tag)
+    expect(isSymbol({ '~tag': 'heyapi.symbol' })).toBe(true);
+
+    // Date, Map, Set should be false
+    expect(isSymbol(new Date())).toBe(false);
+    expect(isSymbol(new Map())).toBe(false);
+    expect(isSymbol(new Set())).toBe(false);
+
+    // Typed arrays and ArrayBuffer should be false
+    expect(isSymbol(new Uint8Array())).toBe(false);
+    expect(isSymbol(new ArrayBuffer(8))).toBe(false);
+
+    // Functions without tag should be false
+    const fn = () => {};
+    expect(isSymbol(fn)).toBe(false);
+
+    // Class instance without tag should be false
+    class Foo {}
+    const foo = new Foo();
+    expect(isSymbol(foo)).toBe(false);
+
+    // Proxy with tag should be true if own property is present
+    const target = {} as Record<string, unknown>;
+    const proxied = new Proxy(target, {
+      get(_, prop) {
+        if (prop === '~tag') return 'heyapi.symbol';
+        return undefined;
+      },
+      getOwnPropertyDescriptor(_, prop) {
+        if (prop === '~tag')
+          return {
+            configurable: true,
+            enumerable: true,
+            value: 'heyapi.symbol',
+            writable: false,
+          };
+        return undefined;
+      },
+      has(_, prop) {
+        return prop === '~tag';
+      },
+    });
+    // Define as own property to satisfy hasOwn
+    Object.defineProperty(target, '~tag', {
+      configurable: true,
+      value: 'heyapi.symbol',
+    });
+    expect(isSymbol(proxied)).toBe(true);
+
+    // Inherited tag should be false (not own property)
+    const proto = { '~tag': 'heyapi.symbol' };
+    const objWithProto = Object.create(proto);
+    expect(isSymbol(objWithProto)).toBe(false);
+
+    // Primitive edge cases
+    expect(isSymbol(Symbol('x'))).toBe(false);
+    expect(isSymbol(0n)).toBe(false);
+  });
 });

packages/codegen-core/src/bindings/plan.d.ts

@@ -0,0 +1,76 @@
+import type { SymbolImportKind } from '../symbols/types';
+
+export interface PlannedImport {
+  /** ID of the file where the symbol lives */
+  from: number;
+  /** The final exported name of the symbol in its source file */
+  importedName: string;
+  /** Whether this import is type-only. */
+  isTypeOnly: boolean;
+  /** Import flavor. */
+  kind: SymbolImportKind;
+  /**
+   * The name this symbol will have locally in this file.
+   * This is where aliasing is applied:
+   *
+   * import { Foo as Foo$2 } from "./x"
+   *
+   * localName === "Foo$2"
+   */
+  localName: string;
+  /** ID of the symbol being imported */
+  symbolId: number;
+}
+
+export interface PlannedExport {
+  /**
+   * Whether the export was explicitly requested by the plugin/DSL
+   * (e.g. symbol.exported = true) vs implicitly required (e.g. re-export).
+   */
+  explicit: boolean;
+  /**
+   * The name this symbol will be exported under from this file.
+   *
+   * This may differ from the symbol's finalName if aliasing is needed:
+   *
+   * export { Foo as Foo2 }
+   *
+   * exportedName === "Foo2"
+   */
+  exportedName: string;
+  /** Whether this export is type-only. */
+  isTypeOnly: boolean;
+  /** Export flavor. */
+  kind: SymbolImportKind;
+  /** ID of the symbol being exported */
+  symbolId: number;
+}
+
+export interface PlannedReexport {
+  /**
+   * Name under which the symbol is exported in this file.
+   *
+   * export { Foo as Bar } from "./models"
+   *
+   * exportedName === "Bar"
+   */
+  exportedName: string;
+  /** ID of the source file containing the symbol */
+  from: number;
+  /**
+   * The name the symbol has in the source file’s exports.
+   *
+   * export { Foo as Bar } from "./models"
+   *
+   * importedName === "Foo"
+   *
+   * This handles aliasing in the source file's export list.
+   */
+  importedName: string;
+  /** Whether this re-export is type-only. */
+  isTypeOnly: boolean;
+  /** Export flavor. */
+  kind: SymbolImportKind;
+  /** ID of the symbol being re-exported */
+  symbolId: number;
+}

packages/codegen-core/src/debug.ts

@@ -5,6 +5,7 @@ import colorSupport from 'color-support';
 colors.enabled = colorSupport().hasBasic;
 
 const DEBUG_GROUPS = {
+  analyzer: colors.greenBright,
   dsl: colors.cyanBright,
   registry: colors.blueBright,
   symbol: colors.magentaBright,

packages/codegen-core/src/files/registry.ts

@@ -99,14 +99,13 @@ export class FileRegistry implements IFileRegistry {
     result = {
       ...result,
       ...file, // clone to avoid mutation
+      exports: result?.exports ?? [],
       id,
-      localNames: new Set(),
+      imports: result?.imports ?? [],
+      reexports: result?.reexports ?? [],
+      reservedNames: result?.reservedNames ?? new Map(),
       resolvedNames: result?.resolvedNames ?? new BiMap(),
-      symbols: result?.symbols ?? {
-        body: [],
-        exports: [],
-        imports: [],
-      },
+      symbols: result?.symbols ?? [],
     };
     this.values.set(id, result);
 

packages/codegen-core/src/files/rules.d.ts

@@ -0,0 +1,14 @@
+export interface Rules {
+  /** Whether two exported names may collide. */
+  allowExportNameShadowing: boolean;
+  /** Whether a local symbol can shadow another local name without error. */
+  allowLocalNameShadowing: boolean;
+  /** Whether the language requires file-scoped name uniqueness. */
+  fileScopedNamesMustBeUnique: boolean;
+  /** Whether `import { X } from "mod"` introduces a local binding `X`. */
+  importCreatesLocalBinding: boolean;
+  /** Whether `export { X } from "mod"` introduces a local binding `X`. */
+  reexportCreatesLocalBinding: boolean;
+  /** Whether the language distinguishes type-only imports. */
+  supportsTypeImports: boolean;
+}