@nextbridgehq/payload-block-builder 0.1.0

package/dist/index.js

@@ -0,0 +1,1199 @@
+// src/plugin.ts
+import { randomUUID } from "crypto";
+
+// src/access/authenticated.ts
+var authenticated = ({ req: { user } }) => Boolean(user);
+
+// src/collections/BlockDefinitions.ts
+var BlockDefinitions = {
+  slug: "block-definitions",
+  admin: {
+    useAsTitle: "name",
+    defaultColumns: ["name", "slug", "currentVersion", "updatedAt"],
+    group: "Dynamic Blocks",
+    hidden: true
+  },
+  access: {
+    create: authenticated,
+    read: authenticated,
+    update: authenticated,
+    delete: authenticated
+  },
+  fields: [
+    {
+      name: "name",
+      type: "text",
+      required: true,
+      admin: { description: 'Human-readable label, e.g. "Hero Section"' }
+    },
+    {
+      name: "slug",
+      type: "text",
+      required: true,
+      unique: true,
+      admin: { description: 'Machine identifier, e.g. "hero-section". Should not change after creation.' }
+    },
+    {
+      name: "description",
+      type: "textarea",
+      required: false
+    },
+    {
+      name: "currentVersion",
+      type: "relationship",
+      relationTo: "block-definition-versions",
+      required: false,
+      admin: {
+        description: "The active schema version used when editors add a new instance of this block."
+      }
+    },
+    {
+      name: "editInBuilderButton",
+      type: "ui",
+      admin: {
+        components: {
+          Field: "@nextbridgehq/payload-block-builder/client#EditInBuilderButton"
+        }
+      }
+    }
+  ]
+};
+
+// src/collections/BlockDefinitionVersions.ts
+var BlockDefinitionVersions = {
+  slug: "block-definition-versions",
+  admin: {
+    useAsTitle: "label",
+    defaultColumns: ["blockDefinition", "versionNumber", "label", "createdAt"],
+    group: "Dynamic Blocks",
+    hidden: true
+  },
+  access: {
+    create: authenticated,
+    read: authenticated,
+    update: () => false,
+    delete: authenticated
+  },
+  fields: [
+    {
+      name: "blockDefinition",
+      type: "relationship",
+      relationTo: "block-definitions",
+      required: true,
+      admin: { description: "Which block type this version belongs to." }
+    },
+    {
+      name: "versionNumber",
+      type: "number",
+      required: true,
+      admin: { description: "Monotonically increasing integer, e.g. 1, 2, 3." }
+    },
+    {
+      name: "label",
+      type: "text",
+      required: false,
+      admin: { description: 'Optional display name, e.g. "v2 \xE2\u20AC\u201D added hero image".' }
+    },
+    {
+      name: "schema",
+      type: "json",
+      required: true,
+      admin: {
+        description: 'JSON object with a "fields" array of BlockFieldDefinition objects. Use the visual editor below to build the schema.',
+        components: {
+          Field: "@nextbridgehq/payload-block-builder/client#SchemaBuilderField"
+        }
+      }
+    },
+    {
+      name: "changelog",
+      type: "textarea",
+      required: false,
+      admin: { description: "Notes on what changed in this version." }
+    }
+  ]
+};
+
+// src/fields/dbLayoutField.ts
+function dbLayoutField(fieldName = "dbLayout", tabLabel = "DB Layout") {
+  return {
+    label: tabLabel,
+    fields: [
+      {
+        name: fieldName,
+        type: "array",
+        label: "DB Layout Blocks",
+        admin: {
+          description: "Dynamic blocks rendered on this page. Add blocks, select a block definition and version, then fill in the data fields that appear.",
+          initCollapsed: true
+        },
+        fields: [
+          {
+            name: "blockDefinition",
+            type: "relationship",
+            relationTo: "block-definitions",
+            required: true,
+            admin: { description: "Which block type to use." }
+          },
+          {
+            name: "blockVersion",
+            type: "relationship",
+            relationTo: "block-definition-versions",
+            required: true,
+            admin: { description: "Which schema version to use." }
+          },
+          {
+            name: "instanceId",
+            type: "text",
+            admin: {
+              hidden: true,
+              readOnly: true,
+              description: "Auto-assigned unique ID for this block instance."
+            }
+          },
+          {
+            name: "label",
+            type: "text",
+            admin: {
+              description: "Optional label to identify this block in the list."
+            }
+          },
+          {
+            name: "data",
+            type: "json",
+            admin: {
+              description: "Block field data. Automatically populated from the selected schema.",
+              components: {
+                Field: "@nextbridgehq/payload-block-builder/client#BlockDataField"
+              }
+            }
+          },
+          {
+            name: "hidden",
+            type: "checkbox",
+            defaultValue: false,
+            admin: { description: "Hide this block on the frontend." }
+          },
+          {
+            name: "anchor",
+            type: "text",
+            admin: { description: "Optional HTML anchor ID for deep-linking." }
+          }
+        ]
+      }
+    ]
+  };
+}
+
+// src/block-builder/lib/codegen.ts
+function indent(n) {
+  return "  ".repeat(n);
+}
+function escStr(s) {
+  return s.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function fieldToCode(field, depth = 1) {
+  const pad = indent(depth);
+  const innerPad = indent(depth + 1);
+  const lines = [];
+  lines.push(`${pad}name: '${escStr(field.name)}'`);
+  lines.push(`${pad}type: '${field.type}'`);
+  if (field.label) lines.push(`${pad}label: '${escStr(field.label)}'`);
+  if (field.required) lines.push(`${pad}required: true`);
+  if (field.unique) lines.push(`${pad}unique: true`);
+  if (field.localized) lines.push(`${pad}localized: true`);
+  if (field.defaultValue !== void 0) {
+    const val = typeof field.defaultValue === "string" ? `'${escStr(String(field.defaultValue))}'` : field.defaultValue;
+    lines.push(`${pad}defaultValue: ${val}`);
+  }
+  if (field.type === "richText") {
+    lines.push(`${pad}editor: lexicalEditor({})`);
+  }
+  if (field.options && field.options.length > 0) {
+    const opts = field.options.map((o) => `{ label: '${escStr(o.label)}', value: '${escStr(o.value)}' }`).join(`, `);
+    lines.push(`${pad}options: [${opts}]`);
+  }
+  if (field.relationTo) {
+    lines.push(`${pad}relationTo: '${escStr(field.relationTo)}'`);
+  }
+  if (field.hasMany !== void 0) {
+    lines.push(`${pad}hasMany: ${field.hasMany}`);
+  }
+  if (field.minRows !== void 0) lines.push(`${pad}minRows: ${field.minRows}`);
+  if (field.maxRows !== void 0) lines.push(`${pad}maxRows: ${field.maxRows}`);
+  if (field.fields && field.fields.length > 0) {
+    const nested = field.fields.map((f) => `${innerPad}{
+${fieldToCode(f, depth + 2)}
+${innerPad}}`).join(",\n");
+    lines.push(`${pad}fields: [
+${nested}
+${innerPad}]`);
+  }
+  const adminParts = [];
+  if (field.admin?.description)
+    adminParts.push(`description: '${escStr(field.admin.description)}'`);
+  if (field.admin?.placeholder)
+    adminParts.push(`placeholder: '${escStr(field.admin.placeholder)}'`);
+  if (field.admin?.readOnly) adminParts.push(`readOnly: true`);
+  if (field.admin?.hidden) adminParts.push(`hidden: true`);
+  if (adminParts.length > 0) {
+    lines.push(`${pad}admin: { ${adminParts.join(", ")} }`);
+  }
+  return lines.join(",\n");
+}
+function generateBlockCode(block) {
+  const hasRichText = containsRichText(block.fields);
+  const imports = [`import type { Block } from 'payload'`];
+  if (hasRichText) {
+    imports.push(`import { lexicalEditor } from '@payloadcms/richtext-lexical'`);
+  }
+  const fieldsCode = block.fields.map((f) => `  {
+${fieldToCode(f, 2)}
+  }`).join(",\n");
+  const labelsCode = block.labels ? `
+  labels: {
+    singular: '${escStr(block.labels.singular ?? block.slug)}',
+    plural: '${escStr(block.labels.plural ?? block.slug + "s")}',
+  },` : "";
+  const interfaceLine = block.interfaceName ? `
+  interfaceName: '${escStr(block.interfaceName)}',` : "";
+  const exportName = block.interfaceName ?? toCamelCase(block.slug);
+  return [
+    imports.join("\n"),
+    "",
+    `export const ${exportName}: Block = {`,
+    `  slug: '${escStr(block.slug)}',${interfaceLine}${labelsCode}`,
+    `  fields: [`,
+    fieldsCode,
+    `  ],`,
+    `}`,
+    ""
+  ].join("\n");
+}
+function containsRichText(fields) {
+  return fields.some(
+    (f) => f.type === "richText" || (f.fields ? containsRichText(f.fields) : false)
+  );
+}
+function toCamelCase(slug) {
+  return slug.split(/[-_]/).map(
+    (part, i) => i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)
+  ).join("");
+}
+function generateBlockOutput(block) {
+  return {
+    filename: `${block.slug}.ts`,
+    code: generateBlockCode(block),
+    language: "typescript"
+  };
+}
+function generateAllBlocks(blocks) {
+  return blocks.map(generateBlockOutput);
+}
+function generateIndexFile(blocks) {
+  const exportName = (b) => b.interfaceName ?? toCamelCase(b.slug);
+  const imports = blocks.map((b) => `import { ${exportName(b)} } from './${b.slug}'`).join("\n");
+  const exportList = blocks.map((b) => `  ${exportName(b)}`).join(",\n");
+  const code = [
+    imports,
+    "",
+    `export const blocks = [`,
+    exportList,
+    `] as const`,
+    ""
+  ].join("\n");
+  return { filename: "index.ts", code, language: "typescript" };
+}
+
+// src/endpoints/generate.ts
+var generateEndpoint = async (req) => {
+  if (!req.user) {
+    return Response.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  let blocks;
+  try {
+    if (!req.json) return Response.json({ error: "No JSON parser available" }, { status: 500 });
+    const body = await req.json();
+    blocks = body.blocks ?? [];
+  } catch {
+    return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+  const blockOutputs = generateAllBlocks(blocks);
+  const indexOutput = generateIndexFile(blocks);
+  const fileMap = {};
+  for (const out of blockOutputs) {
+    fileMap[out.filename] = out.code;
+  }
+  fileMap[indexOutput.filename] = indexOutput.code;
+  return Response.json({ files: fileMap });
+};
+
+// src/block-builder/lib/schemaToBuilderBlock.ts
+import { v4 as uuidv4 } from "uuid";
+var REVERSE_TYPE_MAP = {
+  richtext: "richText",
+  image: "upload"
+};
+var VALID_BUILDER_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "number",
+  "email",
+  "checkbox",
+  "select",
+  "radio",
+  "date",
+  "richText",
+  "upload",
+  "relationship",
+  "array",
+  "group",
+  "tabs",
+  "row",
+  "collapsible",
+  "json",
+  "code",
+  "point",
+  "ui"
+]);
+function fieldToBuilderField(raw) {
+  const rawType = String(raw.type ?? "text");
+  const mappedType = REVERSE_TYPE_MAP[rawType] ?? rawType;
+  const fieldType = VALID_BUILDER_TYPES.has(mappedType) ? mappedType : "text";
+  const field = {
+    id: uuidv4(),
+    type: fieldType,
+    name: String(raw.name ?? "field"),
+    label: raw.label ? String(raw.label) : void 0,
+    required: Boolean(raw.required)
+  };
+  if (raw.options && Array.isArray(raw.options)) {
+    field.options = raw.options.map(
+      (o) => typeof o === "string" ? { label: o, value: o } : { label: String(o.label), value: String(o.value) }
+    );
+  }
+  if (raw.hasMany !== void 0) field.hasMany = Boolean(raw.hasMany);
+  if (raw.collection) field.relationTo = String(raw.collection);
+  if (raw.relationTo) {
+    field.relationTo = String(raw.relationTo);
+  }
+  if (raw.minRows !== void 0) field.minRows = Number(raw.minRows);
+  if (raw.maxRows !== void 0) field.maxRows = Number(raw.maxRows);
+  if (raw.fields && Array.isArray(raw.fields)) {
+    field.fields = raw.fields.map(fieldToBuilderField);
+  }
+  if (raw.admin && typeof raw.admin === "object") {
+    const a = raw.admin;
+    field.admin = {
+      description: a.description ? String(a.description) : void 0,
+      placeholder: a.placeholder ? String(a.placeholder) : void 0,
+      readOnly: Boolean(a.readOnly),
+      hidden: Boolean(a.hidden)
+    };
+  }
+  return field;
+}
+function slugToInterfaceName(slug) {
+  return slug.split(/[-_]/).map((part) => part.charAt(0).toUpperCase() + part.slice(1)).join("");
+}
+function schemaToBuilderBlock(slug, name, labels, schemaFields) {
+  return {
+    id: uuidv4(),
+    slug,
+    interfaceName: slugToInterfaceName(slug),
+    labels,
+    fields: schemaFields.map(fieldToBuilderField)
+  };
+}
+
+// src/endpoints/load.ts
+var loadEndpoint = async (req) => {
+  if (!req.user) {
+    return Response.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  const slug = req.routeParams?.slug;
+  if (!slug) {
+    return Response.json({ error: "Slug is required" }, { status: 400 });
+  }
+  const requestedVersionId = req.url ? new URL(req.url).searchParams.get("versionId") : null;
+  const result = await req.payload.find({
+    collection: "block-definitions",
+    where: { slug: { equals: slug } },
+    depth: 2,
+    limit: 1
+  });
+  const def = result.docs[0];
+  if (!def) {
+    return Response.json({ error: `Block definition "${slug}" not found` }, { status: 404 });
+  }
+  const name = def.name ?? slug;
+  const currentVersionId = def.currentVersion && typeof def.currentVersion === "object" ? String(def.currentVersion.id) : typeof def.currentVersion === "string" || typeof def.currentVersion === "number" ? String(def.currentVersion) : null;
+  let version = null;
+  if (requestedVersionId) {
+    try {
+      const v = await req.payload.findByID({
+        collection: "block-definition-versions",
+        id: requestedVersionId,
+        depth: 0
+      });
+      version = v;
+    } catch {
+      return Response.json({ error: `Version "${requestedVersionId}" not found` }, { status: 404 });
+    }
+  } else if (def.currentVersion && typeof def.currentVersion === "object") {
+    version = def.currentVersion;
+  } else {
+    const latestResult = await req.payload.find({
+      collection: "block-definition-versions",
+      where: { blockDefinition: { equals: def.id } },
+      sort: "-versionNumber",
+      depth: 0,
+      limit: 1
+    });
+    version = latestResult.docs[0] ?? null;
+  }
+  if (!version) {
+    const block2 = schemaToBuilderBlock(slug, name, {}, []);
+    return Response.json({ block: block2, versionId: null, versionNumber: null, isCurrent: true });
+  }
+  const versionId = String(version.id);
+  const schema = version.schema;
+  const schemaFields = schema ? Array.isArray(schema) ? schema : schema.fields ?? [] : [];
+  const labels = version.labels ?? {};
+  const versionNumber = version.versionNumber;
+  const block = schemaToBuilderBlock(slug, name, labels, schemaFields);
+  return Response.json({
+    block,
+    versionId,
+    versionNumber: versionNumber ?? null,
+    isCurrent: versionId === currentVersionId
+  });
+};
+
+// src/builder/normalizer.ts
+var KNOWN_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "richtext",
+  "number",
+  "checkbox",
+  "select",
+  "multiselect",
+  "date",
+  "image",
+  "file",
+  "url",
+  "email",
+  "color",
+  "array",
+  "group",
+  "relationship",
+  "json",
+  "blocks"
+]);
+function normaliseOption(opt) {
+  if (typeof opt === "string") {
+    return { label: opt, value: opt.toLowerCase().replace(/\s+/g, "-") };
+  }
+  if (opt && typeof opt === "object") {
+    const o = opt;
+    const value = String(o.value ?? o.label ?? "").toLowerCase().replace(/\s+/g, "-");
+    const label = String(o.label ?? o.value ?? value);
+    return { label, value };
+  }
+  return { label: String(opt), value: String(opt) };
+}
+function normaliseConditions(raw) {
+  if (!Array.isArray(raw)) return void 0;
+  const result = [];
+  for (const item of raw) {
+    if (item && typeof item === "object" && !Array.isArray(item)) {
+      const c = item;
+      if (typeof c.field === "string" && typeof c.operator === "string") {
+        result.push({ field: c.field, operator: c.operator, value: c.value });
+      }
+    }
+  }
+  return result.length > 0 ? result : void 0;
+}
+function normaliseValidation(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const v = raw;
+  const out = {};
+  if (typeof v.required === "boolean") out.required = v.required;
+  if (typeof v.minLength === "number") out.minLength = v.minLength;
+  if (typeof v.maxLength === "number") out.maxLength = v.maxLength;
+  if (typeof v.regex === "string") out.regex = v.regex;
+  if (typeof v.min === "number") out.min = v.min;
+  if (typeof v.max === "number") out.max = v.max;
+  if (typeof v.step === "number") out.step = v.step;
+  if (typeof v.integerOnly === "boolean") out.integerOnly = v.integerOnly;
+  if (typeof v.minRows === "number") out.minRows = v.minRows;
+  if (typeof v.maxRows === "number") out.maxRows = v.maxRows;
+  if (typeof v.uniqueItems === "boolean") out.uniqueItems = v.uniqueItems;
+  if (Array.isArray(v.allowedMimeTypes)) out.allowedMimeTypes = v.allowedMimeTypes;
+  if (typeof v.maxFileSize === "number") out.maxFileSize = v.maxFileSize;
+  if (typeof v.maxSelections === "number") out.maxSelections = v.maxSelections;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normaliseUI(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return void 0;
+  const u = raw;
+  const out = {};
+  if (typeof u.tab === "string") out.tab = u.tab;
+  if (typeof u.section === "string") out.section = u.section;
+  if (["full", "half", "third", "quarter"].includes(u.width)) {
+    out.width = u.width;
+  }
+  if (typeof u.collapsed === "boolean") out.collapsed = u.collapsed;
+  if (typeof u.order === "number") out.order = u.order;
+  return Object.keys(out).length > 0 ? out : void 0;
+}
+function normaliseField(raw) {
+  const type = raw.type ?? "text";
+  const resolvedType = KNOWN_TYPES.has(type) ? type : "text";
+  const base = {
+    name: String(raw.name ?? "").trim(),
+    type: resolvedType
+  };
+  if (raw.label) base.label = String(raw.label);
+  if (raw.required !== void 0) base.required = Boolean(raw.required);
+  if (raw.admin && typeof raw.admin === "object") base.admin = raw.admin;
+  const conditions = normaliseConditions(raw.conditions);
+  if (conditions) base.conditions = conditions;
+  if (raw.conditionMode === "AND" || raw.conditionMode === "OR") {
+    base.conditionMode = raw.conditionMode;
+  }
+  const validation = normaliseValidation(raw.validation);
+  if (validation) base.validation = validation;
+  const ui = normaliseUI(raw.ui);
+  if (ui) base.ui = ui;
+  switch (resolvedType) {
+    case "text":
+    case "textarea": {
+      if (raw.minLength !== void 0) base.minLength = Number(raw.minLength);
+      if (raw.maxLength !== void 0) base.maxLength = Number(raw.maxLength);
+      if (raw.defaultValue !== void 0) base.defaultValue = raw.defaultValue;
+      break;
+    }
+    case "number": {
+      if (raw.min !== void 0) base.min = Number(raw.min);
+      if (raw.max !== void 0) base.max = Number(raw.max);
+      if (raw.defaultValue !== void 0) base.defaultValue = raw.defaultValue;
+      break;
+    }
+    case "checkbox": {
+      if (raw.defaultValue !== void 0) base.defaultValue = Boolean(raw.defaultValue);
+      break;
+    }
+    case "select":
+    case "multiselect": {
+      const rawOpts = Array.isArray(raw.options) ? raw.options : [];
+      base.options = rawOpts.map(normaliseOption);
+      if (raw.defaultValue !== void 0) base.defaultValue = raw.defaultValue;
+      break;
+    }
+    case "date": {
+      if (raw.timeFormat !== void 0) base.timeFormat = Boolean(raw.timeFormat);
+      break;
+    }
+    case "array": {
+      const subFields = Array.isArray(raw.fields) ? raw.fields.map(normaliseField) : [];
+      base.fields = subFields;
+      if (raw.minRows !== void 0) base.minRows = Number(raw.minRows);
+      if (raw.maxRows !== void 0) base.maxRows = Number(raw.maxRows);
+      break;
+    }
+    case "group": {
+      const subFields = Array.isArray(raw.fields) ? raw.fields.map(normaliseField) : [];
+      base.fields = subFields;
+      break;
+    }
+    case "relationship": {
+      if (raw.collection) base.collection = String(raw.collection);
+      if (raw.hasMany !== void 0) base.hasMany = Boolean(raw.hasMany);
+      break;
+    }
+    case "file": {
+      if (Array.isArray(raw.allowedMimeTypes)) base.allowedMimeTypes = raw.allowedMimeTypes;
+      break;
+    }
+    case "blocks": {
+      if (Array.isArray(raw.allowedBlocks)) {
+        base.allowedBlocks = raw.allowedBlocks.map(String).filter(Boolean);
+      }
+      if (raw.minBlocks !== void 0) base.minBlocks = Number(raw.minBlocks);
+      if (raw.maxBlocks !== void 0) base.maxBlocks = Number(raw.maxBlocks);
+      break;
+    }
+  }
+  return base;
+}
+function normaliseSchema(raw) {
+  const fields = Array.isArray(raw.fields) ? raw.fields.map(normaliseField) : [];
+  const schema = { fields };
+  if (raw.layout === "sidebar" || raw.layout === "tabs") {
+    schema.layout = raw.layout;
+  } else {
+    schema.layout = "default";
+  }
+  return schema;
+}
+
+// src/validation/schemaValidator.ts
+var VALID_FIELD_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "richtext",
+  "number",
+  "checkbox",
+  "select",
+  "multiselect",
+  "date",
+  "image",
+  "file",
+  "url",
+  "email",
+  "color",
+  "array",
+  "group",
+  "relationship",
+  "json",
+  "blocks"
+]);
+var CONTAINER_TYPES = /* @__PURE__ */ new Set(["array", "group"]);
+var LEAF_NAME_RE = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+var VALID_CONDITION_OPERATORS = /* @__PURE__ */ new Set([
+  "equals",
+  "not_equals",
+  "contains",
+  "not_contains",
+  "greater_than",
+  "less_than",
+  "in",
+  "not_in",
+  "exists",
+  "empty"
+]);
+function validateConditions(conditions, path, errors) {
+  if (!Array.isArray(conditions)) {
+    errors.push(`${path}: "conditions" must be an array.`);
+    return;
+  }
+  ;
+  conditions.forEach((cond, i) => {
+    const cp = `${path}[${i}]`;
+    if (!cond || typeof cond !== "object") {
+      errors.push(`${cp}: condition must be an object.`);
+      return;
+    }
+    const c = cond;
+    if (typeof c.field !== "string" || !c.field.trim()) {
+      errors.push(`${cp}: "field" must be a non-empty string.`);
+    }
+    if (typeof c.operator !== "string" || !VALID_CONDITION_OPERATORS.has(c.operator)) {
+      errors.push(
+        `${cp}: "operator" must be one of: ${[...VALID_CONDITION_OPERATORS].join(", ")}.`
+      );
+    }
+  });
+}
+function validateValidationRules(v, path, errors) {
+  const numericProps = [
+    "minLength",
+    "maxLength",
+    "min",
+    "max",
+    "step",
+    "minRows",
+    "maxRows",
+    "maxFileSize",
+    "maxSelections"
+  ];
+  for (const prop of numericProps) {
+    if (v[prop] !== void 0 && typeof v[prop] !== "number") {
+      errors.push(`${path}.${prop}: must be a number.`);
+    }
+  }
+  if (typeof v.minLength === "number" && typeof v.maxLength === "number" && v.minLength > v.maxLength) {
+    errors.push(`${path}: "minLength" (${v.minLength}) must be \xE2\u2030\xA4 "maxLength" (${v.maxLength}).`);
+  }
+  if (typeof v.min === "number" && typeof v.max === "number" && v.min > v.max) {
+    errors.push(`${path}: "min" (${v.min}) must be \xE2\u2030\xA4 "max" (${v.max}).`);
+  }
+  if (typeof v.minRows === "number" && typeof v.maxRows === "number" && v.minRows > v.maxRows) {
+    errors.push(`${path}: "minRows" (${v.minRows}) must be \xE2\u2030\xA4 "maxRows" (${v.maxRows}).`);
+  }
+  if (v.regex !== void 0) {
+    if (typeof v.regex !== "string") {
+      errors.push(`${path}.regex: must be a string.`);
+    } else {
+      try {
+        new RegExp(v.regex);
+      } catch {
+        errors.push(`${path}.regex: invalid regular expression "${v.regex}".`);
+      }
+    }
+  }
+  if (v.integerOnly !== void 0 && typeof v.integerOnly !== "boolean") {
+    errors.push(`${path}.integerOnly: must be a boolean.`);
+  }
+  if (v.uniqueItems !== void 0 && typeof v.uniqueItems !== "boolean") {
+    errors.push(`${path}.uniqueItems: must be a boolean.`);
+  }
+  if (v.allowedMimeTypes !== void 0 && !Array.isArray(v.allowedMimeTypes)) {
+    errors.push(`${path}.allowedMimeTypes: must be an array of strings.`);
+  }
+}
+function validateField(field, path, errors, warnings) {
+  if (!field || typeof field !== "object" || Array.isArray(field)) {
+    errors.push(`${path}: must be a non-array object.`);
+    return;
+  }
+  const f = field;
+  if (typeof f.name !== "string" || !f.name.trim()) {
+    errors.push(`${path}: "name" is required and must be a non-empty string.`);
+  } else if (!LEAF_NAME_RE.test(f.name)) {
+    errors.push(
+      `${path}.name "${f.name}": must start with a letter and contain only letters, digits, or underscores.`
+    );
+  }
+  if (typeof f.type !== "string") {
+    errors.push(`${path}: "type" is required.`);
+    return;
+  }
+  if (!VALID_FIELD_TYPES.has(f.type)) {
+    errors.push(`${path}: unknown field type "${f.type}".`);
+    return;
+  }
+  const type = f.type;
+  if (f.label !== void 0 && typeof f.label !== "string") {
+    errors.push(`${path}: "label" must be a string.`);
+  } else if (f.label === void 0) {
+    warnings.push(`${path}: no "label" defined; consider adding one for admin UX.`);
+  }
+  if (f.required !== void 0 && typeof f.required !== "boolean") {
+    errors.push(`${path}: "required" must be a boolean.`);
+  }
+  if (f.conditions !== void 0) {
+    validateConditions(f.conditions, `${path}.conditions`, errors);
+  }
+  if (f.conditionMode !== void 0 && f.conditionMode !== "AND" && f.conditionMode !== "OR") {
+    errors.push(`${path}: "conditionMode" must be "AND" or "OR".`);
+  }
+  if (f.validation !== void 0) {
+    if (!f.validation || typeof f.validation !== "object" || Array.isArray(f.validation)) {
+      errors.push(`${path}: "validation" must be an object.`);
+    } else {
+      validateValidationRules(
+        f.validation,
+        `${path}.validation`,
+        errors
+      );
+    }
+  }
+  if (f.ui !== void 0) {
+    if (!f.ui || typeof f.ui !== "object" || Array.isArray(f.ui)) {
+      errors.push(`${path}: "ui" must be an object.`);
+    } else {
+      const ui = f.ui;
+      if (ui.width !== void 0 && !["full", "half", "third", "quarter"].includes(ui.width)) {
+        errors.push(`${path}.ui.width: must be "full", "half", "third", or "quarter".`);
+      }
+      if (ui.order !== void 0 && typeof ui.order !== "number") {
+        errors.push(`${path}.ui.order: must be a number.`);
+      }
+      if (ui.collapsed !== void 0 && typeof ui.collapsed !== "boolean") {
+        errors.push(`${path}.ui.collapsed: must be a boolean.`);
+      }
+    }
+  }
+  if (type === "select" || type === "multiselect") {
+    if (!Array.isArray(f.options) || f.options.length === 0) {
+      errors.push(`${path}: "${type}" fields must have a non-empty "options" array.`);
+    } else {
+      ;
+      f.options.forEach((opt, i) => {
+        if (!opt || typeof opt !== "object") {
+          errors.push(`${path}.options[${i}]: must be an object.`);
+          return;
+        }
+        const o = opt;
+        if (typeof o.label !== "string" || !o.label.trim()) {
+          errors.push(`${path}.options[${i}]: "label" is required.`);
+        }
+        if (typeof o.value !== "string" || !o.value.trim()) {
+          errors.push(`${path}.options[${i}]: "value" is required.`);
+        }
+      });
+    }
+  }
+  if (type === "number") {
+    if (f.min !== void 0 && typeof f.min !== "number") {
+      errors.push(`${path}: "min" must be a number.`);
+    }
+    if (f.max !== void 0 && typeof f.max !== "number") {
+      errors.push(`${path}: "max" must be a number.`);
+    }
+    if (typeof f.min === "number" && typeof f.max === "number" && f.min > f.max) {
+      errors.push(`${path}: "min" (${f.min}) must be \xE2\u2030\xA4 "max" (${f.max}).`);
+    }
+  }
+  if (type === "text" || type === "textarea") {
+    if (f.minLength !== void 0 && typeof f.minLength !== "number") {
+      errors.push(`${path}: "minLength" must be a number.`);
+    }
+    if (f.maxLength !== void 0 && typeof f.maxLength !== "number") {
+      errors.push(`${path}: "maxLength" must be a number.`);
+    }
+  }
+  if (type === "relationship") {
+    if (typeof f.collection !== "string" || !f.collection.trim()) {
+      errors.push(`${path}: "relationship" fields require a non-empty "collection" string.`);
+    }
+  }
+  if (CONTAINER_TYPES.has(type)) {
+    if (!Array.isArray(f.fields) || f.fields.length === 0) {
+      errors.push(`${path}: "${type}" fields must have a non-empty "fields" array.`);
+    } else {
+      validateFields(f.fields, `${path}.fields`, errors, warnings);
+    }
+    if (type === "array") {
+      if (f.minRows !== void 0 && typeof f.minRows !== "number") {
+        errors.push(`${path}: "minRows" must be a number.`);
+      }
+      if (f.maxRows !== void 0 && typeof f.maxRows !== "number") {
+        errors.push(`${path}: "maxRows" must be a number.`);
+      }
+    }
+  }
+  if (type === "blocks") {
+    if (f.allowedBlocks !== void 0) {
+      if (!Array.isArray(f.allowedBlocks)) {
+        errors.push(`${path}: "allowedBlocks" must be an array.`);
+      } else {
+        ;
+        f.allowedBlocks.forEach((slug, i) => {
+          if (typeof slug !== "string" || !slug.trim()) {
+            errors.push(`${path}.allowedBlocks[${i}]: must be a non-empty string.`);
+          }
+        });
+      }
+    }
+    if (f.minBlocks !== void 0 && typeof f.minBlocks !== "number") {
+      errors.push(`${path}: "minBlocks" must be a number.`);
+    }
+    if (f.maxBlocks !== void 0 && typeof f.maxBlocks !== "number") {
+      errors.push(`${path}: "maxBlocks" must be a number.`);
+    }
+    if (typeof f.minBlocks === "number" && typeof f.maxBlocks === "number" && f.minBlocks > f.maxBlocks) {
+      errors.push(`${path}: "minBlocks" (${f.minBlocks}) must be \xE2\u2030\xA4 "maxBlocks" (${f.maxBlocks}).`);
+    }
+  }
+}
+function validateFields(fields, path, errors, warnings) {
+  const names = /* @__PURE__ */ new Set();
+  fields.forEach((field, index) => {
+    const fieldPath = `${path}[${index}]`;
+    validateField(field, fieldPath, errors, warnings);
+    const f = field;
+    if (typeof f.name === "string" && f.name) {
+      if (names.has(f.name)) {
+        errors.push(`${path}: duplicate field name "${f.name}".`);
+      }
+      names.add(f.name);
+    }
+  });
+}
+function validateBlockSchema(schema) {
+  const errors = [];
+  const warnings = [];
+  if (!schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return {
+      valid: false,
+      errors: ['Schema must be a non-array object with a "fields" property.'],
+      warnings: []
+    };
+  }
+  const s = schema;
+  if (!Array.isArray(s.fields)) {
+    errors.push('Schema must have a "fields" array.');
+  } else if (s.fields.length === 0) {
+    warnings.push("Schema has no fields defined.");
+  } else {
+    validateFields(s.fields, "schema.fields", errors, warnings);
+  }
+  if (s.layout !== void 0 && !["default", "sidebar", "tabs"].includes(s.layout)) {
+    errors.push(`schema.layout must be one of: "default", "sidebar", "tabs".`);
+  }
+  return { valid: errors.length === 0, errors, warnings };
+}
+
+// src/builder/saveSchema.ts
+async function saveSchemaLocally(payload, request) {
+  const { blockSlug, name, description, category, schema: rawSchema, changelog } = request;
+  const schema = normaliseSchema(rawSchema);
+  if (!schema.fields?.length) {
+    return {
+      success: false,
+      definitionId: "",
+      versionId: "",
+      versionNumber: 0,
+      errors: [`Block "${blockSlug}" schema has no fields. Schemas must be imported from a server-safe module (not a "use client" file).`],
+      warnings: []
+    };
+  }
+  const validation = validateBlockSchema(schema);
+  if (!validation.valid) {
+    return {
+      success: false,
+      definitionId: "",
+      versionId: "",
+      versionNumber: 0,
+      errors: validation.errors,
+      warnings: validation.warnings
+    };
+  }
+  try {
+    let definitionId;
+    const existing = await payload.find({
+      collection: "block-definitions",
+      where: { slug: { equals: blockSlug } },
+      limit: 1
+    });
+    if (existing.docs.length > 0) {
+      definitionId = existing.docs[0].id;
+      const updates = {};
+      if (description !== void 0) updates.description = description;
+      if (category !== void 0) updates.category = category;
+      if (name !== void 0) updates.name = name;
+      if (Object.keys(updates).length > 0) {
+        await payload.update({
+          collection: "block-definitions",
+          id: definitionId,
+          // eslint-disable-next-line @typescript-eslint/no-explicit-any
+          data: updates
+        });
+      }
+    } else {
+      if (!name) {
+        return {
+          success: false,
+          definitionId: "",
+          versionId: "",
+          versionNumber: 0,
+          errors: [`Block definition "${blockSlug}" not found. Provide a "name" to create it.`],
+          warnings: validation.warnings
+        };
+      }
+      const created = await payload.create({
+        collection: "block-definitions",
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        data: {
+          slug: blockSlug,
+          name,
+          description
+        }
+      });
+      definitionId = created.id;
+    }
+    const existingVersions = await payload.find({
+      collection: "block-definition-versions",
+      where: { blockDefinition: { equals: definitionId } },
+      limit: 0
+    });
+    const versionNumber = existingVersions.totalDocs + 1;
+    const version = await payload.create({
+      collection: "block-definition-versions",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      data: {
+        blockDefinition: definitionId,
+        versionNumber,
+        label: `v${versionNumber}`,
+        schema,
+        changelog: changelog ?? "Created via Block Builder"
+      }
+    });
+    await payload.update({
+      collection: "block-definitions",
+      id: definitionId,
+      data: { currentVersion: version.id }
+    });
+    return {
+      success: true,
+      definitionId: String(definitionId),
+      versionId: String(version.id),
+      versionNumber: version.versionNumber ?? 0,
+      warnings: validation.warnings
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      definitionId: "",
+      versionId: "",
+      versionNumber: 0,
+      errors: [`Unexpected error: ${message}`],
+      warnings: validation.warnings
+    };
+  }
+}
+
+// src/endpoints/save.ts
+var saveEndpoint = async (req) => {
+  if (!req.user) {
+    return Response.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  let body;
+  try {
+    if (!req.json) return Response.json({ error: "No JSON parser available" }, { status: 500 });
+    body = await req.json();
+  } catch {
+    return Response.json({ error: "Invalid JSON body" }, { status: 400 });
+  }
+  if (!body.blockSlug) {
+    return Response.json({ error: "blockSlug is required" }, { status: 400 });
+  }
+  const result = await saveSchemaLocally(req.payload, body);
+  return Response.json(result, { status: result.success ? 200 : 422 });
+};
+
+// src/endpoints/versions.ts
+var versionsEndpoint = async (req) => {
+  if (!req.user) {
+    return Response.json({ error: "Unauthorized" }, { status: 401 });
+  }
+  const slug = req.routeParams?.slug;
+  if (!slug) {
+    return Response.json({ error: "Slug is required" }, { status: 400 });
+  }
+  const defResult = await req.payload.find({
+    collection: "block-definitions",
+    where: { slug: { equals: slug } },
+    depth: 1,
+    limit: 1
+  });
+  const def = defResult.docs[0];
+  if (!def) {
+    return Response.json({ error: `Block definition "${slug}" not found` }, { status: 404 });
+  }
+  const currentVersionId = def.currentVersion && typeof def.currentVersion === "object" ? String(def.currentVersion.id) : typeof def.currentVersion === "string" || typeof def.currentVersion === "number" ? String(def.currentVersion) : null;
+  const versionsResult = await req.payload.find({
+    collection: "block-definition-versions",
+    where: { blockDefinition: { equals: def.id } },
+    sort: "-versionNumber",
+    depth: 0,
+    limit: 100
+  });
+  const versions = versionsResult.docs.map((v) => {
+    const id = String(v.id);
+    return {
+      id,
+      versionNumber: v.versionNumber,
+      label: v.label ?? `v${v.versionNumber}`,
+      changelog: v.changelog ?? "",
+      createdAt: v.createdAt,
+      isCurrent: id === currentVersionId
+    };
+  });
+  return Response.json({ versions });
+};
+
+// src/plugin.ts
+var dynamicBlocksPlugin = (options = {}) => {
+  return (incomingConfig) => {
+    const {
+      enabled = true,
+      collections: targetCollections = [],
+      fieldName = "dbLayout",
+      tabLabel = "DB Layout"
+    } = options;
+    if (!enabled) return incomingConfig;
+    const config = { ...incomingConfig };
+    config.collections = [
+      ...config.collections ?? [],
+      BlockDefinitions,
+      BlockDefinitionVersions
+    ];
+    config.endpoints = [
+      ...config.endpoints ?? [],
+      {
+        path: "/block-builder/generate",
+        method: "post",
+        handler: generateEndpoint
+      },
+      {
+        path: "/block-builder/load/:slug",
+        method: "get",
+        handler: loadEndpoint
+      },
+      {
+        path: "/blocks/save",
+        method: "post",
+        handler: saveEndpoint
+      },
+      {
+        path: "/block-builder/versions/:slug",
+        method: "get",
+        handler: versionsEndpoint
+      }
+    ];
+    if (targetCollections.length > 0) {
+      config.collections = config.collections.map((collection) => {
+        if (!targetCollections.includes(collection.slug)) return collection;
+        const layoutTab = dbLayoutField(fieldName, tabLabel);
+        const existingTabsIdx = collection.fields.findIndex((f) => f.type === "tabs");
+        if (existingTabsIdx !== -1) {
+          const existingTabs = collection.fields[existingTabsIdx];
+          return {
+            ...collection,
+            fields: collection.fields.map(
+              (f, i) => i === existingTabsIdx ? {
+                ...existingTabs,
+                tabs: [...existingTabs.tabs, layoutTab]
+              } : f
+            )
+          };
+        }
+        return {
+          ...collection,
+          fields: [
+            ...collection.fields,
+            {
+              type: "tabs",
+              tabs: [layoutTab]
+            }
+          ]
+        };
+      });
+      config.collections = config.collections.map((collection) => {
+        if (!targetCollections.includes(collection.slug)) return collection;
+        const existingHooks = collection.hooks?.beforeChange ?? [];
+        return {
+          ...collection,
+          hooks: {
+            ...collection.hooks,
+            beforeChange: [
+              ...existingHooks,
+              ({ data }) => {
+                if (Array.isArray(data[fieldName])) {
+                  data[fieldName] = data[fieldName].map(
+                    (row) => row.instanceId ? row : { ...row, instanceId: randomUUID() }
+                  );
+                }
+                return data;
+              }
+            ]
+          }
+        };
+      });
+    }
+    return config;
+  };
+};
+export {
+  BlockDefinitionVersions,
+  BlockDefinitions,
+  dbLayoutField,
+  dynamicBlocksPlugin
+};