@easy-cms/core 0.47.4 → 0.49.0

package/dist/chunk-CGVNZUW4.js

@@ -0,0 +1,534 @@
+// src/errors.ts
+function codeOfStatus(status) {
+  switch (status) {
+    case 400:
+      return "BAD_USER_INPUT";
+    case 401:
+      return "UNAUTHORIZED";
+    case 403:
+      return "FORBIDDEN";
+    case 404:
+      return "NOT_FOUND";
+    case 405:
+      return "METHOD_NOT_ALLOWED";
+    case 413:
+      return "PAYLOAD_TOO_LARGE";
+    case 415:
+      return "UNSUPPORTED_MEDIA_TYPE";
+    case 429:
+      return "TOO_MANY_REQUESTS";
+    default:
+      return status >= 400 && status < 500 ? "BAD_USER_INPUT" : "INTERNAL_SERVER_ERROR";
+  }
+}
+var EasyCMSError = class extends Error {
+  status;
+  code;
+  constructor(message, status, code = codeOfStatus(status)) {
+    super(message);
+    this.name = "EasyCMSError";
+    this.status = status;
+    this.code = code;
+  }
+};
+var ConfigError = class _ConfigError extends EasyCMSError {
+  issues;
+  constructor(issues) {
+    super(_ConfigError.format(issues), 500, "CONFIG_ERROR");
+    this.name = "ConfigError";
+    this.issues = issues;
+  }
+  static format(issues) {
+    const lines = issues.map((issue) => {
+      const hint = issue.hint ? `
+    \u2192 ${issue.hint}` : "";
+      return `  \u2022 ${issue.path}: ${issue.message}${hint}`;
+    });
+    const noun = issues.length === 1 ? "problem" : "problems";
+    return `Invalid Easy CMS config (${issues.length} ${noun}):
+${lines.join("\n")}`;
+  }
+};
+var ValidationError = class extends EasyCMSError {
+  errors;
+  constructor(collection, errors) {
+    const list = errors.map((e) => `${e.field}: ${e.message}`).join("; ");
+    super(`Invalid data for "${collection}": ${list}`, 400, "VALIDATION_ERROR");
+    this.name = "ValidationError";
+    this.errors = errors;
+  }
+};
+var NotFoundError = class extends EasyCMSError {
+  constructor(collection, id) {
+    super(`No document with id ${JSON.stringify(id)} in "${collection}"`, 404);
+    this.name = "NotFoundError";
+  }
+};
+var QueryError = class extends EasyCMSError {
+  constructor(message) {
+    super(message, 400);
+    this.name = "QueryError";
+  }
+};
+var SchemaError = class extends EasyCMSError {
+  constructor(message) {
+    super(message, 500);
+    this.name = "SchemaError";
+  }
+};
+var UnauthorizedError = class extends EasyCMSError {
+  constructor(message = "You must be logged in") {
+    super(message, 401);
+    this.name = "UnauthorizedError";
+  }
+};
+var ForbiddenError = class extends EasyCMSError {
+  constructor(message = "You are not allowed to do this") {
+    super(message, 403);
+    this.name = "ForbiddenError";
+  }
+};
+var TooManyRequestsError = class extends EasyCMSError {
+  /** When to try again, in seconds (the REST API sends it as `Retry-After`). */
+  retryAfter;
+  constructor(message, retryAfter) {
+    super(message, 429);
+    this.name = "TooManyRequestsError";
+    this.retryAfter = retryAfter;
+  }
+};
+var PayloadTooLargeError = class extends EasyCMSError {
+  constructor(message) {
+    super(message, 413);
+    this.name = "PayloadTooLargeError";
+  }
+};
+
+// src/media.ts
+var EXTENSIONS = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/gif": "gif",
+  "image/webp": "webp",
+  "image/avif": "avif",
+  "image/svg+xml": "svg",
+  "application/pdf": "pdf",
+  "video/mp4": "mp4",
+  "video/webm": "webm",
+  "video/quicktime": "mov",
+  "audio/mpeg": "mp3",
+  "audio/wav": "wav",
+  "audio/ogg": "ogg",
+  "audio/mp4": "m4a",
+  "text/plain": "txt",
+  "text/csv": "csv",
+  "application/zip": "zip",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx",
+  "application/vnd.oasis.opendocument.text": "odt",
+  "application/vnd.oasis.opendocument.spreadsheet": "ods",
+  "application/vnd.oasis.opendocument.presentation": "odp"
+};
+var OFFICE = [
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+];
+var MIME_GROUPS = {
+  office: OFFICE,
+  documents: [
+    "application/pdf",
+    ...OFFICE,
+    "application/vnd.oasis.opendocument.text",
+    "application/vnd.oasis.opendocument.spreadsheet",
+    "application/vnd.oasis.opendocument.presentation",
+    "text/csv",
+    "text/plain"
+  ],
+  archives: ["application/zip"]
+};
+function expandMimeTypes(patterns) {
+  return [...new Set(patterns.flatMap((p) => MIME_GROUPS[p.toLowerCase()] ?? [p]))];
+}
+var startsWith = (data, bytes, offset = 0) => bytes.every((b, i) => data[offset + i] === b);
+var ascii = (data, start, end) => String.fromCharCode(...data.subarray(start, end));
+var contains = (data, text) => Buffer.from(data.buffer, data.byteOffset, data.byteLength).includes(text, 0, "latin1");
+function zipType(data) {
+  if (ascii(data, 30, 38) === "mimetype") {
+    const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+    const start = 30 + view.getUint16(26, true) + view.getUint16(28, true);
+    const type = ascii(data, start, start + Math.min(view.getUint32(18, true), 80));
+    if (EXTENSIONS[type]?.startsWith("od")) return type;
+  }
+  if (contains(data, "word/document.xml")) return OFFICE[0];
+  if (contains(data, "xl/workbook.xml")) return OFFICE[1];
+  if (contains(data, "ppt/presentation.xml")) return OFFICE[2];
+  return "application/zip";
+}
+function sniffMimeType(data, name = "") {
+  if (startsWith(data, [137, 80, 78, 71, 13, 10, 26, 10])) return "image/png";
+  if (startsWith(data, [255, 216, 255])) return "image/jpeg";
+  if (ascii(data, 0, 6) === "GIF87a" || ascii(data, 0, 6) === "GIF89a") return "image/gif";
+  if (ascii(data, 0, 4) === "RIFF" && ascii(data, 8, 12) === "WEBP") return "image/webp";
+  if (ascii(data, 0, 4) === "RIFF" && ascii(data, 8, 12) === "WAVE") return "audio/wav";
+  if (ascii(data, 4, 8) === "ftyp") {
+    const brand = ascii(data, 8, 12);
+    if (brand === "avif" || brand === "avis") return "image/avif";
+    if (["isom", "iso2", "mp41", "mp42", "avc1", "M4V "].includes(brand)) return "video/mp4";
+    if (brand === "M4A ") return "audio/mp4";
+    if (brand === "qt  ") return "video/quicktime";
+  }
+  if (ascii(data, 0, 5) === "%PDF-") return "application/pdf";
+  if (startsWith(data, [80, 75, 3, 4])) return zipType(data);
+  if (ascii(data, 0, 4) === "OggS") return "audio/ogg";
+  if (startsWith(data, [26, 69, 223, 163]) && ascii(data, 0, 64).includes("webm"))
+    return "video/webm";
+  if (ascii(data, 0, 3) === "ID3" || data[0] === 255 && ((data[1] ?? 0) & 230) === 226)
+    return "audio/mpeg";
+  const head = data.subarray(0, 4096);
+  if (head.includes(0)) return void 0;
+  let text;
+  try {
+    text = new TextDecoder("utf-8", { fatal: true }).decode(head);
+  } catch {
+    return void 0;
+  }
+  const trimmed = text.replace(/^/, "").trimStart();
+  if (/^(<\?xml[^>]*>\s*)?(<!--[\s\S]*?-->\s*)*(<!DOCTYPE svg[^>]*>\s*)?<svg[\s>]/i.test(trimmed))
+    return "image/svg+xml";
+  return /\.csv$/i.test(name) ? "text/csv" : "text/plain";
+}
+function mimeAllowed(type, allowed) {
+  return expandMimeTypes(allowed).some(
+    (pattern) => pattern.endsWith("/*") ? type.startsWith(pattern.slice(0, -1)) && type !== "image/svg+xml" : pattern === type
+  );
+}
+function imageDimensions(data, type) {
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  try {
+    switch (type) {
+      case "image/png":
+        return { width: view.getUint32(16), height: view.getUint32(20) };
+      case "image/gif":
+        return { width: view.getUint16(6, true), height: view.getUint16(8, true) };
+      case "image/webp": {
+        const chunk = ascii(data, 12, 16);
+        if (chunk === "VP8 ")
+          return {
+            width: view.getUint16(26, true) & 16383,
+            height: view.getUint16(28, true) & 16383
+          };
+        if (chunk === "VP8L") {
+          const bits = view.getUint32(21, true);
+          return { width: (bits & 16383) + 1, height: (bits >> 14 & 16383) + 1 };
+        }
+        if (chunk === "VP8X") {
+          const w = view.getUint16(24, true) | view.getUint8(26) << 16;
+          const h = view.getUint16(27, true) | view.getUint8(29) << 16;
+          return { width: w + 1, height: h + 1 };
+        }
+        return void 0;
+      }
+      case "image/jpeg": {
+        let offset = 2;
+        while (offset + 9 < data.length) {
+          if (data[offset] !== 255) return void 0;
+          const marker = data[offset + 1];
+          const length = view.getUint16(offset + 2);
+          if (marker >= 192 && marker <= 207 && ![196, 200, 204].includes(marker)) {
+            return { width: view.getUint16(offset + 7), height: view.getUint16(offset + 5) };
+          }
+          offset += 2 + length;
+        }
+        return void 0;
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function typeFromName(name) {
+  const extension = /\.([a-z0-9]+)$/i.exec(name)?.[1]?.toLowerCase();
+  if (!extension) return void 0;
+  if (extension === "jpeg") return "image/jpeg";
+  return Object.entries(EXTENSIONS).find(([, ext]) => ext === extension)?.[0];
+}
+function storageKey(originalName, type, random) {
+  const name = originalName.split(/[\\/]/).pop() ?? "";
+  const base = name.replace(/(?<=.)\.[^.]*$/, "").normalize("NFKC").toLowerCase().replace(/[^\p{L}\p{M}\p{N}]+/gu, "-").replace(/^-+|-+$/g, "").slice(0, 60) || "file";
+  return `${base}-${random}.${EXTENSIONS[type] ?? "bin"}`;
+}
+function isPrivateKey(key) {
+  return /\.private[.-]/.test(key);
+}
+function withPrivacy(key, isPrivate) {
+  const plain = key.replace(/\.private(?=\.[^.]+$)/, "");
+  return isPrivate ? plain.replace(/\.([^.]+)$/, ".private.$1") : plain;
+}
+function sizeKey(filename, size) {
+  return filename.replace(/\.([^.]+)$/, `-${size}.$1`);
+}
+var PRIVATE_KEY = /^[\p{L}\p{M}\p{N}-]+\.private(-[\p{L}\p{N}_-]+)?\.[a-z0-9]+$/u;
+
+// src/fields.ts
+var uniqueWithinOf = (field) => field.uniqueWithin === void 0 ? [] : [field.uniqueWithin].flat();
+var isHasMany = (field) => (field.type === "select" || field.type === "relationship" || field.type === "upload") && field.hasMany === true;
+function mimeAllowedBy(mimeType, patterns) {
+  const type = mimeType.toLowerCase();
+  return expandMimeTypes(patterns).some((pattern) => {
+    const p = pattern.toLowerCase();
+    return p.endsWith("/*") ? type.startsWith(p.slice(0, -1)) && type !== SVG : type === p;
+  });
+}
+var SVG = "image/svg+xml";
+var hasRows = (field) => field.type === "array" || field.type === "blocks";
+function rowFields(field, row) {
+  if (field.type === "array") return field.fields;
+  const type = row && typeof row === "object" ? row.blockType : void 0;
+  return field.blocks.find((block) => block.slug === type)?.fields;
+}
+var FIELD_TYPES = [
+  "text",
+  "textarea",
+  "number",
+  "boolean",
+  "date",
+  "email",
+  "json",
+  "select",
+  "slug",
+  "richText",
+  "upload",
+  "relationship",
+  "array",
+  "group",
+  "blocks"
+];
+
+// src/config.ts
+var ADMIN_ICONS = [
+  "file-text",
+  "newspaper",
+  "book-open",
+  "notebook",
+  "folder",
+  "tag",
+  "tags",
+  "image",
+  "images",
+  "video",
+  "music",
+  "file",
+  "users",
+  "user",
+  "building",
+  "store",
+  "shopping-bag",
+  "shopping-cart",
+  "package",
+  "box",
+  "calendar",
+  "calendar-days",
+  "map-pin",
+  "globe",
+  "house",
+  "layout-grid",
+  "layers",
+  "star",
+  "heart",
+  "message-square",
+  "mail",
+  "phone",
+  "briefcase",
+  "graduation-cap",
+  "utensils",
+  "car",
+  "settings",
+  "sliders-horizontal",
+  "palette",
+  "megaphone",
+  "bell",
+  "link",
+  "quote",
+  "circle-help",
+  "award",
+  "ticket",
+  "camera",
+  "key",
+  "chart-column",
+  "chart-line"
+];
+var PLUGIN_API_VERSION = 1;
+function definePlugin(plugin, info) {
+  if (info) Object.defineProperty(plugin, "info", { value: info, configurable: true });
+  return plugin;
+}
+function defineConfig(config) {
+  return config;
+}
+
+// src/field-types.ts
+var FIELD_TYPE_BASES = [
+  "text",
+  "textarea",
+  "email",
+  "number",
+  "boolean",
+  "date",
+  "json"
+];
+function defineFieldType(definition) {
+  return definition;
+}
+var NAME = /^[a-z][a-zA-Z0-9]*$/;
+function fieldTypeModules(config) {
+  const list = config.fieldTypes;
+  if (!Array.isArray(list)) return [];
+  return list.map((t) => t?.admin?.module).filter((m) => typeof m === "string");
+}
+function applyFieldTypes(config) {
+  const issues = [];
+  const list = config.fieldTypes;
+  if (list === void 0) return { config, issues };
+  if (!Array.isArray(list)) {
+    issues.push({ path: "fieldTypes", message: "must be an array of field types" });
+    return { config, issues };
+  }
+  const types = /* @__PURE__ */ new Map();
+  for (const [i, type] of list.entries()) {
+    const path = `fieldTypes[${i}]`;
+    if (!type || typeof type.name !== "string" || !NAME.test(type.name)) {
+      issues.push({ path: `${path}.name`, message: 'must be a lowercase name like "color"' });
+    } else if (FIELD_TYPES.includes(type.name)) {
+      issues.push({ path: `${path}.name`, message: `"${type.name}" is a built-in field type` });
+    } else if (types.has(type.name)) {
+      issues.push({ path: `${path}.name`, message: `"${type.name}" is listed twice` });
+    } else if (!FIELD_TYPE_BASES.includes(type.base)) {
+      issues.push({
+        path: `${path}.base`,
+        message: `must be one of ${FIELD_TYPE_BASES.join(", ")}`
+      });
+    } else {
+      types.set(type.name, type);
+    }
+  }
+  if (types.size === 0) return { config, issues };
+  const component = (base, field, props) => {
+    if (!base) return void 0;
+    const tag = typeof base === "string" ? base : base.tag;
+    const options = {
+      ...typeof base === "string" ? {} : base.props,
+      ...Object.fromEntries(
+        (props ?? []).filter((key) => field[key] !== void 0).map((key) => [key, field[key]])
+      )
+    };
+    return Object.keys(options).length ? { tag, props: options } : tag;
+  };
+  const convert = (fields, path) => fields.map((field, i) => {
+    const here = `${path}[${i}]`;
+    const own = field;
+    const type = types.get(own.type);
+    if (!type) {
+      if ((field.type === "group" || field.type === "array") && Array.isArray(field.fields))
+        return { ...field, fields: convert(field.fields, `${here}.fields`) };
+      if (field.type === "blocks" && Array.isArray(field.blocks))
+        return {
+          ...field,
+          blocks: field.blocks.map((block, b) => ({
+            ...block,
+            fields: convert(block.fields, `${here}.blocks[${b}].fields`)
+          }))
+        };
+      return field;
+    }
+    const problem = type.checkOptions?.(own);
+    if (problem) issues.push({ path: here, message: problem });
+    const ownValidate = own.validate;
+    const check = type.validate;
+    const admin = own.admin ?? {};
+    const input = admin.component ?? component(type.admin?.component, own, type.admin?.props);
+    const cell = admin.cell ?? component(type.admin?.cell, own, type.admin?.props);
+    return {
+      ...own,
+      type: type.base,
+      customType: type.name,
+      ...check || ownValidate ? {
+        validate: async (value, ctx) => {
+          const empty = value === null || value === void 0 || value === "";
+          if (check && !empty) {
+            const result = await check(value, { ...ctx, field: own });
+            if (result !== true) return result;
+          }
+          return ownValidate ? ownValidate(value, ctx) : true;
+        }
+      } : {},
+      ...input || cell ? {
+        admin: {
+          ...admin,
+          ...input ? { component: input } : {},
+          ...cell ? { cell } : {}
+        }
+      } : {}
+    };
+  });
+  return {
+    config: {
+      ...config,
+      ...config.collections ? {
+        collections: config.collections.map((c, i) => ({
+          ...c,
+          fields: convert(c.fields, `collections[${i}].fields`)
+        }))
+      } : {},
+      ...config.globals ? {
+        globals: config.globals.map((g, i) => ({
+          ...g,
+          fields: convert(g.fields, `globals[${i}].fields`)
+        }))
+      } : {}
+    },
+    issues
+  };
+}
+
+export {
+  codeOfStatus,
+  EasyCMSError,
+  ConfigError,
+  ValidationError,
+  NotFoundError,
+  QueryError,
+  SchemaError,
+  UnauthorizedError,
+  ForbiddenError,
+  TooManyRequestsError,
+  PayloadTooLargeError,
+  EXTENSIONS,
+  MIME_GROUPS,
+  expandMimeTypes,
+  sniffMimeType,
+  mimeAllowed,
+  imageDimensions,
+  typeFromName,
+  storageKey,
+  isPrivateKey,
+  withPrivacy,
+  sizeKey,
+  PRIVATE_KEY,
+  uniqueWithinOf,
+  isHasMany,
+  mimeAllowedBy,
+  hasRows,
+  rowFields,
+  FIELD_TYPES,
+  ADMIN_ICONS,
+  PLUGIN_API_VERSION,
+  definePlugin,
+  defineConfig,
+  FIELD_TYPE_BASES,
+  defineFieldType,
+  fieldTypeModules,
+  applyFieldTypes
+};

package/dist/chunk-K6GTTRN3.js

@@ -0,0 +1,6 @@
+// src/admin-elements.ts
+var ADMIN_API_VERSION = 1;
+
+export {
+  ADMIN_API_VERSION
+};

package/dist/{chunk-C4KJ5TFK.js → chunk-U266LV4M.js}

@@ -22,8 +22,9 @@ function matchesCondition(condition, data) {
   const value = read(data, condition.field);
   if (condition.exists !== void 0 && empty(value) === condition.exists) return false;
   if ("equals" in condition && !same(value, condition.equals)) return false;
-  if ("notEquals" in condition && same(value, condition.notEquals)) return false;
+  if ("not_equals" in condition && same(value, condition.not_equals)) return false;
   if (condition.in && !condition.in.some((v) => same(value, v))) return false;
+  if (condition.not_in?.some((v) => same(value, v))) return false;
   return true;
 }
 function conditionIssues(condition, siblings) {
@@ -36,7 +37,9 @@ function conditionIssues(condition, siblings) {
   if (typeof c.field !== "string" || c.field === "") return ["needs `field`, a sibling field"];
   const first = c.field.split(".")[0];
   if (!siblings.includes(first)) return [`"${c.field}" is not a field beside it`];
+  if ("notEquals" in c) return ["`notEquals` is now `not_equals`, as in `where`"];
   if (c.in !== void 0 && !Array.isArray(c.in)) return ["`in` must be a list"];
+  if (c.not_in !== void 0 && !Array.isArray(c.not_in)) return ["`not_in` must be a list"];
   if (c.exists !== void 0 && typeof c.exists !== "boolean")
     return ["`exists` must be true or false"];
   return [];

package/dist/conditions.d.ts

@@ -2,7 +2,8 @@
  * When a field is shown, from its sibling fields' values (the fields beside it, in its group,
  * array row or block):
  *
- * - `{ field: 'linkType', equals: 'external' }`, also `notEquals`, `in: [...]`, `exists: true`
+ * - `{ field: 'linkType', equals: 'external' }`, also `not_equals`, `in: [...]`, `not_in: [...]`,
+ *   `exists: true` (named as in `where`)
  * - `{ and: [...] }`, `{ or: [...] }`, `{ not: … }`
  *
  * A hidden field isn't required, and keeps its value.
@@ -11,8 +12,9 @@ type FieldCondition = {
     /** A sibling field's name; a path with `.` reads inside a group, e.g. `link.type`. */
     readonly field: string;
     readonly equals?: unknown;
-    readonly notEquals?: unknown;
+    readonly not_equals?: unknown;
     readonly in?: readonly unknown[];
+    readonly not_in?: readonly unknown[];
     /** `true`: has a value (not empty); `false`: empty. */
     readonly exists?: boolean;
 } | {

package/dist/conditions.js

@@ -1,7 +1,7 @@
 import {
   conditionIssues,
   matchesCondition
-} from "./chunk-C4KJ5TFK.js";
+} from "./chunk-U266LV4M.js";
 export {
   conditionIssues,
   matchesCondition