@fluojs/cli 1.1.0 → 3.0.0

package/dist/commands/typegen-generation-process.d.ts

@@ -0,0 +1,46 @@
+type TypegenGenerationRequest = {
+    readonly cwd: string;
+    readonly exportName: string;
+    readonly modulePath: string;
+};
+/** Listener boundary for one short-lived typegen generation child. */
+export type TypegenGenerationChild = {
+    readonly kill: (signal: NodeJS.Signals) => boolean;
+    readonly offError: (listener: (error: Error) => void) => void;
+    readonly offExit: (listener: (code: number | null, signal: NodeJS.Signals | null) => void) => void;
+    readonly offMessage: (listener: (message: unknown) => void) => void;
+    readonly onError: (listener: (error: Error) => void) => void;
+    readonly onExit: (listener: (code: number | null, signal: NodeJS.Signals | null) => void) => void;
+    readonly onMessage: (listener: (message: unknown) => void) => void;
+};
+type TypegenGenerationSpawner = (request: TypegenGenerationRequest) => TypegenGenerationChild;
+/** One short-lived typegen generation process controlled by its watch coordinator. */
+export type TypegenGenerationProcess = {
+    cancel(): void;
+    readonly result: Promise<string>;
+};
+/**
+ * Waits for a generation child to return source and exit, then removes every completion listener.
+ *
+ * @param child Generation child listener boundary.
+ * @returns Generated source after successful process exit.
+ */
+export declare function waitForTypegenGenerationChild(child: TypegenGenerationChild): Promise<string>;
+/**
+ * Starts one default typegen generation child for a coordinator to complete or cancel.
+ *
+ * @param request Consumer directory, application module path, and selected export.
+ * @param spawnGeneration Child-process factory used by the default runtime and lifecycle tests.
+ * @returns A cancellable child process whose result settles only after a clean process exit.
+ */
+export declare function startTypegenGenerationProcess(request: TypegenGenerationRequest, spawnGeneration?: TypegenGenerationSpawner): TypegenGenerationProcess;
+/**
+ * Runs one default typegen generation in a short-lived child process.
+ *
+ * @param request Consumer directory, application module path, and selected export.
+ * @param spawnGeneration Child-process factory used by the default runtime and lifecycle tests.
+ * @returns Generated source after the child process has exited.
+ */
+export declare function runTypegenGenerationProcess(request: TypegenGenerationRequest, spawnGeneration?: TypegenGenerationSpawner): Promise<string>;
+export {};
+//# sourceMappingURL=typegen-generation-process.d.ts.map

package/dist/commands/typegen-generation-process.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen-generation-process.d.ts","sourceRoot":"","sources":["../../src/commands/typegen-generation-process.ts"],"names":[],"mappings":"AAQA,KAAK,wBAAwB,GAAG;IAC9B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF,sEAAsE;AACtE,MAAM,MAAM,sBAAsB,GAAG;IACnC,QAAQ,CAAC,IAAI,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,KAAK,OAAO,CAAC;IACnD,QAAQ,CAAC,QAAQ,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAAK,IAAI,CAAC;IAC9D,QAAQ,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC;IACnG,QAAQ,CAAC,UAAU,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,KAAK,IAAI,CAAC;IACpE,QAAQ,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,KAAK,IAAI,KAAK,IAAI,CAAC;IAC7D,QAAQ,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,EAAE,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,KAAK,IAAI,KAAK,IAAI,CAAC;IAClG,QAAQ,CAAC,SAAS,EAAE,CAAC,QAAQ,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,KAAK,IAAI,CAAC;CACpE,CAAC;AAEF,KAAK,wBAAwB,GAAG,CAAC,OAAO,EAAE,wBAAwB,KAAK,sBAAsB,CAAC;AA2B9F,sFAAsF;AACtF,MAAM,MAAM,wBAAwB,GAAG;IACrC,MAAM,IAAI,IAAI,CAAC;IACf,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,CAAC;CAClC,CAAC;AASF;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,sBAAsB,GAAG,OAAO,CAAC,MAAM,CAAC,CAsC5F;AAED;;;;;;GAMG;AACH,wBAAgB,6BAA6B,CAC3C,OAAO,EAAE,wBAAwB,EACjC,eAAe,GAAE,wBAAgD,GAChE,wBAAwB,CA0B1B;AAED;;;;;;GAMG;AACH,wBAAsB,2BAA2B,CAC/C,OAAO,EAAE,wBAAwB,EACjC,eAAe,GAAE,wBAAgD,GAChE,OAAO,CAAC,MAAM,CAAC,CAEjB"}

package/dist/commands/typegen-generation-process.js

@@ -0,0 +1,131 @@
+import { fork } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { dirname, extname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { parseTypegenGenerationMessage } from './typegen-generation-protocol.js';
+import { TypegenCommandError } from './typegen-options.js';
+
+/** Listener boundary for one short-lived typegen generation child. */
+
+const CHILD_TERMINATION_GRACE_MS = 500;
+function createGenerationChild(request) {
+  const currentPath = fileURLToPath(import.meta.url);
+  const extension = extname(currentPath);
+  const childPath = join(dirname(currentPath), `typegen-generation-child${extension}`);
+  const execArgv = extension === '.ts' ? ['--experimental-import-meta-resolve', '--import', createRequire(import.meta.url).resolve('tsx')] : ['--experimental-import-meta-resolve'];
+  const child = fork(childPath, [request.cwd, request.modulePath, request.exportName], {
+    cwd: request.cwd,
+    execArgv,
+    stdio: ['ignore', 'ignore', 'ignore', 'ipc']
+  });
+  return {
+    kill: signal => child.kill(signal),
+    offError: listener => child.off('error', listener),
+    offExit: listener => child.off('exit', listener),
+    offMessage: listener => child.off('message', listener),
+    onError: listener => child.once('error', listener),
+    onExit: listener => child.once('exit', listener),
+    onMessage: listener => child.on('message', listener)
+  };
+}
+
+/** One short-lived typegen generation process controlled by its watch coordinator. */
+
+function describeExit(code, signal) {
+  if (signal !== null) {
+    return `signal ${signal}`;
+  }
+  return code === null ? 'without an exit code' : `with exit code ${String(code)}`;
+}
+
+/**
+ * Waits for a generation child to return source and exit, then removes every completion listener.
+ *
+ * @param child Generation child listener boundary.
+ * @returns Generated source after successful process exit.
+ */
+export function waitForTypegenGenerationChild(child) {
+  return new Promise((resolve, reject) => {
+    let message;
+    const cleanup = () => {
+      child.offError(onError);
+      child.offExit(onExit);
+      child.offMessage(onMessage);
+    };
+    const onError = error => {
+      cleanup();
+      reject(error);
+    };
+    const onMessage = value => {
+      try {
+        message = parseTypegenGenerationMessage(value);
+      } catch (error) {
+        message = {
+          kind: 'error',
+          message: error instanceof Error ? error.message : String(error)
+        };
+      }
+    };
+    const onExit = (code, signal) => {
+      cleanup();
+      if (message?.kind === 'error') {
+        reject(new TypegenCommandError(message.message));
+        return;
+      }
+      if (message?.kind === 'source' && code === 0) {
+        resolve(message.source);
+        return;
+      }
+      reject(new TypegenCommandError(`Typegen generation process exited ${describeExit(code, signal)} before returning source.`));
+    };
+    child.onError(onError);
+    child.onExit(onExit);
+    child.onMessage(onMessage);
+  });
+}
+
+/**
+ * Starts one default typegen generation child for a coordinator to complete or cancel.
+ *
+ * @param request Consumer directory, application module path, and selected export.
+ * @param spawnGeneration Child-process factory used by the default runtime and lifecycle tests.
+ * @returns A cancellable child process whose result settles only after a clean process exit.
+ */
+export function startTypegenGenerationProcess(request, spawnGeneration = createGenerationChild) {
+  const child = spawnGeneration(request);
+  let cancelled = false;
+  let forcedKillTimer;
+  const result = waitForTypegenGenerationChild(child).finally(() => {
+    if (forcedKillTimer !== undefined) {
+      clearTimeout(forcedKillTimer);
+      forcedKillTimer = undefined;
+    }
+  });
+  return {
+    cancel() {
+      if (cancelled) {
+        return;
+      }
+      cancelled = true;
+      if (!child.kill('SIGTERM')) {
+        return;
+      }
+      forcedKillTimer = setTimeout(() => {
+        forcedKillTimer = undefined;
+        child.kill('SIGKILL');
+      }, CHILD_TERMINATION_GRACE_MS);
+    },
+    result
+  };
+}
+
+/**
+ * Runs one default typegen generation in a short-lived child process.
+ *
+ * @param request Consumer directory, application module path, and selected export.
+ * @param spawnGeneration Child-process factory used by the default runtime and lifecycle tests.
+ * @returns Generated source after the child process has exited.
+ */
+export async function runTypegenGenerationProcess(request, spawnGeneration = createGenerationChild) {
+  return startTypegenGenerationProcess(request, spawnGeneration).result;
+}

package/dist/commands/typegen-generation-protocol.d.ts

@@ -0,0 +1,16 @@
+/** IPC outcome emitted by one isolated typegen generation child. */
+export type TypegenGenerationMessage = {
+    readonly kind: 'error';
+    readonly message: string;
+} | {
+    readonly kind: 'source';
+    readonly source: string;
+};
+/**
+ * Parses an untrusted generation child IPC payload.
+ *
+ * @param value IPC payload received from the child process.
+ * @returns A validated source or error message.
+ */
+export declare function parseTypegenGenerationMessage(value: unknown): TypegenGenerationMessage;
+//# sourceMappingURL=typegen-generation-protocol.d.ts.map

package/dist/commands/typegen-generation-protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen-generation-protocol.d.ts","sourceRoot":"","sources":["../../src/commands/typegen-generation-protocol.ts"],"names":[],"mappings":"AAEA,oEAAoE;AACpE,MAAM,MAAM,wBAAwB,GAChC;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpD;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAEzD;;;;;GAKG;AACH,wBAAgB,6BAA6B,CAAC,KAAK,EAAE,OAAO,GAAG,wBAAwB,CAkBtF"}

package/dist/commands/typegen-generation-protocol.js

@@ -0,0 +1,35 @@
+import { TypegenCommandError } from './typegen-options.js';
+
+/** IPC outcome emitted by one isolated typegen generation child. */
+
+/**
+ * Parses an untrusted generation child IPC payload.
+ *
+ * @param value IPC payload received from the child process.
+ * @returns A validated source or error message.
+ */
+export function parseTypegenGenerationMessage(value) {
+  if (typeof value !== 'object' || value === null) {
+    throw new TypegenCommandError('Typegen generation process returned an invalid IPC message.');
+  }
+  const kind = Reflect.get(value, 'kind');
+  if (kind === 'error') {
+    const message = Reflect.get(value, 'message');
+    if (typeof message === 'string') {
+      return {
+        kind,
+        message
+      };
+    }
+  }
+  if (kind === 'source') {
+    const source = Reflect.get(value, 'source');
+    if (typeof source === 'string') {
+      return {
+        kind,
+        source
+      };
+    }
+  }
+  throw new TypegenCommandError('Typegen generation process returned an invalid IPC message.');
+}

package/dist/commands/typegen-isolated-source.d.ts

@@ -0,0 +1,10 @@
+import type { ParsedTypegenArgs } from './typegen-options.js';
+/**
+ * Generates source inside the default short-lived process while preserving one native module graph.
+ *
+ * @param parsed Parsed typegen command options.
+ * @param cwd Consumer project directory.
+ * @returns Complete deterministic generated source.
+ */
+export declare function createProcessIsolatedTypegenSource(parsed: ParsedTypegenArgs, cwd: string): Promise<string>;
+//# sourceMappingURL=typegen-isolated-source.d.ts.map

package/dist/commands/typegen-isolated-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen-isolated-source.d.ts","sourceRoot":"","sources":["../../src/commands/typegen-isolated-source.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAkE9D;;;;;;GAMG;AACH,wBAAsB,kCAAkC,CACtD,MAAM,EAAE,iBAAiB,EACzB,GAAG,EAAE,MAAM,GACV,OAAO,CAAC,MAAM,CAAC,CAcjB"}

package/dist/commands/typegen-isolated-source.js

@@ -0,0 +1,75 @@
+import { existsSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { TypegenCommandError } from './typegen-options.js';
+import { createTypegenSource, generateTypegenSource, loadReactTypegenModules } from './typegen-source.js';
+const TYPESCRIPT_MODULE_EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts']);
+const TYPEGEN_MODULE_IDS = ['@fluojs/react', '@fluojs/react/typegen', '@fluojs/runtime'];
+function isModuleNotFoundError(error) {
+  return typeof error === 'object' && error !== null && 'code' in error && (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND');
+}
+function resolveProjectModuleUrl(moduleId, cwd) {
+  const parentUrls = [pathToFileURL(resolve(cwd, 'package.json')).href, import.meta.url];
+  for (const parentUrl of parentUrls) {
+    try {
+      return import.meta.resolve(moduleId, parentUrl);
+    } catch (error) {
+      if (!isModuleNotFoundError(error)) {
+        throw error;
+      }
+    }
+  }
+  throw new TypegenCommandError(`Unable to resolve ${moduleId} from the inspected project.`);
+}
+function requireNamespace(owner, name) {
+  const value = Reflect.get(owner, name);
+  if (typeof value !== 'object' || value === null) {
+    throw new TypegenCommandError(`Required typegen namespace ${name} is unavailable.`);
+  }
+  return value;
+}
+async function importNativeTypegenGraph(modulePath, cwd) {
+  const imports = {
+    application: pathToFileURL(modulePath).href,
+    react: resolveProjectModuleUrl(TYPEGEN_MODULE_IDS[0], cwd),
+    typegen: resolveProjectModuleUrl(TYPEGEN_MODULE_IDS[1], cwd),
+    runtime: resolveProjectModuleUrl(TYPEGEN_MODULE_IDS[2], cwd)
+  };
+  const source = `${Object.entries(imports).map(([name, url]) => `import * as ${name} from ${JSON.stringify(url)};`).join('\n')}\nexport { application, react, runtime, typegen };\n`;
+  const graphUrl = `data:text/javascript;charset=utf-8,${encodeURIComponent(source)}`;
+  const graph = await import(graphUrl);
+  return {
+    application: requireNamespace(graph, 'application'),
+    modules: {
+      react: requireNamespace(graph, 'react'),
+      runtime: requireNamespace(graph, 'runtime'),
+      typegen: requireNamespace(graph, 'typegen')
+    }
+  };
+}
+
+/**
+ * Generates source inside the default short-lived process while preserving one native module graph.
+ *
+ * @param parsed Parsed typegen command options.
+ * @param cwd Consumer project directory.
+ * @returns Complete deterministic generated source.
+ */
+export async function createProcessIsolatedTypegenSource(parsed, cwd) {
+  const modulePath = resolve(cwd, parsed.modulePath);
+  if (TYPESCRIPT_MODULE_EXTENSIONS.has(extname(modulePath))) {
+    const tsconfigPath = resolve(dirname(modulePath), 'tsconfig.json');
+    const modules = await loadReactTypegenModules(cwd, existsSync(tsconfigPath) ? tsconfigPath : false);
+    return createTypegenSource({
+      cwd,
+      modules,
+      parsed
+    });
+  }
+  const imported = await importNativeTypegenGraph(modulePath, cwd);
+  return generateTypegenSource({
+    application: imported.application,
+    modules: imported.modules,
+    parsed
+  });
+}

package/dist/commands/typegen-options.d.ts

@@ -0,0 +1,20 @@
+/** Parsed lifecycle and path options for one typegen invocation. */
+export type ParsedTypegenArgs = {
+    readonly check: boolean;
+    readonly exportName: string;
+    readonly modulePath: string;
+    readonly outputPath: string;
+    readonly watch: boolean;
+};
+/** Invalid typegen command arguments or unavailable runtime tooling. */
+export declare class TypegenCommandError extends Error {
+    readonly name = "TypegenCommandError";
+}
+/**
+ * Parses command arguments after `fluo typegen`.
+ *
+ * @param argv Raw typegen command arguments.
+ * @returns Parsed module, output, export, and lifecycle options.
+ */
+export declare function parseTypegenArgs(argv: readonly string[]): ParsedTypegenArgs;
+//# sourceMappingURL=typegen-options.d.ts.map

package/dist/commands/typegen-options.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen-options.d.ts","sourceRoot":"","sources":["../../src/commands/typegen-options.ts"],"names":[],"mappings":"AAAA,oEAAoE;AACpE,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC;CACzB,CAAC;AAEF,wEAAwE;AACxE,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,QAAQ,CAAC,IAAI,yBAAyB;CACvC;AAED;;;;;GAKG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,SAAS,MAAM,EAAE,GAAG,iBAAiB,CAsD3E"}

package/dist/commands/typegen-options.js

@@ -0,0 +1,71 @@
+/** Parsed lifecycle and path options for one typegen invocation. */
+
+/** Invalid typegen command arguments or unavailable runtime tooling. */
+export class TypegenCommandError extends Error {
+  name = 'TypegenCommandError';
+}
+
+/**
+ * Parses command arguments after `fluo typegen`.
+ *
+ * @param argv Raw typegen command arguments.
+ * @returns Parsed module, output, export, and lifecycle options.
+ */
+export function parseTypegenArgs(argv) {
+  let check = false;
+  let exportName = 'AppModule';
+  let modulePath;
+  let outputPath;
+  let watch = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    const option = argv[index];
+    if (option === '--check') {
+      check = true;
+      continue;
+    }
+    if (option === '--watch') {
+      watch = true;
+      continue;
+    }
+    if (option === '--output') {
+      const next = argv[index + 1];
+      if (next === undefined || next.startsWith('-')) {
+        throw new TypegenCommandError('Expected --output to have a file path value.');
+      }
+      outputPath = next;
+      index += 1;
+      continue;
+    }
+    if (option === '--export') {
+      const next = argv[index + 1];
+      if (next === undefined || next.startsWith('-')) {
+        throw new TypegenCommandError('Expected --export to have a symbol name value.');
+      }
+      exportName = next;
+      index += 1;
+      continue;
+    }
+    if (option?.startsWith('-')) {
+      throw new TypegenCommandError(`Unknown option for typegen command: ${option}`);
+    }
+    if (option !== undefined) {
+      if (modulePath !== undefined) {
+        throw new TypegenCommandError(`Unexpected extra positional argument: ${option}`);
+      }
+      modulePath = option;
+    }
+  }
+  if (modulePath === undefined || outputPath === undefined) {
+    throw new TypegenCommandError('Usage: fluo typegen <module-path> --output <path> [--export <name>] [--check|--watch]');
+  }
+  if (check && watch) {
+    throw new TypegenCommandError('fluo typegen accepts only one of --check or --watch.');
+  }
+  return {
+    check,
+    exportName,
+    modulePath,
+    outputPath,
+    watch
+  };
+}

package/dist/commands/typegen-source.d.ts

@@ -0,0 +1,59 @@
+import type { ParsedTypegenArgs } from './typegen-options.js';
+/** Dynamically loaded package surfaces required by typegen. */
+export type ReactTypegenModules = {
+    readonly react: object;
+    readonly runtime: object;
+    readonly typegen: object;
+};
+/** Structural artifact result returned by the React typegen package. */
+export type ReactTypegenArtifactInspection = {
+    readonly status: 'malformed';
+} | {
+    readonly status: 'unsupported-version';
+    readonly version: number;
+} | {
+    readonly status: 'valid';
+    readonly version: number;
+};
+type CreateTypegenSourceOptions = {
+    readonly cwd: string;
+    readonly modules: ReactTypegenModules;
+    readonly parsed: ParsedTypegenArgs;
+};
+type GenerateTypegenSourceOptions = {
+    readonly application: object;
+    readonly modules: ReactTypegenModules;
+    readonly parsed: ParsedTypegenArgs;
+};
+/**
+ * Loads typegen package entrypoints from the consumer project or CLI installation.
+ *
+ * @param cwd Consumer project directory used for package resolution.
+ * @param tsconfig TypeScript configuration path, or `false` for native package resolution.
+ * @returns React, React typegen, and runtime module namespaces.
+ */
+export declare function loadReactTypegenModules(cwd: string, tsconfig?: string | false): Promise<ReactTypegenModules>;
+/**
+ * Bootstraps the selected module and generates source from authoritative route descriptors.
+ *
+ * @param options Parsed command, consumer directory, module namespaces, and native import boundary.
+ * @returns Complete deterministic generated source.
+ */
+export declare function createTypegenSource(options: CreateTypegenSourceOptions): Promise<string>;
+/**
+ * Generates source from one already-imported application and its matching tooling namespaces.
+ *
+ * @param options Application namespace, generation modules, and parsed command selection.
+ * @returns Complete deterministic generated source.
+ */
+export declare function generateTypegenSource(options: GenerateTypegenSourceOptions): Promise<string>;
+/**
+ * Inspects an existing generated source value through the loaded React typegen package.
+ *
+ * @param modules Loaded React typegen module namespace.
+ * @param source Existing artifact source.
+ * @returns Parsed current, malformed, or unsupported-version status.
+ */
+export declare function inspectReactTypegenArtifact(modules: ReactTypegenModules, source: string): ReactTypegenArtifactInspection;
+export {};
+//# sourceMappingURL=typegen-source.d.ts.map

package/dist/commands/typegen-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typegen-source.d.ts","sourceRoot":"","sources":["../../src/commands/typegen-source.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,sBAAsB,CAAC;AAG9D,+DAA+D;AAC/D,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,wEAAwE;AACxE,MAAM,MAAM,8BAA8B,GACtC;IAAE,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAA;CAAE,GAChC;IAAE,QAAQ,CAAC,MAAM,EAAE,qBAAqB,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpE;IAAE,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE3D,KAAK,0BAA0B,GAAG;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;CACpC,CAAC;AAEF,KAAK,4BAA4B,GAAG;IAClC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,OAAO,EAAE,mBAAmB,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,iBAAiB,CAAC;CACpC,CAAC;AAwEF;;;;;;GAMG;AACH,wBAAsB,uBAAuB,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,GAAE,MAAM,GAAG,KAAa,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAKzH;AAED;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,OAAO,EAAE,0BAA0B,GAAG,OAAO,CAAC,MAAM,CAAC,CAU9F;AAED;;;;;GAKG;AACH,wBAAsB,qBAAqB,CAAC,OAAO,EAAE,4BAA4B,GAAG,OAAO,CAAC,MAAM,CAAC,CAqClG;AAED;;;;;;GAMG;AACH,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,mBAAmB,EAC5B,MAAM,EAAE,MAAM,GACb,8BAA8B,CAmBhC"}

package/dist/commands/typegen-source.js

@@ -0,0 +1,183 @@
+import { existsSync } from 'node:fs';
+import { dirname, extname, resolve } from 'node:path';
+import { pathToFileURL } from 'node:url';
+import { tsImport } from 'tsx/esm/api';
+import { TypegenCommandError } from './typegen-options.js';
+
+/** Dynamically loaded package surfaces required by typegen. */
+
+/** Structural artifact result returned by the React typegen package. */
+
+const TYPESCRIPT_MODULE_EXTENSIONS = new Set(['.ts', '.tsx', '.mts', '.cts']);
+const TYPEGEN_MODULE_IDS = ['@fluojs/react', '@fluojs/react/typegen', '@fluojs/runtime'];
+const SILENT_APPLICATION_LOGGER = Object.freeze({
+  debug() {},
+  error() {},
+  log() {},
+  warn() {}
+});
+let applicationImportSequence = 0;
+function isModuleNotFoundError(error) {
+  return typeof error === 'object' && error !== null && 'code' in error && (error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND');
+}
+async function importProjectModule(moduleId, cwd, tsconfig) {
+  const importOptions = [{
+    parentURL: pathToFileURL(resolve(cwd, 'package.json')).href,
+    tsconfig
+  }, {
+    parentURL: import.meta.url,
+    tsconfig: false
+  }];
+  for (const options of importOptions) {
+    try {
+      const imported = await tsImport(moduleId, options);
+      if (typeof imported !== 'object' || imported === null) {
+        throw new TypegenCommandError(`Resolved ${moduleId} to an invalid module namespace.`);
+      }
+      return imported;
+    } catch (error) {
+      if (!isModuleNotFoundError(error)) {
+        throw error;
+      }
+    }
+  }
+  throw new TypegenCommandError(`Unable to resolve ${moduleId} from the inspected project.`);
+}
+async function importTypeScriptApplicationModule(modulePath) {
+  const moduleUrl = pathToFileURL(modulePath).href;
+  const tsconfigPath = resolve(dirname(modulePath), 'tsconfig.json');
+  return existsSync(tsconfigPath) ? tsImport(moduleUrl, {
+    parentURL: import.meta.url,
+    tsconfig: tsconfigPath
+  }) : tsImport(moduleUrl, {
+    parentURL: import.meta.url,
+    tsconfig: false
+  });
+}
+function requireNamespace(owner, name) {
+  const value = Reflect.get(owner, name);
+  if (typeof value !== 'object' || value === null) {
+    throw new TypegenCommandError(`Required typegen namespace ${name} is unavailable.`);
+  }
+  return value;
+}
+async function importNativeApplicationModule(modulePath) {
+  applicationImportSequence += 1;
+  const source = `import * as application from ${JSON.stringify(pathToFileURL(modulePath).href)};\nexport { application };\n`;
+  const graphUrl = `data:text/javascript;charset=utf-8,${encodeURIComponent(source)}#fluo-typegen-${String(applicationImportSequence)}`;
+  const graph = await tsImport(graphUrl, import.meta.url);
+  return requireNamespace(graph, 'application');
+}
+function requireFunction(owner, name) {
+  const value = Reflect.get(owner, name);
+  if (typeof value !== 'function') {
+    throw new TypegenCommandError(`Required typegen function ${name} is unavailable.`);
+  }
+  return value;
+}
+
+/**
+ * Loads typegen package entrypoints from the consumer project or CLI installation.
+ *
+ * @param cwd Consumer project directory used for package resolution.
+ * @param tsconfig TypeScript configuration path, or `false` for native package resolution.
+ * @returns React, React typegen, and runtime module namespaces.
+ */
+export async function loadReactTypegenModules(cwd, tsconfig = false) {
+  const [react, typegen, runtime] = await Promise.all(TYPEGEN_MODULE_IDS.map(moduleId => importProjectModule(moduleId, cwd, tsconfig)));
+  return {
+    react,
+    runtime,
+    typegen
+  };
+}
+
+/**
+ * Bootstraps the selected module and generates source from authoritative route descriptors.
+ *
+ * @param options Parsed command, consumer directory, module namespaces, and native import boundary.
+ * @returns Complete deterministic generated source.
+ */
+export async function createTypegenSource(options) {
+  const modulePath = resolve(options.cwd, options.parsed.modulePath);
+  const importedApplication = TYPESCRIPT_MODULE_EXTENSIONS.has(extname(modulePath)) ? await importTypeScriptApplicationModule(modulePath) : await importNativeApplicationModule(modulePath);
+  return generateTypegenSource({
+    application: importedApplication,
+    modules: options.modules,
+    parsed: options.parsed
+  });
+}
+
+/**
+ * Generates source from one already-imported application and its matching tooling namespaces.
+ *
+ * @param options Application namespace, generation modules, and parsed command selection.
+ * @returns Complete deterministic generated source.
+ */
+export async function generateTypegenSource(options) {
+  const rootModule = Reflect.get(options.application, options.parsed.exportName);
+  if (typeof rootModule !== 'function') {
+    throw new TypegenCommandError(`Export "${options.parsed.exportName}" is not a module class constructor.`);
+  }
+  const factory = Reflect.get(options.modules.runtime, 'FluoFactory');
+  if (typeof factory !== 'function') {
+    throw new TypegenCommandError('Required runtime FluoFactory is unavailable.');
+  }
+  const application = await Reflect.apply(requireFunction(factory, 'create'), factory, [rootModule, {
+    logger: SILENT_APPLICATION_LOGGER
+  }]);
+  if (typeof application !== 'object' || application === null) {
+    throw new TypegenCommandError('Runtime application bootstrap returned an invalid value.');
+  }
+  const close = requireFunction(application, 'close');
+  try {
+    const dispatcher = Reflect.get(application, 'dispatcher');
+    if (typeof dispatcher !== 'object' || dispatcher === null) {
+      throw new TypegenCommandError('Runtime application dispatcher is unavailable.');
+    }
+    const descriptors = Reflect.apply(requireFunction(dispatcher, 'describeRoutes'), dispatcher, []);
+    if (!Array.isArray(descriptors)) {
+      throw new TypegenCommandError('Runtime route descriptors are unavailable.');
+    }
+    const catalog = Reflect.apply(requireFunction(options.modules.react, 'createReactPageCatalog'), undefined, [descriptors]);
+    const source = Reflect.apply(requireFunction(options.modules.typegen, 'generateReactPageTypes'), undefined, [catalog]);
+    if (typeof source !== 'string') {
+      throw new TypegenCommandError('React page typegen returned an invalid artifact.');
+    }
+    return source;
+  } finally {
+    await Reflect.apply(close, application, []);
+  }
+}
+
+/**
+ * Inspects an existing generated source value through the loaded React typegen package.
+ *
+ * @param modules Loaded React typegen module namespace.
+ * @param source Existing artifact source.
+ * @returns Parsed current, malformed, or unsupported-version status.
+ */
+export function inspectReactTypegenArtifact(modules, source) {
+  const inspection = Reflect.apply(requireFunction(modules.typegen, 'inspectReactPageTypeArtifact'), undefined, [source]);
+  if (typeof inspection !== 'object' || inspection === null || !('status' in inspection)) {
+    throw new TypegenCommandError('React page typegen artifact inspection returned an invalid result.');
+  }
+  if (inspection.status === 'malformed') {
+    return {
+      status: 'malformed'
+    };
+  }
+  if (inspection.status === 'unsupported-version' && 'version' in inspection && typeof inspection.version === 'number') {
+    return {
+      status: 'unsupported-version',
+      version: inspection.version
+    };
+  }
+  if (inspection.status === 'valid' && 'version' in inspection && typeof inspection.version === 'number') {
+    return {
+      status: 'valid',
+      version: inspection.version
+    };
+  }
+  throw new TypegenCommandError('React page typegen artifact inspection returned an invalid result.');
+}