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

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 };

package/src/vite-plugins/built-url.ts

@@ -1,6 +1,32 @@
 import type { Plugin } from "vite";
 
-export function gtkxBuiltUrl(assetBase?: string): Plugin {
+const renderAssetUrl = (
+    filename: string,
+    type: string,
+    assetBase: string | undefined,
+): { runtime: string } | undefined => {
+    if (type !== "asset") {
+        return undefined;
+    }
+
+    if (assetBase) {
+        const executableDir = "require(\"path\").dirname(process.execPath)";
+
+        return {
+            runtime:
+                `require("path").join(${executableDir},` +
+                `${JSON.stringify(assetBase)},${JSON.stringify(filename)})`,
+        };
+    }
+
+    const filenameLiteral = JSON.stringify(`./${filename}`);
+
+    return {
+        runtime: `new URL(${filenameLiteral}, import.meta.url).pathname`,
+    };
+};
+
+function gtkxBuiltUrl(assetBase?: string): Plugin {
     return {
         name: "gtkx:built-url",
         apply: "build",
@@ -13,23 +39,12 @@ export function gtkxBuiltUrl(assetBase?: string): Plugin {
             return {
                 experimental: {
                     renderBuiltUrl(filename, { type }) {
-                        if (type !== "asset") {
-                            return;
-                        }
-
-                        if (assetBase) {
-                            return {
-                                runtime: `require("path").join(require("path").dirname(process.execPath),${JSON.stringify(assetBase)},${JSON.stringify(filename)})`,
-                            };
-                        }
-
-                        const filenameLiteral = JSON.stringify(`./${filename}`);
-                        return {
-                            runtime: `new URL(${filenameLiteral}, import.meta.url).pathname`,
-                        };
+                        return renderAssetUrl(filename, type, assetBase);
                     },
                 },
             };
         },
     };
 }
+
+export { gtkxBuiltUrl };

package/src/vite-plugins/css.ts

@@ -1,38 +1,53 @@
-import { readFileSync } from "node:fs";
 import type { Plugin } from "vite";
+import { readFileSync } from "node:fs";
 import { createVirtualNamespace } from "./virtual-module.js";
 
+type CssResolveContext = Parameters<typeof resolveToVirtual>[0];
+type CssResolveRequest = Parameters<typeof resolveToVirtual>[1];
+
 const CSS_RE = /\.css$/i;
 const INJECT_SUFFIX = "?inject";
 const VIRTUAL_PREFIX = "\0gtkx-css:";
 const { isVirtual, fromVirtualId, resolveToVirtual } = createVirtualNamespace(VIRTUAL_PREFIX);
 
-export function gtkxCss(): Plugin {
+const resolveCssId = async (ctx: CssResolveContext, request: CssResolveRequest): Promise<string | undefined> => {
+    if (!CSS_RE.test(request.source)) {
+        return;
+    }
+
+    const virtualId = await resolveToVirtual(ctx, request);
+
+    if (virtualId === undefined) {
+        return;
+    }
+
+    return virtualId + INJECT_SUFFIX;
+};
+
+const loadInjectedCss = (id: string): string | undefined => {
+    if (!isVirtual(id) || !id.endsWith(INJECT_SUFFIX)) {
+        return;
+    }
+
+    const filePath = fromVirtualId(id.slice(0, -INJECT_SUFFIX.length));
+    const content = readFileSync(filePath, "utf8");
+
+    return ["import { injectGlobal } from \"@gtkx/css\";", `injectGlobal(${JSON.stringify(content)});`].join("\n");
+};
+
+function gtkxCss(): Plugin {
     return {
         name: "gtkx:css",
         enforce: "pre",
 
-        async resolveId(source, importer, options) {
-            if (!CSS_RE.test(source)) {
-                return;
-            }
-
-            const virtualId = await resolveToVirtual(this, { source, importer, options });
-            if (virtualId === undefined) return;
-
-            return virtualId + INJECT_SUFFIX;
+        resolveId(source, importer, options) {
+            return resolveCssId(this, { source, importer, options });
         },
 
         load(id) {
-            if (isVirtual(id) && id.endsWith(INJECT_SUFFIX)) {
-                const filePath = fromVirtualId(id.slice(0, -INJECT_SUFFIX.length));
-                const content = readFileSync(filePath, "utf-8");
-                return [`import { injectGlobal } from "@gtkx/css";`, `injectGlobal(${JSON.stringify(content)});`].join(
-                    "\n",
-                );
-            }
-
-            return;
+            return loadInjectedCss(id);
         },
     };
 }
+
+export { gtkxCss };

package/src/vite-plugins/fast-refresh/refresh-filter.ts

@@ -1,18 +1,26 @@
-export const REFRESH_REG = "$RefreshReg$";
-
-export const REFRESH_SIG = "$RefreshSig$";
-
-export const REFRESH_RUNTIME_SPECIFIER = "@gtkx/cli/refresh-runtime";
-
+const REFRESH_REG = "$RefreshReg$";
+const REFRESH_SIG = "$RefreshSig$";
+const REFRESH_RUNTIME_SPECIFIER = "@gtkx/cli/refresh-runtime";
 const REFRESH_INCLUDE = /\.[tj]sx?$/;
 const REFRESH_EXCLUDE = /node_modules|[/\\]dist[/\\]|[/\\]\.gtkx[/\\]/;
 
-export const shouldTransformForRefresh = (
+const shouldTransformForRefresh = (
     id: string,
     transformOptions: { ssr?: boolean | undefined } | undefined,
 ): boolean => {
-    if (!transformOptions?.ssr) return false;
-    if (!REFRESH_INCLUDE.test(id)) return false;
-    if (REFRESH_EXCLUDE.test(id)) return false;
+    if (!transformOptions?.ssr) {
+        return false;
+    }
+
+    if (!REFRESH_INCLUDE.test(id)) {
+        return false;
+    }
+
+    if (REFRESH_EXCLUDE.test(id)) {
+        return false;
+    }
+
     return true;
 };
+
+export { REFRESH_REG, REFRESH_SIG, REFRESH_RUNTIME_SPECIFIER, shouldTransformForRefresh };