@gtkx/cli 1.3.0 → 1.5.0

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

@@ -1,9 +1,81 @@
 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";
+
+type ResourceSpecifier = {
+    assetSource: string;
+    resourcePath: string | null;
+};
+
+type IconSpecifier = {
+    assetSource: string;
+    iconName: string | null;
+};
 
 const DATA_PREFIX = `${DATA_IMPORT_PREFIX}/`;
+const RELATIVE_PREFIX_RE = /^\.\.?(?:\/|$)/;
+const RESOURCE_QUERY_RE = /^resource(?:=([^&#]+))?$/;
+const ICON_QUERY_RE = /^icon(?:=([^&#]+))?$/;
+const URL_QUERY_RE = /(?:^|&)url(?:&|$)/;
+
+const getQuery = (source: string): string | null => {
+    const queryIndex = source.indexOf("?");
+
+    return queryIndex === -1 ? null : source.slice(queryIndex + 1);
+};
 
 const isAssetSpecifier = (source: string): boolean => ASSET_PATH_RE.test(source);
 const isDataAsset = (source: string): boolean => source.startsWith(DATA_PREFIX) && ASSET_RE.test(source);
 
-export { DATA_PREFIX, isAssetSpecifier, isDataAsset };
+const isBareRelativeAsset = (source: string): boolean =>
+    getQuery(source) === null && RELATIVE_PREFIX_RE.test(source) && ASSET_RE.test(source);
+
+const parseResourceSpecifier = (source: string): ResourceSpecifier | null => {
+    const query = getQuery(source);
+    const assetSource = stripQuery(source);
+
+    if (query === null || !ASSET_RE.test(assetSource)) {
+        return null;
+    }
+
+    const match = RESOURCE_QUERY_RE.exec(query);
+
+    if (match === null) {
+        return null;
+    }
+
+    return { assetSource, resourcePath: match[1] ?? null };
+};
+
+const parseIconSpecifier = (source: string): IconSpecifier | null => {
+    const query = getQuery(source);
+    const assetSource = stripQuery(source);
+
+    if (query === null || !ASSET_RE.test(assetSource)) {
+        return null;
+    }
+
+    const match = ICON_QUERY_RE.exec(query);
+
+    if (match === null) {
+        return null;
+    }
+
+    return { assetSource, iconName: match[1] ?? null };
+};
+
+const isUrlSpecifier = (source: string): boolean => {
+    const query = getQuery(source);
+
+    return query !== null && URL_QUERY_RE.test(query);
+};
+
+export {
+    DATA_PREFIX,
+    isAssetSpecifier,
+    isBareRelativeAsset,
+    isDataAsset,
+    isUrlSpecifier,
+    parseIconSpecifier,
+    parseResourceSpecifier,
+};

package/src/vite-plugins/{bundled-packages.ts → build-manifest.ts}

@@ -2,6 +2,14 @@ import type { Plugin } from "vite";
 import { isRecord, sortStringsBy } from "@gtkx/utils";
 import { readFileSync } from "node:fs";
 import { dirname, join, relative, resolve } from "node:path";
+import {
+    BUILD_MANIFEST_FILENAME,
+    BUILD_MANIFEST_FORMAT_VERSION,
+    BUILD_MANIFEST_GENERATOR,
+    type BuildManifest,
+    type BuildManifestCollector,
+    type RecordedPackage,
+} from "../internal/build-manifest.js";
 import { stripQuery } from "./strip-query.js";
 
 type PackageIdentity = {
@@ -9,22 +17,17 @@ type PackageIdentity = {
     version: string | null;
 };
 
-type RecordedPackage = PackageIdentity & {
-    dir: string;
-};
-
-type PackagesState = {
+type ManifestState = {
     outDir: string;
 };
 
-const BUNDLED_PACKAGES_FILENAME = "gtkx-packages.json";
-const MANIFEST_FILENAME = "package.json";
+const PACKAGE_MANIFEST_FILENAME = "package.json";
 const DEFAULT_OUT_DIR = "dist";
 const JSON_INDENT = 4;
 
 const identityIn = (dir: string): PackageIdentity | null => {
     try {
-        const parsed: unknown = JSON.parse(readFileSync(join(dir, MANIFEST_FILENAME), "utf8"));
+        const parsed: unknown = JSON.parse(readFileSync(join(dir, PACKAGE_MANIFEST_FILENAME), "utf8"));
 
         if (!isRecord(parsed) || typeof parsed.name !== "string") {
             return null;
@@ -54,26 +57,27 @@ const packageForModule = (id: string): RecordedPackage | null => {
     return path.startsWith("/") ? packageIn(dirname(path)) : null;
 };
 
-const keyFor = (entry: RecordedPackage): string => `${entry.name}@${entry.version ?? ""}`;
+const packageKey = (entry: RecordedPackage): string => `${entry.name}@${entry.version ?? ""}`;
 
 const relativeTo = (outDir: string, entry: RecordedPackage): RecordedPackage => ({
     ...entry,
     dir: relative(outDir, entry.dir),
 });
 
-const renderPackages = (outDir: string, ids: string[]): string => {
+const packagesFor = (outDir: string, ids: string[]): RecordedPackage[] => {
     const found = ids.map((id) => packageForModule(id)).filter((entry) => entry !== null);
-    const unique: Map<string, RecordedPackage> = new Map(found.map((entry) => [keyFor(entry), entry]));
-    const packages = sortStringsBy(unique.values(), keyFor).map((entry) => relativeTo(outDir, entry));
+    const unique: Map<string, RecordedPackage> = new Map(found.map((entry) => [packageKey(entry), entry]));
 
-    return `${JSON.stringify({ packages }, null, JSON_INDENT)}\n`;
+    return sortStringsBy(unique.values(), packageKey).map((entry) => relativeTo(outDir, entry));
 };
 
-function gtkxBundledPackages(root: string): Plugin {
-    const state: PackagesState = { outDir: join(root, DEFAULT_OUT_DIR) };
+const renderManifest = (manifest: BuildManifest): string => `${JSON.stringify(manifest, null, JSON_INDENT)}\n`;
+
+function gtkxBuildManifest(root: string, collector: BuildManifestCollector): Plugin {
+    const state: ManifestState = { outDir: join(root, DEFAULT_OUT_DIR) };
 
     return {
-        name: "gtkx:bundled-packages",
+        name: "gtkx:build-manifest",
         apply: "build",
 
         configResolved(config) {
@@ -83,13 +87,20 @@ function gtkxBundledPackages(root: string): Plugin {
         generateBundle(_options, bundle) {
             const ids = Object.values(bundle).flatMap((output) => (output.type === "chunk" ? output.moduleIds : []));
 
+            const manifest: BuildManifest = {
+                generator: BUILD_MANIFEST_GENERATOR,
+                formatVersion: BUILD_MANIFEST_FORMAT_VERSION,
+                schemas: collector.schemas,
+                packages: packagesFor(state.outDir, ids),
+            };
+
             this.emitFile({
                 type: "asset",
-                fileName: BUNDLED_PACKAGES_FILENAME,
-                source: renderPackages(state.outDir, ids),
+                fileName: BUILD_MANIFEST_FILENAME,
+                source: renderManifest(manifest),
             });
         },
     };
 }
 
-export { BUNDLED_PACKAGES_FILENAME, gtkxBundledPackages };
+export { gtkxBuildManifest };

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

@@ -1,14 +1,12 @@
-import type { Plugin } from "vite";
-import { posix } from "node:path";
+import type { Plugin, UserConfig } from "vite";
+import { existsSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { stripQuery } from "./strip-query.js";
 
-const EXECUTABLE_URL_BASE = "`file://${process.execPath}`";
-const LEADING_SLASHES = /^\/+/;
+type PluginState = { isBuild: boolean };
+type WatchContext = { addWatchFile: (file: string) => void };
 
-const executableRelativeUrl = (target: string): string => {
-    const specifier = JSON.stringify(target.replace(LEADING_SLASHES, "./"));
-
-    return `decodeURIComponent(new URL(${specifier}, ${EXECUTABLE_URL_BASE}).pathname)`;
-};
+const URL_QUERY_RE = /\?url(?:&t=\d+)?$/;
 
 const bundleRelativeUrl = (filename: string): string => {
     const specifier = JSON.stringify(`./${filename}`);
@@ -19,36 +17,59 @@ const bundleRelativeUrl = (filename: string): string => {
 const renderAssetUrl = (
     filename: string,
     type: string,
-    assetBase: string | undefined,
 ): { runtime: string } | undefined => {
     if (type !== "asset") {
         return undefined;
     }
 
-    if (assetBase === undefined) {
-        return { runtime: bundleRelativeUrl(filename) };
+    return { runtime: bundleRelativeUrl(filename) };
+};
+
+const configureBuiltUrl = (userConfig: UserConfig, command: string): UserConfig | undefined => {
+    if (command !== "build" || userConfig.experimental?.renderBuiltUrl) {
+        return undefined;
     }
 
-    return { runtime: executableRelativeUrl(posix.join(assetBase, filename)) };
+    return {
+        experimental: {
+            renderBuiltUrl(filename, { type }) {
+                return renderAssetUrl(filename, type);
+            },
+        },
+    };
 };
 
-function gtkxBuiltUrl(assetBase?: string): Plugin {
+const loadDevFileUrl = (ctx: WatchContext, state: PluginState, id: string): string | undefined => {
+    if (state.isBuild || !URL_QUERY_RE.test(id)) {
+        return undefined;
+    }
+
+    const file = stripQuery(id);
+
+    if (!isAbsolute(file) || !existsSync(file)) {
+        return undefined;
+    }
+
+    ctx.addWatchFile(file);
+
+    return `export default ${JSON.stringify(file)};`;
+};
+
+function gtkxBuiltUrl(): Plugin {
+    const state: PluginState = { isBuild: false };
+
     return {
         name: "gtkx:built-url",
-        apply: "build",
-
-        config(userConfig) {
-            if (userConfig.experimental?.renderBuiltUrl) {
-                return;
-            }
-
-            return {
-                experimental: {
-                    renderBuiltUrl(filename, { type }) {
-                        return renderAssetUrl(filename, type, assetBase);
-                    },
-                },
-            };
+        enforce: "pre",
+
+        config: (userConfig, { command }) => configureBuiltUrl(userConfig, command),
+
+        configResolved(config) {
+            state.isBuild = config.command === "build";
+        },
+
+        load(id) {
+            return loadDevFileUrl(this, state, id);
         },
     };
 }

package/src/vite-plugins/i18n.ts

@@ -0,0 +1,146 @@
+import type { ConfigLoader } from "@gtkx/config";
+import type { Plugin, ResolvedConfig } from "vite";
+import { createConfigLoader } from "@gtkx/config/internal";
+import { existsSync, mkdirSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join, posix, relative, resolve } from "node:path";
+import {
+    type CatalogProject,
+    compileCatalogs,
+    LOCALE_DIRNAME,
+    resolveCatalogProject,
+    synchronizeCatalogs,
+} from "../i18n/catalogs.js";
+import { extractSourceCatalog } from "../i18n/source-messages.js";
+import { discoverSourceFiles } from "../internal/source-imports.js";
+import { stripQuery } from "./strip-query.js";
+
+type I18nState = {
+    entryPath: string;
+    i18nRoot: string;
+    outDir: string;
+    project: CatalogProject | null;
+};
+
+const BOOTSTRAP_SPECIFIER = "@gtkx/i18n/bootstrap";
+const LOCALE_URL_PLACEHOLDER = "__GTKX_BUNDLE_LOCALE_DIR__";
+const LOCALE_MODULE_PATHS = new Set(["dist/locale.js", "src/locale.ts"]);
+const LOCALE_URL_PATTERN = /new URL\((["'])locale\1,\s*import\.meta\.url\)/;
+
+const isI18nLocaleModule = (state: I18nState, id: string): boolean => {
+    if (state.i18nRoot.length === 0) {
+        return false;
+    }
+
+    const path = relative(state.i18nRoot, stripQuery(id)).replaceAll("\\", "/");
+
+    return LOCALE_MODULE_PATHS.has(path);
+};
+
+const markLocaleUrl = (code: string): string =>
+    code.replace(
+        LOCALE_URL_PATTERN,
+        () => `new URL(${JSON.stringify(LOCALE_URL_PLACEHOLDER)}, import.meta.url)`,
+    );
+
+const localeUrlForChunk = (fileName: string): string => {
+    const path = posix.relative(posix.dirname(fileName), LOCALE_DIRNAME);
+
+    return path.length === 0 ? "." : path;
+};
+
+const rebaseLocaleUrl = (state: I18nState, code: string, fileName: string, moduleIds: string[]): string | null => {
+    if (moduleIds.every((id) => !isI18nLocaleModule(state, id))) {
+        return null;
+    }
+
+    const placeholder = JSON.stringify(LOCALE_URL_PLACEHOLDER);
+
+    if (!code.includes(placeholder)) {
+        throw new Error(`Unable to locate the @gtkx/i18n locale fallback in ${fileName}`);
+    }
+
+    return code.replace(placeholder, () => JSON.stringify(localeUrlForChunk(fileName)));
+};
+
+const applyResolvedConfig = async (
+    state: I18nState,
+    config: ResolvedConfig,
+    loadConfig: ConfigLoader,
+): Promise<void> => {
+    state.entryPath = resolve(config.root, state.entryPath);
+    state.outDir = resolve(config.root, config.build.outDir);
+    const application = await loadConfig.resolve(config.root);
+    state.project = resolveCatalogProject(config.root, application.applicationId);
+
+    if (state.project !== null) {
+        const projectRequire = createRequire(resolve(config.root, "package.json"));
+        state.i18nRoot = dirname(projectRequire.resolve("@gtkx/i18n/package.json"));
+    }
+};
+
+const buildCatalogs = (state: I18nState): void => {
+    const project = state.project;
+
+    if (project === null) {
+        return;
+    }
+
+    mkdirSync(state.outDir, { recursive: true });
+    compileCatalogs(project, resolve(state.outDir, LOCALE_DIRNAME));
+};
+
+const extractProjectMessages = async (
+    state: I18nState,
+    shouldPreserveMetadataMessages: boolean,
+): Promise<void> => {
+    const project = state.project;
+
+    if (project === null) {
+        return;
+    }
+
+    const srcDir = join(project.root, "src");
+    const sourceFiles = discoverSourceFiles(existsSync(srcDir) ? srcDir : project.root);
+    await extractSourceCatalog(project, sourceFiles, shouldPreserveMetadataMessages);
+    synchronizeCatalogs(project);
+};
+
+const gtkxI18n = (
+    entryPath: string,
+    loadConfig: ConfigLoader = createConfigLoader(),
+    shouldPreserveMetadataMessages = true,
+): Plugin => {
+    const state: I18nState = { entryPath, i18nRoot: "", outDir: "", project: null };
+
+    return {
+        name: "gtkx:i18n",
+        enforce: "pre",
+
+        configResolved: (config) => applyResolvedConfig(state, config, loadConfig),
+
+        buildStart: () => extractProjectMessages(state, shouldPreserveMetadataMessages),
+
+        transform(code, id) {
+            if (isI18nLocaleModule(state, id)) {
+                return markLocaleUrl(code);
+            }
+
+            if (state.project === null || resolve(stripQuery(id)) !== state.entryPath) {
+                return;
+            }
+
+            return `import ${JSON.stringify(BOOTSTRAP_SPECIFIER)};\n${code}`;
+        },
+
+        renderChunk(code, chunk) {
+            return rebaseLocaleUrl(state, code, chunk.fileName, chunk.moduleIds);
+        },
+
+        generateBundle() {
+            buildCatalogs(state);
+        },
+    };
+};
+
+export { gtkxI18n };

package/src/vite-plugins/icons.ts

@@ -1,14 +1,21 @@
+import type { ConfigLoader } from "@gtkx/config";
 import type { Plugin, UserConfig } from "vite";
+import { createConfigLoader } from "@gtkx/config/internal";
 import { info } from "@gtkx/utils";
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
 import type { AssetEmitter } from "./asset-emitter.js";
 import { prependBanner } from "../internal/banner.js";
-import { resolveDataDir } from "../internal/data-dir.js";
+import {
+    relativeIconPath,
+    resolveApplicationIcon,
+    type ResolvedApplicationIcon,
+} from "../internal/icon-path.js";
 import { type ListedFile, listFilesRecursive } from "../internal/list-files.js";
 
 type PluginState = {
-    iconsDir: string | null;
+    applicationId: string;
+    source: ResolvedApplicationIcon;
 };
 
 const ICONS_DIR = "icons";
@@ -20,14 +27,25 @@ const XDG_ENV_BANNER = [
     "].join(\":\");",
 ].join("\n");
 
-const findIconFiles = (iconsDir: string | null): ListedFile[] =>
-    iconsDir === null ? [] : listFilesRecursive(iconsDir);
+const findIconFiles = (state: PluginState): ListedFile[] => {
+    if (state.source.kind === "theme") {
+        return listFilesRecursive(state.source.path);
+    }
+
+    if (state.source.kind === "none") {
+        return [];
+    }
 
-const resolveIconsDir = (config: UserConfig): string | null => {
-    const root = config.root ?? process.cwd();
-    const dataDir = resolveDataDir(root);
+    return [{
+        absPath: state.source.path,
+        rel: relativeIconPath(state.applicationId, state.source.path),
+    }];
+};
 
-    return dataDir === null ? null : join(root, dataDir, ICONS_DIR);
+const applyUserConfig = async (state: PluginState, config: UserConfig, loadConfig: ConfigLoader): Promise<void> => {
+    const { config: gtkxConfig, root } = await loadConfig.load(config.root ?? process.cwd());
+    state.applicationId = gtkxConfig.applicationId;
+    state.source = resolveApplicationIcon(root, gtkxConfig.applicationId, gtkxConfig.applicationIcon);
 };
 
 const emitIcons = (ctx: AssetEmitter, icons: ListedFile[]): void => {
@@ -40,9 +58,10 @@ const emitIcons = (ctx: AssetEmitter, icons: ListedFile[]): void => {
     }
 };
 
-function gtkxIcons(): Plugin {
+function gtkxIcons(loadConfig: ConfigLoader = createConfigLoader()): Plugin {
     const state: PluginState = {
-        iconsDir: null,
+        applicationId: "",
+        source: { kind: "none" },
     };
 
     return {
@@ -50,12 +69,12 @@ function gtkxIcons(): Plugin {
         enforce: "pre",
         apply: "build",
 
-        config(config: UserConfig) {
-            state.iconsDir = resolveIconsDir(config);
+        async config(config: UserConfig) {
+            await applyUserConfig(state, config, loadConfig);
         },
 
         outputOptions(options) {
-            if (findIconFiles(state.iconsDir).length === 0) {
+            if (findIconFiles(state).length === 0) {
                 return;
             }
 
@@ -63,7 +82,7 @@ function gtkxIcons(): Plugin {
         },
 
         buildEnd() {
-            emitIcons(this, findIconFiles(state.iconsDir));
+            emitIcons(this, findIconFiles(state));
         },
     };
 }

package/src/vite-plugins/index.ts

@@ -1,8 +1,11 @@
 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 { gtkxAssetImports } from "./asset-imports.js";
+import { gtkxBuiltUrl } from "./built-url.js";
 import { gtkxCss } from "./css.js";
+import { gtkxI18n } from "./i18n.js";
 import { gtkxIcons } from "./icons.js";
 import { gtkxReactCompiler } from "./react-compiler.js";
 import { gtkxResources } from "./resources.js";
@@ -10,17 +13,24 @@ import { gtkxSettings } from "./settings.js";
 import { gtkxStoreLinks } from "./store-links.js";
 import { gtkxUndeclaredLibrary } from "./undeclared-library.js";
 
-const gtkxVitePlugins = (mode?: string): Plugin[] => {
+const gtkxVitePlugins = (
+    mode?: string,
+    entryPath?: string,
+    buildManifest?: BuildManifestCollector,
+    shouldPreserveI18nMetadata = true,
+): Plugin[] => {
     const loadConfig = createConfigLoader(mode === undefined ? {} : { mode });
 
     return [
         createConfigPlugin({ name: "gtkx:config", loadConfig }),
+        ...(entryPath === undefined ? [] : [gtkxI18n(entryPath, loadConfig, shouldPreserveI18nMetadata)]),
         gtkxStoreLinks(),
         gtkxUndeclaredLibrary(loadConfig),
-        gtkxSettings(),
-        gtkxIcons(),
-        gtkxAssetImports(),
-        gtkxResources(loadConfig),
+        gtkxSettings(loadConfig, buildManifest),
+        gtkxIcons(loadConfig),
+        gtkxAssetImports(loadConfig),
+        gtkxBuiltUrl(),
+        gtkxResources(loadConfig, entryPath),
         gtkxCss(),
         gtkxReactCompiler(loadConfig),
     ];

package/src/vite-plugins/native.ts

@@ -6,6 +6,7 @@ import { dirname, join } from "node:path";
 import { stripQuery } from "./strip-query.js";
 
 const EMITTED_BINDING_SPECIFIER = "./gtkx.node";
+const BINDING_FILENAME = "gtkx.node";
 
 function resolveBinaryPath(projectRequire: ReturnType<typeof createRequire>, currentArch: string): string {
     const nativeRoot = dirname(projectRequire.resolve("@gtkx/native/package.json"));
@@ -30,7 +31,7 @@ function resolvePlatformBinary(projectRequire: ReturnType<typeof createRequire>)
     return readFileSync(resolveBinaryPath(projectRequire, currentArch));
 }
 
-function rewriteLoader(code: string): string {
+function rewriteLoader(code: string, bindingReferenceId: string): string {
     const idents: string[] = [];
 
     for (const match of code.matchAll(/export\s*\{\s*([A-Za-z0-9_$]+)\s*\}/g)) {
@@ -45,15 +46,37 @@ function rewriteLoader(code: string): string {
 
     return [
         "import { createRequire as __gtkxCreateRequire } from \"node:module\";",
-        `const __gtkxNative = __gtkxCreateRequire(import.meta.url)(${JSON.stringify(EMITTED_BINDING_SPECIFIER)});`,
+        "import { fileURLToPath as __gtkxFileURLToPath } from \"node:url\";",
+        `const __gtkxNativeLocation = import.meta.ROLLUP_FILE_URL_${bindingReferenceId};`,
+        "const __gtkxNativePath = __gtkxNativeLocation.startsWith(\"file:\") " +
+        "? __gtkxFileURLToPath(__gtkxNativeLocation) : __gtkxNativeLocation;",
+        "const __gtkxNative = __gtkxCreateRequire(import.meta.url)(__gtkxNativePath);",
         `const { ${bindings} } = __gtkxNative;`,
         `export { ${bindings} };`,
     ].join("\n");
 }
 
+const transformLoader = (
+    code: string,
+    id: string,
+    loaderPath: string,
+    bindingReferenceId: string | null,
+): string | null => {
+    if (stripQuery(id) !== loaderPath) {
+        return null;
+    }
+
+    if (bindingReferenceId === null) {
+        throw new Error("Cannot render the native loader before its binary has been emitted");
+    }
+
+    return rewriteLoader(code, bindingReferenceId);
+};
+
 function gtkxNative(root: string): Plugin {
     const projectRequire = createRequire(join(root, "package.json"));
     let cachedLoaderPath: string | undefined;
+    let bindingReferenceId: string | null = null;
 
     const loaderPath = (): string => {
         cachedLoaderPath ??= join(dirname(projectRequire.resolve("@gtkx/native/package.json")), "index.js");
@@ -67,7 +90,11 @@ function gtkxNative(root: string): Plugin {
         apply: "build",
 
         buildStart() {
-            this.emitFile({ type: "asset", fileName: "gtkx.node", source: resolvePlatformBinary(projectRequire) });
+            bindingReferenceId = this.emitFile({
+                type: "asset",
+                fileName: BINDING_FILENAME,
+                source: resolvePlatformBinary(projectRequire),
+            });
         },
 
         resolveId(id) {
@@ -75,7 +102,7 @@ function gtkxNative(root: string): Plugin {
         },
 
         transform(code, id) {
-            return stripQuery(id) === loaderPath() ? rewriteLoader(code) : null;
+            return transformLoader(code, id, loaderPath(), bindingReferenceId);
         },
     };
 }