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

package/src/gir/libraries.ts

@@ -1,64 +1,87 @@
-import { readdirSync } from "node:fs";
-import type { Config } from "@gtkx/config";
-import { GIR_LIBRARY_PATTERN, LIBRARIES_WILDCARD } from "@gtkx/config/internal";
 import { sortStrings } from "@gtkx/utils";
+import { readdirSync } from "node:fs";
 
-const DEFAULT_LIBRARIES: string[] = ["Gtk-4.0"];
+type GirNamespace = { name: string; version: string; identifier: string };
+type LibrarySelection = typeof LIBRARIES_WILDCARD | string[] | undefined;
 
+const LIBRARIES_WILDCARD = "*";
+const GIR_LIBRARY_PATTERN = /^[A-Za-z][A-Za-z0-9]*-\d+(?:\.\d+)*$/;
+const DEFAULT_LIBRARIES: string[] = ["Gtk-4.0"];
 const GIR_FILE_SUFFIX = ".gir";
 
-export const resolveLibraries = (libraries: Config["libraries"], girPath: string[]): string[] => {
+const resolveLibraries = (libraries: LibrarySelection, girPath: string[]): string[] => {
     if (libraries === undefined) {
         return [...DEFAULT_LIBRARIES];
     }
 
     if (libraries === LIBRARIES_WILDCARD) {
         const discovered = discoverGirNamespaces(girPath);
+
         if (discovered.length === 0) {
             throw new Error(
                 `gtkx.config.ts: \`libraries: "*"\` matched no .gir files in [${girPath.join(", ")}]. ` +
-                    "Install gobject-introspection data packages, or list the libraries explicitly.",
+                "Install gobject-introspection data packages, or list the libraries explicitly.",
             );
         }
+
         return discovered;
     }
 
     const hasGtk = libraries.some((library) => library.startsWith("Gtk-"));
+
     return [...new Set([...(hasGtk ? [] : DEFAULT_LIBRARIES), ...libraries])];
 };
 
-export const discoverGirNamespaces = (girPath: string[]): string[] => {
-    const highestByName = new Map<string, { version: string; identifier: string }>();
+const readDirEntries = (dir: string): string[] => {
+    try {
+        return readdirSync(dir);
+    } catch {
+        return [];
+    }
+};
 
-    for (const dir of girPath) {
-        let entries: string[];
-        try {
-            entries = readdirSync(dir);
-        } catch {
-            continue;
-        }
+const parseGirNamespace = (entry: string): GirNamespace | undefined => {
+    if (!entry.endsWith(GIR_FILE_SUFFIX)) {
+        return undefined;
+    }
+
+    const identifier = entry.slice(0, -GIR_FILE_SUFFIX.length);
+
+    if (!GIR_LIBRARY_PATTERN.test(identifier)) {
+        return undefined;
+    }
 
-        for (const entry of entries) {
-            if (!entry.endsWith(GIR_FILE_SUFFIX)) {
-                continue;
-            }
-
-            const identifier = entry.slice(0, -GIR_FILE_SUFFIX.length);
-            if (!GIR_LIBRARY_PATTERN.test(identifier)) {
-                continue;
-            }
-
-            const separator = identifier.indexOf("-");
-            const name = identifier.slice(0, separator);
-            const version = identifier.slice(separator + 1);
-            const existing = highestByName.get(name);
-            if (existing === undefined || compareVersions(version, existing.version) > 0) {
-                highestByName.set(name, { version, identifier });
-            }
+    const separator = identifier.indexOf("-");
+
+    return { name: identifier.slice(0, separator), version: identifier.slice(separator + 1), identifier };
+};
+
+const recordHighest = (highestByName: Map<string, GirNamespace>, parsed: GirNamespace): void => {
+    const existing = highestByName.get(parsed.name);
+
+    if (existing === undefined || compareVersions(parsed.version, existing.version) > 0) {
+        highestByName.set(parsed.name, parsed);
+    }
+};
+
+const collectDirNamespaces = (highestByName: Map<string, GirNamespace>, dir: string): void => {
+    for (const entry of readDirEntries(dir)) {
+        const parsed = parseGirNamespace(entry);
+
+        if (parsed !== undefined) {
+            recordHighest(highestByName, parsed);
         }
     }
+};
+
+const discoverGirNamespaces = (girPath: string[]): string[] => {
+    const highestByName: Map<string, GirNamespace> = new Map();
 
-    return sortStrings([...highestByName.values()].map(({ identifier }) => identifier));
+    for (const dir of girPath) {
+        collectDirNamespaces(highestByName, dir);
+    }
+
+    return sortStrings(highestByName.values().map(({ identifier }) => identifier));
 };
 
 const compareVersions = (a: string, b: string): number => {
@@ -68,6 +91,7 @@ const compareVersions = (a: string, b: string): number => {
 
     for (let index = 0; index < length; index += 1) {
         const difference = Number(aParts[index] ?? 0) - Number(bParts[index] ?? 0);
+
         if (difference !== 0) {
             return difference;
         }
@@ -75,3 +99,5 @@ const compareVersions = (a: string, b: string): number => {
 
     return 0;
 };
+
+export { resolveLibraries, discoverGirNamespaces, type LibrarySelection };

package/src/gir/library.ts

@@ -1,5 +1,8 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
+import type { PrimitiveCategory } from "./primitives.js";
+import type { CArrayType, HashTableType, ListType, ParseContext, TypeId } from "./type-id.js";
+import type { GirType } from "./type.js";
 import { callbackFromNode } from "./callback.js";
 import {
     createNamespaceShell,
@@ -9,35 +12,73 @@ import {
     populateNamespaceBody,
 } from "./namespace.js";
 import { parseGirFile, type RawNode } from "./parse.js";
-import type { PrimitiveCategory } from "./primitives.js";
-import type { GirType } from "./type.js";
-import type { CArrayType, HashTableType, ListType, ParseContext, TypeId } from "./type-id.js";
 import { splitOptionalNamespace } from "./type-ref.js";
 
-const INTERNAL_NS_ID = 0;
-
 type TypeTable = {
     types: (GirType | undefined)[];
     names: (string | undefined)[];
     index: Map<string, number>;
 };
 
-export class Library {
-    private namespacesByName = new Map<string, GirNamespace>();
-    private namespaceById: (GirNamespace | undefined)[] = [];
-    private nsNameById: string[] = [];
-    private nsIdByName = new Map<string, number>();
-    private typeTables: TypeTable[] = [];
-    private girFilesValue: string[] = [];
+type DiscoveredNamespace = { header: NamespaceHeader; shell: GirNamespace };
 
-    public get namespaces(): Map<string, GirNamespace> {
-        return this.namespacesByName;
+const INTERNAL_NS_ID = 0;
+
+const readRepositoryNode = (path: string): RawNode => {
+    const root = parseGirFile(path);
+    const repository = root.repository;
+
+    if (typeof repository !== "object" || repository === null) {
+        throw new Error(`GIR file at ${path} has no <repository> root`);
     }
 
-    public get girFiles(): string[] {
-        return this.girFilesValue;
+    return repository as RawNode;
+};
+
+const locateGirFile = (identifier: string, girPath: string[]): string => {
+    const filename = `${identifier}.gir`;
+
+    for (const directory of girPath) {
+        const candidate = join(directory, filename);
+
+        if (existsSync(candidate)) {
+            return candidate;
+        }
+    }
+
+    const tried = girPath.map((directory) => join(directory, filename)).join(", ");
+    throw new Error(`GIR file ${filename} not found on girPath. Tried: ${tried}`);
+};
+
+class Library {
+    private static drive(library: Library, libraries: string[], girPath: string[]): void {
+        const { discovered, girFiles } = library.discoverNamespaces(libraries, girPath);
+
+        for (const { header, shell } of discovered) {
+            populateNamespaceBody(shell, header.namespaceNode, library.parseContext(shell.id));
+        }
+
+        for (const { shell } of discovered) {
+            library.addDeclarations(shell);
+        }
+
+        library.girFilesValue = girFiles;
+    }
+
+    static load(libraries: string[], girPath: string[]): Library {
+        const library = new Library();
+        this.drive(library, libraries, girPath);
+
+        return library;
     }
 
+    private namespacesByName: Map<string, GirNamespace> = new Map();
+    private namespaceById: (GirNamespace | undefined)[] = [];
+    private nsNameById: string[] = [];
+    private nsIdByName: Map<string, number> = new Map();
+    private typeTables: TypeTable[] = [];
+    private girFilesValue: string[] = [];
+
     constructor() {
         this.typeTables[INTERNAL_NS_ID] = { types: [], names: [], index: new Map() };
         this.namespaceById[INTERNAL_NS_ID] = undefined;
@@ -46,12 +87,17 @@ export class Library {
 
     private ensureNsId(name: string): number {
         const existing = this.nsIdByName.get(name);
-        if (existing !== undefined) return existing;
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
         const nsId = this.typeTables.length;
         this.typeTables[nsId] = { types: [], names: [], index: new Map() };
         this.namespaceById[nsId] = undefined;
         this.nsNameById[nsId] = name;
         this.nsIdByName.set(name, nsId);
+
         return nsId;
     }
 
@@ -60,22 +106,27 @@ export class Library {
         const shell = createNamespaceShell(header, nsId);
         this.namespaceById[nsId] = shell;
         this.namespacesByName.set(header.name, shell);
+
         return shell;
     }
 
-    private namespaceOf(nsId: number): GirNamespace {
+    private namespaceFor(nsId: number): GirNamespace {
         const namespace = this.namespaceById[nsId];
+
         if (namespace === undefined) {
-            throw new Error(`No namespace registered for type table id ${nsId}`);
+            throw new Error(`No namespace registered for type table id ${String(nsId)}`);
         }
+
         return namespace;
     }
 
-    private typeTableOf(nsId: number): TypeTable {
+    private typeTableFor(nsId: number): TypeTable {
         const typeTable = this.typeTables[nsId];
+
         if (typeTable === undefined) {
-            throw new Error(`No type table for namespace id ${nsId}`);
+            throw new Error(`No type table for namespace id ${String(nsId)}`);
         }
+
         return typeTable;
     }
 
@@ -86,37 +137,44 @@ export class Library {
         const id = typeTable.types.length;
         typeTable.types.push(slot.type);
         typeTable.names.push(slot.displayName);
-        if (slot.indexKey !== undefined) typeTable.index.set(slot.indexKey, id);
+
+        if (slot.indexKey !== undefined) {
+            typeTable.index.set(slot.indexKey, id);
+        }
+
         return id;
     }
 
-    private addType(nsId: number, name: string, type: GirType): void {
-        const typeTable = this.typeTableOf(nsId);
+    private resolveTypeId(nsId: number, name: string, type: GirType | undefined): number {
+        const typeTable = this.typeTableFor(nsId);
         const existing = typeTable.index.get(name);
+
         if (existing !== undefined) {
-            typeTable.types[existing] = type;
-            return;
+            return existing;
         }
-        this.insertIntoTypeTable(typeTable, { type, indexKey: name, displayName: name });
+
+        return this.insertIntoTypeTable(typeTable, { type, indexKey: name, displayName: name });
+    }
+
+    private addType(nsId: number, name: string, type: GirType): void {
+        this.typeTableFor(nsId).types[this.resolveTypeId(nsId, name, type)] = type;
     }
 
     private findType(nsId: number, name: string): TypeId {
-        const typeTable = this.typeTableOf(nsId);
-        const existing = typeTable.index.get(name);
-        if (existing !== undefined) return { nsId, id: existing };
-        const id = this.insertIntoTypeTable(typeTable, { type: undefined, indexKey: name, displayName: name });
-        return { nsId, id };
+        return { nsId, id: this.resolveTypeId(nsId, name, undefined) };
     }
 
     private addAnonymousType(nsId: number, type: GirType): TypeId {
-        const typeTable = this.typeTableOf(nsId);
+        const typeTable = this.typeTableFor(nsId);
         const id = this.insertIntoTypeTable(typeTable, { type });
+
         return { nsId, id };
     }
 
     private findTypeByName(currentNsId: number, name: string): TypeId {
         const [namespaceName, localName] = splitOptionalNamespace(name);
         const targetNsId = namespaceName === undefined ? currentNsId : this.ensureNsId(namespaceName);
+
         return this.findType(targetNsId, localName);
     }
 
@@ -130,10 +188,11 @@ export class Library {
             addAnonymousCallback: (node) =>
                 this.addAnonymousType(nsId, {
                     kind: "callback",
-                    namespace: this.namespaceOf(nsId),
+                    namespace: this.namespaceFor(nsId),
                     value: callbackFromNode(node, context),
                 }),
         };
+
         return context;
     }
 
@@ -146,103 +205,147 @@ export class Library {
     }
 
     private findOrAddContainer(key: string, type: GirType): TypeId {
-        const typeTable = this.typeTableOf(INTERNAL_NS_ID);
+        const typeTable = this.typeTableFor(INTERNAL_NS_ID);
         const existing = typeTable.index.get(key);
-        if (existing !== undefined) return { nsId: INTERNAL_NS_ID, id: existing };
+
+        if (existing !== undefined) {
+            return { nsId: INTERNAL_NS_ID, id: existing };
+        }
+
         const id = this.insertIntoTypeTable(typeTable, { type, indexKey: key });
+
         return { nsId: INTERNAL_NS_ID, id };
     }
 
     private addDeclarations(shell: GirNamespace): void {
+        this.addClassDeclarations(shell);
+        this.addValueDeclarations(shell);
+    }
+
+    private addClassDeclarations(shell: GirNamespace): void {
         const nsId = shell.id;
-        for (const value of shell.classes) this.addType(nsId, value.name, { kind: "class", namespace: shell, value });
+
+        for (const value of shell.classes) {
+            this.addType(nsId, value.name, { kind: "class", namespace: shell, value });
+        }
+
         for (const value of shell.interfaces) {
             this.addType(nsId, value.name, { kind: "interface", namespace: shell, value });
         }
-        for (const value of shell.records) this.addType(nsId, value.name, { kind: "record", namespace: shell, value });
-        for (const value of shell.enums) this.addType(nsId, value.name, { kind: "enum", namespace: shell, value });
+
+        for (const value of shell.records) {
+            this.addType(nsId, value.name, { kind: "record", namespace: shell, value });
+        }
+    }
+
+    private addValueDeclarations(shell: GirNamespace): void {
+        const nsId = shell.id;
+
+        for (const value of shell.enums) {
+            this.addType(nsId, value.name, { kind: "enum", namespace: shell, value });
+        }
+
         for (const value of shell.callbacks) {
             this.addType(nsId, value.name, { kind: "callback", namespace: shell, value });
         }
+
         for (const alias of shell.aliases) {
             this.addType(nsId, alias.name, { kind: "alias", namespace: shell, value: alias });
         }
     }
 
-    typeOf(tid: TypeId): GirType | undefined {
+    private processIdentifier(input: {
+        identifier: string;
+        girPath: string[];
+        seen: Set<string>;
+        queue: string[];
+        girFiles: string[];
+        discovered: DiscoveredNamespace[];
+    }): void {
+        const { identifier, girPath, seen, queue, girFiles, discovered } = input;
+        const namespaceName = identifier.split("-", 1)[0] ?? identifier;
+
+        if (seen.has(namespaceName)) {
+            return;
+        }
+
+        seen.add(namespaceName);
+        const path = locateGirFile(identifier, girPath);
+        girFiles.push(path);
+        const header = parseNamespaceHeader(readRepositoryNode(path));
+        const shell = this.registerNamespace(header);
+        discovered.push({ header, shell });
+
+        for (const include of header.includes) {
+            queue.push(`${include.name}-${include.version}`);
+        }
+    }
+
+    private discoverNamespaces(
+        libraries: string[],
+        girPath: string[],
+    ): { discovered: DiscoveredNamespace[]; girFiles: string[] } {
+        const queue: string[] = [...libraries];
+        const seen: Set<string> = new Set();
+        const discovered: DiscoveredNamespace[] = [];
+        const girFiles: string[] = [];
+
+        while (queue.length > 0) {
+            const identifier = queue.shift();
+
+            if (identifier !== undefined) {
+                this.processIdentifier({ identifier, girPath, seen, queue, girFiles, discovered });
+            }
+        }
+
+        return { discovered, girFiles };
+    }
+
+    public get namespaces(): Map<string, GirNamespace> {
+        return this.namespacesByName;
+    }
+
+    public get girFiles(): string[] {
+        return this.girFilesValue;
+    }
+
+    typeFor(tid: TypeId): GirType | undefined {
         return this.typeTables[tid.nsId]?.types[tid.id];
     }
 
-    nameOf(tid: TypeId): { namespaceName: string; typeName: string } | undefined {
+    nameFor(tid: TypeId): { namespaceName: string; typeName: string } | undefined {
         const typeName = this.typeTables[tid.nsId]?.names[tid.id];
         const namespaceName = this.nsNameById[tid.nsId];
-        if (typeName === undefined || namespaceName === undefined) return undefined;
+
+        if (typeName === undefined || namespaceName === undefined) {
+            return undefined;
+        }
+
         return { namespaceName, typeName };
     }
 
     resolveType(currentNamespaceName: string, name: string): GirType | undefined {
         const currentNsId = this.nsIdByName.get(currentNamespaceName);
-        if (currentNsId === undefined) return undefined;
+
+        if (currentNsId === undefined) {
+            return undefined;
+        }
+
         const [namespaceName, localName] = splitOptionalNamespace(name);
         const targetNsId = namespaceName === undefined ? currentNsId : this.nsIdByName.get(namespaceName);
-        if (targetNsId === undefined) return undefined;
-        const id = this.typeTableOf(targetNsId).index.get(localName);
-        if (id === undefined) return undefined;
-        return this.typeTableOf(targetNsId).types[id];
-    }
 
-    private static drive(library: Library, libraries: string[], girPath: string[]): void {
-        const queue: string[] = [...libraries];
-        const seen = new Set<string>();
-        const discovered: { header: NamespaceHeader; shell: GirNamespace }[] = [];
-        const girFiles: string[] = [];
-        while (queue.length > 0) {
-            const identifier = queue.shift();
-            if (identifier === undefined) continue;
-            const namespaceName = identifier.split("-")[0] ?? identifier;
-            if (seen.has(namespaceName)) continue;
-            seen.add(namespaceName);
-            const path = locateGirFile(identifier, girPath);
-            girFiles.push(path);
-            const repositoryNode = readRepositoryNode(path);
-            const header = parseNamespaceHeader(repositoryNode);
-            const shell = library.registerNamespace(header);
-            discovered.push({ header, shell });
-            for (const include of header.includes) {
-                queue.push(`${include.name}-${include.version}`);
-            }
-        }
-        for (const { header, shell } of discovered) {
-            populateNamespaceBody(shell, header.namespaceNode, library.parseContext(shell.id));
+        if (targetNsId === undefined) {
+            return undefined;
         }
-        for (const { shell } of discovered) {
-            library.addDeclarations(shell);
+
+        const id = this.typeTableFor(targetNsId).index.get(localName);
+
+        if (id === undefined) {
+            return undefined;
         }
-        library.girFilesValue = girFiles;
-    }
 
-    static load(libraries: string[], girPath: string[]): Library {
-        const library = new Library();
-        Library.drive(library, libraries, girPath);
-        return library;
+        return this.typeTableFor(targetNsId).types[id];
     }
 }
 
-const readRepositoryNode = (path: string): RawNode => {
-    const root = parseGirFile(path);
-    const repository = root.repository;
-    if (typeof repository !== "object" || repository === null) {
-        throw new Error(`GIR file at ${path} has no <repository> root`);
-    }
-    return repository as RawNode;
-};
-
-const locateGirFile = (identifier: string, girPath: string[]): string => {
-    const filename = `${identifier}.gir`;
-    for (const directory of girPath) {
-        const candidate = join(directory, filename);
-        if (existsSync(candidate)) return candidate;
-    }
-    const tried = girPath.map((directory) => join(directory, filename)).join(", ");
-    throw new Error(`GIR file ${filename} not found on girPath. Tried: ${tried}`);
-};
+export { Library };