@gtkx/cli 1.6.0 → 2.0.0-beta.1

package/src/internal/icon-path.ts

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

package/src/internal/source-imports.ts

@@ -1,6 +1,6 @@
 import type { ESTree, ParseResult, ParserOptions } from "vite";
 import { sortStringsBy } from "@gtkx/utils";
-import { type Dirent, readdirSync, readFileSync } from "node:fs";
+import { globSync, readFileSync } from "node:fs";
 import { extname, join } from "node:path";
 import { parseSync, Visitor } from "vite";
 
@@ -13,8 +13,6 @@ type SourceLanguage = NonNullable<ParserOptions["lang"]>;
 type ParsedModule = ParseResult["module"];
 
 const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
-    [".cjs", "jsx"],
-    [".cts", "ts"],
     [".js", "jsx"],
     [".jsx", "jsx"],
     [".mjs", "jsx"],
@@ -23,60 +21,26 @@ const SOURCE_LANGUAGES: Map<string, SourceLanguage> = new Map([
     [".tsx", "tsx"],
 ]);
 
-const EXCLUDED_DIRECTORIES: Set<string> = new Set([
-    "build",
-    "coverage",
-    "dist",
-    "node_modules",
-    "out-tsc",
-]);
-
 const sourceLanguage = (path: string): SourceLanguage | undefined => {
-    if (path.endsWith(".d.ts") || path.endsWith(".d.cts") || path.endsWith(".d.mts")) {
+    if (path.endsWith(".d.ts") || path.endsWith(".d.mts")) {
         return undefined;
     }
 
     return SOURCE_LANGUAGES.get(extname(path).toLowerCase());
 };
 
-const isWalkableDirectory = (name: string): boolean => !name.startsWith(".") && !EXCLUDED_DIRECTORIES.has(name);
-
-const collectSourceEntry = (dir: string, entry: Dirent, found: string[]): void => {
-    const path = join(dir, entry.name);
-
-    if (entry.isDirectory()) {
-        if (isWalkableDirectory(entry.name)) {
-            sourceFilesIn(path, found);
-        }
-
-        return;
-    }
-
-    if (entry.isFile() && sourceLanguage(path) !== undefined) {
-        found.push(path);
-    }
-};
-
-const sourceFilesIn = (dir: string, found: string[]): void => {
-    let entries: Dirent[];
-
-    try {
-        entries = readdirSync(dir, { withFileTypes: true });
-    } catch {
-        return;
-    }
-
-    for (const entry of entries) {
-        collectSourceEntry(dir, entry, found);
-    }
-};
-
-const discoverSourceFiles = (dir: string): string[] => {
-    const files: string[] = [];
-    sourceFilesIn(dir, files);
-
-    return sortStringsBy(files, (path) => path);
-};
+const discoverSourceFiles = (dir: string): string[] =>
+    sortStringsBy(
+        globSync("**/{*,.*}", {
+            cwd: dir,
+            exclude: ["**/{build,coverage,dist,node_modules,out-tsc}/**"],
+            withFileTypes: true,
+        })
+            .filter((entry) => entry.isFile())
+            .map((entry) => join(entry.parentPath, entry.name))
+            .filter((path) => sourceLanguage(path) !== undefined),
+        (path) => path,
+    );
 
 const staticImportSources = (module: ParsedModule): string[] => [
     ...module.staticImports.map((statement) => statement.moduleRequest.value),

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,21 @@
-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 { 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 { removeTempDir } from "../internal/staging-dir.js";
 import {
     isBareRelativeAsset,
-    isDataAsset,
     parseIconSpecifier,
     parseResourceSpecifier,
 } from "../vite-plugins/asset-specifier.js";
@@ -57,27 +53,20 @@ 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 => {
@@ -99,9 +88,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 +145,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 +183,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 stageAndCompileProjectSchemas = (root: string): 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 schemaFiles = findImportedSchemaFiles(imports);
+    assertUniqueSchemaBasenames(schemaFiles);
 
     if (schemaFiles.length === 0) {
         return null;
@@ -307,25 +256,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 emitSchemaEnv = (rootDir: string): SchemaEnvResult => {
     const imports = discoverSourceImports(sourceDirFor(rootDir));
-
-    const legacy = dataDirAbs === null
-        ? []
-        : parseProjectSchemas(legacyFiles, (filePath) => getModuleSpecifier(dataDirAbs, filePath));
-
     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-imports.ts

@@ -1,13 +1,9 @@
-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 { ASSET_MENTION_RE } from "./asset-extensions.js";
 import {
-    DATA_PREFIX,
     isAssetSpecifier,
-    isDataAsset,
     isUrlSpecifier,
     parseIconSpecifier,
     parseResourceSpecifier,
@@ -21,18 +17,11 @@ 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 VIRTUAL_PREFIX = "\0";
 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}.`;
@@ -43,9 +32,7 @@ const RESOURCE_ADVICE =
 const ICON_ADVICE = "An icon asset exports only its default icon-theme 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, or ?url for an emitted file.";
 
 const boundName = (entry: BindingEntry): string | null => {
     const { name } = entry.importName;
@@ -78,50 +65,46 @@ 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 isBundledResource = (source: string, isV2: boolean): boolean =>
-    isV2
-        ? parseResourceSpecifier(source) !== null || parseIconSpecifier(source) !== null
-        : isDataAsset(source);
+const unbackedBinding = (parsed: ParsedModule): NamedBinding | undefined =>
+    bindings(parsed).find((binding) => isCheckedSpecifier(binding.source) && !isBacked(binding));
 
-const v2BundleAdvice = (source: string): string =>
-    parseIconSpecifier(source) === null ? RESOURCE_ADVICE : ICON_ADVICE;
+const adviceFor = (source: string): string => {
+    if (parseResourceSpecifier(source) !== null) {
+        return RESOURCE_ADVICE;
+    }
 
-const bundleAdvice = (source: string, isV2: boolean): string => {
-    if (isBundledResource(source, isV2)) {
-        return isV2 ? v2BundleAdvice(source) : BUNDLE_ADVICE;
+    if (parseIconSpecifier(source) !== null) {
+        return ICON_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 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 +118,20 @@ 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(code, id) {
-            checkAssetImports(code, id, state.isV2);
+            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,7 +11,6 @@ type IconSpecifier = {
     iconName: string | null;
 };
 
-const DATA_PREFIX = `${DATA_IMPORT_PREFIX}/`;
 const RELATIVE_PREFIX_RE = /^\.\.?(?:\/|$)/;
 const RESOURCE_QUERY_RE = /^resource(?:=([^&#]+))?$/;
 const ICON_QUERY_RE = /^icon(?:=([^&#]+))?$/;
@@ -25,7 +23,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);
@@ -71,10 +68,8 @@ const isUrlSpecifier = (source: string): boolean => {
 };
 
 export {
-    DATA_PREFIX,
     isAssetSpecifier,
     isBareRelativeAsset,
-    isDataAsset,
     isUrlSpecifier,
     parseIconSpecifier,
     parseResourceSpecifier,

package/src/vite-plugins/i18n.ts

@@ -1,6 +1,7 @@
 import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, ResolvedConfig } from "vite";
 import { createConfigLoader } from "@gtkx/config/internal";
+import { toPosixPath } from "@gtkx/utils";
 import { existsSync, mkdirSync } from "node:fs";
 import { createRequire } from "node:module";
 import { dirname, join, posix, relative, resolve } from "node:path";
@@ -32,7 +33,7 @@ const isI18nLocaleModule = (state: I18nState, id: string): boolean => {
         return false;
     }
 
-    const path = relative(state.i18nRoot, stripQuery(id)).replaceAll("\\", "/");
+    const path = toPosixPath(relative(state.i18nRoot, stripQuery(id)));
 
     return LOCALE_MODULE_PATHS.has(path);
 };

package/src/vite-plugins/index.ts

@@ -2,7 +2,6 @@ import type { Plugin } from "vite";
 import { createConfigLoader } from "@gtkx/config/internal";
 import createConfigPlugin from "@gtkx/config/vite-plugin";
 import type { BuildManifestCollector } from "../internal/build-manifest.js";
-import { gtkxAnimated } from "./animated.js";
 import { gtkxAssetImports } from "./asset-imports.js";
 import { gtkxBuiltUrl } from "./built-url.js";
 import { gtkxCss } from "./css.js";
@@ -27,13 +26,12 @@ const gtkxVitePlugins = (
         ...(entryPath === undefined ? [] : [gtkxI18n(entryPath, loadConfig, shouldPreserveI18nMetadata)]),
         gtkxStoreLinks(),
         gtkxUndeclaredLibrary(loadConfig),
-        gtkxSettings(loadConfig, buildManifest),
+        gtkxSettings(buildManifest),
         gtkxIcons(loadConfig),
-        gtkxAssetImports(loadConfig),
+        gtkxAssetImports(),
         gtkxBuiltUrl(),
         gtkxResources(loadConfig, entryPath),
         gtkxCss(),
-        gtkxAnimated(loadConfig),
         gtkxReactCompiler(loadConfig),
     ];
 };