@agntcms/next 0.2.0

package/dist/index.mjs

@@ -0,0 +1,319 @@
+// src/domain/fields.ts
+var TextField = { kind: "text" };
+var RichTextField = { kind: "richText" };
+var ImageField = { kind: "image" };
+var VideoField = { kind: "video" };
+var ReferenceField = { kind: "reference" };
+var LinkField = { kind: "link" };
+var NumberField = { kind: "number" };
+var BooleanField = { kind: "boolean" };
+var SelectField = (options, opts) => ({
+  kind: "select",
+  options,
+  ...opts?.default !== void 0 ? { default: opts.default } : {}
+});
+var ButtonField = (variants, opts) => ({
+  kind: "button",
+  variants,
+  ...opts?.default !== void 0 ? { default: opts.default } : {}
+});
+var ListField = (itemSchema, opts) => ({
+  kind: "list",
+  itemSchema,
+  ...opts?.min !== void 0 ? { min: opts.min } : {},
+  ...opts?.max !== void 0 ? { max: opts.max } : {},
+  ...opts?.default !== void 0 ? { default: opts.default } : {}
+});
+
+// src/domain/invariants.ts
+function hasUniqueSectionIds(page) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const section of page.sections) {
+    if (seen.has(section.id)) return false;
+    seen.add(section.id);
+  }
+  return true;
+}
+
+// src/domain/linkValidation.ts
+var SLUG_PATTERN = /^[a-z0-9](?:[a-z0-9-/]*[a-z0-9])?$/;
+var validateInternalSlug = (slug) => {
+  if (slug === "") return null;
+  if (/^https?:\/\//i.test(slug)) return "slug must not include a protocol";
+  if (slug.startsWith("//")) return "slug must not start with //";
+  if (slug.startsWith("/")) return "slug must not start with /";
+  if (slug.endsWith("/")) return "slug must not end with /";
+  if (slug.includes("//")) return "slug must not contain //";
+  if (slug.includes("..")) return "slug must not contain ..";
+  if (!SLUG_PATTERN.test(slug)) {
+    return "slug must use lowercase letters, digits, hyphens, and slashes only";
+  }
+  return null;
+};
+var validateExternalUrl = (url) => {
+  if (url === "") return null;
+  if (typeof url !== "string") return "URL must be a string";
+  if (!/^https?:\/\//i.test(url)) {
+    return "External link must start with http:// or https://";
+  }
+  try {
+    const parsed = new globalThis.URL(url);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return "External link must use http or https";
+    }
+  } catch {
+    return "External link is not a valid URL";
+  }
+  return null;
+};
+var EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var validateEmail = (email) => {
+  if (email === "") return null;
+  if (typeof email !== "string") return "Invalid email address";
+  if (!EMAIL_PATTERN.test(email)) return "Invalid email address";
+  return null;
+};
+var validatePhone = (phone) => {
+  if (phone === "") return null;
+  if (typeof phone !== "string") return "Phone number is too short";
+  const digits = phone.replace(/[^\d+]/g, "").replace(/\+/g, "");
+  if (digits.length < 7) return "Phone number is too short";
+  return null;
+};
+
+// src/domain/link.ts
+function hrefOf(link) {
+  if (link.type === "external") return link.url;
+  if (link.type === "email") {
+    if (link.email === "") return "";
+    return "mailto:" + link.email;
+  }
+  if (link.type === "phone") {
+    if (link.phone === "") return "";
+    return "tel:" + link.phone.replace(/[^\d+]/g, "");
+  }
+  const slug = link.slug.startsWith("/") ? link.slug.slice(1) : link.slug;
+  if (slug === "" || slug === "home") return "/";
+  return "/" + slug;
+}
+function isExternalLink(link) {
+  return link.type === "external";
+}
+function linkAnchorAttrs(link) {
+  const href = hrefOf(link);
+  if (link.type === "external") {
+    return { href, target: "_blank", rel: "noreferrer" };
+  }
+  return { href };
+}
+function normalizeLinkValue(raw) {
+  if (raw === null || typeof raw !== "object") {
+    return { type: "internal", slug: "", label: "" };
+  }
+  const obj = raw;
+  const label = typeof obj["label"] === "string" ? obj["label"] : "";
+  if (obj["type"] === "internal") {
+    const slug = typeof obj["slug"] === "string" ? obj["slug"] : "";
+    return { type: "internal", slug, label };
+  }
+  if (obj["type"] === "external") {
+    const url = typeof obj["url"] === "string" ? obj["url"] : "";
+    return { type: "external", url, label };
+  }
+  if (obj["type"] === "email") {
+    const email = typeof obj["email"] === "string" ? obj["email"] : "";
+    return { type: "email", email, label };
+  }
+  if (obj["type"] === "phone") {
+    const phone = typeof obj["phone"] === "string" ? obj["phone"] : "";
+    return { type: "phone", phone, label };
+  }
+  if (typeof obj["href"] === "string") {
+    const href = obj["href"];
+    if (/^mailto:/i.test(href)) {
+      return { type: "email", email: href.slice("mailto:".length), label };
+    }
+    if (/^tel:/i.test(href)) {
+      return { type: "phone", phone: href.slice("tel:".length), label };
+    }
+    if (/^https?:\/\//i.test(href)) {
+      return { type: "external", url: href, label };
+    }
+    const slug = href.startsWith("/") ? href.slice(1) : href;
+    return { type: "internal", slug, label };
+  }
+  return { type: "internal", slug: "", label: "" };
+}
+
+// src/domain/form.ts
+var FORM_FORBIDDEN_KINDS = /* @__PURE__ */ new Set([
+  "image",
+  "video",
+  "reference",
+  "list",
+  // `formOverrides` is a section-only descriptor (it overrides another
+  // form schema instance). Putting it inside a form would mean a form's
+  // payload could carry overrides for itself or another form — a
+  // recursive shape with no ergonomic editor UI. Section-only by design.
+  "formOverrides",
+  // `button` is a section-only descriptor: a styled CTA with an
+  // optional link. Public-form payloads collect user input — a button
+  // value is authored content, not a submitted answer. Section-only
+  // by design (mirrors `formOverrides`).
+  "button"
+]);
+var SubmissionsNotReadableError = class extends Error {
+  constructor(message = "submission adapter does not support reading") {
+    super(message);
+    this.name = "SubmissionsNotReadableError";
+  }
+};
+
+// src/domain/formOverrides.ts
+var FormOverridesField = (formName, opts) => ({
+  kind: "formOverrides",
+  formName,
+  ...opts?.default !== void 0 ? { default: opts.default } : {}
+});
+
+// src/sections/defineSection.ts
+function builtInDefault(fieldName, descriptor) {
+  switch (descriptor.kind) {
+    case "image":
+      return { filename: "placeholder.png", alt: "Placeholder image" };
+    case "video":
+      return { url: "" };
+    case "richText":
+      return "Start writing here...";
+    case "text":
+      return fieldName.charAt(0).toUpperCase() + fieldName.slice(1).replace(/([A-Z])/g, " $1");
+    case "reference":
+      return { slug: "" };
+    case "link":
+      return { type: "internal", slug: "", label: "Learn more" };
+    case "button": {
+      const firstVariant = descriptor.variants[0]?.value ?? "";
+      return { label: "Get started", variant: firstVariant };
+    }
+    case "number":
+      return 0;
+    case "boolean":
+      return false;
+    case "select":
+      return descriptor.options[0]?.value ?? "";
+    case "list":
+      return [];
+    case "formOverrides":
+      return {};
+    default: {
+      const _exhaustive = descriptor;
+      void _exhaustive;
+      return "";
+    }
+  }
+}
+function defineSection(input) {
+  const defaults = {};
+  for (const [key, descriptor] of Object.entries(input.schema)) {
+    defaults[key] = descriptor.default ?? builtInDefault(key, descriptor);
+  }
+  return {
+    name: input.name,
+    ...input.category !== void 0 ? { category: input.category } : {},
+    schema: input.schema,
+    component: input.component,
+    defaults,
+    // Conditional spread mirrors the `category` pattern — required so
+    // `exactOptionalPropertyTypes` does not see `layouts: undefined` being
+    // assigned to an optional-only property.
+    ...input.layouts !== void 0 ? { layouts: input.layouts } : {}
+  };
+}
+
+// src/forms/defineForm.ts
+var InvalidFormFieldError = class extends Error {
+  formName;
+  fieldName;
+  fieldKind;
+  constructor(formName, fieldName, fieldKind) {
+    super(
+      `Form "${formName}": field "${fieldName}" uses kind "${fieldKind}", which is not allowed in a form schema in v1. Allowed kinds: text, richText, number, boolean, select, link. Forbidden kinds: image, reference, list, formOverrides. See ARCHITECTURE.md \xA76.5.`
+    );
+    this.name = "InvalidFormFieldError";
+    this.formName = formName;
+    this.fieldName = fieldName;
+    this.fieldKind = fieldKind;
+  }
+};
+var HoneypotCollisionError = class extends Error {
+  formName;
+  fieldName;
+  reason;
+  constructor(formName, fieldName, reason = "collision") {
+    super(
+      reason === "empty" ? `Form "${formName}": honeypot name must be a non-empty string.` : `Form "${formName}": honeypot name "${fieldName}" collides with a real field. Choose a honeypot name that does not appear in the schema.`
+    );
+    this.name = "HoneypotCollisionError";
+    this.formName = formName;
+    this.fieldName = fieldName;
+    this.reason = reason;
+  }
+};
+var InvalidFormNameError = class extends Error {
+  constructor(name) {
+    super(
+      `Invalid form name ${JSON.stringify(name)}. Use letters, digits, hyphen, and underscore only (no path separators).`
+    );
+    this.name = "InvalidFormNameError";
+  }
+};
+var FORM_NAME_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function defineForm(input) {
+  if (typeof input.name !== "string" || !FORM_NAME_PATTERN.test(input.name)) {
+    throw new InvalidFormNameError(input.name);
+  }
+  for (const [fieldName, descriptor] of Object.entries(input.schema)) {
+    const kind = descriptor.kind;
+    if (FORM_FORBIDDEN_KINDS.has(kind)) {
+      throw new InvalidFormFieldError(input.name, fieldName, kind);
+    }
+  }
+  if (input.honeypot !== void 0) {
+    if (typeof input.honeypot !== "string" || input.honeypot === "") {
+      throw new HoneypotCollisionError(input.name, input.honeypot, "empty");
+    }
+    if (Object.prototype.hasOwnProperty.call(input.schema, input.honeypot)) {
+      throw new HoneypotCollisionError(input.name, input.honeypot, "collision");
+    }
+  }
+  return input.honeypot !== void 0 ? { name: input.name, schema: input.schema, honeypot: input.honeypot } : { name: input.name, schema: input.schema };
+}
+export {
+  BooleanField,
+  ButtonField,
+  FormOverridesField,
+  HoneypotCollisionError,
+  ImageField,
+  InvalidFormFieldError,
+  InvalidFormNameError,
+  LinkField,
+  ListField,
+  NumberField,
+  ReferenceField,
+  RichTextField,
+  SelectField,
+  SubmissionsNotReadableError,
+  TextField,
+  VideoField,
+  defineForm,
+  defineSection,
+  hasUniqueSectionIds,
+  hrefOf,
+  isExternalLink,
+  linkAnchorAttrs,
+  normalizeLinkValue,
+  validateEmail,
+  validateExternalUrl,
+  validateInternalSlug,
+  validatePhone
+};