@momentumcms/core 0.1.9 → 0.1.10

package/generators/generator.cjs

@@ -0,0 +1,813 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// libs/core/src/generators/generator.ts
+var generator_exports = {};
+__export(generator_exports, {
+  computeRelativeImport: () => computeRelativeImport,
+  default: () => runGenerator,
+  generateAdminConfig: () => generateAdminConfig,
+  generateTypes: () => generateTypes,
+  serializeCollection: () => serializeCollection,
+  serializeField: () => serializeField,
+  serializeGlobal: () => serializeGlobal,
+  serializeValue: () => serializeValue
+});
+module.exports = __toCommonJS(generator_exports);
+var import_node_fs = require("node:fs");
+var import_node_child_process = require("node:child_process");
+var import_node_path = require("node:path");
+var import_node_url = require("node:url");
+
+// libs/core/src/lib/fields/field.types.ts
+function flattenDataFields(fields) {
+  const result = [];
+  for (const field of fields) {
+    if (field.type === "tabs") {
+      for (const tab of field.tabs) {
+        result.push(...flattenDataFields(tab.fields));
+      }
+    } else if (field.type === "collapsible" || field.type === "row") {
+      result.push(...flattenDataFields(field.fields));
+    } else {
+      result.push(field);
+    }
+  }
+  return result;
+}
+
+// libs/core/src/generators/field-to-typescript.ts
+function slugToPascalCase(slug) {
+  return slug.split("-").map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("").replace(/[^a-zA-Z0-9_$]/g, "");
+}
+function needsQuoting(name) {
+  return /[^a-zA-Z0-9_$]/.test(name) || /^\d/.test(name);
+}
+function safeQuote(value) {
+  return JSON.stringify(String(value));
+}
+function formatPropName(name) {
+  return needsQuoting(name) ? safeQuote(name) : name;
+}
+function fieldTypeToTS(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "richText":
+    case "email":
+    case "password":
+    case "slug":
+      return "string";
+    case "number":
+      return "number";
+    case "checkbox":
+      return "boolean";
+    case "date":
+      return "string";
+    case "select": {
+      if (field.options && field.options.length > 0) {
+        const union = field.options.map((opt) => safeQuote(opt.value)).join(" | ");
+        return field.hasMany ? `(${union})[]` : union;
+      }
+      return field.hasMany ? "string[]" : "string";
+    }
+    case "radio": {
+      if (field.options && field.options.length > 0) {
+        return field.options.map((opt) => safeQuote(opt.value)).join(" | ");
+      }
+      return "string";
+    }
+    case "relationship": {
+      return field.hasMany ? "string[]" : "string";
+    }
+    case "upload":
+      return field.hasMany ? "string[]" : "string";
+    case "array": {
+      if (field.fields && field.fields.length > 0) {
+        const arrayItemType = generateFieldsInterface(field.fields, "    ");
+        return `Array<{
+${arrayItemType}
+  }>`;
+      }
+      return "unknown[]";
+    }
+    case "group": {
+      if (field.fields && field.fields.length > 0) {
+        const groupType = generateFieldsInterface(field.fields, "    ");
+        return `{
+${groupType}
+  }`;
+      }
+      return "Record<string, unknown>";
+    }
+    case "blocks":
+      return "unknown[]";
+    case "json":
+      return "Record<string, unknown>";
+    case "point":
+      return "[number, number]";
+    default:
+      return "unknown";
+  }
+}
+function generateFieldsInterface(fields, indent = "  ") {
+  const dataFields = flattenDataFields(fields);
+  return dataFields.map((field) => {
+    const tsType = fieldTypeToTS(field);
+    const optional = field.required ? "" : "?";
+    const propName = formatPropName(field.name);
+    return `${indent}${propName}${optional}: ${tsType};`;
+  }).join("\n");
+}
+function generateBlockTypes(collectionName, fieldName, blocksField) {
+  const collectionPascal = slugToPascalCase(collectionName);
+  const fieldPascal = slugToPascalCase(fieldName);
+  const prefix = `${collectionPascal}${fieldPascal}`;
+  const blockTypeNames = [];
+  const declarations = [];
+  for (const block of blocksField.blocks) {
+    const blockPascal = slugToPascalCase(block.slug);
+    const typeName = `${prefix}${blockPascal}Block`;
+    blockTypeNames.push(typeName);
+    const fieldsCode = generateFieldsInterface(block.fields);
+    declarations.push(`export interface ${typeName} {`);
+    declarations.push(`  blockType: ${safeQuote(block.slug)};`);
+    if (fieldsCode) {
+      declarations.push(fieldsCode);
+    }
+    declarations.push(`}`);
+    declarations.push("");
+  }
+  const unionTypeName = `${prefix}Block`;
+  if (blockTypeNames.length > 0) {
+    declarations.push(`export type ${unionTypeName} =`);
+    declarations.push(blockTypeNames.map((name) => `  | ${name}`).join("\n") + ";");
+    declarations.push("");
+  }
+  return { declarations: declarations.join("\n"), unionTypeName };
+}
+function getFieldWhereType(field) {
+  switch (field.type) {
+    case "text":
+    case "textarea":
+    case "richText":
+    case "email":
+    case "slug":
+      return `string | { equals?: string; not?: string; contains?: string; in?: string[] }`;
+    case "number":
+      return `number | { equals?: number; not?: number; gt?: number; gte?: number; lt?: number; lte?: number; in?: number[] }`;
+    case "checkbox":
+      return `boolean | { equals?: boolean }`;
+    case "date":
+      return `string | { equals?: string; not?: string; gt?: string; gte?: string; lt?: string; lte?: string }`;
+    case "select":
+    case "radio": {
+      if (field.options && field.options.length > 0) {
+        const options = field.options.map((opt) => safeQuote(opt.value)).join(" | ");
+        return `${options} | { equals?: ${options}; not?: ${options}; in?: (${options})[] }`;
+      }
+      return `string | { equals?: string; in?: string[] }`;
+    }
+    case "relationship":
+    case "upload":
+      return `string | { equals?: string; not?: string; in?: string[] }`;
+    default:
+      return "unknown";
+  }
+}
+function generateWhereClauseInterface(slug, fields, hasTimestamps) {
+  const interfaceName = slugToPascalCase(slug);
+  const lines = [];
+  const dataFields = flattenDataFields(fields);
+  lines.push(`export interface ${interfaceName}WhereClause {`);
+  lines.push(`  id?: string | { equals?: string; not?: string; in?: string[] };`);
+  for (const field of dataFields) {
+    const whereType = getFieldWhereType(field);
+    if (whereType !== "unknown") {
+      const propName = formatPropName(field.name);
+      lines.push(`  ${propName}?: ${whereType};`);
+    }
+  }
+  if (hasTimestamps) {
+    lines.push(
+      `  createdAt?: string | { equals?: string; gt?: string; gte?: string; lt?: string; lte?: string };`
+    );
+    lines.push(
+      `  updatedAt?: string | { equals?: string; gt?: string; gte?: string; lt?: string; lte?: string };`
+    );
+  }
+  lines.push(`}`);
+  return lines.join("\n");
+}
+
+// libs/core/src/generators/generator.ts
+async function loadConfig(configPath) {
+  try {
+    const configUrl = (0, import_node_url.pathToFileURL)(configPath).href;
+    const configModule = await import(configUrl);
+    return configModule.default || configModule;
+  } catch (error) {
+    throw new Error(`Failed to load config from ${configPath}: ${error}`);
+  }
+}
+function resolveAllCollections(config) {
+  const allCollections = [...config.collections];
+  for (const plugin of config.plugins ?? []) {
+    if (plugin.collections) {
+      for (const col of plugin.collections) {
+        if (!allCollections.some((c) => c.slug === col.slug)) {
+          allCollections.push({ ...col, fields: col.fields ?? [] });
+        }
+      }
+    }
+  }
+  for (const plugin of config.plugins ?? []) {
+    if (plugin.modifyCollections) {
+      plugin.modifyCollections(allCollections);
+    }
+  }
+  return allCollections;
+}
+function generateTypes(config) {
+  const allCollections = resolveAllCollections(config);
+  const globals = config.globals ?? [];
+  const lines = [];
+  lines.push("/**");
+  lines.push(" * AUTO-GENERATED by @momentumcms/core");
+  lines.push(" * DO NOT EDIT - regenerate with: nx run <app>:generate");
+  lines.push(" */");
+  lines.push("");
+  const blockDeclarations = [];
+  for (const collection of allCollections) {
+    const interfaceName = slugToPascalCase(collection.slug);
+    const dataFields = flattenDataFields(collection.fields);
+    const hasVersionsDrafts = hasVersionsWithDrafts(collection);
+    const hasSoftDelete = !!collection.softDelete;
+    const hasTimestamps = collection.timestamps !== false;
+    for (const field of dataFields) {
+      if (field.type === "blocks") {
+        const blockResult = generateBlockTypes(
+          collection.slug,
+          field.name,
+          field
+        );
+        blockDeclarations.push(blockResult.declarations);
+      }
+    }
+    if (blockDeclarations.length > 0) {
+      lines.push(blockDeclarations.join("\n"));
+      blockDeclarations.length = 0;
+    }
+    lines.push(`export interface ${interfaceName} {`);
+    lines.push(`  id: string;`);
+    for (const field of dataFields) {
+      const optional = field.required ? "" : "?";
+      const propName = needsQuoting2(field.name) ? safeQuote(field.name) : field.name;
+      if (field.type === "blocks") {
+        const blockResult = generateBlockTypes(
+          collection.slug,
+          field.name,
+          field
+        );
+        lines.push(`  ${propName}${optional}: ${blockResult.unionTypeName}[];`);
+      } else {
+        const tsType = fieldTypeToTS(field);
+        lines.push(`  ${propName}${optional}: ${tsType};`);
+      }
+    }
+    if (hasVersionsDrafts) {
+      lines.push(`  _status?: 'draft' | 'published';`);
+    }
+    if (hasSoftDelete) {
+      const fieldName = typeof collection.softDelete === "object" && collection.softDelete.field ? collection.softDelete.field : "deletedAt";
+      lines.push(`  ${fieldName}?: string | null;`);
+    }
+    if (hasTimestamps) {
+      lines.push(`  createdAt: string;`);
+      lines.push(`  updatedAt: string;`);
+    }
+    lines.push(`}`);
+    lines.push("");
+  }
+  if (globals.length > 0) {
+    lines.push("// \u2500\u2500 Global Types \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    lines.push("");
+    for (const global of globals) {
+      const interfaceName = slugToPascalCase(global.slug) + "Global";
+      const fieldsCode = generateFieldsInterface(global.fields);
+      lines.push(`export interface ${interfaceName} {`);
+      if (fieldsCode) {
+        lines.push(fieldsCode);
+      }
+      lines.push(`  updatedAt: string;`);
+      lines.push(`}`);
+      lines.push("");
+    }
+  }
+  lines.push("// \u2500\u2500 Where Clauses \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+  lines.push("");
+  for (const collection of allCollections) {
+    const hasTimestamps = collection.timestamps !== false;
+    lines.push(
+      // eslint-disable-next-line @typescript-eslint/consistent-type-assertions -- boundary: local FieldDefinition[] → library Field[]
+      generateWhereClauseInterface(collection.slug, collection.fields, hasTimestamps)
+    );
+    lines.push("");
+  }
+  const slugs = allCollections.map((c) => safeQuote(c.slug)).join(" | ");
+  lines.push(`export type CollectionSlug = ${slugs || "never"};`);
+  lines.push("");
+  if (globals.length > 0) {
+    const globalSlugs = globals.map((g) => safeQuote(g.slug)).join(" | ");
+    lines.push(`export type GlobalSlug = ${globalSlugs};`);
+    lines.push("");
+  }
+  lines.push(`export interface MomentumCollections {`);
+  for (const collection of allCollections) {
+    const interfaceName = slugToPascalCase(collection.slug);
+    lines.push(`  ${safeQuote(collection.slug)}: ${interfaceName};`);
+  }
+  lines.push(`}`);
+  lines.push("");
+  if (globals.length > 0) {
+    lines.push(`export interface MomentumGlobals {`);
+    for (const global of globals) {
+      const interfaceName = slugToPascalCase(global.slug) + "Global";
+      lines.push(`  ${safeQuote(global.slug)}: ${interfaceName};`);
+    }
+    lines.push(`}`);
+    lines.push("");
+  }
+  lines.push(`export type TypedMomentumCollections = {`);
+  for (const collection of allCollections) {
+    const interfaceName = slugToPascalCase(collection.slug);
+    lines.push(
+      `  ${safeQuote(collection.slug)}: { doc: ${interfaceName}; where: ${interfaceName}WhereClause };`
+    );
+  }
+  lines.push(`};`);
+  lines.push("");
+  lines.push(`export type DocumentType<S extends CollectionSlug> = MomentumCollections[S];`);
+  lines.push("");
+  lines.push(
+    `export type WhereClauseType<S extends CollectionSlug> = TypedMomentumCollections[S]['where'];`
+  );
+  lines.push("");
+  return lines.join("\n");
+}
+function hasVersionsWithDrafts(collection) {
+  if (!collection.versions)
+    return false;
+  if (collection.versions === true)
+    return false;
+  return !!collection.versions.drafts;
+}
+function needsQuoting2(name) {
+  return /[^a-zA-Z0-9_$]/.test(name) || /^\d/.test(name);
+}
+var FIELD_STRIP_KEYS = /* @__PURE__ */ new Set(["access", "hooks", "validate", "filterOptions"]);
+var FIELD_ADMIN_STRIP_KEYS = /* @__PURE__ */ new Set(["condition"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function serializeValue(value, indent = "	") {
+  if (value === null)
+    return "null";
+  if (value === void 0)
+    return "undefined";
+  if (typeof value === "string")
+    return JSON.stringify(value);
+  if (typeof value === "number" || typeof value === "boolean")
+    return String(value);
+  if (typeof value === "function")
+    return "undefined";
+  if (Array.isArray(value)) {
+    if (value.length === 0)
+      return "[]";
+    const items = value.map((item) => `${indent}	${serializeValue(item, indent + "	")}`).join(",\n");
+    return `[
+${items},
+${indent}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value).filter(
+      ([, v]) => v !== void 0 && typeof v !== "function"
+    );
+    if (entries.length === 0)
+      return "{}";
+    const props = entries.map(([k, v]) => {
+      const key = needsQuoting2(k) ? safeQuote(k) : k;
+      return `${indent}	${key}: ${serializeValue(v, indent + "	")}`;
+    }).join(",\n");
+    return `{
+${props},
+${indent}}`;
+  }
+  return "undefined";
+}
+function serializeField(field, indent = "		") {
+  const props = [];
+  props.push(`${indent}name: ${JSON.stringify(field.name)}`);
+  props.push(`${indent}type: ${JSON.stringify(field.type)}`);
+  for (const [key, value] of Object.entries(field)) {
+    if (key === "name" || key === "type")
+      continue;
+    if (FIELD_STRIP_KEYS.has(key))
+      continue;
+    if (value === void 0)
+      continue;
+    if (key === "collection" && field.type === "relationship" && typeof value === "function") {
+      const stub = resolveRelationshipStub(field);
+      props.push(`${indent}collection: () => (${stub})`);
+      continue;
+    }
+    if (typeof value === "function")
+      continue;
+    if (key === "admin" && isRecord(value)) {
+      const adminVal = serializeFieldAdmin(value, indent + "	");
+      if (adminVal !== null) {
+        props.push(`${indent}admin: ${adminVal}`);
+      }
+      continue;
+    }
+    if (key === "fields" && Array.isArray(value)) {
+      props.push(`${indent}fields: ${serializeFieldsArray(value, indent + "	")}`);
+      continue;
+    }
+    if (key === "blocks" && Array.isArray(value)) {
+      props.push(`${indent}blocks: ${serializeBlocksArray(value, indent + "	")}`);
+      continue;
+    }
+    if (key === "tabs" && Array.isArray(value)) {
+      props.push(`${indent}tabs: ${serializeTabsArray(value, indent + "	")}`);
+      continue;
+    }
+    if (key === "defaultValue") {
+      if (typeof value === "string" || typeof value === "number" || typeof value === "boolean") {
+        props.push(`${indent}defaultValue: ${serializeValue(value)}`);
+      }
+      continue;
+    }
+    props.push(`${indent}${key}: ${serializeValue(value, indent + "	")}`);
+  }
+  return `{
+${props.join(",\n")},
+${indent.slice(0, -1)}}`;
+}
+function serializeFieldAdmin(admin, indent) {
+  const entries = Object.entries(admin).filter(
+    ([k, v]) => v !== void 0 && typeof v !== "function" && !FIELD_ADMIN_STRIP_KEYS.has(k)
+  );
+  if (entries.length === 0)
+    return null;
+  const props = entries.map(([k, v]) => `${indent}	${k}: ${serializeValue(v, indent + "	")}`).join(",\n");
+  return `{
+${props},
+${indent}}`;
+}
+function resolveRelationshipStub(field) {
+  if (!field.collection)
+    return "{}";
+  try {
+    const config = field.collection();
+    if (!config || typeof config !== "object")
+      return "{}";
+    const c = config;
+    const parts = [];
+    if (typeof c["slug"] === "string") {
+      parts.push(`slug: ${JSON.stringify(c["slug"])}`);
+    }
+    const labels = c["labels"];
+    if (labels && typeof labels === "object") {
+      const l = labels;
+      const labelParts = [];
+      if (typeof l["singular"] === "string")
+        labelParts.push(`singular: ${JSON.stringify(l["singular"])}`);
+      if (typeof l["plural"] === "string")
+        labelParts.push(`plural: ${JSON.stringify(l["plural"])}`);
+      if (labelParts.length > 0) {
+        parts.push(`labels: { ${labelParts.join(", ")} }`);
+      }
+    }
+    const admin = c["admin"];
+    if (admin && typeof admin === "object") {
+      const a = admin;
+      if (typeof a["useAsTitle"] === "string") {
+        parts.push(`admin: { useAsTitle: ${JSON.stringify(a["useAsTitle"])} }`);
+      }
+    }
+    return `{ ${parts.join(", ")} }`;
+  } catch {
+    return "{}";
+  }
+}
+function serializeFieldsArray(fields, indent) {
+  if (fields.length === 0)
+    return "[]";
+  const items = fields.map((f) => `${indent}	${serializeField(f, indent + "		")}`).join(",\n");
+  return `[
+${items},
+${indent}]`;
+}
+function serializeBlocksArray(blocks, indent) {
+  if (blocks.length === 0)
+    return "[]";
+  const items = blocks.map((block) => {
+    const parts = [];
+    parts.push(`${indent}		slug: ${JSON.stringify(block.slug)}`);
+    parts.push(`${indent}		fields: ${serializeFieldsArray(block.fields, indent + "		")}`);
+    if (block.labels) {
+      parts.push(`${indent}		labels: ${serializeValue(block.labels, indent + "		")}`);
+    }
+    if (block.editor) {
+      const editorStr = serializeValue(block.editor, indent + "		");
+      if (editorStr !== "undefined") {
+        parts.push(`${indent}		editor: ${editorStr}`);
+      }
+    }
+    return `${indent}	{
+${parts.join(",\n")},
+${indent}	}`;
+  }).join(",\n");
+  return `[
+${items},
+${indent}]`;
+}
+function serializeTabsArray(tabs, indent) {
+  if (tabs.length === 0)
+    return "[]";
+  const items = tabs.map((tab) => {
+    const parts = [];
+    parts.push(`${indent}		label: ${JSON.stringify(tab.label)}`);
+    if (tab.description) {
+      parts.push(`${indent}		description: ${JSON.stringify(tab.description)}`);
+    }
+    parts.push(`${indent}		fields: ${serializeFieldsArray(tab.fields, indent + "		")}`);
+    return `${indent}	{
+${parts.join(",\n")},
+${indent}	}`;
+  }).join(",\n");
+  return `[
+${items},
+${indent}]`;
+}
+function serializeCollection(collection, indent = "	") {
+  const parts = [];
+  parts.push(`${indent}	slug: ${JSON.stringify(collection.slug)}`);
+  if (collection.labels) {
+    parts.push(`${indent}	labels: ${serializeValue(collection.labels, indent + "	")}`);
+  }
+  parts.push(`${indent}	fields: ${serializeFieldsArray(collection.fields, indent + "	")}`);
+  if (collection.admin) {
+    const adminEntries = Object.entries(collection.admin).filter(
+      ([, v]) => v !== void 0 && typeof v !== "function"
+    );
+    if (adminEntries.length > 0) {
+      const adminObj = Object.fromEntries(adminEntries);
+      parts.push(`${indent}	admin: ${serializeValue(adminObj, indent + "	")}`);
+    }
+  }
+  if (collection.auth) {
+    parts.push(`${indent}	auth: true`);
+  }
+  if (collection.timestamps !== void 0) {
+    parts.push(`${indent}	timestamps: ${serializeValue(collection.timestamps, indent + "	")}`);
+  }
+  if (collection.versions !== void 0) {
+    parts.push(`${indent}	versions: ${serializeValue(collection.versions, indent + "	")}`);
+  }
+  if (collection.softDelete !== void 0) {
+    parts.push(`${indent}	softDelete: ${serializeValue(collection.softDelete, indent + "	")}`);
+  }
+  if (collection.managed !== void 0) {
+    parts.push(`${indent}	managed: ${String(collection.managed)}`);
+  }
+  if (collection.defaultSort) {
+    parts.push(`${indent}	defaultSort: ${JSON.stringify(collection.defaultSort)}`);
+  }
+  return `{
+${parts.join(",\n")},
+${indent}}`;
+}
+function serializeGlobal(global, indent = "	") {
+  const parts = [];
+  parts.push(`${indent}	slug: ${JSON.stringify(global.slug)}`);
+  if (global.label) {
+    parts.push(`${indent}	label: ${JSON.stringify(global.label)}`);
+  }
+  parts.push(`${indent}	fields: ${serializeFieldsArray(global.fields, indent + "	")}`);
+  if (global.admin) {
+    const adminEntries = Object.entries(global.admin).filter(
+      ([, v]) => v !== void 0 && typeof v !== "function"
+    );
+    if (adminEntries.length > 0) {
+      const adminObj = Object.fromEntries(adminEntries);
+      parts.push(`${indent}	admin: ${serializeValue(adminObj, indent + "	")}`);
+    }
+  }
+  if (global.versions !== void 0) {
+    parts.push(`${indent}	versions: ${serializeValue(global.versions, indent + "	")}`);
+  }
+  return `{
+${parts.join(",\n")},
+${indent}}`;
+}
+function computeRelativeImport(fromFile, toFile) {
+  const fromDir = (0, import_node_path.dirname)(fromFile);
+  let rel = (0, import_node_path.relative)(fromDir, toFile);
+  rel = rel.replace(/\.ts$/, "");
+  if (!rel.startsWith(".")) {
+    rel = "./" + rel;
+  }
+  return rel;
+}
+function generateAdminConfig(config, typesRelPath) {
+  const lines = [];
+  const allCollections = resolveAllCollections(config);
+  const globals = config.globals ?? [];
+  const plugins = config.plugins ?? [];
+  const pluginsWithAdminRoutes = plugins.filter(
+    (p) => p.browserImports?.adminRoutes && p.adminRoutes && p.adminRoutes.length > 0
+  );
+  lines.push("/**");
+  lines.push(" * AUTO-GENERATED by @momentumcms/core");
+  lines.push(" * DO NOT EDIT - regenerate with: nx run <app>:generate");
+  lines.push(" */");
+  lines.push("");
+  lines.push("import type { MomentumAdminConfig } from '@momentumcms/core';");
+  const typeImports = ["CollectionSlug"];
+  if (globals.length > 0) {
+    typeImports.push("GlobalSlug");
+  }
+  lines.push(`import type { ${typeImports.join(", ")} } from '${typesRelPath}';`);
+  for (const plugin of pluginsWithAdminRoutes) {
+    const imp = plugin.browserImports.adminRoutes;
+    lines.push(`import { ${imp.exportName} } from '${imp.path}';`);
+  }
+  lines.push("");
+  const genericParams = globals.length > 0 ? "<CollectionSlug, GlobalSlug>" : "<CollectionSlug>";
+  lines.push(`export const adminConfig: MomentumAdminConfig${genericParams} = {`);
+  if (allCollections.length > 0) {
+    const collectionItems = allCollections.map((c) => `		${serializeCollection(c, "		")}`).join(",\n");
+    lines.push(`	collections: [
+${collectionItems},
+	],`);
+  } else {
+    lines.push("	collections: [],");
+  }
+  if (globals.length > 0) {
+    const globalItems = globals.map((g) => `		${serializeGlobal(g, "		")}`).join(",\n");
+    lines.push(`	globals: [
+${globalItems},
+	],`);
+  }
+  if (config.admin) {
+    const adminObj = {};
+    if (config.admin.basePath)
+      adminObj["basePath"] = config.admin.basePath;
+    if (config.admin.branding)
+      adminObj["branding"] = config.admin.branding;
+    if (config.admin.toasts !== void 0)
+      adminObj["toasts"] = config.admin.toasts;
+    if (Object.keys(adminObj).length > 0) {
+      lines.push(`	admin: ${serializeValue(adminObj)},`);
+    }
+  }
+  if (pluginsWithAdminRoutes.length > 0) {
+    const pluginItems = pluginsWithAdminRoutes.map((p) => {
+      const imp = p.browserImports.adminRoutes;
+      return `		{ name: ${JSON.stringify(p.name)}, adminRoutes: ${imp.exportName} }`;
+    }).join(",\n");
+    lines.push(`	plugins: [
+${pluginItems},
+	],`);
+  }
+  lines.push("};");
+  lines.push("");
+  return lines.join("\n");
+}
+function parseArgs(args) {
+  const configPath = args[0];
+  let typesOutputPath = "";
+  let configOutputPath = "";
+  let watchMode = false;
+  for (let i = 1; i < args.length; i++) {
+    if (args[i] === "--types" && args[i + 1]) {
+      typesOutputPath = args[++i];
+    } else if (args[i] === "--config" && args[i + 1]) {
+      configOutputPath = args[++i];
+    } else if (args[i] === "--watch") {
+      watchMode = true;
+    }
+  }
+  if (!configPath) {
+    console.error(
+      "Usage: npx tsx generator.ts <config-path> --types <types-output> --config <config-output> [--watch]"
+    );
+    process.exit(1);
+  }
+  if (!typesOutputPath) {
+    typesOutputPath = "src/generated/momentum.types.ts";
+  }
+  if (!configOutputPath) {
+    configOutputPath = "src/generated/momentum.config.ts";
+  }
+  return { configPath, typesOutputPath, configOutputPath, watch: watchMode };
+}
+async function runGenerator(options) {
+  const configPath = (0, import_node_path.resolve)(options.configPath);
+  const typesOutputPath = (0, import_node_path.resolve)(options.typesOutputPath);
+  const configOutputPath = (0, import_node_path.resolve)(options.configOutputPath);
+  console.info(`Generating from: ${configPath}`);
+  console.info(`Types output: ${typesOutputPath}`);
+  console.info(`Config output: ${configOutputPath}`);
+  const typesRelPath = computeRelativeImport(configOutputPath, typesOutputPath);
+  async function generate() {
+    try {
+      const config = await loadConfig(configPath);
+      const typesContent = generateTypes(config);
+      (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(typesOutputPath), { recursive: true });
+      (0, import_node_fs.writeFileSync)(typesOutputPath, typesContent, "utf-8");
+      console.info(`Types generated: ${typesOutputPath}`);
+      const adminConfigContent = generateAdminConfig(config, typesRelPath);
+      (0, import_node_fs.mkdirSync)((0, import_node_path.dirname)(configOutputPath), { recursive: true });
+      (0, import_node_fs.writeFileSync)(configOutputPath, adminConfigContent, "utf-8");
+      console.info(`Admin config generated: ${configOutputPath}`);
+    } catch (error) {
+      console.error(`Error generating:`, error);
+      throw error;
+    }
+  }
+  await generate();
+  if (options.watch) {
+    console.info(`Watching for changes...`);
+    const configDir = (0, import_node_path.dirname)(configPath);
+    let debounceTimer = null;
+    (0, import_node_fs.watch)(configDir, { recursive: true }, (_eventType, filename) => {
+      if (!filename?.endsWith(".ts"))
+        return;
+      if (debounceTimer)
+        clearTimeout(debounceTimer);
+      debounceTimer = setTimeout(() => {
+        debounceTimer = null;
+        console.info(`Change detected: ${filename}`);
+        try {
+          (0, import_node_child_process.execFileSync)(
+            process.execPath,
+            [
+              ...process.execArgv,
+              process.argv[1],
+              configPath,
+              "--types",
+              typesOutputPath,
+              "--config",
+              configOutputPath
+            ],
+            { stdio: "inherit" }
+          );
+        } catch {
+        }
+      }, 100);
+    });
+    return new Promise(() => {
+    });
+  }
+  return { success: true };
+}
+if (process.argv[1]?.endsWith("generator.ts") || process.argv[1]?.endsWith("generator.js") || process.argv[1]?.endsWith("generator.cjs")) {
+  const options = parseArgs(process.argv.slice(2));
+  runGenerator(options).then((result) => {
+    if (!result.success) {
+      process.exit(1);
+    }
+  }).catch((error) => {
+    console.error(error);
+    process.exit(1);
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  computeRelativeImport,
+  generateAdminConfig,
+  generateTypes,
+  serializeCollection,
+  serializeField,
+  serializeGlobal,
+  serializeValue
+});