@ecopages/core 0.2.0-beta.4 → 0.2.0-beta.40

package/src/build/rolldown-dev-build-adapter.js

@@ -1,166 +0,0 @@
-import { createRequire } from "node:module";
-import path from "node:path";
-import { dev } from "rolldown/experimental";
-import {
-  buildResultFromRolldownOutput,
-  resolveRolldownOptions,
-  rewriteBrowserRuntimeImportsInOutputs,
-  toBuildLogs,
-  transpileProfileToOptions
-} from "./rolldown-adapter-helpers.js";
-const moduleRequire = createRequire(import.meta.url);
-class RolldownDevBuildAdapter {
-  /**
-   * `'rolldown-dev'` (not `'rolldown'`) so {@link getBuildAdapterOwnership}
-   * round-trips correctly and `createBuildAdapter({ ownership })` can
-   * re-select this class.
-   */
-  ownership = "rolldown-dev";
-  cachedEngine;
-  engineInstanceCount = 0;
-  pendingBuilds = [];
-  appRootRequireCache = /* @__PURE__ */ new Map();
-  /**
-   * Stable key over the inputs that affect the engine configuration.
-   * Plugin order is intentionally not part of the key: two plugin
-   * sets with the same names are interchangeable for caching.
-   */
-  getCacheKey(plugins, contextRoot, target, format) {
-    const pluginNames = plugins.map((p) => p.name).join(":");
-    return `${contextRoot}::${pluginNames}::${target ?? "default"}::${format ?? "esm"}`;
-  }
-  /**
-   * Returns the cached engine, creating a new one when the cache
-   * key changes. On a cache miss the prior engine is closed and
-   * {@link engineInstanceCount} is incremented.
-   */
-  async getOrCreateEngine(options, contextRoot) {
-    const bundlePlugins = options.plugins ?? [];
-    const cacheKey = this.getCacheKey(bundlePlugins, contextRoot, options.target, options.format);
-    if (this.cachedEngine) {
-      const existingKey = this.getCacheKey(
-        this.cachedEngine.bundlePlugins,
-        this.cachedEngine.contextRoot,
-        options.target,
-        options.format
-      );
-      if (existingKey === cacheKey) {
-        return this.cachedEngine;
-      }
-      await this.cachedEngine.engine.close();
-      this.cachedEngine = void 0;
-    }
-    const outdir = path.resolve(options.outdir ?? "dist/assets");
-    const { inputOptions, outputOptions } = resolveRolldownOptions(
-      options,
-      contextRoot,
-      outdir,
-      this.appRootRequireCache
-    );
-    const engine = await dev(inputOptions, outputOptions, {
-      rebuildStrategy: "never",
-      onOutput: (result) => {
-        if (result instanceof Error) {
-          return;
-        }
-        const next = this.pendingBuilds.shift();
-        if (next) {
-          next.resolve(result);
-        }
-      }
-    });
-    this.cachedEngine = {
-      engine,
-      engineStarted: false,
-      contextRoot,
-      bundlePlugins
-    };
-    this.engineInstanceCount += 1;
-    return this.cachedEngine;
-  }
-  /**
-   * Triggers a build on the cached engine and returns the next
-   * `RolldownOutput` delivered to `onOutput`.
-   *
-   * First call after engine creation invokes `engine.run`; subsequent
-   * calls invoke `engine.triggerFullBuild` and reuse the cached
-   * module graph, resolver, and transform caches.
-   *
-   * If the trigger itself throws, the queued build is removed so
-   * the next `build()` does not consume a stale slot.
-   */
-  async runBuild(cached) {
-    const outputPromise = new Promise((resolve, reject) => {
-      this.pendingBuilds.push({ resolve, reject });
-    });
-    try {
-      if (!cached.engineStarted) {
-        cached.engineStarted = true;
-        await cached.engine.run();
-      } else {
-        cached.engine.triggerFullBuild();
-      }
-    } catch (error) {
-      this.pendingBuilds.shift();
-      throw error;
-    }
-    return outputPromise;
-  }
-  /** Throws on error; see {@link build} for the no-throw variant. */
-  async buildOrThrow(options) {
-    const contextRoot = options.root ? path.resolve(options.root) : process.cwd();
-    const outdir = path.resolve(options.outdir ?? "dist/assets");
-    const plugins = options.plugins ?? [];
-    const cached = await this.getOrCreateEngine(options, contextRoot);
-    const output = await this.runBuild(cached);
-    const baseResult = buildResultFromRolldownOutput(output, outdir, contextRoot);
-    return rewriteBrowserRuntimeImportsInOutputs(baseResult, contextRoot, plugins);
-  }
-  async build(options) {
-    try {
-      return await this.buildOrThrow(options);
-    } catch (error) {
-      return {
-        success: false,
-        logs: toBuildLogs(error),
-        outputs: []
-      };
-    }
-  }
-  resolve(importPath, rootDir) {
-    return moduleRequire.resolve(importPath, { paths: [rootDir] });
-  }
-  getTranspileOptions(profile) {
-    return transpileProfileToOptions(profile);
-  }
-  /**
-   * Closes the cached DevEngine and rejects any in-flight builds
-   * with `'DevBuildAdapter closed'`.
-   *
-   * @remarks
-   * Not on the {@link BuildAdapter} interface, so it is only
-   * reachable through the concrete class. The adapter is meant to
-   * live for the process lifetime; this is for explicit teardown.
-   */
-  async close() {
-    if (this.cachedEngine) {
-      await this.cachedEngine.engine.close();
-      this.cachedEngine = void 0;
-    }
-    while (this.pendingBuilds.length > 0) {
-      const pending = this.pendingBuilds.shift();
-      pending?.reject(new Error("DevBuildAdapter closed"));
-    }
-  }
-  /** Test-only: number of engines created over the adapter's lifetime. */
-  getEngineInstanceCountForTests() {
-    return this.engineInstanceCount;
-  }
-}
-function createRolldownDevBuildAdapter() {
-  return new RolldownDevBuildAdapter();
-}
-export {
-  RolldownDevBuildAdapter,
-  createRolldownDevBuildAdapter
-};

package/src/build/rolldown-plugin-bridge.js

@@ -1,199 +0,0 @@
-import path from "node:path";
-import { escapeRegExp } from "./browser-runtime-plugin-helpers.js";
-const NAMESPACE_SEPARATOR = ":";
-function joinNamespace(namespace, value) {
-  return namespace ? `${namespace}${NAMESPACE_SEPARATOR}${value}` : value;
-}
-function splitNamespace(id) {
-  const separatorIndex = id.indexOf(NAMESPACE_SEPARATOR);
-  if (separatorIndex <= 0) {
-    return { namespace: void 0, path: id };
-  }
-  return {
-    namespace: id.slice(0, separatorIndex),
-    path: id.slice(separatorIndex + 1)
-  };
-}
-function inferRolldownModuleTypeFromPath(filePath) {
-  const extension = path.extname(filePath).toLowerCase();
-  switch (extension) {
-    case ".ts":
-      return "ts";
-    case ".tsx":
-      return "tsx";
-    case ".jsx":
-      return "jsx";
-    case ".json":
-      return "json";
-    case ".css":
-      return "css";
-    default:
-      return "js";
-  }
-}
-function normalizeRolldownModuleType(loader) {
-  switch (loader) {
-    case "js":
-    case "jsx":
-    case "ts":
-    case "tsx":
-    case "json":
-    case "css":
-    case "text":
-    case "base64":
-    case "dataurl":
-    case "binary":
-    case "empty":
-      return loader;
-    case "global-css":
-    case "local-css":
-      return "css";
-    case "file":
-    case "copy":
-      return "asset";
-    default:
-      return void 0;
-  }
-}
-function convertLoadResultToModuleSource(result) {
-  if (result.loader === "object" && result.exports && typeof result.exports === "object") {
-    return Object.entries(result.exports).map(
-      ([key, value]) => key === "default" ? `export default ${JSON.stringify(value)};` : `export const ${key} = ${JSON.stringify(value)};`
-    ).join("\n");
-  }
-  return void 0;
-}
-function buildIdFilter(filter, namespace) {
-  if (!namespace) {
-    return filter;
-  }
-  return new RegExp(`^${escapeRegExp(namespace)}${NAMESPACE_SEPARATOR}${filter.source.slice(1)}`);
-}
-function resolvePluginPath(value, importer, contextRoot) {
-  if (path.isAbsolute(value)) {
-    return value;
-  }
-  if (value.startsWith(".") || value.startsWith("..")) {
-    const baseDir = importer ? path.dirname(importer) : contextRoot;
-    return path.resolve(baseDir, value);
-  }
-  return value;
-}
-function convertPluginOnLoadResult(args, result) {
-  if (!result || typeof result !== "object") {
-    return void 0;
-  }
-  const candidate = result;
-  const { path: sourcePath } = splitNamespace(args.id);
-  const sourceFromExports = convertLoadResultToModuleSource(candidate);
-  if (sourceFromExports) {
-    const description = {
-      code: sourceFromExports,
-      moduleType: "js"
-    };
-    return description;
-  }
-  if (typeof candidate.contents === "string" || candidate.contents instanceof Uint8Array) {
-    const code = typeof candidate.contents === "string" ? candidate.contents : new TextDecoder().decode(candidate.contents);
-    const description = {
-      code,
-      moduleType: normalizeRolldownModuleType(candidate.loader) ?? inferRolldownModuleTypeFromPath(sourcePath)
-    };
-    return description;
-  }
-  return void 0;
-}
-function convertPluginOnResolveResult(result, importer, contextRoot) {
-  if (!result || typeof result !== "object") {
-    return void 0;
-  }
-  const candidate = result;
-  if (typeof candidate.path !== "string" && typeof candidate.namespace !== "string") {
-    if (typeof candidate.external !== "boolean") {
-      return void 0;
-    }
-  }
-  const partial = { id: "" };
-  if (typeof candidate.path === "string") {
-    partial.id = joinNamespace(candidate.namespace, resolvePluginPath(candidate.path, importer, contextRoot));
-  } else if (typeof candidate.namespace === "string") {
-    partial.id = joinNamespace(candidate.namespace, "");
-  }
-  if (typeof candidate.external === "boolean") {
-    partial.external = candidate.external;
-  }
-  return partial;
-}
-function createRolldownPluginBridge(plugins, contextRoot) {
-  if (plugins.length === 0) {
-    return [];
-  }
-  const moduleCounter = { value: 0 };
-  const resolveRegistrations = [];
-  const loadRegistrations = [];
-  const registerResolve = (filter, callback) => {
-    resolveRegistrations.push({ filter, callback });
-  };
-  const registerLoad = (filter, callback) => {
-    loadRegistrations.push({ filter, callback });
-  };
-  const resolveIdHandler = async (source, importer, _extraOptions) => {
-    for (const { filter, callback } of resolveRegistrations) {
-      if (!filter.test(source)) {
-        continue;
-      }
-      const { namespace, path: sourcePath } = splitNamespace(source);
-      const result = await callback({ path: sourcePath, importer, namespace });
-      const converted = convertPluginOnResolveResult(result, importer, contextRoot);
-      if (converted !== void 0) {
-        return converted;
-      }
-    }
-    return void 0;
-  };
-  const loadHandler = async (id) => {
-    for (const { filter, callback } of loadRegistrations) {
-      if (!filter.test(id)) {
-        continue;
-      }
-      const { namespace, path: sourcePath } = splitNamespace(id);
-      const result = await callback({ path: sourcePath, namespace });
-      const converted = convertPluginOnLoadResult({ id }, result);
-      if (converted !== void 0) {
-        return converted;
-      }
-    }
-    return void 0;
-  };
-  const plugin = {
-    name: "ecopages-plugin-bridge",
-    buildStart: async () => {
-      for (const ecoPlugin of plugins) {
-        const bridge = {
-          onResolve: (options, callback) => {
-            registerResolve(buildIdFilter(options.filter, options.namespace), callback);
-          },
-          onLoad: (options, callback) => {
-            registerLoad(buildIdFilter(options.filter, options.namespace), callback);
-          },
-          module: (specifier, callback) => {
-            const namespace = `ecopages-module-${moduleCounter.value}`;
-            moduleCounter.value += 1;
-            const filter = new RegExp(`^${escapeRegExp(specifier)}$`);
-            registerResolve(filter, async () => ({
-              path: joinNamespace(namespace, specifier)
-            }));
-            registerLoad(buildIdFilter(/.*/, namespace), async () => callback());
-          }
-        };
-        await ecoPlugin.setup(bridge);
-      }
-    },
-    resolveId: resolveIdHandler,
-    load: loadHandler
-  };
-  return [plugin];
-}
-export {
-  createRolldownPluginBridge
-};

package/src/build/runtime-build-executor.d.ts

@@ -1,21 +0,0 @@
-import type { EcoPagesAppConfig } from '../types/internal-types.js';
-import { type BuildExecutor } from './build-adapter.js';
-/**
- * Installs the app-owned runtime build executor for one app instance.
- *
- * @remarks
- * Wraps the app-owned adapter in a {@link SerializedBuildExecutor} so
- * every dev-watch caller issues builds against a single FIFO queue.
- * Plugin injection is applied here via {@link withBuildExecutorPlugins}
- * so app-owned plugins are merged into every rebuild without callers
- * having to know about the manifest.
- *
- * Idempotent across calls: re-invoking replaces the existing executor
- * on `appConfig.runtime` with a fresh wrapper.
- *
- * @param appConfig - The app config whose runtime state is updated.
- *   The function reads the existing executor (falling back to the
- *   app-owned adapter) and writes the wrapped executor back.
- * @returns The installed {@link BuildExecutor}.
- */
-export declare function installAppRuntimeBuildExecutor(appConfig: EcoPagesAppConfig): BuildExecutor;

package/src/build/runtime-build-executor.js

@@ -1,19 +0,0 @@
-import {
-  getAppBuildAdapter,
-  getAppBuildExecutor,
-  getAppServerBuildPlugins,
-  setAppBuildExecutor,
-  withBuildExecutorPlugins
-} from "./build-adapter.js";
-import { SerializedBuildExecutor } from "./serialized-build-executor.js";
-function installAppRuntimeBuildExecutor(appConfig) {
-  const baseExecutor = getAppBuildExecutor(appConfig) ?? getAppBuildAdapter(appConfig);
-  const buildExecutor = new SerializedBuildExecutor(
-    withBuildExecutorPlugins(baseExecutor, () => getAppServerBuildPlugins(appConfig))
-  );
-  setAppBuildExecutor(appConfig, buildExecutor);
-  return buildExecutor;
-}
-export {
-  installAppRuntimeBuildExecutor
-};

package/src/build/runtime-build-output-normalizer.d.ts

@@ -1,3 +0,0 @@
-export declare function isDeclaredAppPackageImport(specifier: string, rootDir: string): boolean;
-export declare function normalizeNodeRuntimeBuildOutputFile(filePath: string, rootDir: string): void;
-export declare function normalizeNodeRuntimeBuildOutputs(outputPaths: string[], rootDir: string): void;

package/src/build/runtime-build-output-normalizer.js

@@ -1,111 +0,0 @@
-import { createRequire } from "node:module";
-import { readFileSync } from "node:fs";
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-const corePackageRequire = createRequire(new URL("../../package.json", import.meta.url));
-const appDeclaredPackageCache = /* @__PURE__ */ new Map();
-function tryResolveRuntimeImport(specifier, resolver) {
-  try {
-    return resolver.resolve(specifier);
-  } catch {
-    return void 0;
-  }
-}
-function isBareRuntimeImport(specifier) {
-  return !specifier.startsWith(".") && !path.isAbsolute(specifier) && !specifier.startsWith("/") && !specifier.startsWith("node:") && !specifier.startsWith("@/") && !specifier.startsWith("~/") && !specifier.startsWith("#") && !specifier.includes(":");
-}
-function getPackageNameFromSpecifier(specifier) {
-  if (specifier.startsWith("@")) {
-    return specifier.split("/").slice(0, 2).join("/");
-  }
-  return specifier.split("/")[0] ?? specifier;
-}
-function getDeclaredAppPackages(rootDir) {
-  const cacheKey = path.resolve(rootDir);
-  const cached = appDeclaredPackageCache.get(cacheKey);
-  if (cached) {
-    return cached;
-  }
-  const packageJsonPath = path.resolve(rootDir, "package.json");
-  const declaredPackages = /* @__PURE__ */ new Set();
-  try {
-    const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
-    for (const field of ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"]) {
-      const entries = packageJson[field];
-      if (!entries || typeof entries !== "object") {
-        continue;
-      }
-      for (const packageName of Object.keys(entries)) {
-        declaredPackages.add(packageName);
-      }
-    }
-  } catch {
-    appDeclaredPackageCache.set(cacheKey, declaredPackages);
-    return declaredPackages;
-  }
-  appDeclaredPackageCache.set(cacheKey, declaredPackages);
-  return declaredPackages;
-}
-function isDeclaredAppPackageImport(specifier, rootDir) {
-  return getDeclaredAppPackages(rootDir).has(getPackageNameFromSpecifier(specifier));
-}
-function rewriteRuntimeImportSpecifier(specifier, quote, rootDir) {
-  if (!isBareRuntimeImport(specifier)) {
-    return void 0;
-  }
-  if (isDeclaredAppPackageImport(specifier, rootDir)) {
-    return void 0;
-  }
-  const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
-  if (!resolvedPath || !/\.(?:[cm]?[jt]s|tsx|jsx)$/u.test(resolvedPath)) {
-    return void 0;
-  }
-  return `${quote}${pathToFileURL(resolvedPath).href}${quote}`;
-}
-function rewriteRuntimeBuildOutputImports(code, rootDir) {
-  const rewriteSpecifier = (prefix, quote, specifier) => {
-    const rewrittenSpecifier = rewriteRuntimeImportSpecifier(specifier, quote, rootDir);
-    return `${prefix}${rewrittenSpecifier ?? `${quote}${specifier}${quote}`}`;
-  };
-  const withResolvedPackages = code.replace(
-    /(\bfrom\s+)(['"])([^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
-  ).replace(
-    /(\bimport\s+)(['"])([^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
-  ).replace(
-    /(\bimport\s*\(\s*)(['"])([^'"\\]+)\2/g,
-    (_match, prefix, quote, specifier) => rewriteSpecifier(prefix, quote, specifier)
-  );
-  return withResolvedPackages.replace(
-    /(['"])(@oxc-project\/runtime\/(?:helpers(?:\/esm)?\/[^'"\\]+))\1/g,
-    (match, quote, specifier) => {
-      const resolvedPath = tryResolveRuntimeImport(specifier, corePackageRequire);
-      return resolvedPath ? `${quote}${pathToFileURL(resolvedPath).href}${quote}` : match;
-    }
-  );
-}
-function normalizeNodeRuntimeBuildOutputFile(filePath, rootDir) {
-  if (!/\.(?:[cm]?js)$/u.test(filePath)) {
-    return;
-  }
-  const fileSystem = corePackageRequire("node:fs");
-  if (!fileSystem.existsSync(filePath)) {
-    return;
-  }
-  const code = fileSystem.readFileSync(filePath, "utf-8");
-  const rewritten = rewriteRuntimeBuildOutputImports(code, rootDir);
-  if (rewritten !== code) {
-    fileSystem.writeFileSync(filePath, rewritten);
-  }
-}
-function normalizeNodeRuntimeBuildOutputs(outputPaths, rootDir) {
-  for (const outputPath of outputPaths) {
-    normalizeNodeRuntimeBuildOutputFile(outputPath, rootDir);
-  }
-}
-export {
-  isDeclaredAppPackageImport,
-  normalizeNodeRuntimeBuildOutputFile,
-  normalizeNodeRuntimeBuildOutputs
-};

package/src/build/serialized-build-executor.js

@@ -1,63 +0,0 @@
-class SerializedBuildExecutor {
-  inner;
-  tail = Promise.resolve();
-  constructor(inner) {
-    this.inner = inner;
-  }
-  /**
-   * Run a build through the serialized queue. The returned promise
-   * resolves with the inner executor's `BuildResult`. A rejected
-   * inner build does not block the queue — the next caller can
-   * proceed.
-   */
-  build(options) {
-    return this.run(() => this.inner.build(options));
-  }
-  /**
-   * Run an arbitrary async operation through the serialized queue.
-   *
-   * Use this when the work is not a `build()` call against a wrapped
-   * executor (e.g. when composing with a coordinator that needs to
-   * inject recovery around the inner call). The returned promise
-   * resolves with the operation's result. A rejected operation does
-   * not block the queue.
-   */
-  run(operation) {
-    const next = this.tail.catch(() => void 0).then(() => operation());
-    this.tail = next.catch(() => void 0);
-    return next;
-  }
-  /**
-   * Returns the wrapped executor. Tests use this to assert the
-   * delegation chain.
-   */
-  unwrap() {
-    return this.inner;
-  }
-  /**
-   * Reset the queue to an empty state. Tests use this to recover
-   * from a poisoned tail.
-   */
-  resetForTests() {
-    this.tail = Promise.resolve();
-  }
-  /**
-   * Overrides the internal queue tail for fault-recovery tests. The
-   * supplied promise is awaited before the next enqueued operation
-   * starts.
-   */
-  setBuildQueueForTests(queue) {
-    this.tail = queue;
-  }
-  /**
-   * Returns the current internal queue tail for fault-recovery
-   * tests. Tests await this to assert that recovery has cleared a
-   * wedged queue.
-   */
-  getBuildQueueForTests() {
-    return this.tail;
-  }
-}
-export {
-  SerializedBuildExecutor
-};

package/src/build/server-side-css-shim-plugin.js

@@ -1,35 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-const CSS_PATH = /\.css$/u;
-const CSS_QUERY = "?ecopages-css-shim";
-function stripShimQuery(id) {
-  const queryIndex = id.indexOf("?");
-  return queryIndex === -1 ? id : id.slice(0, queryIndex);
-}
-function createServerSideCssShimPlugin() {
-  return {
-    name: "ecopages:server-side-css-shim",
-    async resolveId(source, importer) {
-      if (!CSS_PATH.test(source)) {
-        return null;
-      }
-      const resolved = importer ? path.resolve(path.dirname(importer), source) : path.resolve(source);
-      return existsSync(resolved) ? `${resolved}${CSS_QUERY}` : null;
-    },
-    async load(id) {
-      if (!id.endsWith(CSS_QUERY)) {
-        return null;
-      }
-      const realPath = stripShimQuery(id);
-      readFileSync(realPath, "utf-8");
-      return {
-        code: 'export default "";',
-        moduleType: "js",
-        moduleSideEffects: true
-      };
-    }
-  };
-}
-export {
-  createServerSideCssShimPlugin
-};

package/src/hmr/hmr.postcss.test.e2e.js

@@ -1,31 +0,0 @@
-import { test, expect } from "@playwright/test";
-import { readFileSync } from "node:fs";
-import { writeFile } from "node:fs/promises";
-import { resolve } from "node:path";
-const FIXTURE_DIR = resolve(process.cwd(), "packages/core/__fixtures__/app");
-const TEST_CSS_FILE = resolve(FIXTURE_DIR, "src/pages/postcss-hmr.css");
-test.describe("HMR E2E PostCSS", () => {
-  test("should hot-update processor-owned CSS without a full page reload", async ({ page }) => {
-    const originalCss = readFileSync(TEST_CSS_FILE, "utf-8");
-    const title = page.locator(".postcss-title").first();
-    try {
-      await page.goto("/postcss-hmr", { waitUntil: "networkidle" });
-      await expect(title).toBeVisible();
-      const initialColor = await title.evaluate((el) => getComputedStyle(el).color);
-      expect(initialColor).toBeTruthy();
-      await page.evaluate(() => {
-        window.__postcssReloadProbe = "before-change";
-      });
-      const modifiedCss = originalCss.replace(".postcss-title {", ".postcss-title {\n	color: rgb(255, 0, 0);");
-      await writeFile(TEST_CSS_FILE, modifiedCss, { flush: true });
-      await expect.poll(async () => title.evaluate((el) => getComputedStyle(el).color), { timeout: 1e4 }).toBe("rgb(255, 0, 0)");
-      await expect(
-        page.evaluate(
-          () => window.__postcssReloadProbe ?? null
-        )
-      ).resolves.toBe("before-change");
-    } finally {
-      await writeFile(TEST_CSS_FILE, originalCss, { flush: true });
-    }
-  });
-});