@gtkx/codegen 1.0.0-rc.1 → 1.0.0-rc.2

package/src/runner.ts

@@ -1,34 +1,36 @@
 import { mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
-import type { ElementProp } from "@gtkx/config";
+import type { GiStoreOptions } from "./store/gi-store.js";
+import type { JsxStoreOptions } from "./store/jsx-store.js";
 import { checkModules } from "./compile.js";
-import { computeFingerprint, isStoreFresh } from "./fingerprint.js";
+import { isGiStoreFresh } from "./fingerprint.js";
+import { runGiCodegen } from "./gi.js";
 import { Library } from "./gir/library.js";
-import { namespaceDirectory } from "./gir/namespace.js";
-import { type GlGenerationReport, generateGlModules } from "./khronos/pipeline.js";
-import { generateNamespaceModule } from "./store/gi/pipeline.js";
-import { type GiNamespaceInput, type GiStoreOptions, writeGiStore } from "./store/gi-store.js";
-import { type JsxStoreOptions, writeJsxStore } from "./store/jsx-store.js";
-import { generateJsxFiles } from "./store/react/pipeline.js";
-
-export type GlCodegenOptions = {
+import { generateGlModules, type GlGenerationReport } from "./khronos/pipeline.js";
+
+type ModuleExport = { module: string; export: string };
+
+type GlCodegenOptions = {
     registryPath: string;
     overrideExports: Set<string>;
     outputDir: string;
     resolveFrom: string;
 };
 
-export type CodegenRunnerOptions = {
+type CodegenRunnerOptions = {
     libraries?: string[];
     girPath?: string[];
-    elementProps?: Record<string, ElementProp[]> | undefined;
     gi?: GiStoreOptions;
     jsx?: JsxStoreOptions | undefined;
+    reactSubexports?: string[];
+    userComponents?: Record<string, ModuleExport>;
+    userLazyElements?: string[];
+    userProps?: Record<string, ModuleExport>;
     gl?: GlCodegenOptions;
     force?: boolean;
 };
 
-export type CodegenRunnerResult = {
+type CodegenRunnerResult = {
     regenerated: boolean;
     namespaces: number;
     intrinsicElements: number;
@@ -36,7 +38,8 @@ export type CodegenRunnerResult = {
     gl?: GlGenerationReport | undefined;
 };
 
-type GiEmitResult = {
+type StoreResult = {
+    regenerated: boolean;
     namespaces: number;
     intrinsicElements: number;
 };
@@ -44,20 +47,21 @@ type GiEmitResult = {
 /**
  * Runs the `@gtkx` code generators, producing the `@gtkx/gi`, `@gtkx/jsx`, and `@gtkx/gl` bindings from the
  * configured GObject-introspection libraries and OpenGL registry. The gi store is regenerated only when its
- * fingerprint is stale unless `options.force` is set, while the OpenGL modules are regenerated whenever
- * `options.gl` is provided.
+ * fingerprint is stale unless `options.force` is set, then the jsx store is regenerated when the gi store or
+ * the React element config changed; the OpenGL modules are regenerated whenever `options.gl` is provided.
  *
  * @param options - What to generate and where to write it.
  * @returns A summary of what was regenerated and how long the run took.
  */
-export const runCodegen = async (options: CodegenRunnerOptions): Promise<CodegenRunnerResult> => {
+const runCodegen = async (options: CodegenRunnerOptions): Promise<CodegenRunnerResult> => {
     const start = Date.now();
     const gl = options.gl === undefined ? undefined : emitGlModules(options.gl);
-    const gi = emitGiStoreIfStale(options);
+    const store = await emitStores(options);
+
     return {
-        regenerated: gi !== undefined,
-        namespaces: gi?.namespaces ?? 0,
-        intrinsicElements: gi?.intrinsicElements ?? 0,
+        regenerated: store.regenerated,
+        namespaces: store.namespaces,
+        intrinsicElements: store.intrinsicElements,
         duration: Date.now() - start,
         gl,
     };
@@ -68,59 +72,91 @@ const emitGlModules = (options: GlCodegenOptions): GlGenerationReport => {
         registryPath: options.registryPath,
         overrideExports: options.overrideExports,
     });
+
     checkModules({
         modules: [...files].map(([fileName, source]) => ({ fileName, source })),
         resolveFrom: options.resolveFrom,
         label: "the generated gl modules",
     });
+
     mkdirSync(options.outputDir, { recursive: true });
+
     for (const [fileName, source] of files) {
         writeFileSync(join(options.outputDir, fileName), source);
     }
+
     return report;
 };
 
-const emitGiStoreIfStale = (options: CodegenRunnerOptions): GiEmitResult | undefined => {
-    const { gi, libraries, girPath } = options;
-    if (gi === undefined || libraries === undefined || girPath === undefined) return undefined;
-    const elementProps = options.elementProps ?? {};
-    if (options.force !== true && isStoreFresh(gi.storeDir, libraries, elementProps)) return undefined;
-    const library = Library.load(libraries, girPath);
-    emitGiStore(gi, libraries, elementProps, library);
+const jsxUserOptions = (
+    options: CodegenRunnerOptions,
+): {
+    reactSubexports: string[];
+    userComponents: Record<string, ModuleExport>;
+    userLazyElements: string[];
+    userProps: Record<string, ModuleExport>;
+} => ({
+    reactSubexports: options.reactSubexports ?? [],
+    userComponents: options.userComponents ?? {},
+    userLazyElements: options.userLazyElements ?? [],
+    userProps: options.userProps ?? {},
+});
+
+const emitJsxStore = async (input: {
+    options: CodegenRunnerOptions;
+    jsx: JsxStoreOptions;
+    gi: GiStoreOptions;
+    loadLibrary: () => Library;
+    giRegenerated: boolean;
+    namespaces: number;
+}): Promise<StoreResult> => {
+    const { options, jsx, gi, loadLibrary, giRegenerated, namespaces } = input;
+    const { runJsxCodegen } = await import("./jsx.js");
+
+    const jsxResult = await runJsxCodegen({
+        getLibrary: loadLibrary,
+        jsx,
+        giStoreDir: gi.storeDir,
+        ...jsxUserOptions(options),
+        giRegenerated,
+        force: options.force === true,
+    });
+
     return {
-        namespaces: library.namespaces.size,
-        intrinsicElements: emitJsxStore(options.jsx, elementProps, library),
+        regenerated: giRegenerated || jsxResult.regenerated,
+        namespaces,
+        intrinsicElements: jsxResult.intrinsicElementCount,
     };
 };
 
-const emitGiStore = (
-    gi: GiStoreOptions,
-    libraries: string[],
-    elementProps: Record<string, ElementProp[]>,
-    library: Library,
-): void => {
-    const namespaces: GiNamespaceInput[] = [];
-    for (const namespace of library.namespaces.values()) {
-        namespaces.push({
-            directory: namespaceDirectory(namespace),
-            rawSource: generateNamespaceModule(namespace, library),
-        });
+const emitStoresWithConfig = async (config: {
+    options: CodegenRunnerOptions;
+    gi: GiStoreOptions;
+    jsx: JsxStoreOptions | undefined;
+    libraries: string[];
+    girPath: string[];
+}): Promise<StoreResult> => {
+    const { options, gi, jsx, libraries, girPath } = config;
+    let library: Library | undefined;
+    const loadLibrary = (): Library => (library ??= Library.load(libraries, girPath));
+    const isGiRegenerated = options.force === true || !isGiStoreFresh(gi.storeDir, libraries, girPath);
+    const namespaces = isGiRegenerated ? runGiCodegen(loadLibrary(), gi, libraries, girPath) : 0;
+
+    if (jsx === undefined) {
+        return { regenerated: isGiRegenerated, namespaces, intrinsicElements: 0 };
     }
-    const libs = [...libraries];
-    writeGiStore(gi, namespaces, {
-        value: computeFingerprint(library.girFiles, libs, elementProps),
-        girFiles: library.girFiles,
-        libraries: libs,
-    });
+
+    return emitJsxStore({ options, jsx, gi, loadLibrary, giRegenerated: isGiRegenerated, namespaces });
 };
 
-const emitJsxStore = (
-    jsx: JsxStoreOptions | undefined,
-    elementProps: Record<string, ElementProp[]>,
-    library: Library,
-): number => {
-    if (jsx === undefined) return 0;
-    const reactPipeline = generateJsxFiles(library, elementProps);
-    writeJsxStore(jsx, reactPipeline.namespaces, reactPipeline.metadata);
-    return reactPipeline.intrinsicElementCount;
+const emitStores = async (options: CodegenRunnerOptions): Promise<StoreResult> => {
+    const { gi, jsx, libraries, girPath } = options;
+
+    if (gi === undefined || libraries === undefined || girPath === undefined) {
+        return { regenerated: false, namespaces: 0, intrinsicElements: 0 };
+    }
+
+    return emitStoresWithConfig({ options, gi, jsx, libraries, girPath });
 };
+
+export { runCodegen, type GlCodegenOptions, type CodegenRunnerOptions, type CodegenRunnerResult };

package/src/store/compile-store.ts

@@ -1,12 +1,13 @@
-import { rmSync } from "node:fs";
+import { rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { compileProject, type SourceModule } from "../compile.js";
 
-export type CompileStoreParams = {
+type CompileStoreParams = {
     storeDir: string;
     files: SourceModule[];
     packageName: string;
-    exports: Record<string, unknown>;
+    /** Declare `virtual:gtkx-config` for the typecheck, needed when it follows imports into `@gtkx/react` source. */
+    configEnv?: boolean;
 };
 
 const EMIT_OPTIONS = {
@@ -14,36 +15,41 @@ const EMIT_OPTIONS = {
     removeComments: false,
     sourceMap: false,
     declarationMap: false,
-    noEmitOnError: true,
     rootDir: ".",
     outDir: ".",
 };
 
-const selfPaths = (
-    packageName: string,
-    exportsMap: Record<string, unknown>,
-    storeDir: string,
-): Record<string, string[]> => {
-    const paths: Record<string, string[]> = {};
-    for (const [key, value] of Object.entries(exportsMap)) {
-        if (key === "./package.json" || typeof value !== "object" || value === null) continue;
-        const target = (value as { default?: unknown }).default;
-        if (typeof target !== "string") continue;
-        const stem = target.replace(/^\.\//, "").replace(/\.js$/, "");
-        paths[`${packageName}${key.slice(1)}`] = [join(storeDir, stem)];
-    }
-    return paths;
+const ENV_REFERENCE_FILE = "__gtkx-env__.d.ts";
+
+const writeEnvReference = (storeDir: string): (() => void) => {
+    writeFileSync(join(storeDir, ENV_REFERENCE_FILE), "/// <reference types=\"@gtkx/react/env\" />\n");
+
+    return () => {
+        rmSync(join(storeDir, ENV_REFERENCE_FILE), { force: true });
+    };
 };
 
-export const compileStore = (params: CompileStoreParams): void => {
-    compileProject({
-        projectDir: params.storeDir,
-        fileNames: params.files.map((file) => file.fileName),
-        compilerOptions: EMIT_OPTIONS,
-        paths: selfPaths(params.packageName, params.exports, params.storeDir),
-        label: `the generated ${params.packageName} store`,
-    });
+const compileStore = (params: CompileStoreParams): void => {
+    const fileNames = params.files.map((file) => file.fileName);
+
+    const removeEnvReference = params.configEnv === true
+        ? writeEnvReference(params.storeDir)
+        : (): void => undefined;
+
+    try {
+        compileProject({
+            projectDir: params.storeDir,
+            fileNames: params.configEnv === true ? [ENV_REFERENCE_FILE, ...fileNames] : fileNames,
+            compilerOptions: EMIT_OPTIONS,
+            label: `the generated ${params.packageName} store`,
+        });
+    } finally {
+        removeEnvReference();
+    }
+
     for (const file of params.files) {
         rmSync(join(params.storeDir, file.fileName), { force: true });
     }
 };
+
+export { compileStore, type CompileStoreParams };

package/src/store/gi/async.ts

@@ -1,42 +1,69 @@
-import { inputParameters } from "../../analysis/param-structure.js";
 import type { GirFunction } from "../../gir/function.js";
 import type { Library } from "../../gir/library.js";
+import type { TypeId } from "../../gir/type-id.js";
+import { inputParameters } from "../../analysis/param-structure.js";
 
-export const matchAsyncFinish = (
+const matchAsyncFinish = (
     library: Library,
     fn: GirFunction,
     siblings: GirFunction[],
 ): GirFunction | undefined => {
-    if (!hasCanonicalAsyncCallback(library, fn)) return undefined;
-    const finishName = matchAsyncFinishName(fn, siblings);
-    if (finishName === undefined) return undefined;
-    const finishFn = siblings.find((sibling) => sibling.name === finishName);
-    if (finishFn === undefined || !isPromisifiableFinish(library, finishFn)) return undefined;
+    if (!hasCanonicalAsyncCallback(library, fn)) {
+        return undefined;
+    }
+
+    const finishFn = findFinishSibling(fn, siblings);
+
+    if (finishFn === undefined || !isPromisifiableFinish(library, finishFn)) {
+        return undefined;
+    }
+
     return finishFn;
 };
 
-const matchAsyncFinishName = (fn: GirFunction, siblings: GirFunction[]): string | undefined => {
-    if (fn.name.endsWith("_finish")) return undefined;
+const findFinishSibling = (fn: GirFunction, siblings: GirFunction[]): GirFunction | undefined => {
+    const annotated = fn.finishFunc;
+
+    if (annotated !== undefined) {
+        return siblings.find((sibling) => sibling.name === annotated || sibling.cIdentifier === annotated);
+    }
+
+    if (fn.name.endsWith("_finish")) {
+        return undefined;
+    }
+
     const root = fn.name.endsWith("_async") ? fn.name.slice(0, -"_async".length) : fn.name;
     const finishName = `${root}_finish`;
-    return siblings.some((sibling) => sibling.name === finishName) ? finishName : undefined;
+
+    return siblings.find((sibling) => sibling.name === finishName);
 };
 
-const hasCanonicalAsyncCallback = (library: Library, fn: GirFunction): boolean => {
-    let asyncReadyCallbacks = 0;
-    let otherCallbacks = 0;
-    for (const parameter of fn.parameters) {
-        const ref = parameter.type;
-        if (ref === undefined || library.typeOf(ref)?.kind !== "callback") continue;
-        if (library.nameOf(ref)?.typeName === "AsyncReadyCallback") asyncReadyCallbacks += 1;
-        else otherCallbacks += 1;
+const callbackParameterName = (library: Library, ref: TypeId | undefined): string | undefined => {
+    if (ref === undefined || library.typeFor(ref)?.kind !== "callback") {
+        return undefined;
     }
-    return asyncReadyCallbacks === 1 && otherCallbacks === 0;
+
+    return library.nameFor(ref)?.typeName;
+};
+
+const hasCanonicalAsyncCallback = (library: Library, fn: GirFunction): boolean => {
+    const callbackNames = fn.parameters
+        .map((parameter) => callbackParameterName(library, parameter.type))
+        .filter((name): name is string => name !== undefined);
+
+    return callbackNames.length === 1 && callbackNames[0] === "AsyncReadyCallback";
 };
 
 const isPromisifiableFinish = (library: Library, finishFn: GirFunction): boolean => {
     const inputs = inputParameters(library, finishFn);
-    if (inputs.length !== 1) return false;
+
+    if (inputs.length !== 1) {
+        return false;
+    }
+
     const only = inputs[0];
-    return only?.parameter.type !== undefined && library.nameOf(only.parameter.type)?.typeName === "AsyncResult";
+
+    return only?.parameter.type !== undefined && library.nameFor(only.parameter.type)?.typeName === "AsyncResult";
 };
+
+export { matchAsyncFinish };