@gtkx/cli 1.6.0 → 2.0.0-beta.10

package/src/settings/render.ts

@@ -9,7 +9,6 @@ type NamedSchema = {
 type EnvAssetDeclarations = {
     blocked: string[];
     icons: string[];
-    legacy: string[];
     resources: string[];
 };
 
@@ -209,15 +208,6 @@ const renderIconModule = (specifier: string): string => [
     "}",
 ].join("\n");
 
-const renderLegacyAssetModule = (specifier: string): string => [
-    `declare module ${toJsStringLiteral(specifier)} {`,
-    "    const resourceUri: string;",
-    "    const path: string;",
-    "    export { path };",
-    "    export default resourceUri;",
-    "}",
-].join("\n");
-
 const renderBlockedAssetModule = (specifier: string): string => [
     `declare module ${toJsStringLiteral(specifier)} {`,
     "    const assetImportRequiresResourceOrUrlQuery: {",
@@ -232,7 +222,7 @@ const renderEnvModule = (
     assetDeclarations?: EnvAssetDeclarations,
     options: EnvModuleOptions = {},
 ): string => {
-    const assets = assetDeclarations ?? { blocked: [], icons: [], legacy: [], resources: [] };
+    const assets = assetDeclarations ?? { blocked: [], icons: [], resources: [] };
     const usedNames: Set<string> = new Set();
 
     const schemas = files
@@ -241,7 +231,6 @@ const renderEnvModule = (
 
     const blocked = assets.blocked.map((specifier) => renderBlockedAssetModule(specifier));
     const icons = assets.icons.map((specifier) => renderIconModule(specifier));
-    const legacy = assets.legacy.map((specifier) => renderLegacyAssetModule(specifier));
     const resources = assets.resources.map((specifier) => renderResourceModule(specifier));
     const references = (options.references ?? []).map((path) => `/// <reference path=${JSON.stringify(path)} />`);
 
@@ -250,7 +239,6 @@ const renderEnvModule = (
         ...references,
         ...blocked,
         ...icons,
-        ...legacy,
         ...resources,
         ...schemas,
     ].join("\n\n")}\n`;

package/src/settings/schema.ts

@@ -1,25 +1,22 @@
-import { sortStrings, warn } from "@gtkx/utils";
+import { isPathInside, sortStrings, toPosixPath, warn } from "@gtkx/utils";
 import { createHash } from "node:crypto";
 import {
     copyFileSync,
-    type Dirent,
     existsSync,
     mkdirSync,
     mkdtempSync,
-    readdirSync,
     readFileSync,
     realpathSync,
     writeFileSync,
 } from "node:fs";
 import { tmpdir } from "node:os";
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
+import { basename, dirname, join, relative, resolve } from "node:path";
+import type { SourceImport } from "../internal/source-imports.js";
 import { I18N_TYPES_FILENAME, i18nTypesPath } from "../i18n/types.js";
-import { DATA_IMPORT_PREFIX } from "../internal/data-dir.js";
-import { discoverSourceImports, type SourceImport } from "../internal/source-imports.js";
+import { discoverProjectImports } from "../internal/import-scan.js";
 import { removeTempDir } from "../internal/staging-dir.js";
 import {
     isBareRelativeAsset,
-    isDataAsset,
     parseIconSpecifier,
     parseResourceSpecifier,
 } from "../vite-plugins/asset-specifier.js";
@@ -34,7 +31,6 @@ type SchemaEnvResult = {
 
 const SCHEMA_SUFFIX = ".gschema.xml";
 const STAGED_NAME_LENGTH = 16;
-const SOURCE_DIR = "src";
 const RESOURCE_QUERY = "?resource=";
 const ICON_QUERY = "?icon=";
 
@@ -57,35 +53,22 @@ const stageSchema = (dir: string, filePath: string): void => {
     copyFileSync(filePath, join(dir, stagedSchemaName(filePath)));
 };
 
-const toForwardSlashes = (value: string): string => value.replaceAll(/[/\\]/g, "/");
-
 const projectRelativeSchemaPath = (root: string, filePath: string): string | null => {
-    let rel: string;
+    let projectRoot: string;
+    let path: string;
 
     try {
-        rel = relative(realpathSync(root), realpathSync(filePath));
+        projectRoot = realpathSync(root);
+        path = realpathSync(filePath);
     } catch {
         return null;
     }
 
-    if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel)) {
-        return null;
-    }
-
-    return toForwardSlashes(rel);
+    return isPathInside(projectRoot, path) ? toPosixPath(relative(projectRoot, path)) : null;
 };
 
-const getModuleSpecifier = (dataDirAbs: string, filePath: string): string =>
-    `${DATA_IMPORT_PREFIX}/${toForwardSlashes(relative(dataDirAbs, filePath))}`;
-
 const getRelativeModuleSpecifier = (filePath: string): string => `*/${basename(filePath)}`;
 
-const sourceDirFor = (root: string): string => {
-    const sourceDir = join(root, SOURCE_DIR);
-
-    return existsSync(sourceDir) ? sourceDir : root;
-};
-
 const isRelativeImport = (source: string): boolean => source.startsWith("./") || source.startsWith("../");
 
 const schemaFileFor = ({ importer, source }: SourceImport): string | null =>
@@ -99,9 +82,6 @@ const findImportedSchemaFiles = (imports: SourceImport[]): string[] => {
     return sortStrings(new Set(files));
 };
 
-const legacyAssetSpecifier = (source: string): string | null =>
-    isDataAsset(source) ? source : null;
-
 const blockedAssetSpecifier = (source: string): string | null => {
     if (!isBareRelativeAsset(source)) {
         return null;
@@ -159,21 +139,15 @@ const iconModuleSpecifier = (source: string): string | null => {
 
 const findAssetModuleSpecifiers = (
     imports: SourceImport[],
-    isV2ResourceImports: boolean,
-): { blocked: string[]; icons: string[]; legacy: string[]; resources: string[] } => {
+): { blocked: string[]; icons: string[]; resources: string[] } => {
     const collect = (getSpecifier: (source: string) => string | null): string[] =>
         sortStrings(new Set(imports.map((entry) => getSpecifier(entry.source)).filter((value) => value !== null)));
 
-    if (isV2ResourceImports) {
-        return {
-            blocked: collect(blockedAssetSpecifier),
-            icons: collect(iconModuleSpecifier),
-            legacy: [],
-            resources: collect(resourceModuleSpecifier),
-        };
-    }
-
-    return { blocked: [], icons: [], legacy: collect(legacyAssetSpecifier), resources: [] };
+    return {
+        blocked: collect(blockedAssetSpecifier),
+        icons: collect(iconModuleSpecifier),
+        resources: collect(resourceModuleSpecifier),
+    };
 };
 
 const canonicalPath = (path: string): string => {
@@ -203,41 +177,10 @@ const assertUniqueSchemaBasenames = (schemaFiles: string[]): void => {
     }
 };
 
-const readVisibleEntries = (dir: string): Dirent[] => {
-    try {
-        return readdirSync(dir, { withFileTypes: true }).filter((entry) => !entry.name.startsWith("."));
-    } catch {
-        return [];
-    }
-};
-
-const isSchemaFile = (entry: Dirent): boolean => entry.isFile() && entry.name.endsWith(SCHEMA_SUFFIX);
-
-const collectSchemaFiles = (dir: string, found: string[]): void => {
-    for (const entry of readVisibleEntries(dir)) {
-        const full = join(dir, entry.name);
-
-        if (entry.isDirectory()) {
-            collectSchemaFiles(full, found);
-        } else if (isSchemaFile(entry)) {
-            found.push(full);
-        }
-    }
-};
-
-const findSchemaFiles = (dataDir: string): string[] => {
-    const found: string[] = [];
-    collectSchemaFiles(dataDir, found);
-
-    return sortStrings(found);
-};
-
-const stageAndCompileProjectSchemas = (root: string, dataDir: string | null): string | null => {
-    const imports = discoverSourceImports(sourceDirFor(root));
-    const imported = findImportedSchemaFiles(imports);
-    assertUniqueSchemaBasenames(imported);
-    const legacy = dataDir === null ? [] : findSchemaFiles(join(root, dataDir));
-    const schemaFiles = sortStrings(new Set([...legacy, ...imported]));
+const stageAndCompileProjectSchemas = (root: string): string | null => {
+    const imports = discoverProjectImports(root);
+    const schemaFiles = findImportedSchemaFiles(imports);
+    assertUniqueSchemaBasenames(schemaFiles);
 
     if (schemaFiles.length === 0) {
         return null;
@@ -307,25 +250,14 @@ const didWriteChanges = (path: string, content: string): boolean => {
     return true;
 };
 
-const emitSchemaEnv = (
-    rootDir: string,
-    dataDir: string | null,
-    isV2ResourceImports = false,
-): SchemaEnvResult => {
-    const dataDirAbs = dataDir === null ? null : join(rootDir, dataDir);
-    const legacyFiles = dataDirAbs === null ? [] : findSchemaFiles(dataDirAbs);
-    const imports = discoverSourceImports(sourceDirFor(rootDir));
-
-    const legacy = dataDirAbs === null
-        ? []
-        : parseProjectSchemas(legacyFiles, (filePath) => getModuleSpecifier(dataDirAbs, filePath));
-
+const emitSchemaEnv = (rootDir: string): SchemaEnvResult => {
+    const imports = discoverProjectImports(rootDir);
     const importedFiles = findImportedSchemaFiles(imports);
     assertUniqueSchemaBasenames(importedFiles);
     const imported = parseProjectSchemas(importedFiles, getRelativeModuleSpecifier);
-    const assets = findAssetModuleSpecifiers(imports, isV2ResourceImports);
+    const assets = findAssetModuleSpecifiers(imports);
     const references = existsSync(i18nTypesPath(rootDir)) ? [`./${I18N_TYPES_FILENAME}`] : [];
-    const content = renderEnvModule([...legacy, ...imported], assets, { references });
+    const content = renderEnvModule(imported, assets, { references });
     const path = schemaEnvPath(rootDir);
     const isWritten = didWriteChanges(path, content);
 

package/src/vite-plugins/asset-extensions.ts

@@ -18,6 +18,8 @@ const ASSET_EXTENSIONS = [
     "eot",
     "ttf",
     "otf",
+    "ttc",
+    "otc",
     "ico",
     "avif",
     "data",

package/src/vite-plugins/asset-imports.ts

@@ -1,14 +1,11 @@
-import type { ConfigLoader } from "@gtkx/config";
-import type { ParseResult, Plugin, UserConfig } from "vite";
-import { createConfigLoader, resolveFuture } from "@gtkx/config/internal";
+import type { ParseResult, Plugin } from "vite";
 import { parseSync } from "vite";
-import { sourceLanguage } from "../internal/source-imports.js";
+import { SOURCE_ID_RE, sourceLanguage } from "../internal/source-imports.js";
 import { ASSET_MENTION_RE } from "./asset-extensions.js";
 import {
-    DATA_PREFIX,
     isAssetSpecifier,
-    isDataAsset,
     isUrlSpecifier,
+    parseFontSpecifier,
     parseIconSpecifier,
     parseResourceSpecifier,
 } from "./asset-specifier.js";
@@ -21,18 +18,14 @@ type ExportStatement = ParsedModule["staticExports"][number];
 type ExportEntry = ExportStatement["entries"][number];
 type BindingEntry = { importName: { name: string | null }; isType: boolean };
 type NamedBinding = { name: string; source: string };
-type PluginState = { isV2: boolean };
 
 const NODE_MODULES = /(?:^|\/)node_modules\//;
+const NODE_MODULES_ID_RE = /^[^?]*(?:^|\/)node_modules\//;
 const VIRTUAL_PREFIX = "\0";
+const VIRTUAL_ID_RE = /^\0/;
+const URL_QUERY = "?url";
 const DEFAULT_BINDING = "default";
 const RESOURCE_BINDING = JSON.stringify(RESOURCE_PATH_EXPORT);
-const DATA_IMPORT_EXAMPLE = `"${DATA_PREFIX}<path>"`;
-const URL_FALLBACK = ", or import the default for the asset URL.";
-
-const BUNDLE_ADVICE =
-    `An asset staged into the GResource bundle exports ${RESOURCE_BINDING} and a "resource://" default, and ` +
-    "nothing else.";
 
 const QUERY_ADVICE =
     `A URL asset exports only its default filesystem path; import the default instead of ${RESOURCE_BINDING}.`;
@@ -42,10 +35,11 @@ const RESOURCE_ADVICE =
 
 const ICON_ADVICE = "An icon asset exports only its default icon-theme name, and nothing else.";
 
+const FONT_ADVICE = "A font asset exports only its default font family name, and nothing else.";
+
 const RELATIVE_ADVICE =
-    `Only assets imported through "${DATA_PREFIX}" are staged into the GResource bundle and export ` +
-    `${RESOURCE_BINDING}; move the file under the data directory and import it as ` +
-    `${DATA_IMPORT_EXAMPLE}${URL_FALLBACK}`;
+    "Add ?resource for a GResource, ?icon for a themed icon, ?font for a bundled font, or ?url for an " +
+    "emitted file.";
 
 const boundName = (entry: BindingEntry): string | null => {
     const { name } = entry.importName;
@@ -78,50 +72,50 @@ const bindings = (parsed: ParsedModule): NamedBinding[] => [
     ...parsed.staticExports.flatMap((statement) => exportBindings(statement)),
 ];
 
-const isBacked = ({ name, source }: NamedBinding, isV2: boolean): boolean => {
+const isBacked = ({ name, source }: NamedBinding): boolean => {
     if (name !== RESOURCE_PATH_EXPORT) {
         return false;
     }
 
-    return isV2 ? parseResourceSpecifier(source) !== null : isDataAsset(source);
+    return parseResourceSpecifier(source) !== null;
 };
 
 const isCheckedSpecifier = (source: string): boolean => isAssetSpecifier(source) || isUrlSpecifier(source);
 
-const unbackedBinding = (parsed: ParsedModule, isV2: boolean): NamedBinding | undefined =>
-    bindings(parsed).find((binding) => isCheckedSpecifier(binding.source) && !isBacked(binding, isV2));
+const unbackedBinding = (parsed: ParsedModule): NamedBinding | undefined =>
+    bindings(parsed).find((binding) => isCheckedSpecifier(binding.source) && !isBacked(binding));
 
-const isBundledResource = (source: string, isV2: boolean): boolean =>
-    isV2
-        ? parseResourceSpecifier(source) !== null || parseIconSpecifier(source) !== null
-        : isDataAsset(source);
+const adviceFor = (source: string): string => {
+    if (parseResourceSpecifier(source) !== null) {
+        return RESOURCE_ADVICE;
+    }
 
-const v2BundleAdvice = (source: string): string =>
-    parseIconSpecifier(source) === null ? RESOURCE_ADVICE : ICON_ADVICE;
+    if (parseIconSpecifier(source) !== null) {
+        return ICON_ADVICE;
+    }
 
-const bundleAdvice = (source: string, isV2: boolean): string => {
-    if (isBundledResource(source, isV2)) {
-        return isV2 ? v2BundleAdvice(source) : BUNDLE_ADVICE;
+    if (parseFontSpecifier(source) !== null) {
+        return FONT_ADVICE;
     }
 
     if (isUrlSpecifier(source)) {
         return QUERY_ADVICE;
     }
 
-    return source.startsWith(DATA_PREFIX) ? QUERY_ADVICE : RELATIVE_ADVICE;
+    return RELATIVE_ADVICE;
 };
 
-const unbackedBindingError = (path: string, binding: NamedBinding, isV2: boolean): Error =>
+const unbackedBindingError = (path: string, binding: NamedBinding): Error =>
     new Error(
         `${path}: ${JSON.stringify(binding.source)} does not export ${JSON.stringify(binding.name)}, which ` +
         "gtkx build rejects and gtkx dev would bind as undefined. " +
-        bundleAdvice(binding.source, isV2),
+        adviceFor(binding.source),
     );
 
 const isCheckedSource = (path: string): boolean => !path.startsWith(VIRTUAL_PREFIX) && !NODE_MODULES.test(path);
-const hasCheckedAssetMention = (code: string): boolean => ASSET_MENTION_RE.test(code) || code.includes("?url");
+const hasCheckedAssetMention = (code: string): boolean => ASSET_MENTION_RE.test(code) || code.includes(URL_QUERY);
 
-const checkAssetImports = (code: string, id: string, isV2: boolean): void => {
+const checkAssetImports = (code: string, id: string): void => {
     const path = stripQuery(id);
     const lang = sourceLanguage(path);
 
@@ -135,27 +129,27 @@ const checkAssetImports = (code: string, id: string, isV2: boolean): void => {
         return;
     }
 
-    const binding = unbackedBinding(parsed.module, isV2);
+    const binding = unbackedBinding(parsed.module);
 
     if (binding !== undefined) {
-        throw unbackedBindingError(path, binding, isV2);
+        throw unbackedBindingError(path, binding);
     }
 };
 
-function gtkxAssetImports(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
-    const state: PluginState = { isV2: false };
-
+function gtkxAssetImports(): Plugin {
     return {
         name: "gtkx:asset-imports",
         enforce: "pre",
 
-        async config(config: UserConfig) {
-            const loaded = await loadConfig.load(config.root ?? process.cwd());
-            state.isV2 = resolveFuture(loaded.config.future).isResourceImported;
-        },
+        transform: {
+            filter: {
+                id: { include: SOURCE_ID_RE, exclude: [VIRTUAL_ID_RE, NODE_MODULES_ID_RE] },
+                code: { include: [ASSET_MENTION_RE, URL_QUERY] },
+            },
 
-        transform(code, id) {
-            checkAssetImports(code, id, state.isV2);
+            handler(code, id) {
+                checkAssetImports(code, id);
+            },
         },
     };
 }

package/src/vite-plugins/asset-specifier.ts

@@ -1,4 +1,3 @@
-import { DATA_IMPORT_PREFIX } from "../internal/data-dir.js";
 import { ASSET_PATH_RE, ASSET_RE } from "./asset-extensions.js";
 import { stripQuery } from "./strip-query.js";
 
@@ -12,10 +11,14 @@ type IconSpecifier = {
     iconName: string | null;
 };
 
-const DATA_PREFIX = `${DATA_IMPORT_PREFIX}/`;
+type FontSpecifier = {
+    assetSource: string;
+};
+
 const RELATIVE_PREFIX_RE = /^\.\.?(?:\/|$)/;
 const RESOURCE_QUERY_RE = /^resource(?:=([^&#]+))?$/;
 const ICON_QUERY_RE = /^icon(?:=([^&#]+))?$/;
+const FONT_QUERY_RE = /^font$/;
 const URL_QUERY_RE = /(?:^|&)url(?:&|$)/;
 
 const getQuery = (source: string): string | null => {
@@ -25,7 +28,6 @@ const getQuery = (source: string): string | null => {
 };
 
 const isAssetSpecifier = (source: string): boolean => ASSET_PATH_RE.test(source);
-const isDataAsset = (source: string): boolean => source.startsWith(DATA_PREFIX) && ASSET_RE.test(source);
 
 const isBareRelativeAsset = (source: string): boolean =>
     getQuery(source) === null && RELATIVE_PREFIX_RE.test(source) && ASSET_RE.test(source);
@@ -64,6 +66,17 @@ const parseIconSpecifier = (source: string): IconSpecifier | null => {
     return { assetSource, iconName: match[1] ?? null };
 };
 
+const parseFontSpecifier = (source: string): FontSpecifier | null => {
+    const query = getQuery(source);
+    const assetSource = stripQuery(source);
+
+    if (query === null || !ASSET_RE.test(assetSource) || !FONT_QUERY_RE.test(query)) {
+        return null;
+    }
+
+    return { assetSource };
+};
+
 const isUrlSpecifier = (source: string): boolean => {
     const query = getQuery(source);
 
@@ -71,11 +84,10 @@ const isUrlSpecifier = (source: string): boolean => {
 };
 
 export {
-    DATA_PREFIX,
     isAssetSpecifier,
     isBareRelativeAsset,
-    isDataAsset,
     isUrlSpecifier,
+    parseFontSpecifier,
     parseIconSpecifier,
     parseResourceSpecifier,
 };

package/src/vite-plugins/build-manifest.ts

@@ -21,6 +21,11 @@ type ManifestState = {
     outDir: string;
 };
 
+type BuildConfigIdentity = {
+    configFile: string;
+    configDigest: string;
+};
+
 const PACKAGE_MANIFEST_FILENAME = "package.json";
 const DEFAULT_OUT_DIR = "dist";
 const JSON_INDENT = 4;
@@ -73,7 +78,7 @@ const packagesFor = (outDir: string, ids: string[]): RecordedPackage[] => {
 
 const renderManifest = (manifest: BuildManifest): string => `${JSON.stringify(manifest, null, JSON_INDENT)}\n`;
 
-function gtkxBuildManifest(root: string, collector: BuildManifestCollector): Plugin {
+function gtkxBuildManifest(root: string, collector: BuildManifestCollector, identity: BuildConfigIdentity): Plugin {
     const state: ManifestState = { outDir: join(root, DEFAULT_OUT_DIR) };
 
     return {
@@ -90,6 +95,7 @@ function gtkxBuildManifest(root: string, collector: BuildManifestCollector): Plu
             const manifest: BuildManifest = {
                 generator: BUILD_MANIFEST_GENERATOR,
                 formatVersion: BUILD_MANIFEST_FORMAT_VERSION,
+                ...identity,
                 schemas: collector.schemas,
                 packages: packagesFor(state.outDir, ids),
             };

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

@@ -68,8 +68,12 @@ function gtkxBuiltUrl(): Plugin {
             state.isBuild = config.command === "build";
         },
 
-        load(id) {
-            return loadDevFileUrl(this, state, id);
+        load: {
+            filter: { id: URL_QUERY_RE },
+
+            handler(id) {
+                return loadDevFileUrl(this, state, id);
+            },
         },
     };
 }

package/src/vite-plugins/css.ts

@@ -4,10 +4,12 @@ import { createVirtualNamespace } from "./virtual-module.js";
 
 type CssResolveContext = Parameters<typeof resolveToVirtual>[0];
 type CssResolveRequest = Parameters<typeof resolveToVirtual>[1];
+type CssLoadContext = { addWatchFile: (file: string) => void };
 
 const CSS_RE = /\.css$/i;
 const INJECT_SUFFIX = "?inject";
 const VIRTUAL_PREFIX = "\0gtkx-css:";
+const VIRTUAL_ID_RE = new RegExp(`^${VIRTUAL_PREFIX}`);
 const { isVirtual, fromVirtualId, resolveToVirtual } = createVirtualNamespace(VIRTUAL_PREFIX);
 
 const resolveCssId = async (ctx: CssResolveContext, request: CssResolveRequest): Promise<string | undefined> => {
@@ -24,13 +26,14 @@ const resolveCssId = async (ctx: CssResolveContext, request: CssResolveRequest):
     return virtualId + INJECT_SUFFIX;
 };
 
-const loadInjectedCss = (id: string): string | undefined => {
+const loadInjectedCss = (ctx: CssLoadContext, id: string): string | undefined => {
     if (!isVirtual(id) || !id.endsWith(INJECT_SUFFIX)) {
         return;
     }
 
     const filePath = fromVirtualId(id.slice(0, -INJECT_SUFFIX.length));
     const content = readFileSync(filePath, "utf8");
+    ctx.addWatchFile(filePath);
 
     return ["import { injectGlobal } from \"@gtkx/css\";", `injectGlobal(${JSON.stringify(content)});`].join("\n");
 };
@@ -40,12 +43,20 @@ function gtkxCss(): Plugin {
         name: "gtkx:css",
         enforce: "pre",
 
-        resolveId(source, importer, options) {
-            return resolveCssId(this, { source, importer, options });
+        resolveId: {
+            filter: { id: CSS_RE },
+
+            handler(source, importer, options) {
+                return resolveCssId(this, { source, importer, options });
+            },
         },
 
-        load(id) {
-            return loadInjectedCss(id);
+        load: {
+            filter: { id: VIRTUAL_ID_RE },
+
+            handler(id) {
+                return loadInjectedCss(this, id);
+            },
         },
     };
 }

package/src/vite-plugins/ensure-store.ts

@@ -3,11 +3,11 @@ import { ensureGenerated } from "../codegen/run-codegen.js";
 
 const TEST_MODE = "test";
 
-const gtkxEnsureStore = (): Plugin => ({
+const gtkxEnsureStore = (configFile?: string): Plugin => ({
     name: "gtkx:ensure-store",
 
     async config() {
-        await ensureGenerated(process.cwd(), { shouldAnnounce: true, mode: TEST_MODE });
+        await ensureGenerated(process.cwd(), { shouldAnnounce: true, mode: TEST_MODE, configFile });
     },
 });
 

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

@@ -3,6 +3,8 @@ const REFRESH_SIG = "$RefreshSig$";
 const REFRESH_RUNTIME_SPECIFIER = "@gtkx/cli/refresh-runtime";
 const REFRESH_INCLUDE = /\.[tj]sx?$/;
 const REFRESH_EXCLUDE = /node_modules|[/\\]dist[/\\]|[/\\]\.gtkx[/\\]/;
+const REFRESH_ID_FILTER = { include: REFRESH_INCLUDE, exclude: REFRESH_EXCLUDE };
+const REFRESH_RUNTIME_ID_RE = new RegExp(`^${REFRESH_RUNTIME_SPECIFIER}$`);
 
 const shouldTransformForRefresh = (
     id: string,
@@ -23,4 +25,11 @@ const shouldTransformForRefresh = (
     return true;
 };
 
-export { REFRESH_REG, REFRESH_SIG, REFRESH_RUNTIME_SPECIFIER, shouldTransformForRefresh };
+export {
+    REFRESH_ID_FILTER,
+    REFRESH_REG,
+    REFRESH_RUNTIME_ID_RE,
+    REFRESH_RUNTIME_SPECIFIER,
+    REFRESH_SIG,
+    shouldTransformForRefresh,
+};