@gtkx/codegen 0.21.0 → 1.0.0-rc.2

package/src/analysis/ts-type.ts

@@ -0,0 +1,174 @@
+import type { Library } from "../gir/library.js";
+import type { EntityType, GirType } from "../gir/type.js";
+import type { ModuleContext } from "../writer/context.js";
+import { PRIMITIVE_TS_TYPE } from "../gir/primitives.js";
+import {
+    type CArrayType,
+    type HashTableType,
+    hasUnknownArrayLength,
+    type ListType,
+    type TypeId,
+} from "../gir/type-id.js";
+import { isClassStructRecord } from "../store/gi/class-struct-record.js";
+import { gtypeTsType } from "../store/gi/gtype-binding.js";
+
+type ReferenceName = {
+    namespaceName: string;
+    typeName: string;
+};
+
+type TsTypeTarget = {
+    containerStyle: "map" | "record";
+    callbackType: string;
+    byteArrayAsNumber: boolean;
+    renderNamed: (resolved: GirType | undefined, name: ReferenceName) => string;
+    renderGtype: () => string;
+};
+
+const willEmitEntity = (library: Library, type: EntityType): boolean => {
+    switch (type.kind) {
+        case "callback": {
+            return type.value.introspectable && type.value.name.length > 0;
+        }
+        case "record": {
+            return (
+                type.value.introspectable &&
+                !type.value.isVtable &&
+                type.value.name.length > 0 &&
+                !isClassStructRecord(library, type.namespace.name, type.value)
+            );
+        }
+        case "alias":
+        case "class":
+        case "enum":
+        case "interface": {
+            return true;
+        }
+    }
+};
+
+const renderPrimitiveType = (target: TsTypeTarget, type: Extract<GirType, { kind: "primitive" }>): string =>
+    type.category === "gtype" ? target.renderGtype() : PRIMITIVE_TS_TYPE[type.category];
+
+const renderEntityType = (
+    library: Library,
+    target: TsTypeTarget,
+    type: EntityType,
+    name: ReferenceName | undefined,
+): string => renderNamedType(target, type, willEmitEntity(library, type) ? name : undefined);
+
+const renderBaseType = (library: Library, target: TsTypeTarget, ref: TypeId | undefined): string => {
+    if (ref === undefined) {
+        return "void";
+    }
+
+    const type = library.typeFor(ref);
+    const name = library.nameFor(ref);
+
+    if (type === undefined) {
+        return renderNamedType(target, undefined, name);
+    }
+
+    switch (type.kind) {
+        case "primitive": {
+            return renderPrimitiveType(target, type);
+        }
+        case "varargs": {
+            return "unknown[]";
+        }
+        case "callback":
+        case "class":
+        case "interface":
+        case "record":
+        case "enum":
+        case "alias": {
+            return renderEntityType(library, target, type, name);
+        }
+        case "carray":
+        case "list":
+        case "hashtable": {
+            return renderContainerType(library, target, type);
+        }
+    }
+};
+
+const renderContainerType = (
+    library: Library,
+    target: TsTypeTarget,
+    type: CArrayType | ListType | HashTableType,
+): string => {
+    if (type.kind === "hashtable") {
+        const key = renderBaseType(library, target, type.key);
+        const value = renderBaseType(library, target, type.value);
+
+        return target.containerStyle === "record" ? `Record<${key}, ${value}>` : `Map<${key}, ${value}>`;
+    }
+
+    return renderSequenceType(library, target, type);
+};
+
+// An array whose length nothing states decodes as the bare pointer it is, so its TypeScript type has
+// to say so too rather than promising elements nothing can count.
+const renderSequenceType = (library: Library, target: TsTypeTarget, type: CArrayType | ListType): string => {
+    if (type.kind === "list" && type.flavor === "gbytearray" && target.byteArrayAsNumber) {
+        return "number[]";
+    }
+
+    if (type.kind === "carray" && hasUnknownArrayLength(type)) {
+        return "number";
+    }
+
+    return `${renderBaseType(library, target, type.element)}[]`;
+};
+
+const renderNamedType = (
+    target: TsTypeTarget,
+    resolved: GirType | undefined,
+    name: ReferenceName | undefined,
+): string => {
+    if (name === undefined || name.typeName.length === 0) {
+        return resolved?.kind === "callback" ? target.callbackType : "unknown";
+    }
+
+    return target.renderNamed(resolved, name);
+};
+
+const moduleTarget = (context: ModuleContext): TsTypeTarget => ({
+    containerStyle: "map",
+    callbackType: "((...args: any[]) => any)",
+    byteArrayAsNumber: true,
+    renderNamed: (_resolved, name) => context.qualify(name.namespaceName, name.typeName),
+    renderGtype: () => gtypeTsType(context),
+});
+
+const renderTsType = (context: ModuleContext, ref: TypeId | undefined, isNullable = false): string => {
+    const base = renderBaseType(context.library, moduleTarget(context), ref);
+
+    return isNullable ? `${base} | null` : base;
+};
+
+const recordTypeTarget = (
+    library: Library,
+    renderNamedRef: (name: ReferenceName) => string,
+    renderGtype: () => string,
+): TsTypeTarget => {
+    const target: TsTypeTarget = {
+        containerStyle: "record",
+        callbackType: "((...args: unknown[]) => unknown)",
+        byteArrayAsNumber: false,
+        renderNamed: (resolved, name) => {
+            if (resolved?.kind === "alias") {
+                return resolved.value.target === undefined
+                    ? "number"
+                    : renderBaseType(library, target, resolved.value.target);
+            }
+
+            return renderNamedRef(name);
+        },
+        renderGtype,
+    };
+
+    return target;
+};
+
+export { renderBaseType, renderTsType, recordTypeTarget, type TsTypeTarget };

package/src/compile.ts

@@ -0,0 +1,179 @@
+import { existsSync, mkdirSync, mkdtempSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, relative } from "node:path";
+import { fileURLToPath } from "node:url";
+import ts from "typescript";
+
+type SourceModule = {
+    fileName: string;
+    source: string;
+};
+
+type CompileProjectParams = {
+    projectDir: string;
+    fileNames: string[];
+    compilerOptions: Record<string, unknown>;
+    label: string;
+};
+
+const BASE_COMPILER_OPTIONS = {
+    module: "esnext",
+    moduleResolution: "bundler",
+    target: "esnext",
+    lib: ["esnext"],
+    jsx: "react-jsx",
+    jsxImportSource: "react",
+    customConditions: ["source"],
+    strict: true,
+    exactOptionalPropertyTypes: true,
+    noUncheckedIndexedAccess: true,
+    noImplicitReturns: true,
+    noFallthroughCasesInSwitch: true,
+    allowUnreachableCode: false,
+    forceConsistentCasingInFileNames: true,
+    resolveJsonModule: true,
+    skipLibCheck: true,
+    types: ["node"],
+};
+
+const CHECK_OPTIONS = {
+    declaration: true,
+    isolatedDeclarations: true,
+    noEmit: true,
+};
+
+const FORMAT_HOST: ts.FormatDiagnosticsHost = {
+    getCanonicalFileName: (fileName) => fileName,
+    getCurrentDirectory: () => ts.sys.getCurrentDirectory(),
+    getNewLine: () => "\n",
+};
+
+/** `@gtkx/codegen`'s own `node_modules`, which has `@types/node` plus the `@gtkx/*` deps the store typecheck needs. */
+const codegenModules = (): string => {
+    const sourceDir = dirname(fileURLToPath(import.meta.url));
+
+    return join(dirname(sourceDir), "node_modules");
+};
+
+const linkToolingModules = (projectDir: string): (() => void) => {
+    const link = join(projectDir, "node_modules");
+
+    if (existsSync(link)) {
+        return (): void => undefined;
+    }
+
+    symlinkSync(codegenModules(), link, "junction");
+
+    return () => {
+        rmSync(link, { force: true });
+    };
+};
+
+const isProjectFile = (rel: string): boolean =>
+    !rel.startsWith("..") && !isAbsolute(rel) && !rel.split(/[/\\]/).includes("node_modules");
+
+const projectDiagnosticLine = (diagnostic: ts.Diagnostic, projectDir: string): string | undefined => {
+    const { file, start } = diagnostic;
+
+    if (file === undefined || start === undefined) {
+        return undefined;
+    }
+
+    const filePath = relative(projectDir, file.fileName);
+
+    if (!isProjectFile(filePath)) {
+        return undefined;
+    }
+
+    const { line, character } = file.getLineAndCharacterOfPosition(start);
+    const message = ts.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+
+    return `${filePath}:${String(line + 1)}:${String(character + 1)} - ${message} (TS${String(diagnostic.code)})`;
+};
+
+const projectDiagnosticLines = (diagnostics: ts.Diagnostic[], projectDir: string): string[] => {
+    const lines: string[] = [];
+
+    for (const diagnostic of diagnostics) {
+        const line = projectDiagnosticLine(diagnostic, projectDir);
+
+        if (line !== undefined) {
+            lines.push(line);
+        }
+    }
+
+    return lines;
+};
+
+const diagnosticError = (label: string, projectDir: string, diagnostics: ts.Diagnostic[]): Error => {
+    const lines = projectDiagnosticLines(diagnostics, projectDir);
+
+    if (lines.length > 0) {
+        return new Error(`Type checking ${label} found ${String(lines.length)} error(s):\n${lines.join("\n")}`);
+    }
+
+    return new Error(`Type checking ${label} failed:\n${ts.formatDiagnostics(diagnostics, FORMAT_HOST).trim()}`);
+};
+
+const runProgram = (params: CompileProjectParams): ts.Diagnostic[] => {
+    const parsed = ts.parseJsonConfigFileContent(
+        {
+            compilerOptions: { ...BASE_COMPILER_OPTIONS, ...params.compilerOptions },
+            files: params.fileNames.map((name) => `./${name}`),
+        },
+        ts.sys,
+        params.projectDir,
+    );
+
+    const program = ts.createProgram({
+        rootNames: parsed.fileNames,
+        options: parsed.options,
+        configFileParsingDiagnostics: parsed.errors,
+    });
+
+    const diagnostics = ts.getPreEmitDiagnostics(program);
+
+    if (diagnostics.length > 0) {
+        return [...diagnostics];
+    }
+
+    return [...program.emit().diagnostics];
+};
+
+const compileProject = (params: CompileProjectParams): void => {
+    const unlinkToolingModules = linkToolingModules(params.projectDir);
+
+    try {
+        const diagnostics = runProgram(params);
+
+        if (diagnostics.length > 0) {
+            throw diagnosticError(params.label, params.projectDir, diagnostics);
+        }
+    } finally {
+        unlinkToolingModules();
+    }
+};
+
+const checkModules = (params: { modules: SourceModule[]; resolveFrom: string; label: string }): void => {
+    const checkRoot = join(params.resolveFrom, "node_modules");
+    mkdirSync(checkRoot, { recursive: true });
+    const projectDir = mkdtempSync(join(checkRoot, ".gtkx-check-"));
+
+    try {
+        for (const module of params.modules) {
+            const filePath = join(projectDir, module.fileName);
+            mkdirSync(dirname(filePath), { recursive: true });
+            writeFileSync(filePath, module.source);
+        }
+
+        compileProject({
+            projectDir,
+            fileNames: params.modules.map((module) => module.fileName),
+            compilerOptions: CHECK_OPTIONS,
+            label: params.label,
+        });
+    } finally {
+        rmSync(projectDir, { recursive: true, force: true });
+    }
+};
+
+export { compileProject, checkModules, type SourceModule, type CompileProjectParams };