@acmekit/admin-vite-plugin 2.13.1

package/dist/index.js

@@ -0,0 +1,2194 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => index_default
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/plugin.ts
+var import_promises11 = require("fs/promises");
+var import_node_path = __toESM(require("path"));
+
+// src/custom-fields/generate-custom-field-displays.ts
+var import_admin_shared2 = require("@acmekit/admin-shared");
+var import_promises = __toESM(require("fs/promises"));
+
+// src/babel.ts
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"));
+var import_types = require("@babel/types");
+var traverse;
+if (typeof import_traverse.default === "function") {
+  traverse = import_traverse.default;
+} else {
+  traverse = import_traverse.default.default;
+}
+
+// src/logger.ts
+var import_picocolors = __toESM(require("picocolors"));
+function getTimestamp() {
+  const now = /* @__PURE__ */ new Date();
+  return now.toLocaleTimeString("en-US", { hour12: true });
+}
+function getPrefix(type) {
+  const timestamp = import_picocolors.default.dim(getTimestamp());
+  const typeColor = type === "warn" ? import_picocolors.default.yellow : type === "info" ? import_picocolors.default.green : import_picocolors.default.red;
+  const prefix = typeColor("[@acmekit/admin-vite-plugin]");
+  return `${timestamp} ${prefix}`;
+}
+function getFile(options) {
+  if (!options.file) {
+    return "";
+  }
+  const value = Array.isArray(options.file) ? options.file.map((f) => f).join(", ") : options.file;
+  return import_picocolors.default.dim(`${value}`);
+}
+function formatError(error) {
+  if (error instanceof Error) {
+    return import_picocolors.default.red(`${error.name}: ${error.message}
+${error.stack}`);
+  } else if (typeof error === "object") {
+    return import_picocolors.default.red(JSON.stringify(error, null, 2));
+  } else {
+    return import_picocolors.default.red(String(error));
+  }
+}
+var logger = {
+  warn(msg, options = {}) {
+    console.warn(`${getPrefix("warn")} ${msg} ${getFile(options)}`);
+  },
+  info(msg, options = {}) {
+    console.info(`${getPrefix("info")} ${msg} ${getFile(options)}`);
+  },
+  error(msg, options = {}) {
+    console.error(`${getPrefix("error")} ${msg} ${getFile(options)}`);
+    if (options.error) {
+      console.error(formatError(options.error));
+    }
+  }
+};
+
+// src/utils.ts
+var import_fdir = require("fdir");
+var import_magic_string = __toESM(require("magic-string"));
+var import_node_crypto = __toESM(require("crypto"));
+var import_path = __toESM(require("path"));
+function normalizePath(file) {
+  return import_path.default.normalize(file).replace(/\\/g, "/");
+}
+function getParserOptions(file) {
+  const options = {
+    sourceType: "module",
+    plugins: ["jsx"]
+  };
+  if (file.endsWith(".tsx")) {
+    options.plugins?.push("typescript");
+  }
+  return options;
+}
+function generateModule(code) {
+  const magicString = new import_magic_string.default(code);
+  return {
+    code: magicString.toString(),
+    map: magicString.generateMap({ hires: true })
+  };
+}
+var VALID_FILE_EXTENSIONS = [".tsx", ".jsx", ".js", ".ts"];
+async function crawl(dir, file, depth) {
+  const dirDepth = dir.split(import_path.default.sep).length;
+  const crawler = new import_fdir.fdir().withBasePath().exclude((dirName) => dirName.startsWith("_")).filter((path3) => {
+    return VALID_FILE_EXTENSIONS.some((ext) => path3.endsWith(ext));
+  });
+  if (file) {
+    crawler.filter((path3) => {
+      return VALID_FILE_EXTENSIONS.some((ext) => path3.endsWith(file + ext));
+    });
+  }
+  if (depth) {
+    crawler.filter((file2) => {
+      const pathDepth = file2.split(import_path.default.sep).length - 1;
+      if (depth.max && pathDepth > dirDepth + depth.max) {
+        return false;
+      }
+      if (pathDepth < dirDepth + depth.min) {
+        return false;
+      }
+      return true;
+    });
+  }
+  return crawler.crawl(dir).withPromise();
+}
+function getConfigObjectProperties(path3) {
+  if ((0, import_types.isVariableDeclarator)(path3.node)) {
+    const configDeclaration = (0, import_types.isIdentifier)(path3.node.id, { name: "config" }) ? path3.node : null;
+    if (configDeclaration && (0, import_types.isCallExpression)(configDeclaration.init) && configDeclaration.init.arguments.length > 0 && (0, import_types.isObjectExpression)(configDeclaration.init.arguments[0])) {
+      return configDeclaration.init.arguments[0].properties;
+    }
+    return null;
+  }
+  const declaration = path3.node.declaration;
+  if ((0, import_types.isVariableDeclaration)(declaration)) {
+    const configDeclaration = declaration.declarations.find(
+      (d) => (0, import_types.isVariableDeclarator)(d) && (0, import_types.isIdentifier)(d.id, { name: "config" })
+    );
+    if (configDeclaration && (0, import_types.isCallExpression)(configDeclaration.init) && configDeclaration.init.arguments.length > 0 && (0, import_types.isObjectExpression)(configDeclaration.init.arguments[0])) {
+      return configDeclaration.init.arguments[0].properties;
+    }
+  }
+  return null;
+}
+async function hasDefaultExport(ast) {
+  let hasDefaultExport2 = false;
+  traverse(ast, {
+    ExportDefaultDeclaration() {
+      hasDefaultExport2 = true;
+    },
+    AssignmentExpression(path3) {
+      if (path3.node.left.type === "MemberExpression" && path3.node.left.object.type === "Identifier" && path3.node.left.object.name === "exports" && path3.node.left.property.type === "Identifier" && path3.node.left.property.name === "default") {
+        hasDefaultExport2 = true;
+      }
+    },
+    ExportNamedDeclaration(path3) {
+      const specifiers = path3.node.specifiers;
+      if (specifiers?.some(
+        (s) => s.type === "ExportSpecifier" && s.exported.type === "Identifier" && s.exported.name === "default"
+      )) {
+        hasDefaultExport2 = true;
+      }
+    }
+  });
+  return hasDefaultExport2;
+}
+function generateHash(content) {
+  return import_node_crypto.default.createHash("md5").update(content).digest("hex");
+}
+function isFileInAdminSubdirectory(file, subdirectory) {
+  const normalizedPath = normalizePath(file);
+  return normalizedPath.includes(`/src/admin/${subdirectory}/`);
+}
+
+// src/custom-fields/helpers.ts
+var import_admin_shared = require("@acmekit/admin-shared");
+function getModel(path3, file) {
+  const configArgument = getConfigArgument(path3);
+  if (!configArgument) {
+    return null;
+  }
+  const modelProperty = configArgument.properties.find(
+    (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "model" })
+  );
+  if (!modelProperty) {
+    return null;
+  }
+  if ((0, import_types.isTemplateLiteral)(modelProperty.value)) {
+    logger.warn(
+      `'model' property cannot be a template literal (e.g. \`product\`).`,
+      { file }
+    );
+    return null;
+  }
+  if (!(0, import_types.isStringLiteral)(modelProperty.value)) {
+    logger.warn(
+      `'model' is invalid. The 'model' property must be a string literal, e.g. 'product' or 'customer'.`,
+      { file }
+    );
+    return null;
+  }
+  const model = modelProperty.value.value.trim();
+  if (!(0, import_admin_shared.isValidCustomFieldModel)(model)) {
+    logger.warn(
+      `'model' is invalid, received: ${model}. The 'model' property must be set to a valid model, e.g. 'product' or 'customer'.`,
+      { file }
+    );
+    return null;
+  }
+  return model;
+}
+function getConfigArgument(path3) {
+  if (!(0, import_types.isCallExpression)(path3.node.declaration)) {
+    return null;
+  }
+  if (!(0, import_types.isIdentifier)(path3.node.declaration.callee, {
+    name: "unstable_defineCustomFieldsConfig"
+  })) {
+    return null;
+  }
+  const configArgument = path3.node.declaration.arguments[0];
+  if (!(0, import_types.isObjectExpression)(configArgument)) {
+    return null;
+  }
+  return configArgument;
+}
+function validateLink(path3, file) {
+  const configArgument = getConfigArgument(path3);
+  if (!configArgument) {
+    return false;
+  }
+  const linkProperty = configArgument.properties.find(
+    (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "link" })
+  );
+  if (!linkProperty) {
+    logger.warn(`'link' property is missing.`, { file });
+    return false;
+  }
+  return true;
+}
+
+// src/custom-fields/generate-custom-field-displays.ts
+async function generateCustomFieldDisplays(sources) {
+  const files = await getFilesFromSources(sources);
+  const results = await getCustomFieldDisplayResults(files);
+  const imports = results.map((result) => result.import).flat();
+  const code = generateDisplayCode(results);
+  return {
+    imports,
+    code
+  };
+}
+async function getFilesFromSources(sources) {
+  const files = (await Promise.all(
+    Array.from(sources).map(
+      async (source) => crawl(`${source}/custom-fields`)
+    )
+  )).flat();
+  return files;
+}
+function generateDisplayCode(results) {
+  const groupedByModel = /* @__PURE__ */ new Map();
+  results.forEach((result) => {
+    const model = result.model;
+    if (!groupedByModel.has(model)) {
+      groupedByModel.set(model, []);
+    }
+    groupedByModel.get(model).push(result);
+  });
+  const segments = [];
+  groupedByModel.forEach((results2, model) => {
+    const displays = results2.map((result) => formatDisplays(result.displays)).filter((display) => display !== "").join(",\n");
+    segments.push(`
+      ${model}: [
+        ${displays}
+      ],
+    `);
+  });
+  return `
+    displays: {
+      ${segments.join("\n")}
+    }
+  `;
+}
+function formatDisplays(displays) {
+  if (!displays || displays.length === 0) {
+    return "";
+  }
+  return displays.map(
+    (display) => `
+        {
+          zone: "${display.zone}",
+          Component: ${display.Component},
+        }
+      `
+  ).join(",\n");
+}
+async function getCustomFieldDisplayResults(files) {
+  return (await Promise.all(
+    files.map(async (file, index) => parseDisplayFile(file, index))
+  )).filter(Boolean);
+}
+async function parseDisplayFile(file, index) {
+  const content = await import_promises.default.readFile(file, "utf8");
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(content, getParserOptions(file));
+  } catch (e) {
+    logger.error(`An error occurred while parsing the file`, { file, error: e });
+    return null;
+  }
+  const import_ = generateImport(file, index);
+  let displays = null;
+  let model = null;
+  let hasLink = false;
+  try {
+    traverse(ast, {
+      ExportDefaultDeclaration(path3) {
+        const _model = getModel(path3, file);
+        if (!_model) {
+          return;
+        }
+        model = _model;
+        displays = getDisplays(path3, model, index, file);
+        hasLink = validateLink(path3, file);
+      }
+    });
+  } catch (err) {
+    logger.error(`An error occurred while traversing the file.`, {
+      file,
+      error: err
+    });
+    return null;
+  }
+  if (!model) {
+    logger.warn(`'model' property is missing.`, { file });
+    return null;
+  }
+  if (!hasLink) {
+    logger.warn(`'link' property is missing.`, { file });
+    return null;
+  }
+  return {
+    import: import_,
+    model,
+    displays
+  };
+}
+function getDisplays(path3, model, index, file) {
+  const configArgument = getConfigArgument(path3);
+  if (!configArgument) {
+    return null;
+  }
+  const displayProperty = configArgument.properties.find(
+    (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "displays" })
+  );
+  if (!displayProperty) {
+    return null;
+  }
+  if (!(0, import_types.isArrayExpression)(displayProperty.value)) {
+    logger.warn(
+      `'displays' is not an array. The 'displays' property must be an array of objects.`,
+      { file }
+    );
+    return null;
+  }
+  const displays = [];
+  displayProperty.value.elements.forEach((element, j) => {
+    if (!(0, import_types.isObjectExpression)(element)) {
+      return;
+    }
+    const zoneProperty = element.properties.find(
+      (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "zone" })
+    );
+    if (!zoneProperty) {
+      logger.warn(
+        `'zone' property is missing at the ${j} index of the 'displays' property.`,
+        { file }
+      );
+      return;
+    }
+    if (!(0, import_types.isStringLiteral)(zoneProperty.value)) {
+      logger.warn(
+        `'zone' property at index ${j} in the 'displays' property is not a string literal. 'zone' must be a string literal, e.g. 'general' or 'attributes'.`,
+        { file }
+      );
+      return;
+    }
+    const zone = zoneProperty.value.value;
+    const fullPath = getDisplayEntryPath(model, zone);
+    if (!(0, import_admin_shared2.isValidCustomFieldDisplayZone)(zone) || !(0, import_admin_shared2.isValidCustomFieldDisplayPath)(fullPath)) {
+      logger.warn(
+        `'zone' is invalid at index ${j} in the 'displays' property. Received: ${zone}.`,
+        { file }
+      );
+      return;
+    }
+    const componentProperty = element.properties.find(
+      (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "component" })
+    );
+    if (!componentProperty) {
+      logger.warn(
+        `'component' property is missing at index ${j} in the 'displays' property.`,
+        { file }
+      );
+      return;
+    }
+    displays.push({
+      zone,
+      Component: getDisplayComponent(index, j)
+    });
+  });
+  return displays.length > 0 ? displays : null;
+}
+function getDisplayEntryPath(model, zone) {
+  return `${model}.${zone}.$display`;
+}
+function getDisplayComponent(fileIndex, displayEntryIndex) {
+  const import_ = generateCustomFieldConfigName(fileIndex);
+  return `${import_}.displays[${displayEntryIndex}].component`;
+}
+function generateCustomFieldConfigName(index) {
+  return `CustomFieldConfig${index}`;
+}
+function generateImport(file, index) {
+  const path3 = normalizePath(file);
+  return `import ${generateCustomFieldConfigName(index)} from "${path3}"`;
+}
+
+// src/custom-fields/generate-custom-field-forms.ts
+var import_admin_shared3 = require("@acmekit/admin-shared");
+var import_promises2 = __toESM(require("fs/promises"));
+var import_outdent = require("outdent");
+async function generateCustomFieldForms(sources) {
+  const files = await getFilesFromSources2(sources);
+  const results = await getCustomFieldResults(files);
+  const imports = results.map((result) => result.import).flat();
+  const code = generateCode(results);
+  return {
+    imports,
+    code
+  };
+}
+async function getFilesFromSources2(sources) {
+  const files = (await Promise.all(
+    Array.from(sources).map(
+      async (source) => crawl(`${source}/custom-fields`)
+    )
+  )).flat();
+  return files;
+}
+function generateCode(results) {
+  const groupedByModel = /* @__PURE__ */ new Map();
+  results.forEach((result) => {
+    const model = result.model;
+    if (!groupedByModel.has(model)) {
+      groupedByModel.set(model, []);
+    }
+    groupedByModel.get(model).push(result);
+  });
+  const segments = [];
+  groupedByModel.forEach((results2, model) => {
+    const configs = results2.map((result) => formatConfig(result.configs)).filter((config) => config !== "").join(",\n");
+    const forms = results2.map((result) => formatForms(result.forms)).filter((form) => form !== "").join(",\n");
+    segments.push(import_outdent.outdent`
+      ${model}: {
+        configs: [
+          ${configs}
+        ],
+        forms: [
+          ${forms}
+        ],
+      }
+    `);
+  });
+  return import_outdent.outdent`
+    customFields: {
+      ${segments.join("\n")}
+    }
+  `;
+}
+function formatConfig(configs) {
+  if (!configs || configs.length === 0) {
+    return "";
+  }
+  return import_outdent.outdent`
+    ${configs.map(
+    (config) => import_outdent.outdent`
+        {
+          zone: "${config.zone}",
+          fields: {
+            ${config.fields.map(
+      (field) => `${field.name}: {
+              defaultValue: ${field.defaultValue},
+              validation: ${field.validation},
+            }`
+    ).join(",\n")}
+          },
+        }
+      `
+  ).join(",\n")}
+  `;
+}
+function formatForms(forms) {
+  if (!forms || forms.length === 0) {
+    return "";
+  }
+  return forms.map(
+    (form) => import_outdent.outdent`
+        {
+          zone: "${form.zone}",
+          tab: ${form.tab === void 0 ? void 0 : `"${form.tab}"`},
+          fields: {
+            ${form.fields.map(
+      (field) => `${field.name}: {
+              validation: ${field.validation},
+              Component: ${field.Component},
+              label: ${field.label},
+              description: ${field.description},
+              placeholder: ${field.placeholder},
+            }`
+    ).join(",\n")}
+          },
+        }
+      `
+  ).join(",\n");
+}
+async function getCustomFieldResults(files) {
+  return (await Promise.all(files.map(async (file, index) => parseFile(file, index)))).filter(Boolean);
+}
+async function parseFile(file, index) {
+  const content = await import_promises2.default.readFile(file, "utf8");
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(content, getParserOptions(file));
+  } catch (e) {
+    logger.error(`An error occurred while parsing the file`, { file, error: e });
+    return null;
+  }
+  const import_ = generateImport2(file, index);
+  let configs = [];
+  let forms = [];
+  let model = null;
+  let hasLink = false;
+  try {
+    traverse(ast, {
+      ExportDefaultDeclaration(path3) {
+        const _model = getModel(path3, file);
+        if (!_model) {
+          return;
+        }
+        model = _model;
+        hasLink = validateLink(path3, file);
+        configs = getConfigs(path3, model, index, file);
+        forms = getForms(path3, model, index, file);
+      }
+    });
+  } catch (err) {
+    logger.error(`An error occurred while traversing the file.`, {
+      file,
+      error: err
+    });
+    return null;
+  }
+  if (!model) {
+    logger.warn(`'model' property is missing.`, { file });
+    return null;
+  }
+  if (!hasLink) {
+    logger.warn(`'link' property is missing.`, { file });
+    return null;
+  }
+  return {
+    import: import_,
+    model,
+    configs,
+    forms
+  };
+}
+function generateCustomFieldConfigName2(index) {
+  return `CustomFieldConfig${index}`;
+}
+function generateImport2(file, index) {
+  const path3 = normalizePath(file);
+  return `import ${generateCustomFieldConfigName2(index)} from "${path3}"`;
+}
+function getForms(path3, model, index, file) {
+  const formArray = getFormsArgument(path3, file);
+  if (!formArray) {
+    return null;
+  }
+  const forms = [];
+  formArray.elements.forEach((element, j) => {
+    if (!(0, import_types.isObjectExpression)(element)) {
+      return;
+    }
+    const zoneProperty = element.properties.find(
+      (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "zone" })
+    );
+    if (!zoneProperty) {
+      logger.warn(
+        `'zone' property is missing from the ${j} index of the 'forms' property. The 'zone' property is required to load a custom field form.`,
+        { file }
+      );
+      return;
+    }
+    if (!(0, import_types.isStringLiteral)(zoneProperty.value)) {
+      logger.warn(
+        `'zone' property at the ${j} index of the 'forms' property is not a string literal. The 'zone' property must be a string literal, e.g. 'general' or 'attributes'.`,
+        { file }
+      );
+      return;
+    }
+    const tabProperty = element.properties.find(
+      (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "tab" })
+    );
+    let tab;
+    if (tabProperty) {
+      if (!(0, import_types.isStringLiteral)(tabProperty.value)) {
+        logger.warn(
+          `'tab' property at the ${j} index of the 'forms' property is not a string literal. The 'tab' property must be a string literal, e.g. 'general' or 'attributes'.`,
+          { file }
+        );
+        return;
+      }
+      tab = tabProperty.value.value;
+    }
+    if (tab && !(0, import_admin_shared3.isValidCustomFieldFormTab)(tab)) {
+      logger.warn(
+        `'tab' property at the ${j} index of the 'forms' property is not a valid custom field form tab for the '${model}' model. Received: ${tab}.`,
+        { file }
+      );
+      return;
+    }
+    const zone = zoneProperty.value.value;
+    const fullPath = getFormEntryFieldPath(model, zone, tab);
+    if (!(0, import_admin_shared3.isValidCustomFieldFormZone)(zone) || !(0, import_admin_shared3.isValidCustomFieldFormFieldPath)(fullPath)) {
+      logger.warn(
+        `'zone' and 'tab' properties at the ${j} index of the 'forms' property are not a valid for the '${model}' model. Received: { zone: ${zone}, tab: ${tab} }.`,
+        { file }
+      );
+      return;
+    }
+    const fieldsObject = element.properties.find(
+      (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "fields" })
+    );
+    if (!fieldsObject) {
+      logger.warn(
+        `The 'fields' property is missing at the ${j} index of the 'forms' property. The 'fields' property is required to load a custom field form.`,
+        { file }
+      );
+      return;
+    }
+    const fields = [];
+    if (!(0, import_types.isObjectExpression)(fieldsObject.value)) {
+      logger.warn(
+        `The 'fields' property at the ${j} index of the 'forms' property is malformed. The 'fields' property must be an object.`,
+        { file }
+      );
+      return;
+    }
+    fieldsObject.value.properties.forEach((field) => {
+      if (!(0, import_types.isObjectProperty)(field) || !(0, import_types.isIdentifier)(field.key)) {
+        return;
+      }
+      const name = field.key.name;
+      if (!(0, import_types.isObjectExpression)(field.value) && !((0, import_types.isCallExpression)(field.value) && (0, import_types.isMemberExpression)(field.value.callee) && (0, import_types.isIdentifier)(field.value.callee.object) && (0, import_types.isIdentifier)(field.value.callee.property) && field.value.callee.object.name === "form" && field.value.callee.property.name === "define" && field.value.arguments.length === 1 && (0, import_types.isObjectExpression)(field.value.arguments[0]))) {
+        logger.warn(
+          `'${name}' property in the 'fields' property at the ${j} index of the 'forms' property in ${file} is malformed. The property must be an object or a call to form.define().`,
+          { file }
+        );
+        return;
+      }
+      const fieldObject = (0, import_types.isObjectExpression)(field.value) ? field.value : field.value.arguments[0];
+      const labelProperty = fieldObject.properties.find(
+        (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "label" })
+      );
+      const descriptionProperty = fieldObject.properties.find(
+        (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "description" })
+      );
+      const componentProperty = fieldObject.properties.find(
+        (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "component" })
+      );
+      const validationProperty = fieldObject.properties.find(
+        (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "validation" })
+      );
+      const placeholderProperty = fieldObject.properties.find(
+        (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "placeholder" })
+      );
+      const label = getFormFieldSectionValue(
+        !!labelProperty,
+        index,
+        j,
+        name,
+        "label"
+      );
+      const description = getFormFieldSectionValue(
+        !!descriptionProperty,
+        index,
+        j,
+        name,
+        "description"
+      );
+      const placeholder = getFormFieldSectionValue(
+        !!placeholderProperty,
+        index,
+        j,
+        name,
+        "placeholder"
+      );
+      const component = getFormFieldSectionValue(
+        !!componentProperty,
+        index,
+        j,
+        name,
+        "component"
+      );
+      const validation = getFormFieldSectionValue(
+        !!validationProperty,
+        index,
+        j,
+        name,
+        "validation"
+      );
+      fields.push({
+        name,
+        label,
+        description,
+        Component: component,
+        validation,
+        placeholder
+      });
+    });
+    forms.push({
+      zone,
+      tab,
+      fields
+    });
+  });
+  return forms.length > 0 ? forms : null;
+}
+function getFormFieldSectionValue(exists, fileIndex, formIndex, fieldKey, value) {
+  if (!exists) {
+    return "undefined";
+  }
+  const import_ = generateCustomFieldConfigName2(fileIndex);
+  return `${import_}.forms[${formIndex}].fields.${fieldKey}.${value}`;
+}
+function getFormEntryFieldPath(model, zone, tab) {
+  return `${model}.${zone}.${tab ? `${tab}.` : ""}$field`;
+}
+function getConfigs(path3, model, index, file) {
+  const formArray = getFormsArgument(path3, file);
+  if (!formArray) {
+    logger.warn(`'forms' property is missing.`, { file });
+    return null;
+  }
+  const configs = [];
+  formArray.elements.forEach((element, j) => {
+    if (!(0, import_types.isObjectExpression)(element)) {
+      logger.warn(
+        `'forms' property at the ${j} index is malformed. The 'forms' property must be an object.`,
+        { file }
+      );
+      return;
+    }
+    const zoneProperty = element.properties.find(
+      (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "zone" })
+    );
+    if (!zoneProperty) {
+      logger.warn(
+        `'zone' property is missing from the ${j} index of the 'forms' property.`,
+        { file }
+      );
+      return;
+    }
+    if ((0, import_types.isTemplateLiteral)(zoneProperty.value)) {
+      logger.warn(
+        `'zone' property at the ${j} index of the 'forms' property cannot be a template literal (e.g. \`general\`).`,
+        { file }
+      );
+      return;
+    }
+    if (!(0, import_types.isStringLiteral)(zoneProperty.value)) {
+      logger.warn(
+        `'zone' property at the ${j} index of the 'forms' property is not a string literal (e.g. 'general' or 'attributes').`,
+        { file }
+      );
+      return;
+    }
+    const zone = zoneProperty.value.value;
+    const fullPath = getFormEntryConfigPath(model, zone);
+    if (!(0, import_admin_shared3.isValidCustomFieldFormZone)(zone) || !(0, import_admin_shared3.isValidCustomFieldFormConfigPath)(fullPath)) {
+      logger.warn(
+        `'zone' property at the ${j} index of the 'forms' property is not a valid custom field form zone for the '${model}' model. Received: ${zone}.`
+      );
+      return;
+    }
+    const fieldsObject = element.properties.find(
+      (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "fields" })
+    );
+    if (!fieldsObject) {
+      logger.warn(
+        `'fields' property is missing from the ${j} entry in the 'forms' property in ${file}.`,
+        { file }
+      );
+      return;
+    }
+    const fields = [];
+    if (!(0, import_types.isObjectExpression)(fieldsObject.value)) {
+      logger.warn(
+        `'fields' property at the ${j} index of the 'forms' property is malformed. The 'fields' property must be an object.`,
+        { file }
+      );
+      return;
+    }
+    fieldsObject.value.properties.forEach((field) => {
+      if (!(0, import_types.isObjectProperty)(field) || !(0, import_types.isIdentifier)(field.key)) {
+        return;
+      }
+      const name = field.key.name;
+      if (!(0, import_types.isObjectExpression)(field.value) && !((0, import_types.isCallExpression)(field.value) && (0, import_types.isMemberExpression)(field.value.callee) && (0, import_types.isIdentifier)(field.value.callee.object) && (0, import_types.isIdentifier)(field.value.callee.property) && field.value.callee.object.name === "form" && field.value.callee.property.name === "define" && field.value.arguments.length === 1 && (0, import_types.isObjectExpression)(field.value.arguments[0]))) {
+        logger.warn(
+          `'${name}' property in the 'fields' property at the ${j} index of the 'forms' property in ${file} is malformed. The property must be an object or a call to form.define().`,
+          { file }
+        );
+        return;
+      }
+      const fieldObject = (0, import_types.isObjectExpression)(field.value) ? field.value : field.value.arguments[0];
+      const defaultValueProperty = fieldObject.properties.find(
+        (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "defaultValue" })
+      );
+      if (!defaultValueProperty) {
+        logger.warn(
+          `'defaultValue' property is missing at the ${j} index of the 'forms' property in ${file}.`,
+          { file }
+        );
+        return;
+      }
+      const validationProperty = fieldObject.properties.find(
+        (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "validation" })
+      );
+      if (!validationProperty) {
+        logger.warn(
+          `'validation' property is missing at the ${j} index of the 'forms' property in ${file}.`,
+          { file }
+        );
+        return;
+      }
+      const defaultValue = getFormFieldValue(index, j, name, "defaultValue");
+      const validation = getFormFieldValue(index, j, name, "validation");
+      fields.push({
+        name,
+        defaultValue,
+        validation
+      });
+    });
+    configs.push({
+      zone,
+      fields
+    });
+  });
+  return configs.length > 0 ? configs : null;
+}
+function getFormFieldValue(fileIndex, formIndex, fieldKey, value) {
+  const import_ = generateCustomFieldConfigName2(fileIndex);
+  return `${import_}.forms[${formIndex}].fields.${fieldKey}.${value}`;
+}
+function getFormEntryConfigPath(model, zone) {
+  return `${model}.${zone}.$config`;
+}
+function getFormsArgument(path3, file) {
+  const configArgument = getConfigArgument(path3);
+  if (!configArgument) {
+    return null;
+  }
+  const formProperty = configArgument.properties.find(
+    (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "forms" })
+  );
+  if (!formProperty) {
+    return null;
+  }
+  if (!(0, import_types.isArrayExpression)(formProperty.value)) {
+    logger.warn(
+      `The 'forms' property is malformed. The 'forms' property must be an array of objects.`,
+      { file }
+    );
+    return null;
+  }
+  return formProperty.value;
+}
+
+// src/custom-fields/generate-custom-field-hashes.ts
+var import_promises3 = __toESM(require("fs/promises"));
+async function generateCustomFieldHashes(sources) {
+  const files = await getFilesFromSources3(sources);
+  const contents = await Promise.all(files.map(getCustomFieldContents));
+  const linkContents = contents.map((c) => c.link).filter(Boolean);
+  const formContents = contents.map((c) => c.form).filter(Boolean);
+  const displayContents = contents.map((c) => c.display).filter(Boolean);
+  const totalLinkContent = linkContents.join("");
+  const totalFormContent = formContents.join("");
+  const totalDisplayContent = displayContents.join("");
+  return {
+    linkHash: generateHash(totalLinkContent),
+    formHash: generateHash(totalFormContent),
+    displayHash: generateHash(totalDisplayContent)
+  };
+}
+async function getFilesFromSources3(sources) {
+  return (await Promise.all(
+    Array.from(sources).map(
+      async (source) => crawl(`${source}/custom-fields`)
+    )
+  )).flat();
+}
+async function getCustomFieldContents(file) {
+  const code = await import_promises3.default.readFile(file, "utf-8");
+  let ast = null;
+  try {
+    ast = (0, import_parser.parse)(code, getParserOptions(file));
+  } catch (e) {
+    logger.error(`An error occurred while parsing the file.`, {
+      file,
+      error: e
+    });
+    return { link: null, form: null, display: null };
+  }
+  let linkContent = null;
+  let formContent = null;
+  let displayContent = null;
+  try {
+    traverse(ast, {
+      ExportDefaultDeclaration(path3) {
+        const configArgument = getConfigArgument(path3);
+        if (!configArgument) {
+          return;
+        }
+        configArgument.properties.forEach((prop) => {
+          if (!(0, import_types.isObjectProperty)(prop) || !prop.key || !(0, import_types.isIdentifier)(prop.key)) {
+            return;
+          }
+          switch (prop.key.name) {
+            case "link":
+              linkContent = code.slice(prop.start, prop.end);
+              break;
+            case "forms":
+              formContent = code.slice(prop.start, prop.end);
+              break;
+            case "display":
+              displayContent = code.slice(prop.start, prop.end);
+              break;
+          }
+        });
+      }
+    });
+  } catch (e) {
+    logger.error(
+      `An error occurred while processing ${file}. See the below error for more details:
+${e}`,
+      { file, error: e }
+    );
+    return { link: null, form: null, display: null };
+  }
+  return { link: linkContent, form: formContent, display: displayContent };
+}
+
+// src/custom-fields/generate-custom-field-links.ts
+var import_promises4 = __toESM(require("fs/promises"));
+async function generateCustomFieldLinks(sources) {
+  const files = await getFilesFromSources4(sources);
+  const results = await getCustomFieldLinkResults(files);
+  const imports = results.map((result) => result.import);
+  const code = generateCode2(results);
+  return {
+    imports,
+    code
+  };
+}
+async function getFilesFromSources4(sources) {
+  const files = (await Promise.all(
+    Array.from(sources).map(
+      async (source) => crawl(`${source}/custom-fields`)
+    )
+  )).flat();
+  return files;
+}
+function generateCode2(results) {
+  const groupedByModel = /* @__PURE__ */ new Map();
+  results.forEach((result) => {
+    const model = result.model;
+    if (!groupedByModel.has(model)) {
+      groupedByModel.set(model, []);
+    }
+    groupedByModel.get(model).push(result);
+  });
+  const segments = [];
+  groupedByModel.forEach((results2, model) => {
+    const links = results2.map((result) => result.link).join(",\n");
+    segments.push(`
+      ${model}: [
+        ${links}
+      ],
+    `);
+  });
+  return `
+    links: {
+      ${segments.join("\n")}
+    }
+  `;
+}
+async function getCustomFieldLinkResults(files) {
+  return (await Promise.all(files.map(async (file, index) => parseFile2(file, index)))).filter(Boolean);
+}
+async function parseFile2(file, index) {
+  const content = await import_promises4.default.readFile(file, "utf8");
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(content, getParserOptions(file));
+  } catch (e) {
+    logger.error(`An error occurred while parsing the file`, { file, error: e });
+    return null;
+  }
+  const import_ = generateImport3(file, index);
+  let link = null;
+  let model = null;
+  try {
+    traverse(ast, {
+      ExportDefaultDeclaration(path3) {
+        const _model = getModel(path3, file);
+        if (!_model) {
+          return;
+        }
+        model = _model;
+        link = getLink(path3, index, file);
+      }
+    });
+  } catch (err) {
+    logger.error(`An error occurred while traversing the file.`, {
+      file,
+      error: err
+    });
+    return null;
+  }
+  if (!link || !model) {
+    return null;
+  }
+  return {
+    import: import_,
+    model,
+    link
+  };
+}
+function generateCustomFieldConfigName3(index) {
+  return `CustomFieldConfig${index}`;
+}
+function generateImport3(file, index) {
+  const path3 = normalizePath(file);
+  return `import ${generateCustomFieldConfigName3(index)} from "${path3}"`;
+}
+function getLink(path3, index, file) {
+  const configArgument = getConfigArgument(path3);
+  if (!configArgument) {
+    return null;
+  }
+  const linkProperty = configArgument.properties.find(
+    (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "link" })
+  );
+  if (!linkProperty) {
+    logger.warn(`'link' is missing.`, { file });
+    return null;
+  }
+  const import_ = generateCustomFieldConfigName3(index);
+  return `${import_}.link`;
+}
+
+// src/i18n/generate-i18n-hash.ts
+var import_promises5 = __toESM(require("fs/promises"));
+
+// src/i18n/helpers.ts
+async function getI18nIndexFilesFromSources(sources) {
+  return (await Promise.all(
+    Array.from(sources).map(
+      async (source) => crawl(`${source}/i18n`, "index", { min: 0, max: 0 })
+    )
+  )).flat();
+}
+
+// src/i18n/generate-i18n-hash.ts
+async function generateI18nHash(sources) {
+  const indexFiles = await getI18nIndexFilesFromSources(sources);
+  const contents = await Promise.all(
+    indexFiles.map((file) => import_promises5.default.readFile(file, "utf-8"))
+  );
+  const totalContent = contents.join("");
+  return generateHash(totalContent);
+}
+
+// src/i18n/generate-i18n.ts
+var import_outdent2 = require("outdent");
+async function generateI18n(sources) {
+  const indexFiles = await getI18nIndexFilesFromSources(sources);
+  const imports = indexFiles.map((file, index) => {
+    const normalizedPath = normalizePath(file);
+    return `import i18nTranslations${index} from "${normalizedPath}"`;
+  });
+  let mergeCode = "{}";
+  if (indexFiles.length === 1) {
+    mergeCode = "i18nTranslations0";
+  } else if (indexFiles.length > 1) {
+    mergeCode = indexFiles.slice(1).reduce((acc, _, index) => {
+      return `deepMerge(${acc}, i18nTranslations${index + 1})`;
+    }, "i18nTranslations0");
+  }
+  const code = import_outdent2.outdent`
+        resources: ${mergeCode}
+    `;
+  return {
+    imports,
+    code
+  };
+}
+
+// src/routes/generate-menu-items.ts
+var import_admin_shared4 = require("@acmekit/admin-shared");
+var import_promises6 = __toESM(require("fs/promises"));
+var import_outdent3 = require("outdent");
+
+// src/routes/helpers.ts
+function getRoute(file) {
+  const importPath = normalizePath(file);
+  return importPath.replace(/.*\/admin\/(routes)/, "").replace("[[*]]", "*?").replace("[*]", "*").replace(/\(([^\[\]\)]+)\)/g, "$1?").replace(/\[\[([^\]]+)\]\]/g, ":$1?").replace(/\[([^\]]+)\]/g, ":$1").replace(
+    new RegExp(
+      `/page\\.(${VALID_FILE_EXTENSIONS.map((ext) => ext.slice(1)).join(
+        "|"
+      )})$`
+    ),
+    ""
+  );
+}
+
+// src/routes/generate-menu-items.ts
+async function generateMenuItems(sources) {
+  const files = await getFilesFromSources5(sources);
+  const results = await getMenuItemResults(files);
+  const imports = results.map((result) => result.import);
+  const code = generateCode3(results);
+  return { imports, code };
+}
+function generateCode3(results) {
+  return import_outdent3.outdent`
+        menuItems: [
+            ${results.map((result) => formatMenuItem(result.menuItem)).join(",\n")}
+        ]
+    }
+  `;
+}
+function formatMenuItem(route) {
+  const { label, icon, path: path3, nested, rank, translationNs } = route;
+  return `{
+    label: ${label},
+    icon: ${icon || "undefined"},
+    path: "${path3}",
+    nested: ${nested ? `"${nested}"` : "undefined"},
+    rank: ${rank !== void 0 ? rank : "undefined"},
+    translationNs: ${translationNs ? `${translationNs}` : "undefined"}
+  }`;
+}
+async function getFilesFromSources5(sources) {
+  const files = (await Promise.all(
+    Array.from(sources).map(
+      async (source) => crawl(`${source}/routes`, "page", { min: 1 })
+    )
+  )).flat();
+  return files;
+}
+async function getMenuItemResults(files) {
+  const results = await Promise.all(files.map(parseFile3));
+  return results.filter((item) => item !== null);
+}
+async function parseFile3(file, index) {
+  const config = await getRouteConfig(file);
+  if (!config) {
+    return null;
+  }
+  if (!config.label) {
+    logger.warn(`Config is missing a label.`, {
+      file
+    });
+  }
+  const import_ = generateImport4(file, index);
+  const menuItem = generateMenuItem(config, file, index);
+  return {
+    import: import_,
+    menuItem
+  };
+}
+function generateImport4(file, index) {
+  const path3 = normalizePath(file);
+  return `import { config as ${generateRouteConfigName(index)} } from "${path3}"`;
+}
+function generateMenuItem(config, file, index) {
+  const configName = generateRouteConfigName(index);
+  return {
+    label: `${configName}.label`,
+    icon: config.icon ? `${configName}.icon` : void 0,
+    path: getRoute(file),
+    nested: config.nested,
+    rank: config.rank,
+    translationNs: config.translationNs ? `${configName}.translationNs` : void 0
+  };
+}
+async function getRouteConfig(file) {
+  const code = await import_promises6.default.readFile(file, "utf-8");
+  let ast = null;
+  try {
+    ast = (0, import_parser.parse)(code, getParserOptions(file));
+  } catch (e) {
+    logger.error(`An error occurred while parsing the file.`, {
+      file,
+      error: e
+    });
+    return null;
+  }
+  let config = null;
+  let configFound = false;
+  try {
+    traverse(ast, {
+      /**
+       * For bundled files, the config will not be a named export,
+       * but instead a variable declaration.
+       */
+      VariableDeclarator(path3) {
+        if (configFound) {
+          return;
+        }
+        const properties = getConfigObjectProperties(path3);
+        if (!properties) {
+          return;
+        }
+        config = processConfigProperties(properties, file);
+        if (config) {
+          configFound = true;
+        }
+      },
+      /**
+       * For unbundled files, the `config` will always be a named export.
+       */
+      ExportNamedDeclaration(path3) {
+        if (configFound) {
+          return;
+        }
+        const properties = getConfigObjectProperties(path3);
+        if (!properties) {
+          return;
+        }
+        config = processConfigProperties(properties, file);
+        if (config) {
+          configFound = true;
+        }
+      }
+    });
+  } catch (e) {
+    logger.error(`An error occurred while traversing the file.`, {
+      file,
+      error: e
+    });
+  }
+  return config;
+}
+function processConfigProperties(properties, file) {
+  const hasProperty = (name) => properties.some(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name })
+  );
+  const hasLabel = hasProperty("label");
+  if (!hasLabel) {
+    return null;
+  }
+  const nested = properties.find(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "nested" })
+  );
+  let nestedValue;
+  if ((0, import_types.isStringLiteral)(nested?.value)) {
+    nestedValue = nested.value.value;
+  }
+  if (nestedValue && !import_admin_shared4.NESTED_ROUTE_POSITIONS.includes(nestedValue)) {
+    logger.error(
+      `Invalid nested route position: "${nestedValue}". Allowed values are: ${import_admin_shared4.NESTED_ROUTE_POSITIONS.join(
+        ", "
+      )}`,
+      { file }
+    );
+    return null;
+  }
+  const translationNs = properties.find(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "translationNs" })
+  );
+  let translationNsValue = void 0;
+  if ((0, import_types.isStringLiteral)(translationNs?.value)) {
+    translationNsValue = translationNs.value.value;
+  }
+  const rank = properties.find(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "rank" })
+  );
+  let rankValue;
+  if ((0, import_types.isNumericLiteral)(rank?.value)) {
+    rankValue = rank.value.value;
+  }
+  return {
+    label: hasLabel,
+    icon: hasProperty("icon"),
+    nested: nestedValue,
+    rank: rankValue,
+    translationNs: translationNsValue
+  };
+}
+function generateRouteConfigName(index) {
+  return `RouteConfig${index}`;
+}
+
+// src/routes/generate-route-hashes.ts
+var import_promises7 = __toESM(require("fs/promises"));
+async function generateRouteHashes(sources) {
+  const files = await getFilesFromSources6(sources);
+  const contents = await Promise.all(files.map(getRouteContents));
+  const defaultExportContents = contents.map((c) => c.defaultExport).filter(Boolean);
+  const configContents = contents.map((c) => c.config).filter(Boolean);
+  const totalDefaultExportContent = defaultExportContents.join("");
+  const totalConfigContent = configContents.join("");
+  return {
+    defaultExportHash: generateHash(totalDefaultExportContent),
+    configHash: generateHash(totalConfigContent)
+  };
+}
+async function getFilesFromSources6(sources) {
+  return (await Promise.all(
+    Array.from(sources).map(
+      async (source) => crawl(`${source}/routes`, "page", { min: 1 })
+    )
+  )).flat();
+}
+async function getRouteContents(file) {
+  const code = await import_promises7.default.readFile(file, "utf-8");
+  let ast = null;
+  try {
+    ast = (0, import_parser.parse)(code, getParserOptions(file));
+  } catch (e) {
+    logger.error(`An error occurred while parsing the file.`, {
+      file,
+      error: e
+    });
+    return { defaultExport: null, config: null };
+  }
+  let defaultExportContent = null;
+  let configContent = null;
+  try {
+    traverse(ast, {
+      ExportDefaultDeclaration(path3) {
+        defaultExportContent = code.slice(path3.node.start, path3.node.end);
+      },
+      ExportNamedDeclaration(path3) {
+        const properties = getConfigObjectProperties(path3);
+        if (properties) {
+          configContent = code.slice(path3.node.start, path3.node.end);
+        }
+      }
+    });
+  } catch (e) {
+    logger.error(
+      `An error occurred while processing ${file}. See the below error for more details:
+${e}`,
+      { file, error: e }
+    );
+    return { defaultExport: null, config: null };
+  }
+  return { defaultExport: defaultExportContent, config: configContent };
+}
+
+// src/routes/generate-routes.ts
+var import_promises8 = __toESM(require("fs/promises"));
+var import_outdent4 = require("outdent");
+async function generateRoutes(sources) {
+  const files = await getFilesFromSources7(sources);
+  const results = await getRouteResults(files);
+  const imports = results.map((result) => result.imports).flat();
+  const code = generateCode4(results);
+  return {
+    imports,
+    code
+  };
+}
+function generateCode4(results) {
+  return import_outdent4.outdent`
+        routes: [
+            ${results.map((result) => formatRoute(result.route)).join(",\n")}
+        ]
+    }
+  `;
+}
+function formatRoute(route) {
+  let base = `{
+    Component: ${route.Component},
+    path: "${route.path}"`;
+  if (route.handle) {
+    base += `,
+    handle: ${route.handle}`;
+  }
+  if (route.loader) {
+    base += `,
+    loader: ${route.loader}`;
+  }
+  if (route.children?.length) {
+    return `${base},
+    children: [
+      ${route.children.map((child) => formatRoute(child)).join(",\n      ")}
+    ]
+  }`;
+  }
+  return `${base}
+  }`;
+}
+async function getFilesFromSources7(sources) {
+  const files = (await Promise.all(
+    Array.from(sources).map(
+      async (source) => crawl(`${source}/routes`, "page", { min: 1 })
+    )
+  )).flat();
+  return files;
+}
+async function getRouteResults(files) {
+  const results = (await Promise.all(files.map(parseFile4))).filter(
+    (result) => result !== null
+  );
+  const routeMap = /* @__PURE__ */ new Map();
+  results.forEach((result) => {
+    const routePath = result.route.path;
+    const isParallel = routePath.includes("/@");
+    if (isParallel) {
+      const parentPath = routePath.split("/@")[0];
+      const parent = routeMap.get(parentPath);
+      if (parent) {
+        parent.route.children = parent.route.children || [];
+        const finalRoute = {
+          ...result.route,
+          path: result.route.path.replace("@", "")
+        };
+        parent.route.children.push(finalRoute);
+        parent.imports.push(...result.imports);
+      }
+    } else {
+      routeMap.set(routePath, result);
+    }
+  });
+  return Array.from(routeMap.values());
+}
+async function parseFile4(file, index) {
+  const code = await import_promises8.default.readFile(file, "utf-8");
+  let ast = null;
+  try {
+    ast = (0, import_parser.parse)(code, getParserOptions(file));
+  } catch (e) {
+    logger.error("An error occurred while parsing the file.", {
+      file,
+      error: e
+    });
+    return null;
+  }
+  if (!await isValidRouteFile(ast, file)) {
+    return null;
+  }
+  const { hasHandle, hasLoader } = await hasNamedExports(ast, file);
+  const routePath = getRoute(file);
+  const imports = generateImports(file, index, hasHandle, hasLoader);
+  const route = generateRoute(routePath, index, hasHandle, hasLoader);
+  return {
+    imports,
+    route
+  };
+}
+async function isValidRouteFile(ast, file) {
+  try {
+    return await hasDefaultExport(ast);
+  } catch (e) {
+    logger.error(
+      `An error occurred while checking for a default export in ${file}. The file will be ignored. See the below error for more details:
+${e}`
+    );
+    return false;
+  }
+}
+function generateImports(file, index, hasHandle, hasLoader) {
+  const imports = [];
+  const route = generateRouteComponentName(index);
+  const importPath = normalizePath(file);
+  if (!hasHandle && !hasLoader) {
+    imports.push(`import ${route} from "${importPath}"`);
+  } else {
+    const namedImports = [
+      hasHandle && `handle as ${generateHandleName(index)}`,
+      hasLoader && `loader as ${generateLoaderName(index)}`
+    ].filter(Boolean).join(", ");
+    imports.push(`import ${route}, { ${namedImports} } from "${importPath}"`);
+  }
+  return imports;
+}
+function generateRoute(route, index, hasHandle, hasLoader) {
+  return {
+    Component: generateRouteComponentName(index),
+    path: route,
+    handle: hasHandle ? generateHandleName(index) : void 0,
+    loader: hasLoader ? generateLoaderName(index) : void 0
+  };
+}
+function generateRouteComponentName(index) {
+  return `RouteComponent${index}`;
+}
+function generateHandleName(index) {
+  return `handle${index}`;
+}
+function generateLoaderName(index) {
+  return `loader${index}`;
+}
+async function hasNamedExports(ast, file) {
+  let hasHandle = false;
+  let hasLoader = false;
+  try {
+    traverse(ast, {
+      ExportNamedDeclaration(path3) {
+        const declaration = path3.node.declaration;
+        if (declaration?.type === "VariableDeclaration") {
+          declaration.declarations.forEach((decl) => {
+            if (decl.id.type === "Identifier" && decl.id.name === "handle") {
+              hasHandle = true;
+            }
+            if (decl.id.type === "Identifier" && decl.id.name === "loader") {
+              hasLoader = true;
+            }
+          });
+        }
+        if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "loader") {
+          hasLoader = true;
+        }
+      }
+    });
+  } catch (e) {
+    logger.error("An error occurred while checking for named exports.", {
+      file,
+      error: e
+    });
+  }
+  return { hasHandle, hasLoader };
+}
+
+// src/virtual-modules/generate-virtual-display-module.ts
+var import_outdent5 = require("outdent");
+async function generateVirtualDisplayModule(sources, pluginMode = false) {
+  const displays = await generateCustomFieldDisplays(sources);
+  const code = import_outdent5.outdent`
+    ${displays.imports.join("\n")}
+
+    ${pluginMode ? `const displayModule = { ${displays.code} }` : `export default { ${displays.code} }`}
+  `;
+  return generateModule(code);
+}
+
+// src/virtual-modules/generate-virtual-form-module.ts
+var import_outdent6 = __toESM(require("outdent"));
+async function generateVirtualFormModule(sources, pluginMode = false) {
+  const customFields = await generateCustomFieldForms(sources);
+  const imports = [...customFields.imports];
+  const code = import_outdent6.default`
+          ${imports.join("\n")}
+
+    ${pluginMode ? `const formModule = { ${customFields.code} }` : `export default { ${customFields.code} }`}
+  `;
+  return generateModule(code);
+}
+
+// src/virtual-modules/generate-virtual-link-module.ts
+var import_outdent7 = require("outdent");
+async function generateVirtualLinkModule(sources, pluginMode = false) {
+  const links = await generateCustomFieldLinks(sources);
+  const code = import_outdent7.outdent`
+    ${links.imports.join("\n")}
+
+    ${pluginMode ? `const linkModule = { ${links.code} }` : `export default { ${links.code} }`}
+  `;
+  return generateModule(code);
+}
+
+// src/virtual-modules/generate-virtual-menu-item-module.ts
+var import_outdent8 = __toESM(require("outdent"));
+async function generateVirtualMenuItemModule(sources, pluginMode = false) {
+  const menuItems = await generateMenuItems(sources);
+  const code = import_outdent8.default`
+          ${menuItems.imports.join("\n")}
+
+    ${pluginMode ? `const menuItemModule = { ${menuItems.code} }` : `export default { ${menuItems.code} }`}
+  `;
+  return generateModule(code);
+}
+
+// src/virtual-modules/generate-virtual-route-module.ts
+var import_outdent9 = require("outdent");
+async function generateVirtualRouteModule(sources, pluginMode = false) {
+  const routes = await generateRoutes(sources);
+  const imports = [...routes.imports];
+  const code = import_outdent9.outdent`
+    ${imports.join("\n")}
+
+    ${pluginMode ? `const routeModule = { ${routes.code} }` : `export default { ${routes.code} }`}
+  `;
+  return generateModule(code);
+}
+
+// src/virtual-modules/generate-virtual-widget-module.ts
+var import_outdent11 = __toESM(require("outdent"));
+
+// src/widgets/generate-widget-hash.ts
+var import_promises9 = __toESM(require("fs/promises"));
+
+// src/widgets/helpers.ts
+async function getWidgetFilesFromSources(sources) {
+  return (await Promise.all(
+    Array.from(sources).map(async (source) => crawl(`${source}/widgets`))
+  )).flat();
+}
+
+// src/widgets/generate-widget-hash.ts
+async function generateWidgetHash(sources) {
+  const files = await getWidgetFilesFromSources(sources);
+  const contents = await Promise.all(files.map(getWidgetContents));
+  const totalContent = contents.flatMap(({ config, defaultExport }) => [config, defaultExport]).filter(Boolean).join("");
+  return generateHash(totalContent);
+}
+async function getWidgetContents(file) {
+  const code = await import_promises9.default.readFile(file, "utf-8");
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(code, getParserOptions(file));
+  } catch (e) {
+    logger.error(
+      `An error occurred while parsing the file. Due to the error we cannot validate whether the widget has changed. If your changes aren't correctly reflected try restarting the dev server.`,
+      {
+        file,
+        error: e
+      }
+    );
+    return { config: null, defaultExport: null };
+  }
+  let configContent = null;
+  let defaultExportContent = null;
+  traverse(ast, {
+    ExportNamedDeclaration(path3) {
+      const properties = getConfigObjectProperties(path3);
+      if (properties) {
+        configContent = code.slice(path3.node.start, path3.node.end);
+      }
+    },
+    ExportDefaultDeclaration(path3) {
+      defaultExportContent = code.slice(path3.node.start, path3.node.end);
+    }
+  });
+  return { config: configContent, defaultExport: defaultExportContent };
+}
+
+// src/widgets/generate-widgets.ts
+var import_admin_shared5 = require("@acmekit/admin-shared");
+var import_promises10 = __toESM(require("fs/promises"));
+var import_outdent10 = __toESM(require("outdent"));
+async function generateWidgets(sources) {
+  const files = await getWidgetFilesFromSources(sources);
+  const results = await getWidgetResults(files);
+  const imports = results.map((r) => r.import);
+  const code = generateCode5(results);
+  return {
+    imports,
+    code
+  };
+}
+async function getWidgetResults(files) {
+  return (await Promise.all(files.map(parseFile5))).filter(
+    (r) => r !== null
+  );
+}
+function generateCode5(results) {
+  return import_outdent10.default`
+    widgets: [
+      ${results.map((r) => formatWidget(r.widget)).join(",\n")}
+    ]
+  `;
+}
+function formatWidget(widget) {
+  return import_outdent10.default`
+    {
+        Component: ${widget.Component},
+        zone: [${widget.zone.map((z) => `"${z}"`).join(", ")}]
+    }
+  `;
+}
+async function parseFile5(file, index) {
+  const code = await import_promises10.default.readFile(file, "utf-8");
+  let ast;
+  try {
+    ast = (0, import_parser.parse)(code, getParserOptions(file));
+  } catch (e) {
+    logger.error(`An error occurred while parsing the file.`, {
+      file,
+      error: e
+    });
+    return null;
+  }
+  let fileHasDefaultExport = false;
+  try {
+    fileHasDefaultExport = await hasDefaultExport(ast);
+  } catch (e) {
+    logger.error(`An error occurred while checking for a default export.`, {
+      file,
+      error: e
+    });
+    return null;
+  }
+  if (!fileHasDefaultExport) {
+    return null;
+  }
+  let zone;
+  try {
+    zone = await getWidgetZone(ast, file);
+  } catch (e) {
+    logger.error(`An error occurred while traversing the file.`, {
+      file,
+      error: e
+    });
+    return null;
+  }
+  if (!zone) {
+    logger.warn(`'zone' property is missing from the widget config.`, { file });
+    return null;
+  }
+  const import_ = generateImport5(file, index);
+  const widget = generateWidget(zone, index);
+  return {
+    widget,
+    import: import_
+  };
+}
+function generateWidgetComponentName(index) {
+  return `WidgetComponent${index}`;
+}
+function generateWidgetConfigName(index) {
+  return `WidgetConfig${index}`;
+}
+function generateImport5(file, index) {
+  const path3 = normalizePath(file);
+  return `import ${generateWidgetComponentName(
+    index
+  )}, { config as ${generateWidgetConfigName(index)} } from "${path3}"`;
+}
+function generateWidget(zone, index) {
+  return {
+    Component: generateWidgetComponentName(index),
+    zone
+  };
+}
+async function getWidgetZone(ast, file) {
+  const zones = [];
+  let zoneFound = false;
+  traverse(ast, {
+    /**
+     * In case we are processing a bundled file, the `config` will most likely
+     * not be a named export. Instead we look for a `VariableDeclaration` named
+     * `config` and extract the `zone` property from it.
+     */
+    VariableDeclarator(path3) {
+      if (zoneFound) {
+        return;
+      }
+      if (path3.node.id.type === "Identifier" && path3.node.id.name === "config" && path3.node.init?.type === "CallExpression") {
+        const arg = path3.node.init.arguments[0];
+        if (arg?.type === "ObjectExpression") {
+          const zoneProperty = arg.properties.find(
+            (p) => p.type === "ObjectProperty" && p.key.name === "zone"
+          );
+          if (zoneProperty?.type === "ObjectProperty") {
+            extractZoneValues(zoneProperty.value, zones, file);
+            zoneFound = true;
+          }
+        }
+      }
+    },
+    /**
+     * For unbundled files, the `config` will always be a named export.
+     */
+    ExportNamedDeclaration(path3) {
+      if (zoneFound) {
+        return;
+      }
+      const declaration = path3.node.declaration;
+      if (declaration?.type === "VariableDeclaration" && declaration.declarations[0]?.type === "VariableDeclarator" && declaration.declarations[0].id.type === "Identifier" && declaration.declarations[0].id.name === "config" && declaration.declarations[0].init?.type === "CallExpression") {
+        const arg = declaration.declarations[0].init.arguments[0];
+        if (arg?.type === "ObjectExpression") {
+          const zoneProperty = arg.properties.find(
+            (p) => p.type === "ObjectProperty" && p.key.name === "zone"
+          );
+          if (zoneProperty?.type === "ObjectProperty") {
+            extractZoneValues(zoneProperty.value, zones, file);
+            zoneFound = true;
+          }
+        }
+      }
+    }
+  });
+  if (!zoneFound) {
+    logger.warn(`'zone' property is missing from the widget config.`, { file });
+    return null;
+  }
+  const validatedZones = zones.filter(import_admin_shared5.isValidInjectionZone);
+  if (validatedZones.length === 0) {
+    logger.warn(`'zone' property is not a valid injection zone.`, {
+      file
+    });
+    return null;
+  }
+  return validatedZones;
+}
+function extractZoneValues(value, zones, file) {
+  if ((0, import_types.isTemplateLiteral)(value)) {
+    logger.warn(
+      `'zone' property cannot be a template literal (e.g. \`product.details.after\`).`,
+      { file }
+    );
+    return;
+  }
+  if ((0, import_types.isStringLiteral)(value)) {
+    zones.push(value.value);
+  } else if ((0, import_types.isArrayExpression)(value)) {
+    const values = value.elements.filter((e) => (0, import_types.isStringLiteral)(e)).map((e) => e.value);
+    zones.push(...values);
+  } else {
+    logger.warn(`'zone' property is not a string or array.`, { file });
+    return;
+  }
+}
+
+// src/virtual-modules/generate-virtual-widget-module.ts
+async function generateVirtualWidgetModule(sources, pluginMode = false) {
+  const widgets = await generateWidgets(sources);
+  const imports = [...widgets.imports];
+  const code = import_outdent11.default`
+    ${imports.join("\n")}
+
+    ${pluginMode ? `const widgetModule = { ${widgets.code} }` : `export default { ${widgets.code} }`}
+  `;
+  return generateModule(code);
+}
+
+// src/virtual-modules/generate-virtual-i18n-module.ts
+var import_outdent12 = __toESM(require("outdent"));
+async function generateVirtualI18nModule(sources, pluginMode = false) {
+  const i18n = await generateI18n(sources);
+  const imports = [
+    'import { deepMerge } from "@acmekit/admin-shared"',
+    ...i18n.imports
+  ];
+  const code = import_outdent12.default`
+        ${imports.join("\n")}
+
+        ${pluginMode ? `const i18nModule = { ${i18n.code} }` : `export default { ${i18n.code} }`}
+    `;
+  return generateModule(code);
+}
+
+// src/vmod.ts
+var import_admin_shared6 = require("@acmekit/admin-shared");
+var RESOLVED_LINK_VIRTUAL_MODULE = `\0${import_admin_shared6.LINK_VIRTUAL_MODULE}`;
+var RESOLVED_FORM_VIRTUAL_MODULE = `\0${import_admin_shared6.FORM_VIRTUAL_MODULE}`;
+var RESOLVED_DISPLAY_VIRTUAL_MODULE = `\0${import_admin_shared6.DISPLAY_VIRTUAL_MODULE}`;
+var RESOLVED_ROUTE_VIRTUAL_MODULE = `\0${import_admin_shared6.ROUTE_VIRTUAL_MODULE}`;
+var RESOLVED_MENU_ITEM_VIRTUAL_MODULE = `\0${import_admin_shared6.MENU_ITEM_VIRTUAL_MODULE}`;
+var RESOLVED_WIDGET_VIRTUAL_MODULE = `\0${import_admin_shared6.WIDGET_VIRTUAL_MODULE}`;
+var RESOLVED_I18N_VIRTUAL_MODULE = `\0${import_admin_shared6.I18N_VIRTUAL_MODULE}`;
+var VIRTUAL_MODULES = [
+  import_admin_shared6.LINK_VIRTUAL_MODULE,
+  import_admin_shared6.FORM_VIRTUAL_MODULE,
+  import_admin_shared6.DISPLAY_VIRTUAL_MODULE,
+  import_admin_shared6.ROUTE_VIRTUAL_MODULE,
+  import_admin_shared6.MENU_ITEM_VIRTUAL_MODULE,
+  import_admin_shared6.WIDGET_VIRTUAL_MODULE,
+  import_admin_shared6.I18N_VIRTUAL_MODULE
+];
+var RESOLVED_VIRTUAL_MODULES = [
+  RESOLVED_LINK_VIRTUAL_MODULE,
+  RESOLVED_FORM_VIRTUAL_MODULE,
+  RESOLVED_DISPLAY_VIRTUAL_MODULE,
+  RESOLVED_ROUTE_VIRTUAL_MODULE,
+  RESOLVED_MENU_ITEM_VIRTUAL_MODULE,
+  RESOLVED_WIDGET_VIRTUAL_MODULE,
+  RESOLVED_I18N_VIRTUAL_MODULE
+];
+function resolveVirtualId(id) {
+  return `\0${id}`;
+}
+function isVirtualModuleId(id) {
+  return VIRTUAL_MODULES.includes(id);
+}
+function isResolvedVirtualModuleId(id) {
+  return RESOLVED_VIRTUAL_MODULES.includes(
+    id
+  );
+}
+var resolvedVirtualModuleIds = {
+  link: RESOLVED_LINK_VIRTUAL_MODULE,
+  form: RESOLVED_FORM_VIRTUAL_MODULE,
+  display: RESOLVED_DISPLAY_VIRTUAL_MODULE,
+  route: RESOLVED_ROUTE_VIRTUAL_MODULE,
+  menuItem: RESOLVED_MENU_ITEM_VIRTUAL_MODULE,
+  widget: RESOLVED_WIDGET_VIRTUAL_MODULE,
+  i18n: RESOLVED_I18N_VIRTUAL_MODULE
+};
+var virtualModuleIds = {
+  link: import_admin_shared6.LINK_VIRTUAL_MODULE,
+  form: import_admin_shared6.FORM_VIRTUAL_MODULE,
+  display: import_admin_shared6.DISPLAY_VIRTUAL_MODULE,
+  route: import_admin_shared6.ROUTE_VIRTUAL_MODULE,
+  menuItem: import_admin_shared6.MENU_ITEM_VIRTUAL_MODULE,
+  widget: import_admin_shared6.WIDGET_VIRTUAL_MODULE,
+  i18n: import_admin_shared6.I18N_VIRTUAL_MODULE
+};
+var vmod = {
+  resolved: resolvedVirtualModuleIds,
+  virtual: virtualModuleIds
+};
+
+// src/plugin.ts
+var acmekitVitePlugin = (options) => {
+  const hashMap = /* @__PURE__ */ new Map();
+  const _sources = new Set(options?.sources ?? []);
+  const mode = options?.pluginMode ? "plugin" /* PLUGIN */ : "application" /* APPLICATION */;
+  let watcher;
+  function isFileInSources(file) {
+    for (const source of _sources) {
+      if (file.startsWith(import_node_path.default.resolve(source))) {
+        return true;
+      }
+    }
+    return false;
+  }
+  async function loadVirtualModule(config) {
+    const hash = await config.hashGenerator(_sources);
+    hashMap.set(config.hashKey, hash);
+    return config.moduleGenerator(_sources);
+  }
+  async function handleFileChange(server, config) {
+    const hashes = await config.hashGenerator(_sources);
+    for (const module2 of config.modules) {
+      const newHash = hashes[module2.hashKey];
+      if (newHash !== hashMap.get(module2.virtualModule)) {
+        const moduleToReload = server.moduleGraph.getModuleById(
+          module2.resolvedModule
+        );
+        if (moduleToReload) {
+          await server.reloadModule(moduleToReload);
+        }
+        hashMap.set(module2.virtualModule, newHash);
+      }
+    }
+  }
+  async function generatePluginEntryModule(sources) {
+    const widgetModule = await generateVirtualWidgetModule(sources, true);
+    const routeModule = await generateVirtualRouteModule(sources, true);
+    const menuItemModule = await generateVirtualMenuItemModule(sources, true);
+    const formModule = await generateVirtualFormModule(sources, true);
+    const displayModule = await generateVirtualDisplayModule(sources, true);
+    const i18nModule = await generateVirtualI18nModule(sources, true);
+    return `
+      // Auto-generated index file for AcmeKit Admin UI extensions
+    ${widgetModule.code}
+    ${routeModule.code}
+    ${menuItemModule.code}
+    ${formModule.code}
+    ${displayModule.code}
+    ${i18nModule.code}
+    
+    const plugin = {
+      widgetModule,
+      routeModule,
+      menuItemModule,
+      formModule,
+      displayModule,
+      i18nModule
+    }
+
+    export default plugin
+    `;
+  }
+  const pluginEntryFile = import_node_path.default.resolve(
+    process.cwd(),
+    "src/admin/__admin-extensions__.js"
+  );
+  return {
+    name: "@acmekit/admin-vite-plugin",
+    enforce: "pre",
+    async buildStart() {
+      switch (mode) {
+        case "plugin" /* PLUGIN */: {
+          const code = await generatePluginEntryModule(_sources);
+          await (0, import_promises11.writeFile)(pluginEntryFile, code, "utf-8");
+          break;
+        }
+        case "application" /* APPLICATION */: {
+          break;
+        }
+      }
+    },
+    async buildEnd() {
+      switch (mode) {
+        case "plugin" /* PLUGIN */: {
+          try {
+            await (0, import_promises11.rm)(pluginEntryFile, { force: true });
+          } catch (error) {
+          }
+          break;
+        }
+        case "application" /* APPLICATION */: {
+          break;
+        }
+      }
+    },
+    configureServer(server) {
+      watcher = server.watcher;
+      watcher?.add(Array.from(_sources));
+      watcher?.on("all", async (_event, file) => {
+        if (!isFileInSources(file)) {
+          return;
+        }
+        for (const config of watcherConfigs) {
+          if (isFileInAdminSubdirectory(file, config.subdirectory)) {
+            await handleFileChange(server, config);
+          }
+        }
+      });
+    },
+    resolveId(id) {
+      if (!isVirtualModuleId(id)) {
+        return null;
+      }
+      return resolveVirtualId(id);
+    },
+    async load(id) {
+      if (!isResolvedVirtualModuleId(id)) {
+        return null;
+      }
+      const config = loadConfigs[id];
+      if (!config) {
+        return null;
+      }
+      return loadVirtualModule(config);
+    },
+    async closeBundle() {
+      if (watcher) {
+        await watcher.close();
+      }
+    }
+  };
+};
+var loadConfigs = {
+  [vmod.resolved.widget]: {
+    hashGenerator: async (sources) => generateWidgetHash(sources),
+    moduleGenerator: async (sources) => generateVirtualWidgetModule(sources),
+    hashKey: vmod.virtual.widget
+  },
+  [vmod.resolved.link]: {
+    hashGenerator: async (sources) => (await generateCustomFieldHashes(sources)).linkHash,
+    moduleGenerator: async (sources) => generateVirtualLinkModule(sources),
+    hashKey: vmod.virtual.link
+  },
+  [vmod.resolved.form]: {
+    hashGenerator: async (sources) => (await generateCustomFieldHashes(sources)).formHash,
+    moduleGenerator: async (sources) => generateVirtualFormModule(sources),
+    hashKey: vmod.virtual.form
+  },
+  [vmod.resolved.display]: {
+    hashGenerator: async (sources) => (await generateCustomFieldHashes(sources)).displayHash,
+    moduleGenerator: async (sources) => generateVirtualDisplayModule(sources),
+    hashKey: vmod.virtual.display
+  },
+  [vmod.resolved.route]: {
+    hashGenerator: async (sources) => (await generateRouteHashes(sources)).defaultExportHash,
+    moduleGenerator: async (sources) => generateVirtualRouteModule(sources),
+    hashKey: vmod.virtual.route
+  },
+  [vmod.resolved.menuItem]: {
+    hashGenerator: async (sources) => (await generateRouteHashes(sources)).configHash,
+    moduleGenerator: async (sources) => generateVirtualMenuItemModule(sources),
+    hashKey: vmod.virtual.menuItem
+  },
+  [vmod.resolved.i18n]: {
+    hashGenerator: async (sources) => generateI18nHash(sources),
+    moduleGenerator: async (sources) => generateVirtualI18nModule(sources),
+    hashKey: vmod.virtual.i18n
+  }
+};
+var watcherConfigs = [
+  {
+    subdirectory: "routes",
+    hashGenerator: async (sources) => generateRouteHashes(sources),
+    modules: [
+      {
+        virtualModule: vmod.virtual.route,
+        resolvedModule: vmod.resolved.route,
+        hashKey: "defaultExportHash"
+      },
+      {
+        virtualModule: vmod.virtual.menuItem,
+        resolvedModule: vmod.resolved.menuItem,
+        hashKey: "configHash"
+      }
+    ]
+  },
+  {
+    subdirectory: "widgets",
+    hashGenerator: async (sources) => ({
+      widgetConfigHash: await generateWidgetHash(sources)
+    }),
+    modules: [
+      {
+        virtualModule: vmod.virtual.widget,
+        resolvedModule: vmod.resolved.widget,
+        hashKey: "widgetConfigHash"
+      }
+    ]
+  },
+  {
+    subdirectory: "custom-fields",
+    hashGenerator: async (sources) => generateCustomFieldHashes(sources),
+    modules: [
+      {
+        virtualModule: vmod.virtual.link,
+        resolvedModule: vmod.resolved.link,
+        hashKey: "linkHash"
+      },
+      {
+        virtualModule: vmod.virtual.form,
+        resolvedModule: vmod.resolved.form,
+        hashKey: "formHash"
+      },
+      {
+        virtualModule: vmod.virtual.display,
+        resolvedModule: vmod.resolved.display,
+        hashKey: "displayHash"
+      }
+    ]
+  },
+  {
+    subdirectory: "i18n",
+    hashGenerator: async (sources) => ({
+      i18nHash: await generateI18nHash(sources)
+    }),
+    modules: [
+      {
+        virtualModule: vmod.virtual.i18n,
+        resolvedModule: vmod.resolved.i18n,
+        hashKey: "i18nHash"
+      }
+    ]
+  }
+];
+
+// src/index.ts
+var index_default = acmekitVitePlugin;