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

package/src/settings/parser.ts

@@ -1,6 +1,6 @@
 import { XMLParser } from "fast-xml-parser";
 
-export type ParsedKey = {
+type ParsedKey = {
     name: string;
     variantType: string | null;
     enumId: string | null;
@@ -9,23 +9,34 @@ export type ParsedKey = {
     summary: string | null;
 };
 
-export type ParsedSchema = {
+type ParsedSchema = {
     id: string;
     path: string | null;
     keys: ParsedKey[];
 };
 
-export type ParsedSchemaFile = {
+type ParsedSchemaFile = {
     fileName: string;
     schemas: ParsedSchema[];
     enums: Map<string, string[]>;
     flags: Map<string, string[]>;
 };
 
-export class SchemaParseError extends Error {}
-
 type RawNode = Record<string, unknown>;
 
+type RawSchema = {
+    id: string;
+    path: string | null;
+    extendsId: string | null;
+    keys: ParsedKey[];
+};
+
+type MergeContext = {
+    byId: Map<string, RawSchema>;
+    merged: Map<string, ParsedKey>;
+    visited: Set<string>;
+};
+
 const MULTI_TAGS: Set<string> = new Set(["schema", "key", "enum", "flags", "value", "choice"]);
 
 const PARSER = new XMLParser({
@@ -41,17 +52,23 @@ const isRawNode = (value: unknown): value is RawNode => typeof value === "object
 
 const attr = (node: RawNode, name: string): string | null => {
     const value = node[`@_${name}`];
+
     return typeof value === "string" ? value : null;
 };
 
 const text = (node: RawNode, name: string): string | null => {
     const value = node[name];
+
     return typeof value === "string" && value.length > 0 ? value : null;
 };
 
 const children = (node: RawNode, name: string): RawNode[] => {
     const value = node[name];
-    if (!Array.isArray(value)) return [];
+
+    if (!Array.isArray(value)) {
+        return [];
+    }
+
     return value.filter(isRawNode);
 };
 
@@ -61,17 +78,26 @@ const parseNicks = (definition: RawNode): string[] =>
         .filter((nick): nick is string => nick !== null);
 
 const parseDefinitions = (schemalist: RawNode, tag: string): Map<string, string[]> => {
-    const definitions = new Map<string, string[]>();
+    const definitions: Map<string, string[]> = new Map();
+
     for (const definition of children(schemalist, tag)) {
         const id = attr(definition, "id");
-        if (id !== null) definitions.set(id, parseNicks(definition));
+
+        if (id !== null) {
+            definitions.set(id, parseNicks(definition));
+        }
     }
+
     return definitions;
 };
 
 const parseChoices = (key: RawNode): string[] => {
     const choices = key.choices;
-    if (!isRawNode(choices)) return [];
+
+    if (!isRawNode(choices)) {
+        return [];
+    }
+
     return children(choices, "choice")
         .map((choice) => attr(choice, "value"))
         .filter((value): value is string => value !== null);
@@ -79,9 +105,11 @@ const parseChoices = (key: RawNode): string[] => {
 
 const parseKey = (key: RawNode, fileName: string): ParsedKey => {
     const name = attr(key, "name");
+
     if (name === null) {
         throw new SchemaParseError(`A <key> in ${fileName} has no name attribute`);
     }
+
     return {
         name,
         variantType: attr(key, "type"),
@@ -92,18 +120,13 @@ const parseKey = (key: RawNode, fileName: string): ParsedKey => {
     };
 };
 
-type RawSchema = {
-    id: string;
-    path: string | null;
-    extendsId: string | null;
-    keys: ParsedKey[];
-};
-
 const parseRawSchema = (schema: RawNode, fileName: string): RawSchema => {
     const id = attr(schema, "id");
+
     if (id === null) {
         throw new SchemaParseError(`A <schema> in ${fileName} has no id attribute`);
     }
+
     return {
         id,
         path: attr(schema, "path"),
@@ -112,35 +135,47 @@ const parseRawSchema = (schema: RawNode, fileName: string): RawSchema => {
     };
 };
 
+const collectInheritedKeys = (context: MergeContext, current: RawSchema): void => {
+    if (context.visited.has(current.id)) {
+        return;
+    }
+
+    context.visited.add(current.id);
+    const parent = current.extendsId === null ? undefined : context.byId.get(current.extendsId);
+
+    if (parent !== undefined) {
+        collectInheritedKeys(context, parent);
+    }
+
+    for (const key of current.keys) {
+        context.merged.set(key.name, key);
+    }
+};
+
 const mergeInheritedKeys = (schema: RawSchema, byId: Map<string, RawSchema>): ParsedKey[] => {
-    const merged = new Map<string, ParsedKey>();
-    const visited = new Set<string>();
-    const collect = (current: RawSchema): void => {
-        if (visited.has(current.id)) return;
-        visited.add(current.id);
-        if (current.extendsId !== null) {
-            const parent = byId.get(current.extendsId);
-            if (parent !== undefined) collect(parent);
-        }
-        for (const key of current.keys) merged.set(key.name, key);
-    };
-    collect(schema);
-    return [...merged.values()];
+    const context: MergeContext = { byId, merged: new Map(), visited: new Set() };
+    collectInheritedKeys(context, schema);
+
+    return context.merged.values().toArray();
 };
 
-export const parseSchemaXml = (xml: string, fileName: string): ParsedSchemaFile => {
+const parseSchemaXml = (xml: string, fileName: string): ParsedSchemaFile => {
     let document: unknown;
+
     try {
         document = PARSER.parse(xml);
     } catch (error) {
         throw new SchemaParseError(`Failed to parse ${fileName} as XML: ${String(error)}`, { cause: error });
     }
+
     if (!isRawNode(document) || !("schemalist" in document)) {
         throw new SchemaParseError(`${fileName} has no <schemalist> root element`);
     }
+
     const schemalist = isRawNode(document.schemalist) ? document.schemalist : {};
     const rawSchemas = children(schemalist, "schema").map((schema) => parseRawSchema(schema, fileName));
     const byId = new Map(rawSchemas.map((schema) => [schema.id, schema]));
+
     return {
         fileName,
         schemas: rawSchemas.map((schema) => ({
@@ -152,3 +187,7 @@ export const parseSchemaXml = (xml: string, fileName: string): ParsedSchemaFile
         flags: parseDefinitions(schemalist, "flags"),
     };
 };
+
+class SchemaParseError extends Error {}
+
+export { parseSchemaXml, SchemaParseError, type ParsedKey, type ParsedSchema, type ParsedSchemaFile };

package/src/settings/render.ts

@@ -7,132 +7,123 @@ const GTKX_ENV_MODULE_HEADER = `/**
  * \`gtkx build\`; do not edit.
  */`;
 
-const VARIANT_TS_TYPES: Record<string, string> = {
-    b: "boolean",
-    i: "number",
-    u: "number",
-    x: "number",
-    t: "number",
-    d: "number",
-    s: "string",
-    as: "string[]",
-};
-
-const VARIANT_FALLBACK_TS_TYPE = `import("@gtkx/gi/glib").Variant`;
-
 const ENUM_KIND = "enum";
 const FLAGS_KIND = "flags";
 
 const toJsStringLiteral = (value: string): string =>
-    JSON.stringify(value).replaceAll("\u2028", "\\u2028").replaceAll("\u2029", "\\u2029");
+    JSON.stringify(value).replaceAll("\u{2028}", String.raw`\u2028`).replaceAll("\u{2029}", String.raw`\u2029`);
 
-const exportNameFor = (schemaId: string): string => schemaId.replaceAll(".", "_");
+const getExportName = (schemaId: string): string => schemaId.replaceAll(".", "_");
 
-const unionOf = (values: string[]): string => values.map(toJsStringLiteral).join(" | ");
-
-const tsTypeForKey = (key: ParsedKey, file: ParsedSchemaFile): string => {
+const runtimeKindForKey = (key: ParsedKey): string => {
     if (key.enumId !== null) {
-        const nicks = file.enums.get(key.enumId);
-        return nicks !== undefined && nicks.length > 0 ? unionOf(nicks) : "string";
+        return ENUM_KIND;
     }
+
     if (key.flagsId !== null) {
-        const nicks = file.flags.get(key.flagsId);
-        return nicks !== undefined && nicks.length > 0 ? `(${unionOf(nicks)})[]` : "string[]";
-    }
-    if (key.variantType === "s" && key.choices.length > 0) {
-        return unionOf(key.choices);
+        return FLAGS_KIND;
     }
-    return VARIANT_TS_TYPES[key.variantType ?? ""] ?? VARIANT_FALLBACK_TS_TYPE;
-};
 
-const runtimeKindForKey = (key: ParsedKey): string => {
-    if (key.enumId !== null) return ENUM_KIND;
-    if (key.flagsId !== null) return FLAGS_KIND;
     return key.variantType ?? "";
 };
 
-const runtimeKeysFor = (schema: ParsedSchema): string => {
+const getRuntimeKeys = (schema: ParsedSchema): string => {
     const entries = schema.keys.map(
         (key) => `${toJsStringLiteral(key.name)}: ${toJsStringLiteral(runtimeKindForKey(key))}`,
     );
+
     return `{ ${entries.join(", ")} }`;
 };
 
-export const renderRuntimeModule = (file: ParsedSchemaFile): string => {
+const renderRuntimeModule = (file: ParsedSchemaFile): string => {
     const lines: string[] = [];
-    file.schemas.forEach((schema, index) => {
-        const keysName = `keys_${index}`;
+
+    for (const [index, schema] of file.schemas.entries()) {
+        const keysName = `keys_${String(index)}`;
         const id = toJsStringLiteral(schema.id);
-        lines.push(`const ${keysName} = ${runtimeKeysFor(schema)};`);
+        lines.push(`const ${keysName} = ${getRuntimeKeys(schema)};`);
+
         if (schema.path === null) {
             lines.push(
-                `export const ${exportNameFor(schema.id)} = { id: ${id}, keys: ${keysName}, at: (path) => ({ id: ${id}, path, keys: ${keysName} }) };`,
+                `export const ${getExportName(schema.id)} = { id: ${id}, keys: ${keysName}, ` +
+                `at: (path) => ({ id: ${id}, path, keys: ${keysName} }) };`,
             );
         } else {
-            lines.push(`export const ${exportNameFor(schema.id)} = { id: ${id}, path: null, keys: ${keysName} };`);
+            lines.push(`export const ${getExportName(schema.id)} = { id: ${id}, path: null, keys: ${keysName} };`);
         }
-    });
+    }
+
     const first = file.schemas[0];
+
     if (first !== undefined) {
-        lines.push(`export default ${exportNameFor(first.id)};`);
+        lines.push(`export default ${getExportName(first.id)};`);
     }
+
     return lines.join("\n");
 };
 
-const sanitizeSummary = (summary: string): string => summary.replaceAll("*/", "*\\/");
+const sanitizeSummary = (summary: string): string => summary.replaceAll("*/", String.raw`*\/`);
 
-const interfaceNameFor = (schemaId: string, usedNames: Set<string>): string => {
+const allocateInterfaceName = (schemaId: string, usedNames: Set<string>): string => {
     const base = `${schemaId
         .split(/[^a-zA-Z0-9]+/)
         .filter((part) => part.length > 0)
-        .map(upperFirst)
+        .map((part) => upperFirst(part))
         .join("")}Keys`;
+
     let name = base;
     let suffix = 2;
+
     while (usedNames.has(name)) {
-        name = `${base}${suffix}`;
+        name = `${base}${String(suffix)}`;
         suffix += 1;
     }
+
     usedNames.add(name);
+
     return name;
 };
 
-const renderKeysType = (name: string, schema: ParsedSchema, file: ParsedSchemaFile): string[] => {
+const renderKeysType = (name: string, schema: ParsedSchema): string[] => {
     const lines = [`    type ${name} = {`];
+
     for (const key of schema.keys) {
         if (key.summary !== null) {
             lines.push(`        /** ${sanitizeSummary(key.summary)} */`);
         }
-        lines.push(`        ${toJsStringLiteral(key.name)}: ${tsTypeForKey(key, file)};`);
+
+        lines.push(`        ${toJsStringLiteral(key.name)}: ${toJsStringLiteral(runtimeKindForKey(key))};`);
     }
+
     lines.push("    };");
+
     return lines;
 };
 
 const boundRefTypeLines = (interfaceName: string, indent: string): string[] => [
     `${indent}id: string;`,
     `${indent}path: string | null;`,
-    `${indent}keys: { [P in keyof ${interfaceName}]: string };`,
-    `${indent}__keys__?: ${interfaceName};`,
+    `${indent}keys: ${interfaceName};`,
 ];
 
 const renderSchemaConst = (schema: ParsedSchema, interfaceName: string): string[] => {
-    const exportName = exportNameFor(schema.id);
+    const exportName = getExportName(schema.id);
+
     if (schema.path !== null) {
         return [
             `    const ${exportName}: {`,
             `        id: ${toJsStringLiteral(schema.id)};`,
-            ...boundRefTypeLines(interfaceName, "        ").slice(1),
+            ...boundRefTypeLines(interfaceName, " ".repeat(8)).slice(1),
             "    };",
         ];
     }
+
     return [
         `    const ${exportName}: {`,
         `        id: ${JSON.stringify(schema.id)};`,
-        `        keys: { [P in keyof ${interfaceName}]: string };`,
-        `        __keys__?: ${interfaceName};`,
+        `        keys: ${interfaceName};`,
         "        at(path: string): {",
-        ...boundRefTypeLines(interfaceName, "            "),
+        ...boundRefTypeLines(interfaceName, " ".repeat(12)),
         "        };",
         "    };",
     ];
@@ -141,27 +132,36 @@ const renderSchemaConst = (schema: ParsedSchema, interfaceName: string): string[
 const renderFileModule = (file: ParsedSchemaFile, usedNames: Set<string>): string[] => {
     const lines = [`declare module "${file.fileName}" {`];
     const exportNames: string[] = [];
-    file.schemas.forEach((schema, index) => {
-        if (index > 0) lines.push("");
-        const interfaceName = interfaceNameFor(schema.id, usedNames);
-        lines.push(...renderKeysType(interfaceName, schema, file));
-        lines.push("");
-        lines.push(...renderSchemaConst(schema, interfaceName));
-        exportNames.push(exportNameFor(schema.id));
-    });
-    if (exportNames.length > 0) {
-        lines.push("");
-        lines.push(`    export { ${exportNames.join(", ")} };`);
-        lines.push(`    export default ${exportNames[0]};`);
+
+    for (const [index, schema] of file.schemas.entries()) {
+        if (index > 0) {
+            lines.push("");
+        }
+
+        const interfaceName = allocateInterfaceName(schema.id, usedNames);
+        lines.push(...renderKeysType(interfaceName, schema), "", ...renderSchemaConst(schema, interfaceName));
+        exportNames.push(getExportName(schema.id));
     }
+
+    const [firstExport] = exportNames;
+
+    if (firstExport !== undefined) {
+        lines.push("", `    export { ${exportNames.join(", ")} };`, `    export default ${firstExport};`);
+    }
+
     lines.push("}");
+
     return lines;
 };
 
-export const renderEnvModule = (files: ParsedSchemaFile[]): string => {
-    const usedNames = new Set<string>();
+const renderEnvModule = (files: ParsedSchemaFile[]): string => {
+    const usedNames: Set<string> = new Set();
+
     const blocks = files
         .filter((file) => file.schemas.length > 0)
         .map((file) => renderFileModule(file, usedNames).join("\n"));
+
     return `${[GTKX_ENV_MODULE_HEADER, ...blocks].join("\n\n")}\n`;
 };
+
+export { renderRuntimeModule, renderEnvModule };

package/src/settings/schema.ts

@@ -1,41 +1,46 @@
+import { sortStrings, warn } from "@gtkx/utils";
 import { createHash } from "node:crypto";
 import { copyFileSync, type Dirent, mkdirSync, mkdtempSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { dirname, join, relative } from "node:path";
-import { sortStrings, warn } from "@gtkx/utils";
 import { DATA_IMPORT_PREFIX } from "../internal/data-dir.js";
 import { removeTempDir } from "../internal/staging-dir.js";
 import { compileSchemas } from "./compile.js";
 import { type ParsedSchemaFile, parseSchemaXml, SchemaParseError } from "./parser.js";
 import { renderEnvModule } from "./render.js";
 
-export const SCHEMA_SUFFIX = ".gschema.xml";
-
-export const prependSchemaDir = (dir: string, existing: string | undefined): string => {
-    if (existing === undefined || existing.length === 0) return dir;
-    if (existing.split(":").includes(dir)) return existing;
-    return `${dir}:${existing}`;
+type SchemaEnvResult = {
+    path: string;
+    written: boolean;
 };
 
+const SCHEMA_SUFFIX = ".gschema.xml";
 const STAGED_NAME_LENGTH = 16;
 
+const prependSchemaDir = (dir: string, existing: string | undefined): string => {
+    if (existing === undefined || existing.length === 0) {
+        return dir;
+    }
+
+    if (existing.split(":").includes(dir)) {
+        return existing;
+    }
+
+    return `${dir}:${existing}`;
+};
+
 const stagedSchemaName = (filePath: string): string =>
     `${createHash("sha1").update(filePath).digest("hex").slice(0, STAGED_NAME_LENGTH)}${SCHEMA_SUFFIX}`;
 
-export const stageSchema = (dir: string, filePath: string): void => {
+const stageSchema = (dir: string, filePath: string): void => {
     copyFileSync(filePath, join(dir, stagedSchemaName(filePath)));
 };
 
 const toForwardSlashes = (value: string): string => value.replaceAll(/[/\\]/g, "/");
 
-const moduleSpecifierFor = (dataDirAbs: string, filePath: string): string =>
+const getModuleSpecifier = (dataDirAbs: string, filePath: string): string =>
     `${DATA_IMPORT_PREFIX}/${toForwardSlashes(relative(dataDirAbs, filePath))}`;
 
-type SchemaEnvResult = {
-    path: string;
-    written: boolean;
-};
-
 const readVisibleEntries = (dir: string): Dirent[] => {
     try {
         return readdirSync(dir, { withFileTypes: true }).filter((entry) => !entry.name.startsWith("."));
@@ -46,70 +51,119 @@ const readVisibleEntries = (dir: string): Dirent[] => {
 
 const isSchemaFile = (entry: Dirent): boolean => entry.isFile() && entry.name.endsWith(SCHEMA_SUFFIX);
 
-export const findSchemaFiles = (dataDir: string): string[] => {
-    const found: string[] = [];
-    const walk = (dir: string): void => {
-        for (const entry of readVisibleEntries(dir)) {
-            const full = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                walk(full);
-            } else if (isSchemaFile(entry)) {
-                found.push(full);
-            }
+const collectSchemaFiles = (dir: string, found: string[]): void => {
+    for (const entry of readVisibleEntries(dir)) {
+        const full = join(dir, entry.name);
+
+        if (entry.isDirectory()) {
+            collectSchemaFiles(full, found);
+        } else if (isSchemaFile(entry)) {
+            found.push(full);
         }
-    };
-    walk(dataDir);
+    }
+};
+
+const findSchemaFiles = (dataDir: string): string[] => {
+    const found: string[] = [];
+    collectSchemaFiles(dataDir, found);
+
     return sortStrings(found);
 };
 
-export const stageAndCompileProjectSchemas = (root: string, dataDir: string | null): string | null => {
-    if (dataDir === null) return null;
+const stageAndCompileProjectSchemas = (root: string, dataDir: string | null): string | null => {
+    if (dataDir === null) {
+        return null;
+    }
+
     const schemaFiles = findSchemaFiles(join(root, dataDir));
-    if (schemaFiles.length === 0) return null;
+
+    if (schemaFiles.length === 0) {
+        return null;
+    }
 
     const dir = mkdtempSync(join(tmpdir(), "gtkx-schemas-"));
-    for (const filePath of schemaFiles) stageSchema(dir, filePath);
+
+    for (const filePath of schemaFiles) {
+        stageSchema(dir, filePath);
+    }
+
     compileSchemas(dir);
-    process.once("exit", () => removeTempDir(dir));
+
+    process.once("exit", () => {
+        removeTempDir(dir);
+    });
 
     return dir;
 };
 
-export const schemaEnvPath = (rootDir: string): string => join(rootDir, "node_modules", ".gtkx", "env.d.ts");
+const schemaEnvPath = (rootDir: string): string => join(rootDir, "node_modules", ".gtkx", "env.d.ts");
+
+const parseSchemaFileOrWarn = (filePath: string, dataDirAbs: string): ParsedSchemaFile | null => {
+    const specifier = getModuleSpecifier(dataDirAbs, filePath);
+
+    try {
+        return parseSchemaXml(readFileSync(filePath, "utf8"), specifier);
+    } catch (error) {
+        if (!(error instanceof SchemaParseError)) {
+            throw error;
+        }
+
+        warn(`Skipping ${filePath} in schema type generation: ${error.message}`);
+
+        return null;
+    }
+};
 
 const parseProjectSchemas = (schemaFiles: string[], dataDirAbs: string): ParsedSchemaFile[] => {
     const parsed: ParsedSchemaFile[] = [];
+
     for (const filePath of schemaFiles) {
-        const specifier = moduleSpecifierFor(dataDirAbs, filePath);
-        try {
-            parsed.push(parseSchemaXml(readFileSync(filePath, "utf-8"), specifier));
-        } catch (error) {
-            if (!(error instanceof SchemaParseError)) throw error;
-            warn(`Skipping ${filePath} in schema type generation: ${error.message}`);
+        const result = parseSchemaFileOrWarn(filePath, dataDirAbs);
+
+        if (result !== null) {
+            parsed.push(result);
         }
     }
+
     return parsed;
 };
 
-const writeIfChanged = (path: string, content: string): boolean => {
-    let existing: string | null = null;
+const readFileOrNull = (path: string): string | null => {
     try {
-        existing = readFileSync(path, "utf-8");
+        return readFileSync(path, "utf8");
     } catch {
-        existing = null;
+        return null;
     }
-    if (existing === content) return false;
+};
+
+const didWriteChanges = (path: string, content: string): boolean => {
+    if (readFileOrNull(path) === content) {
+        return false;
+    }
+
     mkdirSync(dirname(path), { recursive: true });
     writeFileSync(path, content);
+
     return true;
 };
 
-export const emitSchemaEnv = (rootDir: string, dataDir: string | null): SchemaEnvResult => {
+const emitSchemaEnv = (rootDir: string, dataDir: string | null): SchemaEnvResult => {
     const dataDirAbs = dataDir === null ? null : join(rootDir, dataDir);
     const schemaFiles = dataDirAbs === null ? [] : findSchemaFiles(dataDirAbs);
     const parsed = dataDirAbs === null ? [] : parseProjectSchemas(schemaFiles, dataDirAbs);
     const content = renderEnvModule(parsed);
     const path = schemaEnvPath(rootDir);
-    const written = writeIfChanged(path, content);
-    return { path, written };
+    const isWritten = didWriteChanges(path, content);
+
+    return { path, written: isWritten };
+};
+
+export {
+    SCHEMA_SUFFIX,
+    prependSchemaDir,
+    stageSchema,
+    findSchemaFiles,
+    stageAndCompileProjectSchemas,
+    schemaEnvPath,
+    emitSchemaEnv,
 };

package/src/vite-plugins/asset-extensions.ts

@@ -1,4 +1,4 @@
-export const ASSET_EXTENSIONS = [
+const ASSET_EXTENSIONS = [
     "png",
     "jpg",
     "jpeg",
@@ -23,6 +23,7 @@ export const ASSET_EXTENSIONS = [
     "gpa",
 ];
 
-export const ASSET_RE = new RegExp(String.raw`\.(?:${ASSET_EXTENSIONS.join("|")})$`, "i");
+const ASSET_RE = new RegExp(String.raw`\.(?:${ASSET_EXTENSIONS.join("|")})$`, "i");
+const ASSET_PATH_RE = new RegExp(String.raw`\.(?:${ASSET_EXTENSIONS.join("|")})(?:\?.*)?$`, "i");
 
-export const ASSET_PATH_RE = new RegExp(String.raw`\.(?:${ASSET_EXTENSIONS.join("|")})(?:\?.*)?$`, "i");
+export { ASSET_EXTENSIONS, ASSET_RE, ASSET_PATH_RE };