@gtkx/cli 1.3.0 → 1.4.0

package/src/deploy/payload/icons.ts

@@ -1,53 +1,82 @@
-import { basename, join } from "node:path";
+import { join } from "node:path";
 import type { DeploySettings, StagedFile } from "../types.js";
+import { relativeIconPath } from "../../internal/icon-path.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
 import { copyInto } from "./copy-tree.js";
 
+type ApplicationIconVariant = {
+    effectivePixels: number;
+    scalable: boolean;
+};
+
 const ICON_EXTENSIONS = [".svg", ".png", ".xpm"];
 const SHARE_ICONS = "share/icons";
-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 isApplicationIcon = (settings: DeploySettings, rel: string): boolean =>
-    ICON_EXTENSIONS.some((extension) => basename(rel) === `${settings.applicationId}${extension}`);
+const SIZE_PATTERN = /^(?<width>[1-9]\d{0,3})x(?<height>[1-9]\d{0,3})(?:@(?<scale>[1-9]\d*))?$/;
 
-const getSquareSize = (token: string): number | null => {
+const getSquareSize = (token: string): { pixels: number; scale: number } | null => {
     const groups = SIZE_PATTERN.exec(token)?.groups;
 
     if (groups === undefined || groups.width !== groups.height) {
         return null;
     }
 
-    return Number(groups.width);
+    const pixels = Number(groups.width);
+    const scale = Number(groups.scale ?? "1");
+
+    return Number.isSafeInteger(pixels * scale) ? { pixels, scale } : null;
+};
+
+const isIconThemeSize = (segment: string | undefined): boolean =>
+    segment === "scalable" || segment === "symbolic" ||
+    (segment !== undefined && getSquareSize(segment) !== null);
+
+const iconExtension = (applicationId: string, filename: string | undefined): string | undefined =>
+    ICON_EXTENSIONS.find((candidate) => filename === `${applicationId}${candidate}`);
+
+const isApplicationIconLayout = (segments: (string | undefined)[]): boolean => {
+    const [share, icons, theme, size, context] = segments;
+
+    return share === "share" &&
+        icons === "icons" &&
+        theme === "hicolor" &&
+        context === "apps" &&
+        isIconThemeSize(size);
 };
 
-const firstSquareSize = (tokens: string[]): number | null =>
-    tokens.map((token) => getSquareSize(token)).find((size) => size !== null) ?? null;
+const classifyApplicationIcon = (applicationId: string, rel: string): ApplicationIconVariant | null => {
+    const segments = rel.split(/[\\/]/);
+
+    if (segments.length !== 6) {
+        return null;
+    }
 
-const getIconSize = (rel: string): number | null => firstSquareSize(rel.split("/").slice(0, -1));
+    const size = segments[3];
+    const filename = segments[5];
+    const extension = iconExtension(applicationId, filename);
 
-const themeDirFor = (file: string): string => {
-    if (file.endsWith(".svg")) {
-        return SCALABLE_DIR;
+    if (extension === undefined || !isApplicationIconLayout(segments)) {
+        return null;
     }
 
-    const size = firstSquareSize(basename(file).split(SIZE_SEPARATORS));
+    const square = size === undefined ? null : getSquareSize(size);
 
-    return size === null ? SCALABLE_DIR : `hicolor/${String(size)}x${String(size)}/apps`;
+    return {
+        effectivePixels: square === null ? 0 : square.pixels * square.scale,
+        scalable: extension === ".svg",
+    };
 };
 
-const stageIconTree = (root: string, iconsDir: string): StagedFile[] =>
-    listFilesRecursive(iconsDir).map((file) => copyInto(root, join(SHARE_ICONS, file.rel), file.absPath));
+const isApplicationIcon = (settings: DeploySettings, rel: string): boolean =>
+    classifyApplicationIcon(settings.applicationId, rel) !== null;
 
-const iconPathFor = (settings: DeploySettings, iconFile: string): string => {
-    const extension = ICON_EXTENSIONS.find((candidate) => iconFile.endsWith(candidate)) ?? ".png";
+const stageIconTree = (root: string, themePath: string): StagedFile[] =>
+    listFilesRecursive(themePath).map((file) => copyInto(root, join(SHARE_ICONS, file.rel), file.absPath));
 
-    return join(themeDirFor(iconFile), `${settings.applicationId}${extension}`);
-};
+const iconPathFor = (settings: DeploySettings, iconPath: string): string =>
+    relativeIconPath(settings.applicationId, iconPath);
 
-const stageIconFile = (settings: DeploySettings, root: string, iconFile: string): StagedFile[] =>
-    [copyInto(root, join(SHARE_ICONS, iconPathFor(settings, iconFile)), iconFile)];
+const stageIconFile = (settings: DeploySettings, root: string, iconPath: string): StagedFile[] =>
+    [copyInto(root, join(SHARE_ICONS, iconPathFor(settings, iconPath)), iconPath)];
 
 const assertApplicationIcon = (settings: DeploySettings, staged: StagedFile[]): void => {
     if (staged.some((file) => isApplicationIcon(settings, file.rel))) {
@@ -55,26 +84,27 @@ const assertApplicationIcon = (settings: DeploySettings, staged: StagedFile[]):
     }
 
     throw new Error(
-        `Cannot deploy without an application icon: no ${settings.applicationId}.svg or ` +
-        `${settings.applicationId}.png under ${settings.paths.iconsDir ?? "the project's icon directory"}. ` +
+        "Cannot deploy without a usable application icon: the configured theme must contain " +
+        `${settings.applicationId}.svg, ${settings.applicationId}.png, or ${settings.applicationId}.xpm ` +
+        "under hicolor/<size>/apps. " +
         "The desktop entry names " +
         `"${settings.applicationId}" as its icon, so the file has to match. ` +
-        `Add ${settings.paths.dataDir ?? "data"}/icons/hicolor/scalable/apps/${settings.applicationId}.svg, ` +
-        "or point `deploy.icons` at one.",
+        "Set `applicationIcon` to a theme directory containing " +
+        `hicolor/scalable/apps/${settings.applicationId}.svg, or point it at a single icon file.`,
     );
 };
 
 const stageIcons = (settings: DeploySettings, root: string): StagedFile[] => {
-    const { iconsDir, iconFile } = settings.paths;
+    const source = settings.paths.applicationIcon;
 
-    if (iconFile !== null) {
-        return stageIconFile(settings, root, iconFile);
+    if (source.kind === "file") {
+        return stageIconFile(settings, root, source.path);
     }
 
-    const staged = iconsDir === null ? [] : stageIconTree(root, iconsDir);
+    const staged = source.kind === "theme" ? stageIconTree(root, source.path) : [];
     assertApplicationIcon(settings, staged);
 
     return staged;
 };
 
-export { getIconSize, iconPathFor, stageIcons };
+export { classifyApplicationIcon, iconPathFor, stageIcons, type ApplicationIconVariant };

package/src/deploy/payload/stage.ts

@@ -2,8 +2,8 @@ import { sortStringsBy } from "@gtkx/utils";
 import { existsSync, rmSync } from "node:fs";
 import { join, resolve } from "node:path";
 import type { DeploySettings, DeployTargetName, NodeRuntime, NoticeSection, StagedFile } from "../types.js";
+import { BUILD_MANIFEST_FILENAME } from "../../internal/build-manifest.js";
 import { listFilesRecursive } from "../../internal/list-files.js";
-import { BUNDLED_PACKAGES_FILENAME } from "../../vite-plugins/bundled-packages.js";
 import { BUNDLE_FILENAME } from "../../vite-plugins/esm-extension.js";
 import { renderCopyright } from "../freedesktop/copyright.js";
 import { renderDbusService } from "../freedesktop/dbus-service.js";
@@ -27,6 +27,7 @@ type StagedMetadata = {
 };
 
 const DIST_ICONS_DIR = "icons";
+const LEGACY_PACKAGES_MANIFEST_FILENAME = "gtkx-packages.json";
 const NOTICES_FILENAME = "THIRD-PARTY-NOTICES";
 const NODE_LICENSE_FILENAME = "LICENSE";
 const SHARE_APPLICATIONS = "share/applications";
@@ -48,7 +49,9 @@ const licenseDirFor = (settings: DeploySettings): string => `${SHARE_LICENSES}/$
 const licenseDestination = (settings: DeploySettings): string => `${licenseDirFor(settings)}/LICENSE`;
 const noticesDestination = (settings: DeploySettings): string => `${licenseDirFor(settings)}/${NOTICES_FILENAME}`;
 const isIconAsset = (rel: string): boolean => rel === DIST_ICONS_DIR || rel.startsWith(`${DIST_ICONS_DIR}/`);
-const isBuildMetadata = (rel: string): boolean => rel === BUNDLED_PACKAGES_FILENAME;
+
+const isBuildMetadata = (rel: string): boolean =>
+    rel === BUILD_MANIFEST_FILENAME || rel === LEGACY_PACKAGES_MANIFEST_FILENAME;
 
 const nodeLicenseDestination = (settings: DeploySettings): string =>
     `${licenseDirFor(settings)}/${NODE_FILENAME}/${NODE_LICENSE_FILENAME}`;

package/src/deploy/run-deploy.ts

@@ -20,10 +20,11 @@ import { resolveNodeRuntime } from "./node-runtime/index.js";
 import { collectNotices } from "./notices/collect.js";
 import { type StagedMetadata, stageOverlays, stagePayload } from "./payload/stage.js";
 import { DEFAULT_TARGETS, parseTargetList, targetsFor } from "./registry.js";
+import { readBuildManifest } from "./settings/build-manifest.js";
 import { resolveDeploySettings } from "./settings/index.js";
 import { readPackageManifest } from "./settings/package-manifest.js";
 import { missingDeployError } from "./settings/starter.js";
-import { finishArgsFor, hasDisplaySocket } from "./targets/flatpak-manifest.js";
+import { finishArgsFor, hasDisplaySocket, runtimeLabelFor } from "./targets/flatpak-manifest.js";
 import { detectPackageManager } from "./targets/flatpak-sources.js";
 import {
     APPSTREAMCLI,
@@ -50,6 +51,8 @@ const BUILD_MODE = "production";
 const BYTES_PER_MIB = 1024 * 1024;
 const WEBKIT_LIBRARY = "WebKit-6.0";
 const NETWORK_ARG = "--share=network";
+const APPIMAGE_TARGET = "appimage";
+const FLATPAK_TARGET = "flatpak";
 
 const displayPath = (settings: DeploySettings, path: string): string => relative(settings.paths.root, path);
 const megabytes = (size: number): string => (size / BYTES_PER_MIB).toFixed(1);
@@ -66,7 +69,7 @@ const renderMetadata = (settings: DeploySettings): StagedMetadata => ({
 });
 
 const isFlathubSubmission = (settings: DeploySettings, targets: DeployTarget[]): boolean =>
-    settings.deploy.flatpak?.mode === "source" && targets.some((target) => target.name === "flatpak");
+    settings.deploy.flatpak?.mode === "source" && targets.some((target) => target.name === FLATPAK_TARGET);
 
 const validateMetadata = (settings: DeploySettings, metadata: StagedMetadata, areWarningsFatal: boolean): void => {
     const dir = settings.paths.metadata;
@@ -104,7 +107,7 @@ const warnMissingNetwork = (settings: DeploySettings, finishArgs: string[]): voi
 };
 
 const warnFlatpakPermissions = (targets: DeployTarget[], settings: DeploySettings): void => {
-    if (targets.every((target) => target.name !== "flatpak")) {
+    if (targets.every((target) => target.name !== FLATPAK_TARGET)) {
         return;
     }
 
@@ -113,10 +116,68 @@ const warnFlatpakPermissions = (targets: DeployTarget[], settings: DeploySetting
     warnMissingNetwork(settings, finishArgs);
 };
 
+const minimumSummary = (settings: DeploySettings): string =>
+    settings.libraries
+        .filter((library) => settings.minimumLibraryVersions[library] !== undefined)
+        .map((library) => `${library} >= ${String(settings.minimumLibraryVersions[library])}`)
+        .join(", ");
+
+const warnAppImageMinimums = (settings: DeploySettings, summary: string): void => {
+    warn(
+        `An AppImage cannot declare a dependency, so nothing stops ${settings.name} from starting on a host ` +
+        `whose libraries are older than the ones its bindings were generated against (${summary}). ` +
+        "Publish that requirement alongside the AppImage, or build on the oldest host you support.",
+    );
+};
+
+const warnFlatpakMinimums = (settings: DeploySettings, summary: string): void => {
+    warn(
+        `The flatpak bundles binaries built against ${summary}, but runs them on ` +
+        `${runtimeLabelFor(settings)}, whose libraries are whatever that runtime ships. ` +
+        'Set `deploy.flatpak.mode: "source"` to build inside the runtime instead.',
+    );
+};
+
+const warnUnusedMinimums = (settings: DeploySettings): void => {
+    const minimums = settings.deploy.minimumLibraryVersions;
+
+    if (minimums === undefined) {
+        return;
+    }
+
+    const unused = Object.keys(minimums).filter((library) => !settings.libraries.includes(library));
+
+    if (unused.length === 0) {
+        return;
+    }
+
+    warn(
+        `\`deploy.minimumLibraryVersions\` names ${unused.join(", ")}, which this project generates no bindings for, ` +
+        "so those minimums change nothing.",
+    );
+};
+
+const isPrebuiltFlatpak = (targets: DeployTarget[], settings: DeploySettings): boolean =>
+    targets.some((target) => target.name === FLATPAK_TARGET) && settings.deploy.flatpak?.mode !== "source";
+
+const warnLibraryMinimums = (targets: DeployTarget[], settings: DeploySettings): void => {
+    const summary = minimumSummary(settings);
+
+    if (summary.length > 0 && targets.some((target) => target.name === APPIMAGE_TARGET)) {
+        warnAppImageMinimums(settings, summary);
+    }
+
+    if (summary.length > 0 && isPrebuiltFlatpak(targets, settings)) {
+        warnFlatpakMinimums(settings, summary);
+    }
+
+    warnUnusedMinimums(settings);
+};
+
 const sourceModeTools = (targets: DeployTarget[], settings: DeploySettings): DeployTool[] => {
     const isFlatpakSource = settings.deploy.flatpak?.mode === "source";
 
-    if (!isFlatpakSource || targets.every((target) => target.name !== "flatpak")) {
+    if (!isFlatpakSource || targets.every((target) => target.name !== FLATPAK_TARGET)) {
         return [];
     }
 
@@ -124,7 +185,7 @@ const sourceModeTools = (targets: DeployTarget[], settings: DeploySettings): Dep
 };
 
 const isNodeRequired = (targets: DeployTarget[], settings: DeploySettings): boolean =>
-    !(settings.deploy.flatpak?.mode === "source" && targets.every((target) => target.name === "flatpak"));
+    !(settings.deploy.flatpak?.mode === "source" && targets.every((target) => target.name === FLATPAK_TARGET));
 
 const runtimeToolsFor = (targets: DeployTarget[], settings: DeploySettings): DeployTool[] => {
     if (!isNodeRequired(targets, settings)) {
@@ -147,6 +208,7 @@ const preflight = (targets: DeployTarget[], settings: DeploySettings, shouldPrin
     assertTools(report);
     warnMissingOptional(report);
     warnFlatpakPermissions(targets, settings);
+    warnLibraryMinimums(targets, settings);
 };
 
 const resolveTargetNames = (options: DeployOptions, settings: DeploySettings): string[] => {
@@ -180,15 +242,28 @@ const buildPayload = async (
         await buildApp({ entry: options.entry, vite: { root: options.cwd } });
     }
 
-    const node = options.shouldPrintManifests || !isNodeRequired(targets, settings)
-        ? null
-        : await resolveNodeRuntime(settings);
+    const buildManifest = readBuildManifest(settings);
 
-    const stage = stagePayload({ settings, node, metadata });
-    info(`Staged ${String(stage.length)} files into ${displayPath(settings, settings.paths.stage)}`);
-    const notices = collectNotices({ settings, node });
+    const builtSettings: DeploySettings = {
+        ...settings,
+        paths: { ...settings.paths, schemaFiles: buildManifest.schemaFiles },
+    };
 
-    return { settings, node, stage, notices, overlays: stageOverlays(settings, notices) };
+    const node = options.shouldPrintManifests || !isNodeRequired(targets, builtSettings)
+        ? null
+        : await resolveNodeRuntime(builtSettings);
+
+    const stage = stagePayload({ settings: builtSettings, node, metadata });
+    info(`Staged ${String(stage.length)} files into ${displayPath(builtSettings, builtSettings.paths.stage)}`);
+    const notices = collectNotices({ settings: builtSettings, node, packages: buildManifest.packages });
+
+    return {
+        settings: builtSettings,
+        node,
+        stage,
+        notices,
+        overlays: stageOverlays(builtSettings, notices),
+    };
 };
 
 const renderTargetManifests = (

package/src/deploy/settings/build-manifest.ts

@@ -0,0 +1,122 @@
+import { isRecord, sortStrings } from "@gtkx/utils";
+import { existsSync, readFileSync, statSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import type { DeploySettings } from "../types.js";
+import {
+    BUILD_MANIFEST_FILENAME,
+    BUILD_MANIFEST_FORMAT_VERSION,
+    BUILD_MANIFEST_GENERATOR,
+    type BuildManifest,
+    type RecordedPackage,
+} from "../../internal/build-manifest.js";
+import {
+    assertUniqueSchemaBasenames,
+    projectRelativeSchemaPath,
+    SCHEMA_SUFFIX,
+} from "../../settings/schema.js";
+
+type ResolvedBuildManifest = {
+    packages: RecordedPackage[];
+    schemaFiles: string[];
+};
+
+const invalidManifest = (path: string): Error =>
+    new Error(`Cannot deploy: ${path} is not a valid GTKX build manifest. Run \`gtkx build\` again.`);
+
+const recordedSchemas = (value: unknown[], path: string): string[] =>
+    value.map((entry) => {
+        if (typeof entry !== "string") {
+            throw invalidManifest(path);
+        }
+
+        return entry;
+    });
+
+const recordedPackage = (value: unknown, path: string): RecordedPackage => {
+    if (
+        !isRecord(value) ||
+        typeof value.name !== "string" ||
+        typeof value.dir !== "string" ||
+        isAbsolute(value.dir) ||
+        (value.version !== null && typeof value.version !== "string")
+    ) {
+        throw invalidManifest(path);
+    }
+
+    return { name: value.name, version: value.version, dir: value.dir };
+};
+
+const parseBuildManifest = (value: unknown, path: string): BuildManifest => {
+    if (
+        !isRecord(value) ||
+        value.generator !== BUILD_MANIFEST_GENERATOR ||
+        value.formatVersion !== BUILD_MANIFEST_FORMAT_VERSION ||
+        !Array.isArray(value.schemas) ||
+        !Array.isArray(value.packages)
+    ) {
+        throw invalidManifest(path);
+    }
+
+    const packages: unknown[] = value.packages;
+
+    return {
+        generator: BUILD_MANIFEST_GENERATOR,
+        formatVersion: BUILD_MANIFEST_FORMAT_VERSION,
+        schemas: recordedSchemas(value.schemas, path),
+        packages: packages.map((entry) => recordedPackage(entry, path)),
+    };
+};
+
+const isFile = (path: string): boolean => {
+    try {
+        return statSync(path, { throwIfNoEntry: false })?.isFile() === true;
+    } catch {
+        return false;
+    }
+};
+
+const isInsideProject = (root: string, filePath: string): boolean => {
+    const rel = relative(root, filePath);
+
+    return rel.length > 0 && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+};
+
+const resolveRecordedSchema = (root: string, manifestPath: string, entry: string): string => {
+    if (isAbsolute(entry) || !entry.endsWith(SCHEMA_SUFFIX)) {
+        throw new Error(`Cannot deploy: ${manifestPath} records an invalid GSettings schema path.`);
+    }
+
+    const filePath = resolve(root, entry);
+
+    if (!isInsideProject(root, filePath)) {
+        throw new Error(`Cannot deploy: ${manifestPath} records a GSettings schema outside the project.`);
+    }
+
+    if (!isFile(filePath)) {
+        throw new Error(`Cannot deploy: the recorded GSettings schema ${filePath} is missing.`);
+    }
+
+    if (projectRelativeSchemaPath(root, filePath) === null) {
+        throw new Error(`Cannot deploy: ${manifestPath} records a GSettings schema outside the project.`);
+    }
+
+    return filePath;
+};
+
+const readBuildManifest = (settings: DeploySettings): ResolvedBuildManifest => {
+    const manifestPath = join(settings.paths.dist, BUILD_MANIFEST_FILENAME);
+
+    if (!existsSync(manifestPath)) {
+        throw new Error(`Cannot deploy: ${manifestPath} is missing. Run \`gtkx build\` first.`);
+    }
+
+    const parsed: unknown = JSON.parse(readFileSync(manifestPath, "utf8"));
+    const manifest = parseBuildManifest(parsed, manifestPath);
+    const files = manifest.schemas.map((entry) => resolveRecordedSchema(settings.paths.root, manifestPath, entry));
+    const unique = sortStrings(new Set(files));
+    assertUniqueSchemaBasenames(unique);
+
+    return { packages: manifest.packages, schemaFiles: unique };
+};
+
+export { readBuildManifest };

package/src/deploy/settings/index.ts

@@ -22,6 +22,7 @@ import {
     resolveSummary,
     resolveVersionString,
 } from "./identity.js";
+import { resolveLibraries } from "./libraries.js";
 import { readPackageManifest } from "./package-manifest.js";
 import { resolvePaths } from "./paths.js";
 import { resolveScreenshots } from "./screenshots.js";
@@ -113,8 +114,6 @@ const resolveDesktopActions = (deploy: DeployConfig): DeployDesktopAction[] =>
         icon: action.icon ?? null,
     }));
 
-const resolveLibraries = (config: Config): string[] => (Array.isArray(config.libraries) ? config.libraries : []);
-
 const identitySlice = ({ identity, developer, date }: ResolvedCore): IdentitySlice => ({
     applicationId: identity.applicationId,
     binaryName: resolveBinaryName(identity),
@@ -181,8 +180,14 @@ const resolveDeploySettings = (request: SettingsRequest): DeploySettings => {
         extraFiles: resolveExtraFiles(deploy),
         versions: core.versions,
         arch: resolveArch(),
-        paths: resolvePaths({ root: request.root, deploy, outDirOverride: request.outDirOverride }),
-        libraries: resolveLibraries(request.config),
+        paths: resolvePaths({
+            root: request.root,
+            deploy,
+            applicationIcon: request.config.applicationIcon,
+            applicationId: request.config.applicationId,
+            outDirOverride: request.outDirOverride,
+        }),
+        ...resolveLibraries(request.root, request.config),
         deploy,
     };
 };

package/src/deploy/settings/libraries.ts

@@ -0,0 +1,57 @@
+import type { Config } from "@gtkx/config";
+import {
+    resolveLibraries as expandLibraries,
+    type GeneratedLibraries,
+    readGeneratedLibraries,
+    resolveGirPath,
+    resolveStore,
+} from "@gtkx/codegen";
+
+type ResolvedLibraries = {
+    libraries: string[];
+    minimumLibraryVersions: Record<string, string>;
+};
+
+const DEFAULT_LIBRARY = "Gtk-4.0";
+const DEFAULT_LIBRARY_PREFIX = "Gtk-";
+
+const generatedLibraries = (root: string): GeneratedLibraries | null => {
+    try {
+        return readGeneratedLibraries(resolveStore(root).gi.storeDir);
+    } catch {
+        return null;
+    }
+};
+
+const discoveredLibraries = (config: Config): string[] | null => {
+    try {
+        return expandLibraries(config.libraries, resolveGirPath(config.girPath));
+    } catch {
+        return null;
+    }
+};
+
+const configLibraries = (config: Config): string[] => {
+    const libraries = config.libraries;
+
+    if (!Array.isArray(libraries)) {
+        return discoveredLibraries(config) ?? [DEFAULT_LIBRARY];
+    }
+
+    return libraries.some((library) => library.startsWith(DEFAULT_LIBRARY_PREFIX))
+        ? [...libraries]
+        : [DEFAULT_LIBRARY, ...libraries];
+};
+
+const resolveLibraries = (root: string, config: Config): ResolvedLibraries => {
+    const generated = generatedLibraries(root);
+    const libraries = generated?.libraries ?? configLibraries(config);
+    const deploy = config.deploy ?? {};
+
+    return {
+        libraries,
+        minimumLibraryVersions: deploy.minimumLibraryVersions ?? {},
+    };
+};
+
+export { resolveLibraries };

package/src/deploy/settings/paths.ts

@@ -1,23 +1,19 @@
-import { type Stats, statSync } from "node:fs";
+import type { Config } from "@gtkx/config";
+import { statSync } from "node:fs";
 import { isAbsolute, join, relative, resolve } from "node:path";
 import type { DeployConfig, DeployPaths } from "../types.js";
-import { resolveDataDir } from "../../internal/data-dir.js";
-import { findSchemaFiles } from "../../settings/schema.js";
+import { resolveApplicationIcon } from "../../internal/icon-path.js";
 
 type PathsRequest = {
     root: string;
     deploy: DeployConfig;
+    applicationIcon: Config["applicationIcon"];
+    applicationId: Config["applicationId"];
     outDirOverride: string | undefined;
 };
 
-type ResolvedIcons = {
-    iconsDir: string | null;
-    iconFile: string | null;
-};
-
 const DEFAULT_OUT_DIR = "build";
 const DIST_DIR = "dist";
-const ICONS_DIR = "icons";
 const LICENSE_CANDIDATES = ["LICENSE", "LICENSE.md", "LICENSE.txt", "COPYING", "COPYING.md"];
 
 const isInside = (parent: string, candidate: string): boolean => {
@@ -37,17 +33,14 @@ const resolveOutDir = ({ root, deploy, outDirOverride }: PathsRequest): string =
     return outDir;
 };
 
-const getStats = (path: string): Stats | undefined => {
+const existingFile = (path: string): string | null => {
     try {
-        return statSync(path, { throwIfNoEntry: false });
+        return statSync(path, { throwIfNoEntry: false })?.isFile() === true ? path : null;
     } catch {
-        return undefined;
+        return null;
     }
 };
 
-const existingFile = (path: string): string | null => (getStats(path)?.isFile() === true ? path : null);
-const existingDir = (path: string): string | null => (getStats(path)?.isDirectory() === true ? path : null);
-
 const resolveLicenseFile = (root: string, configured: string | undefined): string | null => {
     if (configured !== undefined) {
         const path = resolve(root, configured);
@@ -62,37 +55,9 @@ const resolveLicenseFile = (root: string, configured: string | undefined): strin
     return LICENSE_CANDIDATES.map((name) => existingFile(join(root, name))).find((path) => path !== null) ?? null;
 };
 
-const configuredIcons = (root: string, configured: string): ResolvedIcons => {
-    const path = resolve(root, configured);
-
-    if (!isInside(root, path)) {
-        throw new Error(`Cannot use "${configured}" as the icon path: it is outside ${root}`);
-    }
-
-    if (existingDir(path) !== null) {
-        return { iconsDir: path, iconFile: null };
-    }
-
-    if (existingFile(path) === null) {
-        throw new Error(`Cannot read the icon path "${configured}": no such file or directory under ${root}`);
-    }
-
-    return { iconsDir: null, iconFile: path };
-};
-
-const defaultIcons = (root: string, dataDir: string | null): ResolvedIcons => ({
-    iconsDir: dataDir === null ? null : existingDir(join(root, dataDir, ICONS_DIR)),
-    iconFile: null,
-});
-
-const resolveIcons = (root: string, dataDir: string | null, configured: string | undefined): ResolvedIcons =>
-    configured === undefined ? defaultIcons(root, dataDir) : configuredIcons(root, configured);
-
 const resolvePaths = (request: PathsRequest): DeployPaths => {
     const { root, deploy } = request;
     const outDir = resolveOutDir(request);
-    const dataDir = resolveDataDir(root);
-    const { iconsDir, iconFile } = resolveIcons(root, dataDir, deploy.icons);
 
     return {
         root,
@@ -104,11 +69,9 @@ const resolvePaths = (request: PathsRequest): DeployPaths => {
         overlay: join(outDir, "overlay"),
         targets: join(outDir, "targets"),
         output: join(outDir, "out"),
-        dataDir,
-        iconsDir,
-        iconFile,
+        applicationIcon: resolveApplicationIcon(root, request.applicationId, request.applicationIcon),
         licenseFile: resolveLicenseFile(root, deploy.licenseFile),
-        schemaFiles: dataDir === null ? [] : findSchemaFiles(join(root, dataDir)),
+        schemaFiles: [],
     };
 };