@gtkx/cli 1.3.0 → 1.4.0

package/src/deploy/targets/appimage.ts

@@ -1,5 +1,5 @@
 import { existsSync, mkdirSync, rmSync, statSync } from "node:fs";
-import { join } from "node:path";
+import { basename, join } from "node:path";
 import type {
     DeployArtifact,
     DeployManifest,
@@ -10,18 +10,21 @@ import type {
 } from "../types.js";
 import { runCliTool } from "../../internal/run-cli-tool.js";
 import { copyInto, copyTree, EXECUTABLE_MODE, writeInto } from "../payload/copy-tree.js";
-import { getIconSize } from "../payload/icons.js";
+import { type ApplicationIconVariant, classifyApplicationIcon } from "../payload/icons.js";
 import { FILE_TOOL } from "../tools.js";
 import { resolveAppimageTooling } from "../vendored/appimagetool.js";
 
+type RankedIcon = {
+    file: StagedFile;
+    variant: ApplicationIconVariant;
+};
+
 const PREFIX = "/usr";
 const TARGET_DIR = "appimage";
 const APPRUN_FILENAME = "AppRun";
 const APPDIR_NAME = "AppDir";
 const USR_DIR = "usr";
-const ICON_EXTENSIONS = [".svg", ".png", ".xpm"];
 const EXTRACT_AND_RUN = "APPIMAGE_EXTRACT_AND_RUN";
-const SCALABLE_RANK = Number.MAX_SAFE_INTEGER;
 
 const appimageTarget: DeployTarget = {
     name: "appimage",
@@ -50,31 +53,45 @@ const renderManifests = (payload: DeployPayload): DeployManifest[] => [
     { path: appRunPathFor(payload.settings), contents: renderAppRun(payload.settings) },
 ];
 
-const iconRank = (file: StagedFile): number =>
-    file.rel.endsWith(".svg") ? SCALABLE_RANK : (getIconSize(file.rel) ?? 0);
+const rankedIcon = (applicationId: string, file: StagedFile): RankedIcon | null => {
+    const variant = classifyApplicationIcon(applicationId, file.rel);
+
+    return variant === null ? null : { file, variant };
+};
+
+const isLargerIcon = (candidate: RankedIcon, best: RankedIcon): boolean =>
+    candidate.variant.scalable === best.variant.scalable
+        ? candidate.variant.effectivePixels > best.variant.effectivePixels
+        : candidate.variant.scalable;
+
+const largerIcon = (best: RankedIcon | undefined, candidate: RankedIcon): RankedIcon =>
+    best === undefined || isLargerIcon(candidate, best) ? candidate : best;
 
-const largestIcon = (icons: StagedFile[]): StagedFile | undefined => {
-    let best: StagedFile | undefined;
+const largestIcon = (applicationId: string, files: StagedFile[]): StagedFile | undefined => {
+    let best: RankedIcon | undefined;
 
-    for (const file of icons) {
-        if (best === undefined || iconRank(file) > iconRank(best)) {
-            best = file;
+    for (const file of files) {
+        const candidate = rankedIcon(applicationId, file);
+
+        if (candidate === null) {
+            continue;
         }
+
+        best = largerIcon(best, candidate);
     }
 
-    return best;
+    return best?.file;
 };
 
 const rootIconFor = (payload: DeployPayload): { rel: string; abs: string } => {
     const { applicationId } = payload.settings;
-    const names = new Set(ICON_EXTENSIONS.map((extension) => `${applicationId}${extension}`));
-    const icon = largestIcon(payload.stage.filter((file) => names.has(file.rel.split("/").at(-1) ?? "")));
+    const icon = largestIcon(applicationId, payload.stage);
 
     if (icon === undefined) {
         throw new Error(`Cannot build an AppImage without a ${applicationId} icon in the staged icon tree`);
     }
 
-    return { rel: icon.rel.split("/").at(-1) ?? "", abs: icon.abs };
+    return { rel: basename(icon.rel), abs: icon.abs };
 };
 
 const buildAppDir = (payload: DeployPayload): string => {

package/src/deploy/targets/flatpak-manifest.ts

@@ -110,6 +110,12 @@ const runtimeKeys = (settings: DeploySettings): FlatpakManifest => {
     };
 };
 
+const runtimeLabelFor = (settings: DeploySettings): string => {
+    const flatpak = settings.deploy.flatpak ?? {};
+
+    return `${flatpak.runtime ?? DEFAULT_RUNTIME}//${flatpak.runtimeVersion ?? DEFAULT_RUNTIME_VERSION}`;
+};
+
 const renderFlatpakManifest = (payload: DeployPayload): FlatpakManifest => {
     const settings = payload.settings;
 
@@ -123,4 +129,4 @@ const renderFlatpakManifest = (payload: DeployPayload): FlatpakManifest => {
     };
 };
 
-export { branchFor, finishArgsFor, hasDisplaySocket, renderFlatpakManifest };
+export { branchFor, finishArgsFor, hasDisplaySocket, renderFlatpakManifest, runtimeLabelFor };

package/src/deploy/targets/flatpak-source.ts

@@ -120,12 +120,11 @@ const metadataInstallCommands = (settings: DeploySettings): string[] => [
 const schemaInstallCommands = (settings: DeploySettings): string[] =>
     settings.paths.schemaFiles.map((file) => {
         const name = posix.basename(file);
+        const source = projectRelative(settings, file);
+        const destination = `${DESTINATION}/share/glib-2.0/schemas/${shellArgument(name)}`;
+        assertInsideProject(settings, { destination, source, resolved: file });
 
-        return installCommand(
-            projectRelative(settings, file),
-            `${DESTINATION}/share/glib-2.0/schemas/${shellArgument(name)}`,
-            "m644",
-        );
+        return installCommand(source, destination, "m644");
     });
 
 const iconInstallCommand = (settings: DeploySettings, source: string, rel: string): string =>
@@ -136,17 +135,17 @@ const iconInstallCommand = (settings: DeploySettings, source: string, rel: strin
     );
 
 const iconInstallCommands = (settings: DeploySettings): string[] => {
-    const { iconsDir, iconFile } = settings.paths;
+    const source = settings.paths.applicationIcon;
 
-    if (iconFile !== null) {
-        return [iconInstallCommand(settings, iconFile, iconPathFor(settings, iconFile))];
+    if (source.kind === "file") {
+        return [iconInstallCommand(settings, source.path, iconPathFor(settings, source.path))];
     }
 
-    if (iconsDir === null) {
+    if (source.kind === "none") {
         return [];
     }
 
-    return listFilesRecursive(iconsDir).map((icon) => iconInstallCommand(settings, icon.absPath, icon.rel));
+    return listFilesRecursive(source.path).map((icon) => iconInstallCommand(settings, icon.absPath, icon.rel));
 };
 
 const assertInsideProject = (settings: DeploySettings, installed: InstalledFile): void => {

package/src/deploy/types.ts

@@ -1,4 +1,5 @@
 import type { Config } from "@gtkx/config";
+import type { ResolvedApplicationIcon } from "../internal/icon-path.js";
 
 type DeployConfig = NonNullable<Config["deploy"]>;
 type DeployTargetName = NonNullable<DeployConfig["targets"]>[number];
@@ -21,7 +22,7 @@ type NodeRuntime = {
     path: string;
     licenseFile: string | null;
     version: string;
-    glibcFloor: string | null;
+    glibcMinimum: string | null;
     isStripped: boolean;
 };
 
@@ -106,9 +107,7 @@ type DeployPaths = {
     overlay: string;
     targets: string;
     output: string;
-    dataDir: string | null;
-    iconsDir: string | null;
-    iconFile: string | null;
+    applicationIcon: ResolvedApplicationIcon;
     licenseFile: string | null;
     schemaFiles: string[];
 };
@@ -145,6 +144,7 @@ type DeploySettings = {
     arch: DeployArch;
     paths: DeployPaths;
     libraries: string[];
+    minimumLibraryVersions: Record<string, string>;
     deploy: DeployConfig;
 };
 

package/src/dev/icon-dir.ts

@@ -1,18 +1,42 @@
-import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { mkdirSync, symlinkSync } from "node:fs";
+import { dirname, join } from "node:path";
+import {
+    relativeIconPath,
+    resolveApplicationIcon,
+    type ResolvedApplicationIcon,
+} from "../internal/icon-path.js";
+import { createRetainedStagingDir } from "../internal/staging-dir.js";
 import { prependXdgDataDir } from "../internal/xdg-data-dirs.js";
 
-const prepareDevIconDir = (root: string, dataDir: string | null): string | null => {
-    if (dataDir === null) {
-        return null;
+const stageIconSource = (shareDir: string, applicationId: string, source: ResolvedApplicationIcon): void => {
+    if (source.kind === "theme") {
+        symlinkSync(source.path, join(shareDir, "icons"), "dir");
+
+        return;
+    }
+
+    if (source.kind === "none") {
+        return;
     }
 
-    const shareDir = join(root, dataDir);
+    const target = join(shareDir, "icons", relativeIconPath(applicationId, source.path));
+    mkdirSync(dirname(target), { recursive: true });
+    symlinkSync(source.path, target, "file");
+};
+
+const prepareDevIconDir = (
+    root: string,
+    applicationId: string,
+    configured: string | undefined,
+): string | null => {
+    const source = resolveApplicationIcon(root, applicationId, configured);
 
-    if (!existsSync(join(shareDir, "icons"))) {
+    if (source.kind === "none") {
         return null;
     }
 
+    const shareDir = createRetainedStagingDir("icons").retain();
+    stageIconSource(shareDir, applicationId, source);
     process.env.XDG_DATA_DIRS = prependXdgDataDir(shareDir, process.env.XDG_DATA_DIRS);
 
     return shareDir;

package/src/dev/runner-deps.ts

@@ -86,7 +86,11 @@ const defaultDevRunnerDeps = (): DevRunnerDeps => ({
     isRefreshBoundary,
     staleExportName,
     readFileRevision,
-    plugins: () => [...gtkxVitePlugins(DEV_MODE), ...gtkxFastRefresh(), gtkxReactDomPrebundle()],
+    plugins: (entryPath) => [
+        ...gtkxVitePlugins(DEV_MODE, entryPath),
+        ...gtkxFastRefresh(),
+        gtkxReactDomPrebundle(),
+    ],
     log: info,
     exit: (code: number): never => process.exit(code),
 });

package/src/dev/runner-main.ts

@@ -1,6 +1,6 @@
+import { loadConfig } from "@gtkx/config";
 import { error } from "@gtkx/utils";
 import { resolve } from "node:path";
-import { resolveDataDir } from "../internal/data-dir.js";
 import { DEV_ENTRY_ENV } from "./entry-env.js";
 import { prepareDevIconDir } from "./icon-dir.js";
 import { createDevRunner } from "./runner.js";
@@ -21,9 +21,9 @@ const main = async (): Promise<void> => {
         process.exit(1);
     }
 
-    const dataDir = resolveDataDir(cwd);
-    prepareDevSchemaDir(cwd, dataDir);
-    prepareDevIconDir(cwd, dataDir);
+    const { config, root } = await loadConfig(cwd, { mode: "development" });
+    prepareDevSchemaDir(root, config.future?.v2ResourceImports === true);
+    prepareDevIconDir(root, config.applicationId, config.applicationIcon);
     const entryPath = resolve(cwd, entryArg);
     const { defaultDevRunnerDeps } = await import("./runner-deps.js");
     const runner = createDevRunner(defaultDevRunnerDeps());

package/src/dev/runner.ts

@@ -32,7 +32,7 @@ type DevRunnerDeps = {
     isRefreshBoundary(module: Record<string, unknown>): boolean;
     staleExportName(previous: Record<string, unknown>, current: Record<string, unknown>): string | null;
     readFileRevision(path: string): Promise<string>;
-    plugins(): Plugin[];
+    plugins(entryPath: string): Plugin[];
     log(message: string): void;
     exit(code: number): never;
 };
@@ -602,7 +602,7 @@ const createSession = (server: DevServer, deps: DevRunnerDeps): DevSession => {
 
 const createDevRunner = (deps: DevRunnerDeps): DevRunner => ({
     async run(entryPath: string): Promise<void> {
-        const server = await deps.createServer(createDevServerConfig(process.cwd(), deps.plugins()));
+        const server = await deps.createServer(createDevServerConfig(process.cwd(), deps.plugins(entryPath)));
         const session = createSession(server, deps);
         deps.installShutdownHandlers(onShutdownSignal(session));
 

package/src/dev/schema-dir.ts

@@ -1,6 +1,8 @@
+import { resolveDataDir } from "../internal/data-dir.js";
 import { prependSchemaDir, stageAndCompileProjectSchemas } from "../settings/schema.js";
 
-const prepareDevSchemaDir = (root: string, dataDir: string | null): string | null => {
+const prepareDevSchemaDir = (root: string, isV2ResourceImports: boolean): string | null => {
+    const dataDir = isV2ResourceImports ? null : resolveDataDir(root);
     const dir = stageAndCompileProjectSchemas(root, dataDir);
 
     if (dir === null) {

package/src/internal/build-manifest.ts

@@ -0,0 +1,32 @@
+type RecordedPackage = {
+    name: string;
+    version: string | null;
+    dir: string;
+};
+
+type BuildManifest = {
+    generator: typeof BUILD_MANIFEST_GENERATOR;
+    formatVersion: typeof BUILD_MANIFEST_FORMAT_VERSION;
+    schemas: string[];
+    packages: RecordedPackage[];
+};
+
+type BuildManifestCollector = {
+    schemas: string[];
+};
+
+const BUILD_MANIFEST_FILENAME = "gtkx-schemas.json";
+const BUILD_MANIFEST_GENERATOR = "gtkx-build";
+const BUILD_MANIFEST_FORMAT_VERSION = 1;
+
+const createBuildManifestCollector = (): BuildManifestCollector => ({ schemas: [] });
+
+export {
+    BUILD_MANIFEST_FILENAME,
+    BUILD_MANIFEST_FORMAT_VERSION,
+    BUILD_MANIFEST_GENERATOR,
+    createBuildManifestCollector,
+    type BuildManifest,
+    type BuildManifestCollector,
+    type RecordedPackage,
+};

package/src/internal/icon-path.ts

@@ -0,0 +1,127 @@
+import { type Stats, statSync } from "node:fs";
+import { basename, extname, isAbsolute, join, relative, resolve } from "node:path";
+
+type ResolvedApplicationIcon = { kind: "file"; path: string } |
+    { kind: "none" } |
+    { kind: "theme"; path: string };
+
+const ICON_EXTENSIONS: Set<string> = new Set([".svg", ".png", ".xpm"]);
+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();
+
+    if (!ICON_EXTENSIONS.has(extension)) {
+        throw new Error(`Cannot use ${file} as an application icon: expected an SVG, PNG, or XPM file`);
+    }
+
+    return extension;
+};
+
+const defaultIconFiles = (root: string, applicationId: string): string[] =>
+    [...ICON_EXTENSIONS]
+        .map((extension) => join(root, `${applicationId}${extension}`))
+        .filter((path) => getStats(path)?.isFile() === true);
+
+const resolveDefaultApplicationIcon = (root: string, applicationId: string): ResolvedApplicationIcon => {
+    const files = defaultIconFiles(root, applicationId);
+
+    if (files.length === 0) {
+        return { kind: "none" };
+    }
+
+    if (files.length > 1) {
+        throw new Error(
+            `Found multiple default application icons for ${applicationId}; set \`applicationIcon\` to choose one`,
+        );
+    }
+
+    const path = files[0];
+
+    if (path === undefined) {
+        return { kind: "none" };
+    }
+
+    return { kind: "file", path };
+};
+
+const resolveApplicationIcon = (
+    root: string,
+    applicationId: string,
+    configured: string | undefined,
+): ResolvedApplicationIcon => {
+    if (configured === undefined) {
+        return resolveDefaultApplicationIcon(root, applicationId);
+    }
+
+    if (isAbsolute(configured)) {
+        throw new Error(`Cannot use "${configured}" as the application icon: expected a project-relative path`);
+    }
+
+    const path = resolve(root, configured);
+
+    if (!isInside(root, path)) {
+        throw new Error(`Cannot use "${configured}" as the application icon: it is outside ${root}`);
+    }
+
+    const stats = getStats(path);
+
+    if (stats?.isDirectory() === true) {
+        return { kind: "theme", path };
+    }
+
+    if (stats?.isFile() !== true) {
+        throw new Error(`Cannot read the application icon "${configured}": no such file or directory under ${root}`);
+    }
+
+    iconExtension(path);
+
+    return { kind: "file", path };
+};
+
+const squareSize = (token: string): number | null => {
+    const groups = SIZE_PATTERN.exec(token)?.groups;
+
+    if (groups === undefined || groups.width !== groups.height) {
+        return null;
+    }
+
+    return Number(groups.width);
+};
+
+const iconThemeDir = (file: string, extension: string): string => {
+    if (extension === ".svg") {
+        return SCALABLE_DIR;
+    }
+
+    const size = basename(file)
+        .split(SIZE_SEPARATORS)
+        .map((token) => squareSize(token))
+        .find((value) => value !== null);
+
+    return size === undefined ? SCALABLE_DIR : `hicolor/${String(size)}x${String(size)}/apps`;
+};
+
+const relativeIconPath = (applicationId: string, file: string): string => {
+    const extension = iconExtension(file);
+
+    return `${iconThemeDir(file, extension)}/${applicationId}${extension}`;
+};
+
+export { relativeIconPath, resolveApplicationIcon, type ResolvedApplicationIcon };

package/src/internal/source-imports.ts

@@ -0,0 +1,200 @@
+import type { ParseResult, ParserOptions } from "vite";
+import { isRecord, sortStringsBy } from "@gtkx/utils";
+import { type Dirent, readdirSync, readFileSync } from "node:fs";
+import { extname, join } from "node:path";
+import { parseSync } from "vite";
+
+type SourceImport = {
+    importer: string;
+    source: string;
+};
+
+type SourceLanguage = NonNullable<ParserOptions["lang"]>;
+type ParsedModule = ParseResult["module"];
+
+const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
+    [".cjs", "jsx"],
+    [".cts", "ts"],
+    [".js", "jsx"],
+    [".jsx", "jsx"],
+    [".mjs", "jsx"],
+    [".mts", "ts"],
+    [".ts", "ts"],
+    [".tsx", "tsx"],
+]);
+
+const EXCLUDED_DIRECTORIES: Set<string> = new Set([
+    ".git",
+    ".gtkx",
+    "build",
+    "coverage",
+    "dist",
+    "node_modules",
+    "out-tsc",
+]);
+
+const sourceLanguage = (path: string): SourceLanguage | undefined => {
+    if (path.endsWith(".d.ts") || path.endsWith(".d.cts") || path.endsWith(".d.mts")) {
+        return undefined;
+    }
+
+    return SOURCE_LANGUAGES.get(extname(path).toLowerCase());
+};
+
+const collectSourceEntry = (dir: string, entry: Dirent, found: string[]): void => {
+    const path = join(dir, entry.name);
+
+    if (entry.isDirectory()) {
+        if (!EXCLUDED_DIRECTORIES.has(entry.name)) {
+            sourceFilesIn(path, found);
+        }
+
+        return;
+    }
+
+    if (entry.isFile() && sourceLanguage(path) !== undefined) {
+        found.push(path);
+    }
+};
+
+const sourceFilesIn = (dir: string, found: string[]): void => {
+    let entries: Dirent[];
+
+    try {
+        entries = readdirSync(dir, { withFileTypes: true });
+    } catch {
+        return;
+    }
+
+    for (const entry of entries) {
+        collectSourceEntry(dir, entry, found);
+    }
+};
+
+const staticImportSources = (module: ParsedModule): string[] => [
+    ...module.staticImports.map((statement) => statement.moduleRequest.value),
+    ...module.staticExports.flatMap((statement) =>
+        statement.entries
+            .map((entry) => entry.moduleRequest?.value)
+            .filter((source): source is string => source !== undefined),
+    ),
+];
+
+const staticRuntimeImportSources = (module: ParsedModule): string[] => [
+    ...module.staticImports
+        .filter((statement) => statement.entries.length === 0 || statement.entries.some((entry) => !entry.isType))
+        .map((statement) => statement.moduleRequest.value),
+    ...module.staticExports.flatMap((statement) =>
+        statement.entries
+            .filter((entry) => !entry.isType)
+            .map((entry) => entry.moduleRequest?.value)
+            .filter((source): source is string => source !== undefined),
+    ),
+];
+
+const templateImportSource = (node: Record<string, unknown>): string | null => {
+    if (!Array.isArray(node.expressions) || node.expressions.length > 0 || !Array.isArray(node.quasis)) {
+        return null;
+    }
+
+    const quasis: unknown[] = node.quasis;
+    const first: unknown = quasis[0];
+
+    if (!isRecord(first) || !isRecord(first.value)) {
+        return null;
+    }
+
+    return typeof first.value.cooked === "string" ? first.value.cooked : null;
+};
+
+const literalImportSource = (node: unknown): string | null => {
+    if (!isRecord(node)) {
+        return null;
+    }
+
+    if (node.type === "Literal") {
+        return typeof node.value === "string" ? node.value : null;
+    }
+
+    return node.type === "TemplateLiteral" ? templateImportSource(node) : null;
+};
+
+const collectDynamicImportArray = (nodes: unknown[], found: string[]): void => {
+    for (const child of nodes) {
+        collectDynamicImportSources(child, found);
+    }
+};
+
+const collectDynamicImportRecord = (node: Record<string, unknown>, found: string[]): void => {
+    if (node.type === "ImportExpression") {
+        const source = literalImportSource(node.source);
+
+        if (source !== null) {
+            found.push(source);
+        }
+
+        return;
+    }
+
+    collectDynamicImportArray(Object.values(node), found);
+};
+
+const collectDynamicImportSources = (node: unknown, found: string[]): void => {
+    if (Array.isArray(node)) {
+        collectDynamicImportArray(node, found);
+
+        return;
+    }
+
+    if (!isRecord(node)) {
+        return;
+    }
+
+    collectDynamicImportRecord(node, found);
+};
+
+const parseImportsInWith = (
+    path: string,
+    staticSources: (module: ParsedModule) => string[],
+): SourceImport[] | null => {
+    const lang = sourceLanguage(path);
+
+    if (lang === undefined) {
+        return [];
+    }
+
+    let parsed: ParseResult;
+
+    try {
+        parsed = parseSync(path, readFileSync(path, "utf8"), { lang });
+    } catch {
+        return null;
+    }
+
+    if (parsed.errors.length > 0) {
+        return null;
+    }
+
+    const sources = staticSources(parsed.module);
+    collectDynamicImportSources(parsed.program, sources);
+
+    return [...new Set(sources)].map((source) => ({ importer: path, source }));
+};
+
+const parseImportsIn = (path: string): SourceImport[] | null => parseImportsInWith(path, staticImportSources);
+
+const parseRuntimeImportsIn = (path: string): SourceImport[] | null =>
+    parseImportsInWith(path, staticRuntimeImportSources);
+
+const importsIn = (path: string): SourceImport[] => parseImportsIn(path) ?? [];
+const importKey = (entry: SourceImport): string => `${entry.importer}\0${entry.source}`;
+
+const discoverSourceImports = (dir: string): SourceImport[] => {
+    const files: string[] = [];
+    sourceFilesIn(dir, files);
+    const imports = files.flatMap((path) => importsIn(path));
+
+    return sortStringsBy(imports, importKey);
+};
+
+export { discoverSourceImports, parseRuntimeImportsIn, type SourceImport };