@gtkx/cli 1.6.0 → 2.0.0-beta.10

package/src/internal/entry-arg.ts

@@ -14,6 +14,13 @@ const cwdArg: { cwd: StringArgDef } = {
     },
 };
 
+const configArg: { config: StringArgDef } = {
+    config: {
+        type: "string",
+        description: "Project-relative configuration file (default: gtkx.config.*)",
+    },
+};
+
 const entryArg: { entry: PositionalArgDef; cwd: StringArgDef } = {
     entry: {
         type: "positional",
@@ -57,4 +64,4 @@ const resolveGivenEntry = (cwd: string, entry: string): string => {
 const resolveEntry = (cwd: string, entry: string | undefined): string =>
     entry ? resolveGivenEntry(cwd, entry) : resolveDefaultEntry(cwd);
 
-export { cwdArg, entryArg, resolveCwd, resolveEntry };
+export { configArg, cwdArg, entryArg, resolveCwd, resolveEntry };

package/src/internal/errors.ts

@@ -33,4 +33,4 @@ const withErrorBoundary = <T extends ArgsDef>(command: CommandDef<T>): CommandDe
     };
 };
 
-export { withErrorBoundary };
+export { printError, withErrorBoundary };

package/src/internal/font-path.ts

@@ -0,0 +1,15 @@
+import { createHash } from "node:crypto";
+import { basename, extname } from "node:path";
+
+const FONTS_DIR = "fonts";
+const DIGEST_LENGTH = 8;
+
+const fontFileName = (sourcePath: string, content: Buffer): string => {
+    const extension = extname(sourcePath).toLowerCase();
+    const stem = basename(sourcePath, extname(sourcePath));
+    const digest = createHash("sha1").update(content).digest("hex").slice(0, DIGEST_LENGTH);
+
+    return `${stem}-${digest}${extension}`;
+};
+
+export { fontFileName, FONTS_DIR };

package/src/internal/font-staging.ts

@@ -0,0 +1,131 @@
+import { sortStrings } from "@gtkx/utils";
+import { lstatSync, mkdirSync, readFileSync, symlinkSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { parseFontSpecifier } from "../vite-plugins/asset-specifier.js";
+import { fontFileName, FONTS_DIR } from "./font-path.js";
+import { discoverSourceFiles, importsIn, type SourceImport, sourceLanguage } from "./source-imports.js";
+import { createRetainedStagingDir } from "./staging-dir.js";
+
+type FontStagingStatus = "absent" | "staged" | "unmanaged";
+
+const FONT_DIR_ENV = "GTKX_DEV_FONT_DIR";
+const FONT_QUERY = "?font";
+const fontStaging = createRetainedStagingDir("fonts");
+
+const isRelativeImport = (source: string): boolean => source.startsWith("./") || source.startsWith("../");
+
+const existingPath = (path: string): string | null =>
+    lstatSync(path, { throwIfNoEntry: false }) === undefined ? null : path;
+
+const resolveRelativeImport = (importer: string, assetSource: string): string | null =>
+    existingPath(resolve(dirname(importer), assetSource));
+
+const resolveAbsoluteImport = (root: string, assetSource: string): string | null =>
+    existingPath(assetSource) ?? existingPath(join(root, assetSource));
+
+const resolvePackageImport = (importer: string, assetSource: string): string | null => {
+    try {
+        return createRequire(importer).resolve(assetSource);
+    } catch {
+        return null;
+    }
+};
+
+const resolveFontImport = (root: string, importer: string, assetSource: string): string | null => {
+    if (isRelativeImport(assetSource)) {
+        return resolveRelativeImport(importer, assetSource);
+    }
+
+    if (isAbsolute(assetSource)) {
+        return resolveAbsoluteImport(root, assetSource);
+    }
+
+    return resolvePackageImport(importer, assetSource);
+};
+
+const fontFileFor = (root: string, { importer, source }: SourceImport): string | null => {
+    const specifier = parseFontSpecifier(source);
+
+    return specifier === null ? null : resolveFontImport(root, importer, specifier.assetSource);
+};
+
+const hasFontImportMention = (filePath: string): boolean => {
+    if (sourceLanguage(filePath) === undefined) {
+        return false;
+    }
+
+    try {
+        return readFileSync(filePath, "utf8").includes(FONT_QUERY);
+    } catch {
+        return false;
+    }
+};
+
+const projectFontFiles = (root: string): string[] => {
+    const files = discoverSourceFiles(root)
+        .filter((path) => hasFontImportMention(path))
+        .flatMap((path) => importsIn(path))
+        .map((entry) => fontFileFor(root, entry))
+        .filter((path): path is string => path !== null);
+
+    return sortStrings(new Set(files));
+};
+
+const stagedPath = (fontsDir: string, sourcePath: string, content: Buffer): string =>
+    join(fontsDir, fontFileName(sourcePath, content));
+
+const stageFont = (fontsDir: string, sourcePath: string): void => {
+    const target = stagedPath(fontsDir, sourcePath, readFileSync(sourcePath));
+
+    if (existingPath(target) !== null) {
+        return;
+    }
+
+    symlinkSync(sourcePath, target, "file");
+};
+
+const stagedFontsDir = (): string | null => {
+    const shareDir = process.env[FONT_DIR_ENV];
+
+    return shareDir === undefined || shareDir.length === 0 ? null : join(shareDir, FONTS_DIR);
+};
+
+const stagedFontStatus = (sourcePath: string, content: Buffer): FontStagingStatus => {
+    const fontsDir = stagedFontsDir();
+
+    if (fontsDir === null) {
+        return "unmanaged";
+    }
+
+    return existingPath(stagedPath(fontsDir, sourcePath, content)) === null ? "absent" : "staged";
+};
+
+const isUnstagedFont = (fontsDir: string, sourcePath: string): boolean =>
+    existingPath(stagedPath(fontsDir, sourcePath, readFileSync(sourcePath))) === null;
+
+const hasUnstagedFontImport = (root: string, filePath: string): boolean => {
+    const fontsDir = stagedFontsDir();
+
+    if (fontsDir === null || !hasFontImportMention(filePath)) {
+        return false;
+    }
+
+    return projectFontFiles(root).some((sourcePath) => isUnstagedFont(fontsDir, sourcePath));
+};
+
+const stageProjectFonts = (root: string): string => {
+    const shareDir = fontStaging.retain();
+    const fontsDir = join(shareDir, FONTS_DIR);
+    mkdirSync(fontsDir, { recursive: true });
+
+    for (const sourcePath of projectFontFiles(root)) {
+        stageFont(fontsDir, sourcePath);
+    }
+
+    process.env[FONT_DIR_ENV] = shareDir;
+
+    return shareDir;
+};
+
+export { hasUnstagedFontImport, stagedFontStatus, stageProjectFonts };

package/src/internal/icon-path.ts

@@ -1,5 +1,6 @@
-import { type Stats, statSync } from "node:fs";
-import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
+import { isPathInside } from "@gtkx/utils";
+import { statSync } from "node:fs";
+import { basename, extname, isAbsolute, join, resolve } from "node:path";
 
 type ResolvedApplicationIcon = { kind: "file"; path: string } |
     { kind: "none" } |
@@ -10,20 +11,6 @@ const SCALABLE_DIR = "hicolor/scalable/apps";
 const SIZE_PATTERN = /^(?<width>[1-9]\d{0,3})x(?<height>[1-9]\d{0,3})$/;
 const SIZE_SEPARATORS = /[-_.]/;
 
-const isInside = (parent: string, candidate: string): boolean => {
-    const rel = relative(parent, candidate);
-
-    return rel.length > 0 && !rel.startsWith("..") && !isAbsolute(rel);
-};
-
-const getStats = (path: string): Stats | undefined => {
-    try {
-        return statSync(path, { throwIfNoEntry: false });
-    } catch {
-        return undefined;
-    }
-};
-
 const iconExtension = (file: string): string => {
     const extension = extname(file).toLowerCase();
 
@@ -37,7 +24,7 @@ const iconExtension = (file: string): string => {
 const defaultIconFiles = (root: string, applicationId: string): string[] =>
     [...ICON_EXTENSIONS]
         .map((extension) => join(root, `${applicationId}${extension}`))
-        .filter((path) => getStats(path)?.isFile() === true);
+        .filter((path) => statSync(path, { throwIfNoEntry: false })?.isFile() === true);
 
 const resolveDefaultApplicationIcon = (root: string, applicationId: string): ResolvedApplicationIcon => {
     const files = defaultIconFiles(root, applicationId);
@@ -76,11 +63,11 @@ const resolveApplicationIcon = (
 
     const path = resolve(root, configured);
 
-    if (!isInside(root, path)) {
+    if (!isPathInside(root, path)) {
         throw new Error(`Cannot use "${configured}" as the application icon: it is outside ${root}`);
     }
 
-    const stats = getStats(path);
+    const stats = statSync(path, { throwIfNoEntry: false });
 
     if (stats?.isDirectory() === true) {
         return { kind: "theme", path };

package/src/internal/icon-staging.ts

@@ -0,0 +1,58 @@
+import { mkdirSync, rmSync, symlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { relativeIconPath, resolveApplicationIcon, type ResolvedApplicationIcon } from "./icon-path.js";
+import { createRetainedStagingDir, type RetainedStagingDir } from "./staging-dir.js";
+
+const ICONS_DIR = "icons";
+const stagingDirs: Map<string, RetainedStagingDir> = new Map();
+
+const stagingFor = (root: string): RetainedStagingDir => {
+    const existing = stagingDirs.get(root);
+
+    if (existing !== undefined) {
+        return existing;
+    }
+
+    const staging = createRetainedStagingDir("icons");
+    stagingDirs.set(root, staging);
+
+    return staging;
+};
+
+const resetIconsDir = (shareDir: string): string => {
+    const iconsDir = join(shareDir, ICONS_DIR);
+    rmSync(iconsDir, { recursive: true, force: true });
+
+    return iconsDir;
+};
+
+const stageIconSource = (
+    iconsDir: string,
+    applicationId: string,
+    source: Exclude<ResolvedApplicationIcon, { kind: "none" }>,
+): void => {
+    if (source.kind === "theme") {
+        symlinkSync(source.path, iconsDir, "dir");
+
+        return;
+    }
+
+    const target = join(iconsDir, relativeIconPath(applicationId, source.path));
+    mkdirSync(dirname(target), { recursive: true });
+    symlinkSync(source.path, target, "file");
+};
+
+const stageProjectIcons = (root: string, applicationId: string, configured: string | undefined): string | null => {
+    const source = resolveApplicationIcon(root, applicationId, configured);
+
+    if (source.kind === "none") {
+        return null;
+    }
+
+    const shareDir = stagingFor(root).retain();
+    stageIconSource(resetIconsDir(shareDir), applicationId, source);
+
+    return shareDir;
+};
+
+export { stageProjectIcons };

package/src/internal/import-scan.ts

@@ -0,0 +1,206 @@
+import { isRecord } from "@gtkx/utils";
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readdirSync, readFileSync, rmSync } from "node:fs";
+import { createRequire } from "node:module";
+import { basename, dirname, join } from "node:path";
+import packageManifest from "../../package.json" with { type: "json" };
+import { moduleHash } from "./module-hash.js";
+import {
+    discoverSourceFiles,
+    importSourcesIn,
+    readSource,
+    sortSourceImports,
+    sourceDirFor,
+    type SourceImport,
+} from "./source-imports.js";
+import { isStagingOwnerRunning, STAGING_SUFFIX, writeAtomically } from "./staging-file.js";
+
+type ScannedFile = {
+    hash: string;
+    sources: string[];
+};
+
+type ScanIndex = Map<string, ScannedFile>;
+
+type ScanCache = Map<string, ScanIndex>;
+
+type ScanResult = {
+    index: ScanIndex;
+    isChanged: boolean;
+};
+
+const CACHE_FILE = ["node_modules", ".gtkx", "import-scan.json"];
+const PARSER_MANIFEST = "vite/package.json";
+const UNKNOWN_PARSER = "unknown";
+const SCANNER_MODULES = ["source-imports", "import-scan"];
+const identity: { value: string | undefined } = { value: undefined };
+
+const scanCachePath = (root: string): string => join(root, ...CACHE_FILE);
+
+const hashSource = (code: string): string => createHash("sha256").update(code).digest("hex");
+
+const readJson = (path: string): unknown => {
+    try {
+        return JSON.parse(readFileSync(path, "utf8")) as unknown;
+    } catch {
+        return undefined;
+    }
+};
+
+const parserVersion = (): string => {
+    const manifest = readJson(createRequire(import.meta.url).resolve(PARSER_MANIFEST));
+
+    return isRecord(manifest) && typeof manifest.version === "string" ? manifest.version : UNKNOWN_PARSER;
+};
+
+const scannerHash = (): string =>
+    SCANNER_MODULES.map((name) => moduleHash(join(import.meta.dirname, name))).join("-");
+
+const cacheVersion = (): string =>
+    (identity.value ??= `${packageManifest.version}+${parserVersion()}+${scannerHash()}`);
+
+const isStringArray = (value: unknown): value is string[] =>
+    Array.isArray(value) && value.every((entry) => typeof entry === "string");
+
+const scannedFile = (value: unknown): ScannedFile | null => {
+    if (!isRecord(value)) {
+        return null;
+    }
+
+    const { hash, sources } = value;
+
+    return typeof hash === "string" && isStringArray(sources) ? { hash, sources } : null;
+};
+
+const scanIndexFrom = (value: unknown): ScanIndex => {
+    const index: ScanIndex = new Map();
+
+    if (!isRecord(value)) {
+        return index;
+    }
+
+    for (const [file, entry] of Object.entries(value)) {
+        const scanned = scannedFile(entry);
+
+        if (scanned !== null) {
+            index.set(file, scanned);
+        }
+    }
+
+    return index;
+};
+
+const readCache = (path: string): ScanCache => {
+    const parsed = readJson(path);
+    const cache: ScanCache = new Map();
+
+    if (!isRecord(parsed) || parsed.version !== cacheVersion() || !isRecord(parsed.dirs)) {
+        return cache;
+    }
+
+    for (const [dir, files] of Object.entries(parsed.dirs)) {
+        if (existsSync(dir)) {
+            cache.set(dir, scanIndexFrom(files));
+        }
+    }
+
+    return cache;
+};
+
+const pruneStaging = (path: string): void => {
+    const dir = dirname(path);
+    const prefix = `${basename(path)}.`;
+
+    let names: string[];
+
+    try {
+        names = readdirSync(dir);
+    } catch {
+        return;
+    }
+
+    for (const name of names) {
+        if (name.startsWith(prefix) && name.endsWith(STAGING_SUFFIX) && !isStagingOwnerRunning(name)) {
+            rmSync(join(dir, name), { force: true });
+        }
+    }
+};
+
+const cachePayload = (cache: ScanCache): unknown => ({
+    version: cacheVersion(),
+    dirs: Object.fromEntries([...cache].map(([dir, index]) => [dir, Object.fromEntries(index)])),
+});
+
+const writeCache = (path: string, cache: ScanCache): void => {
+    try {
+        mkdirSync(dirname(path), { recursive: true });
+    } catch {
+        return;
+    }
+
+    pruneStaging(path);
+    writeAtomically(path, JSON.stringify(cachePayload(cache)));
+};
+
+/* eslint-disable-next-line unicorn/consistent-boolean-name -- the boolean reports whether the file was rescanned */
+const scanFile = (path: string, previous: ScanIndex, index: ScanIndex): boolean => {
+    const code = readSource(path);
+
+    if (code === null) {
+        return previous.has(path);
+    }
+
+    const hash = hashSource(code);
+    const cached = previous.get(path);
+
+    if (cached?.hash === hash) {
+        index.set(path, cached);
+
+        return false;
+    }
+
+    const sources = importSourcesIn(path, code);
+
+    if (sources === null) {
+        return previous.has(path);
+    }
+
+    index.set(path, { hash, sources });
+
+    return true;
+};
+
+const scanSourceDir = (dir: string, previous: ScanIndex): ScanResult => {
+    const index: ScanIndex = new Map();
+    let isChanged = false;
+
+    for (const path of discoverSourceFiles(dir)) {
+        if (scanFile(path, previous, index)) {
+            isChanged = true;
+        }
+    }
+
+    return { index, isChanged: isChanged || index.size !== previous.size };
+};
+
+const toSourceImports = (index: ScanIndex): SourceImport[] =>
+    sortSourceImports(
+        [...index].flatMap(([importer, { sources }]) => sources.map((source) => ({ importer, source }))),
+    );
+
+const discoverProjectImports = (root: string): SourceImport[] => {
+    const dir = sourceDirFor(root);
+    const path = scanCachePath(root);
+    const cache = readCache(path);
+    const previous = cache.get(dir) ?? new Map<string, ScannedFile>();
+    const { index, isChanged } = scanSourceDir(dir, previous);
+
+    if (isChanged || !cache.has(dir)) {
+        cache.set(dir, index);
+        writeCache(path, cache);
+    }
+
+    return toSourceImports(index);
+};
+
+export { discoverProjectImports };

package/src/internal/module-hash.ts

@@ -0,0 +1,22 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+
+const MODULE_EXTENSIONS = [".js", ".ts"];
+const MODULE_HASH_LENGTH = 16;
+const UNKNOWN_MODULE = "unknown";
+
+const moduleHash = (base: string): string => {
+    for (const extension of MODULE_EXTENSIONS) {
+        try {
+            const contents = readFileSync(`${base}${extension}`);
+
+            return createHash("sha256").update(contents).digest("hex").slice(0, MODULE_HASH_LENGTH);
+        } catch {
+            continue;
+        }
+    }
+
+    return UNKNOWN_MODULE;
+};
+
+export { moduleHash };