objcjs-types 0.2.1 → 0.4.0

package/generator/worker-pool.ts

@@ -0,0 +1,309 @@
+/**
+ * Worker pool for parallel header parsing.
+ * Manages a fixed pool of worker threads and distributes parse tasks
+ * with automatic load balancing via an internal queue.
+ *
+ * Each worker runs clang + AST parsing independently. The pool routes
+ * tasks to idle workers and queues excess tasks until a worker is free.
+ */
+
+import type {
+  ObjCClass,
+  ObjCProtocol,
+  ObjCIntegerEnum,
+  ObjCStringEnum,
+  ObjCStruct,
+  ObjCStructAlias,
+  ObjCFunction
+} from "./ast-parser.ts";
+
+/** Result from a unified parse-all task (classes + protocols + enums + structs from one clang invocation) */
+export interface UnifiedParseResult {
+  /** Parsed classes from the header (class name → ObjCClass) */
+  classes: Map<string, ObjCClass>;
+  /** Parsed protocols from the header (protocol name → ObjCProtocol) */
+  protocols: Map<string, ObjCProtocol>;
+  /** Parsed integer enums from the header (enum name → ObjCIntegerEnum) */
+  integerEnums: Map<string, ObjCIntegerEnum>;
+  /** Parsed string enums from the header (enum name → ObjCStringEnum) */
+  stringEnums: Map<string, ObjCStringEnum>;
+  /** Parsed struct definitions from the header (struct name → ObjCStruct) */
+  structs: Map<string, ObjCStruct>;
+  /** Struct typedef aliases (e.g., NSPoint → CGPoint) */
+  structAliases: ObjCStructAlias[];
+  /** General typedef resolution table (typedef name → underlying qualType) */
+  typedefs: Map<string, string>;
+  /** Parsed C function declarations (function name → ObjCFunction) */
+  functions: Map<string, ObjCFunction>;
+}
+
+export interface ClassParseResult {
+  /** Parsed classes from the header (class name → ObjCClass) */
+  classes: Map<string, ObjCClass>;
+  /** Original target class names that were requested */
+  targets: string[];
+}
+
+export interface ProtocolParseResult {
+  /** Parsed protocols from the header (protocol name → ObjCProtocol) */
+  protocols: Map<string, ObjCProtocol>;
+  /** Original target protocol names that were requested */
+  targets: string[];
+}
+
+export interface EnumParseResult {
+  /** Parsed integer enums from the header (enum name → ObjCIntegerEnum) */
+  integerEnums: Map<string, ObjCIntegerEnum>;
+  /** Parsed string enums from the header (enum name → ObjCStringEnum) */
+  stringEnums: Map<string, ObjCStringEnum>;
+  /** Original target integer enum names that were requested */
+  integerTargets: string[];
+  /** Original target string enum names that were requested */
+  stringTargets: string[];
+}
+
+interface PendingTask {
+  resolve: (value: any) => void;
+  reject: (error: Error) => void;
+}
+
+interface QueuedTask {
+  message: any;
+  resolve: (value: any) => void;
+  reject: (error: Error) => void;
+}
+
+/**
+ * Pool of worker threads for running clang + AST parsing in parallel.
+ * Tasks are automatically load-balanced: each new task goes to an idle
+ * worker, or queues until one becomes available.
+ */
+export class WorkerPool {
+  private workers: Worker[];
+  private idle: Worker[];
+  private queue: QueuedTask[];
+  private pending: Map<Worker, PendingTask>;
+  private nextId = 0;
+
+  constructor(size: number) {
+    const workerUrl = new URL("./parse-worker.ts", import.meta.url).href;
+    this.workers = [];
+    this.idle = [];
+    this.queue = [];
+    this.pending = new Map();
+
+    for (let i = 0; i < size; i++) {
+      const worker = new Worker(workerUrl, { smol: true });
+      worker.onmessage = (event) => this.onWorkerMessage(worker, event.data);
+      worker.onerror = (event) => this.onWorkerError(worker, event);
+      this.workers.push(worker);
+      this.idle.push(worker);
+    }
+  }
+
+  /** Number of workers in the pool. */
+  get size(): number {
+    return this.workers.length;
+  }
+
+  private onWorkerMessage(worker: Worker, data: any): void {
+    const task = this.pending.get(worker);
+    this.pending.delete(worker);
+
+    if (data.type === "error") {
+      task?.reject(new Error(data.error));
+    } else {
+      task?.resolve(data);
+    }
+
+    this.dispatchNext(worker);
+  }
+
+  private onWorkerError(worker: Worker, event: Event | ErrorEvent): void {
+    const task = this.pending.get(worker);
+    this.pending.delete(worker);
+    const msg = event instanceof ErrorEvent ? event.message : "Worker error";
+    task?.reject(new Error(msg));
+    this.dispatchNext(worker);
+  }
+
+  /** Send the next queued task to a now-idle worker, or mark it idle. */
+  private dispatchNext(worker: Worker): void {
+    const next = this.queue.shift();
+    if (next) {
+      this.pending.set(worker, { resolve: next.resolve, reject: next.reject });
+      worker.postMessage(next.message);
+    } else {
+      this.idle.push(worker);
+    }
+  }
+
+  /** Send a message to an available worker, or queue it. */
+  private dispatch(message: any): Promise<any> {
+    return new Promise((resolve, reject) => {
+      const worker = this.idle.pop();
+      if (worker) {
+        this.pending.set(worker, { resolve, reject });
+        worker.postMessage(message);
+      } else {
+        this.queue.push({ message, resolve, reject });
+      }
+    });
+  }
+
+  /**
+   * Parse classes from a header file using a worker thread.
+   * Automatically retries with fallback pre-includes if initial parse finds nothing.
+   */
+  async parseClasses(headerPath: string, targets: string[], fallbackPreIncludes?: string[]): Promise<ClassParseResult> {
+    const result = await this.dispatch({
+      id: this.nextId++,
+      type: "parse-classes",
+      headerPath,
+      targets,
+      fallbackPreIncludes
+    });
+    return {
+      classes: new Map(result.classes),
+      targets: result.targets
+    };
+  }
+
+  /**
+   * Parse protocols from a header file using a worker thread.
+   * Automatically retries with fallback pre-includes if initial parse finds nothing.
+   */
+  async parseProtocols(
+    headerPath: string,
+    targets: string[],
+    fallbackPreIncludes?: string[]
+  ): Promise<ProtocolParseResult> {
+    const result = await this.dispatch({
+      id: this.nextId++,
+      type: "parse-protocols",
+      headerPath,
+      targets,
+      fallbackPreIncludes
+    });
+    return {
+      protocols: new Map(result.protocols),
+      targets: result.targets
+    };
+  }
+
+  /**
+   * Parse enums from a header file using a worker thread.
+   * Extracts both integer enums (NS_ENUM/NS_OPTIONS) and string enums
+   * (NS_TYPED_EXTENSIBLE_ENUM) in a single clang pass.
+   */
+  async parseEnums(
+    headerPath: string,
+    integerTargets: string[],
+    stringTargets: string[],
+    fallbackPreIncludes?: string[]
+  ): Promise<EnumParseResult> {
+    const result = await this.dispatch({
+      id: this.nextId++,
+      type: "parse-enums",
+      headerPath,
+      integerTargets,
+      stringTargets,
+      fallbackPreIncludes
+    });
+    return {
+      integerEnums: new Map(result.integerEnums),
+      stringEnums: new Map(result.stringEnums),
+      integerTargets: result.integerTargets,
+      stringTargets: result.stringTargets
+    };
+  }
+
+  /**
+   * Parse classes, protocols, and enums from a single header in one clang invocation.
+   * This avoids spawning multiple clang processes for the same header file.
+   */
+  async parseAll(
+    headerPath: string,
+    classTargets: string[],
+    protocolTargets: string[],
+    integerEnumTargets: string[],
+    stringEnumTargets: string[],
+    fallbackPreIncludes?: string[]
+  ): Promise<UnifiedParseResult> {
+    const result = await this.dispatch({
+      id: this.nextId++,
+      type: "parse-all",
+      headerPath,
+      classTargets,
+      protocolTargets,
+      integerEnumTargets,
+      stringEnumTargets,
+      fallbackPreIncludes
+    });
+    return {
+      classes: new Map(result.classes),
+      protocols: new Map(result.protocols),
+      integerEnums: new Map(result.integerEnums),
+      stringEnums: new Map(result.stringEnums),
+      structs: new Map(result.structs ?? []),
+      structAliases: result.structAliases ?? [],
+      typedefs: new Map(result.typedefs ?? []),
+      functions: new Map(result.functions ?? [])
+    };
+  }
+
+  /**
+   * Parse all targets from an entire framework using a single batched clang invocation.
+   * All framework headers are included in one temp .m file, reducing clang overhead
+   * from one process per header to one process per framework.
+   *
+   * @param headerPaths - All header file paths for this framework
+   * @param classTargets - All class names to extract
+   * @param protocolTargets - All protocol names to extract
+   * @param integerEnumTargets - All integer enum names to extract
+   * @param stringEnumTargets - All string enum names to extract
+   * @param preIncludes - Pre-include headers for macro expansion (e.g., Foundation/Foundation.h)
+   */
+  async parseBatch(
+    headerPaths: string[],
+    classTargets: string[],
+    protocolTargets: string[],
+    integerEnumTargets: string[],
+    stringEnumTargets: string[],
+    preIncludes: string[],
+    frameworkName?: string
+  ): Promise<UnifiedParseResult> {
+    const result = await this.dispatch({
+      id: this.nextId++,
+      type: "parse-batch",
+      headerPaths,
+      classTargets,
+      protocolTargets,
+      integerEnumTargets,
+      stringEnumTargets,
+      preIncludes,
+      frameworkName
+    });
+    return {
+      classes: new Map(result.classes),
+      protocols: new Map(result.protocols),
+      integerEnums: new Map(result.integerEnums),
+      stringEnums: new Map(result.stringEnums),
+      structs: new Map(result.structs ?? []),
+      structAliases: result.structAliases ?? [],
+      typedefs: new Map(result.typedefs ?? []),
+      functions: new Map(result.functions ?? [])
+    };
+  }
+
+  /** Terminate all workers and clean up resources. */
+  destroy(): void {
+    for (const worker of this.workers) {
+      worker.terminate();
+    }
+    this.workers = [];
+    this.idle = [];
+    this.queue = [];
+    this.pending.clear();
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "objcjs-types",
-  "version": "0.2.1",
+  "version": "0.4.0",
   "description": "Auto-generated TypeScript type declarations for macOS Objective-C frameworks",
   "type": "module",
   "main": "./dist/index.js",
@@ -29,14 +29,24 @@
     "./*": {
       "types": "./dist/*/index.d.ts",
       "default": "./dist/*/index.js"
+    },
+    "./*/functions": {
+      "types": "./dist/*/functions.d.ts",
+      "default": "./dist/*/functions.js"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "generator",
+    "bin"
   ],
+  "bin": {
+    "objcjs-types": "./bin/objcjs-types.ts"
+  },
   "scripts": {
     "clear": "rm -rf src && rm -rf dist",
     "generate": "bun run generator/index.ts",
+    "generate:custom": "bun run generator/custom.ts",
     "build": "bun run clear && bun run generate && bunx tsgo",
     "format": "prettier --write ."
   },
@@ -59,7 +69,10 @@
   "devDependencies": {
     "@types/bun": "latest",
     "@typescript/native-preview": "^7.0.0-dev.20260218.1",
-    "objc-js": "^1.1.0",
+    "objc-js": "^1.2.1",
     "prettier": "^3.8.1"
-  }
+  },
+  "trustedDependencies": [
+    "objc-js"
+  ]
 }