@gtkx/cli 1.3.0 → 1.5.0

package/dist/vite-plugins/resources.js

@@ -1,20 +1,167 @@
-import { createConfigLoader } from "@gtkx/config/internal";
-import { error, info, sortStrings } from "@gtkx/utils";
-import { copyFileSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { createConfigLoader, resourceBasePath } from "@gtkx/config/internal";
+import { error, info, isRecord, sortStrings } from "@gtkx/utils";
+import { copyFileSync, existsSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, isAbsolute, join, posix, relative, sep } from "node:path";
+import { parseSync } from "vite";
 import { resolveDataDir } from "../internal/data-dir.js";
 import { listFilesRecursive } from "../internal/list-files.js";
-import { loadModuleExclusively } from "../internal/module-loads.js";
 import { runCliTool } from "../internal/run-cli-tool.js";
+import { parseRuntimeImportsIn, sourceLanguage } from "../internal/source-imports.js";
 import { createRetainedStagingDir, withStagingDir } from "../internal/staging-dir.js";
 import { ASSET_RE } from "./asset-extensions.js";
-import { DATA_PREFIX, isDataAsset } from "./asset-specifier.js";
+import { DATA_PREFIX, isBareRelativeAsset, isDataAsset, parseIconSpecifier, parseResourceSpecifier, } from "./asset-specifier.js";
 import { renderInitModule } from "./resource-init-module.js";
-import { BUNDLE_FILENAME, escapeXml, fromVirtualId, isVirtual, REFRESH_EXPORT, REL_SEPARATOR, RESOURCE_PATH_EXPORT, toVirtualId, VIRTUAL_INIT, } from "./resource-shared.js";
+import { BUNDLE_FILENAME, escapeXml, fromVirtualId, ICON_NAME_SEPARATOR, isVirtual, REFRESH_EXPORT, REGISTER_REFRESH_EXPORT, REL_SEPARATOR, RESOURCE_PATH_EXPORT, toVirtualId, VIRTUAL_INIT, } from "./resource-shared.js";
+import { stripQuery } from "./strip-query.js";
 const RESOURCE_COMPILER = "glib-compile-resources";
 const MANIFEST_PREFIX = "/";
 const DEV_STAGING_PREFIX = "resources-dev";
-const deriveResourcePrefix = (applicationId) => `/${applicationId.replaceAll(".", "/")}`;
+const MANIFEST_FILENAME = "package.json";
+const BUNDLED_QUERY_MENTION_RE = /[?&](?:icon|resource)(?:[=&]|$)/;
+const ICON_EXTENSIONS = new Set([".png", ".svg", ".xpm"]);
+const ICON_CONTEXTS = new Set([
+    "actions",
+    "animations",
+    "apps",
+    "categories",
+    "devices",
+    "emblems",
+    "emotes",
+    "filesystems",
+    "intl",
+    "mimetypes",
+    "places",
+    "status",
+]);
+const STOCK_ICON_CONTEXTS = new Set([
+    "chart",
+    "code",
+    "data",
+    "form",
+    "image",
+    "io",
+    "media",
+    "navigation",
+    "net",
+    "object",
+    "table",
+    "text",
+]);
+const ICON_SIZE_RE = /^([1-9]\d*)x\1(?:@[1-9]\d*)?$/;
+const RESERVED_ICON_NAMES = new Set(["", ".", ".."]);
+const toForwardSlashes = (value) => value.replaceAll(/[/\\]/g, "/");
+const isWithin = (root, path) => {
+    const rel = relative(root, path);
+    return rel.length > 0 && !isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${sep}`);
+};
+const isDependencyFile = (root, path) => isWithin(root, path) && relative(root, path).split(sep).includes("node_modules");
+const packageIdentityIn = (dir) => {
+    try {
+        const manifest = JSON.parse(readFileSync(join(dir, MANIFEST_FILENAME), "utf8"));
+        return isRecord(manifest) && typeof manifest.name === "string" ? manifest.name : null;
+    }
+    catch {
+        return null;
+    }
+};
+const packageIn = (dir) => {
+    const name = packageIdentityIn(dir);
+    if (name !== null) {
+        return { dir, name };
+    }
+    const parent = dirname(dir);
+    return parent === dir ? null : packageIn(parent);
+};
+const packageForFile = (file) => packageIn(dirname(file));
+const validateResourcePath = (resourcePath) => {
+    if (resourcePath === "/" ||
+        !resourcePath.startsWith("/") ||
+        resourcePath.endsWith("/") ||
+        resourcePath.includes("\0") ||
+        posix.normalize(resourcePath) !== resourcePath) {
+        throw new Error(`${JSON.stringify(resourcePath)} is not a valid GResource path; use an absolute normalized path`);
+    }
+    return resourcePath;
+};
+const derivedResourcePath = (state, sourcePath) => {
+    if (isWithin(state.root, sourcePath) && !isDependencyFile(state.root, sourcePath)) {
+        return validateResourcePath(`${state.prefix}/${toForwardSlashes(relative(state.root, sourcePath))}`);
+    }
+    const owner = packageForFile(sourcePath);
+    if (owner === null || !isWithin(owner.dir, sourcePath)) {
+        throw new Error(`${sourcePath} is outside the application and does not belong to a named package`);
+    }
+    const packagePath = toForwardSlashes(relative(owner.dir, sourcePath));
+    return validateResourcePath(`${state.prefix}/${owner.name}/${packagePath}`);
+};
+const iconExtension = (sourcePath) => {
+    const extension = extname(sourcePath).toLowerCase();
+    if (!ICON_EXTENSIONS.has(extension)) {
+        throw new Error(`${sourcePath} is not a supported themed icon; use an SVG, PNG, or XPM file`);
+    }
+    return extension;
+};
+const hasIconNamePathSeparator = (value) => value.includes("\0") || value.includes("/") || value.includes("\\");
+const validateIconName = (value) => {
+    if (RESERVED_ICON_NAMES.has(value) ||
+        hasIconNamePathSeparator(value) ||
+        ICON_EXTENSIONS.has(extname(value).toLowerCase())) {
+        throw new Error(`${JSON.stringify(value)} is not a valid icon name; use an extensionless filename without slashes`);
+    }
+    return value;
+};
+const isIconContext = (parts) => {
+    const [first, second] = parts;
+    if (parts.length === 1) {
+        return first !== undefined && ICON_CONTEXTS.has(first);
+    }
+    return parts.length === 2 && first === "stock" && second !== undefined && STOCK_ICON_CONTEXTS.has(second);
+};
+const isIconLayout = (parts) => {
+    const [size, ...context] = parts;
+    if (size === "symbolic") {
+        return context.length === 1 && context[0] === "apps";
+    }
+    return size !== undefined && (size === "scalable" || ICON_SIZE_RE.test(size)) && isIconContext(context);
+};
+const iconLayoutInParts = (parts, beforeIndex) => {
+    const index = parts.lastIndexOf("icons", beforeIndex);
+    if (index === -1) {
+        return null;
+    }
+    const treePath = parts.slice(index + 1, -1);
+    const layout = treePath[0] === "hicolor" ? treePath.slice(1) : treePath;
+    return isIconLayout(layout) ? layout.join("/") : iconLayoutInParts(parts, index - 1);
+};
+const iconLayoutFromTree = (sourcePath) => {
+    const parts = toForwardSlashes(sourcePath).split("/");
+    return iconLayoutInParts(parts, parts.length - 2);
+};
+const derivedIconEntry = (state, sourcePath, requestedName) => {
+    const extension = iconExtension(sourcePath);
+    const sourceName = basename(sourcePath, extname(sourcePath));
+    const iconName = validateIconName(requestedName ?? sourceName);
+    const layout = iconLayoutFromTree(sourcePath);
+    const iconIdentity = layout === null
+        ? `${state.prefix}/icons/${iconName}`
+        : `${state.prefix}/icons/${layout}/${iconName}`;
+    const resourcePath = validateResourcePath(`${iconIdentity}${extension}`);
+    return { iconIdentity, iconName, resourcePath };
+};
+const hasSideEffectIconImport = (code, id) => {
+    const lang = sourceLanguage(stripQuery(id));
+    if (lang === undefined || !code.includes("?icon")) {
+        return false;
+    }
+    const parsed = parseSync(id, code, { lang });
+    if (parsed.errors.length > 0) {
+        return false;
+    }
+    return parsed.module.staticImports.some((statement) => statement.entries.length === 0 && parseIconSpecifier(statement.moduleRequest.value) !== null);
+};
+const retainSideEffectIconImport = (state, code, id) => state.isV2 && hasSideEffectIconImport(code, id)
+    ? { code, moduleSideEffects: true }
+    : null;
 const compileBundle = (state, outputPath) => withStagingDir("resources", (dir) => {
     const manifest = stageBundle(dir, state.entries);
     return runCompiler(dir, manifest, outputPath);
@@ -56,29 +203,30 @@ const releaseStagingDir = (state) => {
     state.devBundlePath = "";
     state.compiledSignature = "";
 };
-const entriesSignature = (state) => sortStrings(state.entries.keys()).join("\0");
+const entriesSignature = (state) => sortStrings([...state.entries].map(([resourcePath, entry]) => `${resourcePath}\0${entry.sourcePath}`)).join("\0");
 const compileDevBundle = (state) => {
     ensureStagingDir(state);
     if (state.entries.size === 0) {
+        rmSync(state.devBundlePath, { force: true });
+        state.compiledSignature = "";
         return;
     }
     compileBundle(state, state.devBundlePath);
     state.compiledSignature = entriesSignature(state);
 };
 const isRefreshHook = (value) => typeof value === "function";
-const reregisterDevBundle = async (state) => {
+const refreshRegisteredDevBundle = (state) => {
     const server = state.server;
     if (!server) {
         return;
     }
-    const mod = await loadModuleExclusively(server, VIRTUAL_INIT);
-    const refresh = mod[REFRESH_EXPORT];
+    const refresh = server.moduleGraph.getModuleById(VIRTUAL_INIT)?.ssrModule?.[REFRESH_EXPORT];
     if (isRefreshHook(refresh)) {
         refresh();
     }
 };
 const scanDataAssets = (dataDir) => listFilesRecursive(dataDir, (name) => ASSET_RE.test(name));
-const primeDevBundle = (state) => {
+const primeLegacyDevBundle = (state) => {
     if (state.dataDir === null) {
         return;
     }
@@ -92,102 +240,650 @@ const registerDevAsset = (state) => {
         compileDevBundle(state);
     }
 };
-const registerEntry = (state, absPath, rel) => {
-    const existing = state.entries.get(absPath);
-    if (existing) {
+const importerKey = (importer) => stripQuery(importer);
+const trackBundledSpecifier = (state, importer, source) => {
+    if (importer === undefined) {
+        return;
+    }
+    const key = importerKey(importer);
+    const specifiers = state.bundledSpecifiers.get(key) ?? new Set();
+    specifiers.add(source);
+    state.bundledSpecifiers.set(key, specifiers);
+};
+const createResourceEntry = (sourcePath, resourcePath) => ({
+    sourcePath,
+    stagedRelPath: resourcePath.replace(/^\/+/, ""),
+    resourcePath,
+});
+const activateEntry = (state, entry) => {
+    const existing = state.entries.get(entry.resourcePath);
+    if (existing !== undefined) {
+        if (existing.sourcePath !== entry.sourcePath) {
+            throw new Error(`${existing.sourcePath} and ${entry.sourcePath} both resolve to the GResource path ` +
+                entry.resourcePath);
+        }
         return existing;
     }
-    const resourcePath = `${state.prefix}/${rel}`;
-    const entry = {
-        sourcePath: absPath,
-        stagedRelPath: resourcePath.replace(/^\/+/, ""),
-        resourcePath,
-    };
-    state.entries.set(absPath, entry);
-    state.sourcePaths.add(absPath);
+    state.entries.set(entry.resourcePath, entry);
+    state.sourcePaths.add(entry.sourcePath);
+    return entry;
+};
+const isDeclarativeImporter = (state, importer) => !state.isBuild && state.isV2 && importer !== undefined;
+const setSourceAvailability = (state, file, isAvailable) => {
+    if (isAvailable) {
+        state.missingSourcePaths.delete(file);
+        return;
+    }
+    state.missingSourcePaths.add(file);
+};
+const isDeclaredSourceAvailable = (state, sourcePath) => {
+    const isAvailable = existsSync(sourcePath);
+    setSourceAvailability(state, sourcePath, isAvailable);
+    return isAvailable;
+};
+const declareEntry = (state, importer, entry) => {
+    const key = importerKey(importer);
+    const declarations = state.declaredEntries.get(key) ?? new Map();
+    const existing = declarations.get(entry.resourcePath);
+    if (existing !== undefined && existing.sourcePath !== entry.sourcePath) {
+        throw new Error(`${existing.sourcePath} and ${entry.sourcePath} both resolve to the GResource path ` +
+            entry.resourcePath);
+    }
+    const declared = existing ?? entry;
+    declarations.set(entry.resourcePath, declared);
+    state.declaredEntries.set(key, declarations);
+    state.server?.watcher.add(dirname(declared.sourcePath));
+    return declared;
+};
+const declareIcon = (state, importer, iconIdentity, entry) => {
+    const key = importerKey(importer);
+    const declarations = state.declaredIcons.get(key) ?? new Map();
+    const existing = declarations.get(iconIdentity);
+    if (existing !== undefined && existing.sourcePath !== entry.sourcePath) {
+        throw new Error(`${existing.sourcePath} and ${entry.sourcePath} both claim the themed icon ${iconIdentity}`);
+    }
+    declarations.set(iconIdentity, existing ?? entry);
+    state.declaredIcons.set(key, declarations);
+};
+const assertIconIdentityAvailable = (state, iconIdentity, sourcePath) => {
+    const existing = state.iconOwners.get(iconIdentity);
+    if (existing !== undefined && existing.sourcePath !== sourcePath) {
+        throw new Error(`${existing.sourcePath} and ${sourcePath} both claim the themed icon ${iconIdentity}`);
+    }
+};
+const declareResolvedIcon = (state, importer, iconIdentity, entry) => {
+    if (isDeclarativeImporter(state, importer)) {
+        declareIcon(state, importer, iconIdentity, entry);
+    }
+};
+const registerEntry = (state, absPath, rel, importer) => {
+    const resourcePath = validateResourcePath(rel.startsWith("/") ? rel : `${state.prefix}/${rel}`);
+    let entry = createResourceEntry(absPath, resourcePath);
+    if (isDeclarativeImporter(state, importer)) {
+        entry = declareEntry(state, importer, entry);
+        if (!isImporterActive(state, importer) || !isDeclaredSourceAvailable(state, absPath)) {
+            return entry;
+        }
+    }
+    return activateEntry(state, entry);
+};
+const registerIconEntry = (state, sourcePath, derived, importer) => {
+    const shouldActivate = !isDeclarativeImporter(state, importer) ||
+        (isImporterActive(state, importer) && isDeclaredSourceAvailable(state, sourcePath));
+    if (shouldActivate) {
+        assertIconIdentityAvailable(state, derived.iconIdentity, sourcePath);
+    }
+    const entry = registerEntry(state, sourcePath, derived.resourcePath, importer);
+    declareResolvedIcon(state, importer, derived.iconIdentity, entry);
+    if (shouldActivate) {
+        state.iconOwners.set(derived.iconIdentity, entry);
+    }
     return entry;
 };
 const isTrackedSource = (state, file) => state.sourcePaths.has(file);
-const resolvedAssetId = (resolved, source) => {
+const hasSourceEntry = (entries, file) => {
+    for (const entry of entries.values()) {
+        if (entry.sourcePath === file) {
+            return true;
+        }
+    }
+    return false;
+};
+const hasDeclaredSource = (declarations, file) => {
+    for (const entries of declarations.values()) {
+        if (hasSourceEntry(entries, file)) {
+            return true;
+        }
+    }
+    return false;
+};
+const isDeclaredSource = (state, file) => hasDeclaredSource(state.declaredEntries, file) || hasDeclaredSource(state.declaredIcons, file);
+const virtualAssetId = (entry) => toVirtualId(entry.sourcePath) + REL_SEPARATOR + entry.resourcePath;
+const virtualIconId = ({ entry, iconName }) => virtualAssetId(entry) + ICON_NAME_SEPARATOR + iconName;
+const resolveAssetSource = async (ctx, request) => {
+    const resolved = await ctx.resolve(request.assetSource, request.importer, {
+        ...request.options,
+        skipSelf: true,
+    });
     if (!resolved || resolved.external) {
         return undefined;
     }
-    return toVirtualId(resolved.id) + REL_SEPARATOR + source.slice(DATA_PREFIX.length);
+    const sourcePath = stripQuery(resolved.id);
+    if (!isAbsolute(sourcePath)) {
+        throw new Error(`${JSON.stringify(request.assetSource)} did not resolve to a file-backed asset`);
+    }
+    return sourcePath;
+};
+const resolveAssetEntry = async (ctx, state, request) => {
+    const sourcePath = await resolveAssetSource(ctx, request);
+    if (sourcePath === undefined) {
+        return undefined;
+    }
+    return registerEntry(state, sourcePath, request.resourcePath === null
+        ? derivedResourcePath(state, sourcePath)
+        : validateResourcePath(request.resourcePath), request.importer);
+};
+const resolveIconEntry = async (ctx, state, request) => {
+    const sourcePath = await resolveAssetSource(ctx, request);
+    if (sourcePath === undefined) {
+        return undefined;
+    }
+    const derived = derivedIconEntry(state, sourcePath, request.iconName);
+    return {
+        entry: registerIconEntry(state, sourcePath, derived, request.importer),
+        iconName: derived.iconName,
+    };
+};
+const resolveLegacyAssetEntry = async (ctx, state, request) => {
+    const resolved = await ctx.resolve(request.source, request.importer, { ...request.options, skipSelf: true });
+    if (!resolved || resolved.external) {
+        return undefined;
+    }
+    const sourcePath = stripQuery(resolved.id);
+    if (!isAbsolute(sourcePath)) {
+        return undefined;
+    }
+    return registerEntry(state, sourcePath, request.source.slice(DATA_PREFIX.length));
 };
 const loadInitModule = (state) => {
-    if (!state.isBuild) {
-        ensureStagingDir(state);
+    if (state.isBuild) {
+        if (state.bundleReferenceId === null) {
+            throw new Error("Cannot render the GResource loader before its bundle has been emitted");
+        }
+        return renderInitModule({ isBuild: true, bundleReferenceId: state.bundleReferenceId });
     }
-    return renderInitModule({ isBuild: state.isBuild, devBundlePath: state.devBundlePath });
+    ensureStagingDir(state);
+    return renderInitModule({ isBuild: false, devBundlePath: state.devBundlePath });
 };
-const loadAssetModule = (state, virtualId) => {
+const virtualAssetMetadata = (virtualId) => {
     const rest = fromVirtualId(virtualId);
     const separatorIndex = rest.indexOf(REL_SEPARATOR);
-    const absPath = rest.slice(0, separatorIndex);
-    const rel = rest.slice(separatorIndex + REL_SEPARATOR.length);
-    const entry = registerEntry(state, absPath, rel);
-    const uri = `resource://${entry.resourcePath}`;
-    if (!state.isBuild) {
+    const relAndMetadata = rest.slice(separatorIndex + REL_SEPARATOR.length);
+    const iconSeparatorIndex = relAndMetadata.indexOf(ICON_NAME_SEPARATOR);
+    return {
+        absPath: rest.slice(0, separatorIndex),
+        iconName: iconSeparatorIndex === -1
+            ? null
+            : relAndMetadata.slice(iconSeparatorIndex + ICON_NAME_SEPARATOR.length),
+        rel: iconSeparatorIndex === -1 ? relAndMetadata : relAndMetadata.slice(0, iconSeparatorIndex),
+    };
+};
+const resourcePathExport = (entry, iconName) => iconName === null ? [`export const ${RESOURCE_PATH_EXPORT} = ${JSON.stringify(entry.resourcePath)};`] : [];
+const assetModuleImports = (iconName) => {
+    const initBindings = iconName === null
+        ? "ensureRegistered"
+        : `ensureRegistered, ${REGISTER_REFRESH_EXPORT}`;
+    return [
+        `import { ${initBindings} } from ${JSON.stringify(VIRTUAL_INIT)};`,
+        ...(iconName === null
+            ? []
+            : [
+                "import { Display } from \"@gtkx/gi/gdk\";",
+                "import { IconTheme } from \"@gtkx/gi/gtk\";",
+            ]),
+    ];
+};
+const iconThemeRegistration = (state, iconName) => {
+    if (iconName === null) {
+        return [];
+    }
+    const resourceIconPath = `${state.prefix}/icons`;
+    return [
+        `const resourceIconPath = ${JSON.stringify(resourceIconPath)};`,
+        "function refreshIconTheme() {",
+        "    const display = Display.getDefault();",
+        "    if (!display) return;",
+        "    const theme = IconTheme.getForDisplay(display);",
+        "    const paths = theme.getResourcePath() ?? [];",
+        "    theme.setResourcePath(paths.includes(resourceIconPath) ? [...paths] : [...paths, resourceIconPath]);",
+        "}",
+        `${REGISTER_REFRESH_EXPORT}(resourceIconPath, refreshIconTheme);`,
+    ];
+};
+const loadedResourceEntry = (state, sourcePath, resourcePath) => {
+    const registered = state.entries.get(resourcePath);
+    if (registered === undefined) {
+        return { entry: createResourceEntry(sourcePath, resourcePath), isRegistered: false };
+    }
+    if (registered.sourcePath !== sourcePath) {
+        throw new Error(`${registered.sourcePath} and ${sourcePath} both resolve to the GResource path ${resourcePath}`);
+    }
+    return { entry: registered, isRegistered: true };
+};
+const compileLoadedDevAsset = (state, isRegistered) => {
+    if (isRegistered && !state.isBuild) {
         registerDevAsset(state);
     }
+};
+const loadAssetModule = (state, virtualId) => {
+    const { absPath, iconName, rel } = virtualAssetMetadata(virtualId);
+    const resourcePath = validateResourcePath(rel);
+    const { entry, isRegistered } = loadedResourceEntry(state, absPath, resourcePath);
+    const uri = `resource://${entry.resourcePath}`;
+    const defaultValue = iconName ?? (state.isV2 ? entry.resourcePath : uri);
+    compileLoadedDevAsset(state, isRegistered);
     return [
-        `import { ensureRegistered } from ${JSON.stringify(VIRTUAL_INIT)};`,
+        ...assetModuleImports(iconName),
         "ensureRegistered();",
-        `export default ${JSON.stringify(uri)};`,
-        `export const ${RESOURCE_PATH_EXPORT} = ${JSON.stringify(entry.resourcePath)};`,
+        ...iconThemeRegistration(state, iconName),
+        `export default ${JSON.stringify(defaultValue)};`,
+        ...resourcePathExport(entry, iconName),
     ].join("\n");
 };
-const emitBuildBundle = (ctx, state) => {
-    if (!state.isBuild || state.entries.size === 0) {
+const finalizeBuildBundle = (ctx, bundle, state) => {
+    if (!state.isBuild || state.bundleReferenceId === null) {
+        return;
+    }
+    const fileName = ctx.getFileName(state.bundleReferenceId);
+    const output = bundle[fileName];
+    if (output?.type !== "asset") {
+        throw new Error(`Cannot find the emitted ${BUNDLE_FILENAME} asset`);
+    }
+    if (state.entries.size === 0) {
+        Reflect.deleteProperty(bundle, fileName);
         return;
     }
     const compiled = withStagingDir("resources-out", (outDir) => compileBundle(state, join(outDir, BUNDLE_FILENAME)));
-    ctx.emitFile({ type: "asset", fileName: BUNDLE_FILENAME, source: compiled });
+    output.source = compiled;
     info(`Compiled ${String(state.entries.size)} resource(s) into ${BUNDLE_FILENAME}`);
 };
-const refreshDevRegistration = async (state) => {
+const refreshDevRegistration = (state) => {
     compileDevBundle(state);
     try {
-        await reregisterDevBundle(state);
+        refreshRegisteredDevBundle(state);
     }
     catch (error_) {
         error("Failed to refresh GResource bundle:", error_);
     }
 };
+const isSameSpecifiers = (left, right) => left === undefined
+    ? right.size === 0
+    : left.size === right.size && [...right].every((source) => left.has(source));
+const bundledSpecifiersIn = (imports) => new Set(imports
+    .filter((entry) => parseResourceSpecifier(entry.source) !== null || parseIconSpecifier(entry.source) !== null)
+    .map((entry) => entry.source));
+const isSourceModule = (file) => sourceLanguage(file) !== undefined;
+const isBundledSource = (source) => parseResourceSpecifier(source) !== null || parseIconSpecifier(source) !== null;
+const validateUnbundledV2Source = (source) => {
+    if (isLegacyDataSpecifier(source)) {
+        throw new Error(`${JSON.stringify(source)} uses the legacy #data asset form`);
+    }
+    rejectInvalidV2Specifier(source);
+};
+const resolvedModuleDependency = async (ctx, source, importer) => {
+    if (isBundledSource(source)) {
+        return null;
+    }
+    validateUnbundledV2Source(source);
+    const resolved = await ctx.resolve(source, importer, { skipSelf: true });
+    if (resolved === null) {
+        throw new Error(`${JSON.stringify(source)} could not be resolved from ${importer}`);
+    }
+    return resolved.external ? null : importerKey(resolved.id);
+};
+const resolvedModuleDependencies = async (ctx, imports, importer) => {
+    const dependencies = new Set();
+    for (const entry of imports) {
+        const dependency = await resolvedModuleDependency(ctx, entry.source, importer);
+        if (dependency !== null) {
+            dependencies.add(dependency);
+        }
+    }
+    return dependencies;
+};
+const importerReconciliation = async (ctx, state, id) => {
+    const file = stripQuery(id);
+    const key = importerKey(file);
+    if (!state.isV2 || state.isBuild || !isSourceModule(file)) {
+        return null;
+    }
+    const imports = parseRuntimeImportsIn(file);
+    if (imports === null) {
+        return null;
+    }
+    return {
+        currentBundled: bundledSpecifiersIn(imports),
+        currentDependencies: await resolvedModuleDependencies(ctx, imports, file),
+        file,
+        imports,
+        key,
+        previousBundled: state.bundledSpecifiers.get(key),
+        previousDependencies: state.moduleDependencies.get(key),
+    };
+};
+const moduleNodeKey = (module) => importerKey(module.id ?? module.file ?? module.url);
+const moduleNodeFor = (state, id) => {
+    const server = state.server;
+    if (server === null) {
+        return undefined;
+    }
+    return server.moduleGraph.getModuleById(id) ?? server.moduleGraph.getModuleById(importerKey(id));
+};
+const restoreDependencies = (pruned, current) => {
+    for (const dependency of current) {
+        pruned.delete(dependency);
+    }
+};
+const pruneRemovedDependencies = (pruned, previous, current) => {
+    if (previous === undefined) {
+        return;
+    }
+    for (const dependency of previous) {
+        if (!current.has(dependency)) {
+            pruned.add(dependency);
+        }
+    }
+};
+const storePrunedDependencies = (state, key, pruned) => {
+    if (pruned.size === 0) {
+        state.prunedDependencies.delete(key);
+        return;
+    }
+    state.prunedDependencies.set(key, pruned);
+};
+const updatePrunedDependencies = (state, key, previous, current) => {
+    const pruned = state.prunedDependencies.get(key) ?? new Set();
+    restoreDependencies(pruned, current);
+    pruneRemovedDependencies(pruned, previous, current);
+    storePrunedDependencies(state, key, pruned);
+};
+const isPrunedDependency = (state, importer, imported) => state.prunedDependencies.get(moduleNodeKey(importer))?.has(moduleNodeKey(imported)) === true;
+const fallbackRootModules = (state) => {
+    const roots = [];
+    for (const key of state.moduleDependencies.keys()) {
+        if (moduleNodeFor(state, key)?.importers.size === 0) {
+            roots.push(key);
+        }
+    }
+    return roots;
+};
+const enqueueCurrentDependencies = (state, key, pending) => {
+    const dependencies = state.moduleDependencies.get(key) ?? [];
+    for (const dependency of dependencies) {
+        pending.push(dependency);
+    }
+};
+const enqueueGraphDependencies = (state, key, pending) => {
+    const module = moduleNodeFor(state, key);
+    if (module === undefined) {
+        return;
+    }
+    for (const imported of module.importedModules) {
+        if (!isPrunedDependency(state, module, imported)) {
+            pending.push(moduleNodeKey(imported));
+        }
+    }
+};
+const visitActiveImporter = (state, active, pending, key) => {
+    if (active.has(key)) {
+        return;
+    }
+    active.add(key);
+    enqueueCurrentDependencies(state, key, pending);
+    enqueueGraphDependencies(state, key, pending);
+};
+const activeImporterKeys = (state) => {
+    const active = new Set();
+    const roots = state.entryModule === null ? fallbackRootModules(state) : [state.entryModule];
+    const pending = [...roots];
+    while (pending.length > 0) {
+        const key = pending.pop();
+        if (key === undefined || active.has(key)) {
+            continue;
+        }
+        visitActiveImporter(state, active, pending, key);
+    }
+    return active;
+};
+const isImporterActive = (state, importer) => activeImporterKeys(state).has(importerKey(importer));
+const activateDeclaredIcon = (state, iconIdentity, entry) => {
+    const existing = state.iconOwners.get(iconIdentity);
+    if (existing !== undefined && existing.sourcePath !== entry.sourcePath) {
+        throw new Error(`${existing.sourcePath} and ${entry.sourcePath} both claim the themed icon ${iconIdentity}`);
+    }
+    state.iconOwners.set(iconIdentity, activateEntry(state, entry));
+};
+const activateDeclaredEntries = (state, importer) => {
+    const entries = state.declaredEntries.get(importer)?.values() ?? [];
+    for (const entry of entries) {
+        if (isDeclaredSourceAvailable(state, entry.sourcePath)) {
+            activateEntry(state, entry);
+        }
+    }
+};
+const activateDeclaredIcons = (state, importer) => {
+    const icons = state.declaredIcons.get(importer) ?? [];
+    for (const [iconIdentity, entry] of icons) {
+        if (isDeclaredSourceAvailable(state, entry.sourcePath)) {
+            activateDeclaredIcon(state, iconIdentity, entry);
+        }
+    }
+};
+const activateDeclaredClaims = (state, active) => {
+    for (const importer of sortStrings(active)) {
+        activateDeclaredEntries(state, importer);
+        activateDeclaredIcons(state, importer);
+    }
+};
+const rebuildActiveClaims = (state) => {
+    const previous = {
+        entries: state.entries,
+        iconOwners: state.iconOwners,
+        sourcePaths: state.sourcePaths,
+    };
+    state.entries = new Map();
+    state.iconOwners = new Map();
+    state.sourcePaths = new Set();
+    try {
+        activateDeclaredClaims(state, activeImporterKeys(state));
+    }
+    catch (error_) {
+        state.entries = previous.entries;
+        state.iconOwners = previous.iconOwners;
+        state.sourcePaths = previous.sourcePaths;
+        throw error_;
+    }
+};
+const forgetImporterDeclarations = (state, importer) => {
+    state.declaredEntries.delete(importer);
+    state.declaredIcons.delete(importer);
+};
+const cloneStringSetMap = (source) => {
+    const clone = new Map();
+    for (const [key, values] of source) {
+        clone.set(key, new Set(values));
+    }
+    return clone;
+};
+const cloneDeclarationMap = (source) => {
+    const clone = new Map();
+    for (const [key, declarations] of source) {
+        clone.set(key, new Map(declarations));
+    }
+    return clone;
+};
+const reconciliationCandidate = (state) => ({
+    ...state,
+    bundledSpecifiers: cloneStringSetMap(state.bundledSpecifiers),
+    moduleDependencies: cloneStringSetMap(state.moduleDependencies),
+    prunedDependencies: cloneStringSetMap(state.prunedDependencies),
+    declaredEntries: cloneDeclarationMap(state.declaredEntries),
+    declaredIcons: cloneDeclarationMap(state.declaredIcons),
+    missingSourcePaths: new Set(state.missingSourcePaths),
+});
+const storeBundledSpecifiers = (state, importer, specifiers) => {
+    if (specifiers.size === 0) {
+        state.bundledSpecifiers.delete(importer);
+        return;
+    }
+    state.bundledSpecifiers.set(importer, specifiers);
+};
+const applyImporterGraph = (state, reconciliation) => {
+    updatePrunedDependencies(state, reconciliation.key, reconciliation.previousDependencies, reconciliation.currentDependencies);
+    state.moduleDependencies.set(reconciliation.key, reconciliation.currentDependencies);
+    storeBundledSpecifiers(state, reconciliation.key, reconciliation.currentBundled);
+};
+const declareReconciledResource = async (ctx, state, importer, source) => {
+    const resourceSpecifier = parseResourceSpecifier(source);
+    if (resourceSpecifier === null) {
+        return;
+    }
+    const entry = await resolveAssetEntry(ctx, state, {
+        assetSource: resourceSpecifier.assetSource,
+        importer,
+        resourcePath: resourceSpecifier.resourcePath,
+        options: undefined,
+    });
+    if (entry === undefined || state.missingSourcePaths.has(entry.sourcePath)) {
+        throw new Error(`${JSON.stringify(source)} did not resolve to a bundled resource`);
+    }
+};
+const declareReconciledIcon = async (ctx, state, importer, source) => {
+    const iconSpecifier = parseIconSpecifier(source);
+    if (iconSpecifier === null) {
+        return;
+    }
+    const entry = await resolveIconEntry(ctx, state, {
+        assetSource: iconSpecifier.assetSource,
+        iconName: iconSpecifier.iconName,
+        importer,
+        options: undefined,
+    });
+    if (entry === undefined || state.missingSourcePaths.has(entry.entry.sourcePath)) {
+        throw new Error(`${JSON.stringify(source)} did not resolve to a bundled icon`);
+    }
+};
+const declareReconciledSource = async (ctx, state, importer, source) => {
+    await declareReconciledResource(ctx, state, importer, source);
+    await declareReconciledIcon(ctx, state, importer, source);
+};
+const declareReconciledImports = async (ctx, state, reconciliation) => {
+    for (const entry of reconciliation.imports) {
+        if (isBundledSource(entry.source)) {
+            await declareReconciledSource(ctx, state, reconciliation.file, entry.source);
+        }
+    }
+};
+const prepareReconciliation = async (ctx, state, reconciliation) => {
+    const candidate = reconciliationCandidate(state);
+    const isBundledChanged = !isSameSpecifiers(reconciliation.previousBundled, reconciliation.currentBundled);
+    if (isBundledChanged) {
+        forgetImporterDeclarations(candidate, reconciliation.key);
+    }
+    applyImporterGraph(candidate, reconciliation);
+    rebuildActiveClaims(candidate);
+    if (isBundledChanged) {
+        await declareReconciledImports(ctx, candidate, reconciliation);
+    }
+    return candidate;
+};
+const commitReconciliation = (state, candidate) => {
+    state.entries = candidate.entries;
+    state.bundledSpecifiers = candidate.bundledSpecifiers;
+    state.moduleDependencies = candidate.moduleDependencies;
+    state.prunedDependencies = candidate.prunedDependencies;
+    state.declaredEntries = candidate.declaredEntries;
+    state.declaredIcons = candidate.declaredIcons;
+    state.missingSourcePaths = candidate.missingSourcePaths;
+    state.sourcePaths = candidate.sourcePaths;
+    state.iconOwners = candidate.iconOwners;
+};
+const reconcileV2Importer = async (ctx, state, id) => {
+    const reconciliation = await importerReconciliation(ctx, state, id);
+    if (reconciliation === null) {
+        return;
+    }
+    const previousSignature = entriesSignature(state);
+    const candidate = await prepareReconciliation(ctx, state, reconciliation);
+    commitReconciliation(state, candidate);
+    if (entriesSignature(state) !== previousSignature) {
+        refreshDevRegistration(state);
+    }
+};
 const resolveResourceConfig = async (state, config, loadConfig) => {
-    const { applicationId } = await loadConfig.resolve(config.root ?? process.cwd());
-    state.prefix = deriveResourcePrefix(applicationId);
+    const loaded = await loadConfig.load(config.root ?? process.cwd());
+    state.prefix = resourceBasePath(loaded.config.applicationId);
+    state.root = loaded.root;
+    state.isV2 = loaded.config.future?.v2ResourceImports === true;
     return {
         assetsInclude: [ASSET_RE],
     };
 };
-const refreshTrackedSource = async (state, file) => {
+const refreshTrackedSource = (state, file) => {
     if (!isTrackedSource(state, file)) {
         return;
     }
     try {
-        await refreshDevRegistration(state);
+        refreshDevRegistration(state);
     }
     catch (error_) {
         error("GResource refresh failed:", error_);
     }
 };
+const rebuildForSourceAvailability = (state, previousSignature) => {
+    try {
+        rebuildActiveClaims(state);
+        if (entriesSignature(state) !== previousSignature) {
+            refreshDevRegistration(state);
+        }
+    }
+    catch (error_) {
+        error("GResource source update failed:", error_);
+    }
+};
+const updateTrackedSourceAvailability = (state, file, isAvailable) => {
+    if (!isTrackedSource(state, file) && !state.missingSourcePaths.has(file) && !isDeclaredSource(state, file)) {
+        return;
+    }
+    const previousSignature = entriesSignature(state);
+    setSourceAvailability(state, file, isAvailable);
+    rebuildForSourceAvailability(state, previousSignature);
+};
 const attachResourceWatcher = (state, server) => {
     state.server = server;
-    const onFileEvent = (file) => {
-        void refreshTrackedSource(state, file);
+    const onChange = (file) => {
+        refreshTrackedSource(state, file);
+    };
+    const onAdd = (file) => {
+        updateTrackedSourceAvailability(state, file, true);
+    };
+    const onUnlink = (file) => {
+        updateTrackedSourceAvailability(state, file, false);
     };
     const onClose = () => {
         releaseStagingDir(state);
     };
     server.httpServer?.once("close", onClose);
     server.watcher.once("close", onClose);
-    server.watcher.on("change", onFileEvent);
-    server.watcher.on("add", onFileEvent);
+    server.watcher.on("change", onChange);
+    server.watcher.on("add", onAdd);
+    server.watcher.on("unlink", onUnlink);
 };
 const applyResolvedConfig = (state, config) => {
     state.isBuild = config.command === "build";
-    if (state.isBuild) {
+    state.root = config.root;
+    state.dataDir = null;
+    if (state.isBuild || state.isV2) {
         return;
     }
     const relativeDataDir = resolveDataDir(config.root);
@@ -202,51 +898,146 @@ const loadResourceModule = (state, id) => {
     }
     return loadAssetModule(state, id);
 };
-function gtkxResources(loadConfig = createConfigLoader()) {
+const isLegacyDataSpecifier = (source) => source.startsWith(DATA_PREFIX) && ASSET_RE.test(stripQuery(source));
+const rejectInvalidV2Specifier = (source) => {
+    if (BUNDLED_QUERY_MENTION_RE.test(source)) {
+        throw new Error(`${JSON.stringify(source)} is not a valid bundled asset import; use ?resource, ` +
+            "?resource=/absolute/path, ?icon, or ?icon=name");
+    }
+    if (isBareRelativeAsset(source)) {
+        throw new Error(`${JSON.stringify(source)} must choose ?resource for a GResource, ?icon for a themed icon, ` +
+            "or ?url for an emitted file");
+    }
+};
+const resolveExplicitResourceId = async (ctx, state, request) => {
+    const specifier = parseResourceSpecifier(request.source);
+    if (specifier === null) {
+        return undefined;
+    }
+    const entry = await resolveAssetEntry(ctx, state, {
+        assetSource: specifier.assetSource,
+        importer: request.importer,
+        resourcePath: specifier.resourcePath,
+        options: request.options,
+    });
+    return entry === undefined ? undefined : virtualAssetId(entry);
+};
+const resolveIconResourceId = async (ctx, state, request) => {
+    const specifier = parseIconSpecifier(request.source);
+    if (specifier === null) {
+        return undefined;
+    }
+    const resolved = await resolveIconEntry(ctx, state, {
+        assetSource: specifier.assetSource,
+        iconName: specifier.iconName,
+        importer: request.importer,
+        options: request.options,
+    });
+    return resolved === undefined
+        ? undefined
+        : { id: virtualIconId(resolved), moduleSideEffects: true };
+};
+const resolveV2ResourceId = async (ctx, state, request) => {
+    if (isLegacyDataSpecifier(request.source)) {
+        throw new Error(`${JSON.stringify(request.source)} uses the legacy #data asset form; import it relatively with ` +
+            "?resource or ?url");
+    }
+    if (parseResourceSpecifier(request.source) !== null) {
+        const resolved = await resolveExplicitResourceId(ctx, state, request);
+        trackBundledSpecifier(state, request.importer, request.source);
+        return resolved;
+    }
+    if (parseIconSpecifier(request.source) !== null) {
+        const resolved = await resolveIconResourceId(ctx, state, request);
+        trackBundledSpecifier(state, request.importer, request.source);
+        return resolved;
+    }
+    rejectInvalidV2Specifier(request.source);
+    return undefined;
+};
+const resolveLegacyResourceId = async (ctx, state, request) => {
+    if (BUNDLED_QUERY_MENTION_RE.test(request.source)) {
+        throw new Error(`${JSON.stringify(request.source)} requires future.v2ResourceImports`);
+    }
+    if (!isDataAsset(request.source)) {
+        return undefined;
+    }
+    const entry = await resolveLegacyAssetEntry(ctx, state, request);
+    return entry === undefined ? undefined : virtualAssetId(entry);
+};
+const resolveResourceId = (ctx, state, request) => {
+    if (request.source === VIRTUAL_INIT) {
+        return Promise.resolve(VIRTUAL_INIT);
+    }
+    return state.isV2
+        ? resolveV2ResourceId(ctx, state, request)
+        : resolveLegacyResourceId(ctx, state, request);
+};
+const configureResourceServer = (state, server) => {
+    attachResourceWatcher(state, server);
+    primeLegacyDevBundle(state);
+};
+const createResourcesPlugin = (state, loadConfig) => ({
+    name: "gtkx:resources",
+    enforce: "pre",
+    perEnvironmentStartEndDuringDev: true,
+    config: (config) => resolveResourceConfig(state, config, loadConfig),
+    configResolved: (config) => {
+        applyResolvedConfig(state, config);
+    },
+    configureServer: (server) => {
+        configureResourceServer(state, server);
+    },
+    buildStart() {
+        if (state.isBuild && state.bundleReferenceId === null) {
+            state.bundleReferenceId = this.emitFile({
+                type: "asset",
+                fileName: BUNDLE_FILENAME,
+                source: "",
+            });
+        }
+    },
+    resolveId(source, importer, options) {
+        return resolveResourceId(this, state, { source, importer, options });
+    },
+    load(id) {
+        return loadResourceModule(state, id);
+    },
+    async transform(code, id) {
+        await reconcileV2Importer(this, state, id);
+        return retainSideEffectIconImport(state, code, id);
+    },
+    generateBundle(_options, bundle) {
+        finalizeBuildBundle(this, bundle, state);
+    },
+    closeBundle() {
+        releaseStagingDir(state);
+    },
+});
+function gtkxResources(loadConfig = createConfigLoader(), entryPath) {
     const state = {
         prefix: "",
+        root: "",
         isBuild: false,
+        isV2: false,
         entries: new Map(),
+        bundledSpecifiers: new Map(),
+        moduleDependencies: new Map(),
+        prunedDependencies: new Map(),
+        declaredEntries: new Map(),
+        declaredIcons: new Map(),
+        entryModule: entryPath === undefined ? null : importerKey(entryPath),
         sourcePaths: new Set(),
+        missingSourcePaths: new Set(),
         stagingDir: createRetainedStagingDir(DEV_STAGING_PREFIX),
         devBundlePath: "",
         server: null,
         compiledSignature: "",
         dataDir: null,
+        bundleReferenceId: null,
+        iconOwners: new Map(),
     };
-    return {
-        name: "gtkx:resources",
-        enforce: "pre",
-        config(config) {
-            return resolveResourceConfig(state, config, loadConfig);
-        },
-        configResolved(config) {
-            applyResolvedConfig(state, config);
-        },
-        configureServer(server) {
-            attachResourceWatcher(state, server);
-            primeDevBundle(state);
-        },
-        async resolveId(source, importer, opts) {
-            if (source === VIRTUAL_INIT) {
-                return VIRTUAL_INIT;
-            }
-            if (!isDataAsset(source)) {
-                return;
-            }
-            const resolved = await this.resolve(source, importer, { ...opts, skipSelf: true });
-            return resolvedAssetId(resolved, source);
-        },
-        load(id) {
-            return loadResourceModule(state, id);
-        },
-        buildEnd() {
-            emitBuildBundle(this, state);
-        },
-        closeBundle() {
-            releaseStagingDir(state);
-        },
-    };
+    return createResourcesPlugin(state, loadConfig);
 }
 export { gtkxResources };
 //# sourceMappingURL=resources.js.map