@nonext/husk 0.2.3

package/dist/chunk-JAE7HHMM.js

@@ -0,0 +1,506 @@
+import { assertValidContentType } from './chunk-ROLKRJWI.js';
+import { SchemaError, LockedTypeError } from './chunk-4Z6P3XCE.js';
+
+// src/core/adapter.ts
+var MEDIA_USAGE_LIMIT = 25;
+var MAX_FIELD_PURGE = 250;
+var DEFAULT_PAGE_SIZE = 25;
+var MAX_PAGE_SIZE = 100;
+function normalizeLimit(limit) {
+  if (limit === void 0 || !Number.isFinite(limit)) return DEFAULT_PAGE_SIZE;
+  return Math.min(Math.max(Math.trunc(limit), 1), MAX_PAGE_SIZE);
+}
+
+// src/core/schema-fields.ts
+function fieldKeyState(type, key) {
+  if (key in type.fields) return "live";
+  if (type.removedFields !== void 0 && key in type.removedFields) return "removed";
+  return "free";
+}
+function removedFieldEntries(type) {
+  return Object.entries(type.removedFields ?? {}).map(([key, removed]) => ({ key, ...removed })).sort((left, right) => left.key.localeCompare(right.key));
+}
+function withoutKey(map, key) {
+  const next = {};
+  for (const [existing, value] of Object.entries(map)) {
+    if (existing !== key) next[existing] = value;
+  }
+  return next;
+}
+function rebuild(type, fields, removedFields) {
+  const { removedFields: _dropped, ...rest } = type;
+  const next = {
+    ...rest,
+    fields,
+    ...Object.keys(removedFields).length > 0 ? { removedFields } : {}
+  };
+  assertValidContentType(next);
+  return next;
+}
+function removeField(type, key, context) {
+  const field = type.fields[key];
+  if (!field) {
+    throw new SchemaError(
+      fieldKeyState(type, key) === "removed" ? `Field "${key}" of content type "${type.slug}" is already removed.` : `Content type "${type.slug}" has no field "${key}".`
+    );
+  }
+  if (Object.keys(type.fields).length === 1) {
+    throw new SchemaError(
+      `Field "${key}" is the only field of content type "${type.slug}". A content type must keep at least one field; delete the type instead.`
+    );
+  }
+  if (type.titleField === key) {
+    throw new SchemaError(
+      `Field "${key}" is the title field of content type "${type.slug}". Choose another title field before removing it.`
+    );
+  }
+  if (type.defaultSort?.field === key) {
+    throw new SchemaError(
+      `Field "${key}" is the default sort of content type "${type.slug}". Choose another sort before removing it.`
+    );
+  }
+  const removed = {
+    field,
+    removedAt: context.removedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+    removedBy: context.removedBy
+  };
+  return rebuild(type, withoutKey(type.fields, key), {
+    ...type.removedFields ?? {},
+    [key]: removed
+  });
+}
+function addField(type, key, field) {
+  const state = fieldKeyState(type, key);
+  if (state === "live") {
+    throw new SchemaError(`Content type "${type.slug}" already has a field "${key}".`);
+  }
+  if (state === "removed") {
+    throw new SchemaError(
+      `Field "${key}" of content type "${type.slug}" was removed and its values are still stored. Restore it to get those values back, or purge them first.`
+    );
+  }
+  return rebuild(type, { ...type.fields, [key]: field }, type.removedFields ?? {});
+}
+function restoreField(type, key, options = {}) {
+  const removed = type.removedFields?.[key];
+  if (!removed) {
+    throw new SchemaError(`Content type "${type.slug}" has no removed field "${key}".`);
+  }
+  const field = options.field ?? removed.field;
+  if (!storesTheSameWay(removed.field, field)) {
+    throw new SchemaError(
+      `Field "${key}" of content type "${type.slug}" was removed as "${removed.field.type}" and cannot be restored as "${field.type}": the preserved values are stored in the old shape. Purge the values first, then add the field fresh.`
+    );
+  }
+  return rebuild(
+    type,
+    { ...type.fields, [key]: field },
+    withoutKey(type.removedFields ?? {}, key)
+  );
+}
+function forgetRemovedField(type, key) {
+  if (type.removedFields?.[key] === void 0) {
+    throw new SchemaError(`Content type "${type.slug}" has no removed field "${key}".`);
+  }
+  return rebuild(type, type.fields, withoutKey(type.removedFields, key));
+}
+function storesTheSameWay(left, right) {
+  return storageSignatureOf(left) === storageSignatureOf(right);
+}
+function storageSignatureOf(field) {
+  switch (field.type) {
+    case "select":
+      return `select:${field.multiple === true ? "many" : "one"}:${field.options.map((option) => option.value).sort().join("|")}`;
+    case "relation":
+      return `relation:${field.to}:${field.many === true ? "many" : "one"}`;
+    case "date":
+      return `date:${field.precision ?? "date"}`;
+    case "repeater":
+      return `repeater:{${fieldMapSignature(field.fields)}}`;
+    default:
+      return field.type;
+  }
+}
+function fieldMapSignature(fields) {
+  return Object.entries(fields).map(([key, field]) => `${key}=${storageSignatureOf(field)}`).sort().join(",");
+}
+
+// src/core/slug-field.ts
+function slugFieldKey(type) {
+  for (const [key, field] of Object.entries(type.fields)) {
+    if (field.type === "slug") return key;
+  }
+  return "slug" in type.fields ? "slug" : null;
+}
+
+// src/core/media-constraints.ts
+var MB = 1024 * 1024;
+var MAX_MEDIA_BYTES = 25 * MB;
+var MAX_IMAGE_BYTES = 10 * MB;
+var ALLOWED_MEDIA_TYPES = [
+  {
+    type: "image/jpeg",
+    category: "image",
+    maxBytes: MAX_IMAGE_BYTES,
+    extensions: [".jpg", ".jpeg"]
+  },
+  {
+    type: "image/png",
+    category: "image",
+    maxBytes: MAX_IMAGE_BYTES,
+    extensions: [".png"]
+  },
+  {
+    type: "image/webp",
+    category: "image",
+    maxBytes: MAX_IMAGE_BYTES,
+    extensions: [".webp"]
+  },
+  {
+    type: "image/avif",
+    category: "image",
+    maxBytes: MAX_IMAGE_BYTES,
+    extensions: [".avif"]
+  },
+  {
+    type: "image/gif",
+    category: "image",
+    maxBytes: MAX_IMAGE_BYTES,
+    extensions: [".gif"]
+  },
+  {
+    type: "application/pdf",
+    category: "document",
+    maxBytes: MAX_MEDIA_BYTES,
+    extensions: [".pdf"]
+  },
+  {
+    type: "video/mp4",
+    category: "video",
+    maxBytes: MAX_MEDIA_BYTES,
+    extensions: [".mp4"]
+  },
+  {
+    type: "video/webm",
+    category: "video",
+    maxBytes: MAX_MEDIA_BYTES,
+    extensions: [".webm"]
+  },
+  {
+    type: "audio/mpeg",
+    category: "audio",
+    maxBytes: MAX_MEDIA_BYTES,
+    extensions: [".mp3"]
+  },
+  {
+    type: "audio/ogg",
+    category: "audio",
+    maxBytes: MAX_MEDIA_BYTES,
+    extensions: [".ogg"]
+  },
+  {
+    type: "audio/wav",
+    category: "audio",
+    maxBytes: MAX_MEDIA_BYTES,
+    extensions: [".wav"]
+  }
+];
+var MEDIA_ACCEPT_ATTRIBUTE = ALLOWED_MEDIA_TYPES.map((rule) => rule.type).join(
+  ","
+);
+function mediaTypeRule(type) {
+  const normalized = normalizeMediaType(type);
+  return ALLOWED_MEDIA_TYPES.find((rule) => rule.type === normalized) ?? null;
+}
+function normalizeMediaType(type) {
+  const [base] = type.split(";");
+  return (base ?? "").trim().toLowerCase();
+}
+function fileExtension(name) {
+  const index = name.lastIndexOf(".");
+  return index <= 0 ? "" : name.slice(index).toLowerCase();
+}
+function checkMediaFile(file) {
+  const rule = mediaTypeRule(file.type);
+  if (rule === null) {
+    return {
+      code: "type-not-allowed",
+      message: `Files of type ${file.type || "unknown"} cannot be uploaded.`
+    };
+  }
+  if (file.size <= 0) {
+    return { code: "empty", message: "The file is empty." };
+  }
+  if (file.size > rule.maxBytes) {
+    return {
+      code: "too-large",
+      message: `${describeBytes(file.size)} is over the ${describeBytes(rule.maxBytes)} limit for ${rule.type} files.`
+    };
+  }
+  if (!rule.extensions.includes(fileExtension(file.name))) {
+    return {
+      code: "extension-mismatch",
+      message: `A ${rule.type} file must be named ${rule.extensions.join(" or ")}.`
+    };
+  }
+  return null;
+}
+function safeFileName(name, type) {
+  const extension = mediaTypeRule(type)?.extensions[0] ?? fileExtension(name);
+  const base = (extension !== "" && name.toLowerCase().endsWith(extension) ? name.slice(0, -extension.length) : name).toLowerCase().replace(/[^a-z0-9._-]+/g, "-").replace(/\.{2,}/g, ".").replace(/^[-.]+|[-.]+$/g, "").slice(0, 80);
+  return `${base === "" ? "file" : base}${extension}`;
+}
+function describeBytes(bytes) {
+  if (bytes >= MB) return `${Math.round(bytes / MB * 10) / 10} MB`;
+  if (bytes >= 1024) return `${Math.round(bytes / 1024)} KB`;
+  return `${bytes} bytes`;
+}
+
+// src/core/registry.ts
+function buildRegistry(code, database) {
+  const bySlug = /* @__PURE__ */ new Map();
+  const invalid = [];
+  for (const type of code) {
+    assertValidContentType(type);
+    if (bySlug.has(type.slug)) {
+      throw new SchemaError(
+        `Content type "${type.slug}" is defined twice in code. A slug identifies exactly one content type.`
+      );
+    }
+    bySlug.set(type.slug, {
+      type,
+      source: "code",
+      locked: type.locked ?? false
+    });
+  }
+  for (const type of database) {
+    try {
+      assertValidContentType(type);
+    } catch (thrown) {
+      invalid.push({
+        slug: typeof type?.slug === "string" ? type.slug : "(unknown)",
+        reason: thrown instanceof Error ? thrown.message : String(thrown),
+        definition: type
+      });
+      continue;
+    }
+    const existing = bySlug.get(type.slug);
+    if (!existing) {
+      bySlug.set(type.slug, { type, source: "database", locked: false });
+      continue;
+    }
+    if (existing.source === "database") {
+      invalid.push({
+        slug: type.slug,
+        reason: `Content type "${type.slug}" appears twice in the database. Only the first was loaded.`,
+        definition: type
+      });
+      continue;
+    }
+    bySlug.set(type.slug, { ...existing, conflict: { source: "database", type } });
+  }
+  const types = [...bySlug.values()];
+  return {
+    types,
+    conflicts: types.filter((entry) => entry.conflict !== void 0),
+    invalid,
+    get: (slug) => bySlug.get(slug),
+    has: (slug) => bySlug.has(slug),
+    require(slug) {
+      const entry = bySlug.get(slug);
+      if (!entry) {
+        throw new SchemaError(
+          `Unknown content type "${slug}". Known types: ${types.map((known) => known.type.slug).join(", ") || "none"}.`
+        );
+      }
+      return entry;
+    },
+    bySource: (source) => types.filter((entry) => entry.source === source)
+  };
+}
+function assertSchemaWritable(registry, slug) {
+  const entry = registry.require(slug);
+  if (entry.locked) {
+    throw new LockedTypeError(slug);
+  }
+  if (entry.source === "code") {
+    throw new LockedTypeError(
+      slug,
+      `Content type "${slug}" is defined in code. The Schema Builder writes database-defined types only; change the TypeScript definition and deploy.`
+    );
+  }
+  return entry;
+}
+function isSchemaReadOnly(entry) {
+  return entry.locked || entry.source === "code";
+}
+
+// src/core/schema-version.ts
+function storageSignature(type) {
+  return `${type.kind}|${fieldMapSignature(type.fields)}`;
+}
+var INITIAL_SCHEMA_VERSION = 1;
+function schemaVersionOf(type) {
+  const version = type.schemaVersion;
+  return typeof version === "number" && Number.isInteger(version) && version >= 1 ? version : INITIAL_SCHEMA_VERSION;
+}
+function nextSchemaVersion(previous, next) {
+  if (previous === null) return INITIAL_SCHEMA_VERSION;
+  const current = schemaVersionOf(previous);
+  return storageSignature(previous) === storageSignature(next) ? current : current + 1;
+}
+function storageShapeChanged(previous, next) {
+  return storageSignature(previous) !== storageSignature(next);
+}
+
+// src/core/write-limits.ts
+var FIRESTORE_DOCUMENT_BYTES = 1048576;
+var MAX_WRITE_BYTES = 9e5;
+var MAX_ENTRY_FIELDS = 200;
+var MAX_CONTENT_TYPE_FIELDS = 100;
+var MAX_SETTINGS_FIELDS = 100;
+var MAX_NESTING_DEPTH = 20;
+var MAX_ARRAY_ITEMS = 1e3;
+var MIN_WRITE_INTERVAL_MS = 200;
+var WRITE_BURST_LIMIT = 200;
+var WRITE_BURST_WINDOW_MS = 1e4;
+function approximateBytes(value) {
+  if (value === null || value === void 0) return 1;
+  if (typeof value === "boolean") return 1;
+  if (typeof value === "number") return 8;
+  if (typeof value === "string") return utf8Length(value) + 1;
+  if (value instanceof Date) return 8;
+  if (Array.isArray(value)) {
+    return value.reduce((total, item) => total + approximateBytes(item), 2);
+  }
+  if (typeof value === "object") {
+    return Object.entries(value).reduce(
+      (total, [key, item]) => total + utf8Length(key) + 1 + approximateBytes(item),
+      2
+    );
+  }
+  return 8;
+}
+function utf8Length(value) {
+  return new TextEncoder().encode(value).length;
+}
+function checkWritePayload(values, limits = {}) {
+  const maxFields = limits.maxFields ?? MAX_ENTRY_FIELDS;
+  const maxBytes = limits.maxBytes ?? MAX_WRITE_BYTES;
+  const keys = Object.keys(values);
+  if (keys.length > maxFields) {
+    return {
+      code: "too-many-fields",
+      path: "",
+      message: `This write has ${keys.length} top-level fields and the limit is ${maxFields}.`
+    };
+  }
+  const structural = checkStructure(values, "", 1);
+  if (structural !== null) return structural;
+  const bytes = approximateBytes(values);
+  if (bytes > maxBytes) {
+    return {
+      code: "too-large",
+      path: "",
+      message: `This write is about ${Math.round(bytes / 1024)} KB and the limit is ${Math.round(maxBytes / 1024)} KB. Move large content into a media file and reference it.`
+    };
+  }
+  return null;
+}
+function checkStructure(value, path, depth) {
+  if (depth > MAX_NESTING_DEPTH) {
+    return {
+      code: "too-deep",
+      path,
+      message: `This value nests more than ${MAX_NESTING_DEPTH} levels deep, which Firestore refuses to store.`
+    };
+  }
+  if (Array.isArray(value)) {
+    if (value.length > MAX_ARRAY_ITEMS) {
+      return {
+        code: "too-many-items",
+        path,
+        message: `"${path}" holds ${value.length} items and the limit is ${MAX_ARRAY_ITEMS}.`
+      };
+    }
+    for (const [index, item] of value.entries()) {
+      const found = checkStructure(item, `${path}.${index}`, depth + 1);
+      if (found !== null) return found;
+    }
+    return null;
+  }
+  if (value !== null && typeof value === "object" && !(value instanceof Date)) {
+    for (const [key, item] of Object.entries(value)) {
+      const found = checkStructure(item, path === "" ? key : `${path}.${key}`, depth + 1);
+      if (found !== null) return found;
+    }
+  }
+  return null;
+}
+function createWriteRateLimiter(clock = Date.now) {
+  let window = [];
+  return {
+    check() {
+      const now = clock();
+      window = window.filter((at) => now - at < WRITE_BURST_WINDOW_MS);
+      if (window.length >= WRITE_BURST_LIMIT) {
+        return {
+          code: "too-fast",
+          path: "",
+          message: `More than ${WRITE_BURST_LIMIT} writes in ${WRITE_BURST_WINDOW_MS / 1e3} seconds. Something is looping; nothing was written.`
+        };
+      }
+      window.push(now);
+      return null;
+    }
+  };
+}
+
+// src/core/media-references.ts
+var MEDIA_REFS_KEY = "mediaRefs";
+var MAX_MEDIA_REFS = 100;
+function collectMediaIds(data) {
+  const found = /* @__PURE__ */ new Set();
+  function walk(value) {
+    if (Array.isArray(value)) {
+      for (const item of value) walk(item);
+      return;
+    }
+    if (!isPlainObject(value)) return;
+    const mediaId = value["mediaId"];
+    if (typeof mediaId === "string") {
+      if (mediaId !== "") found.add(mediaId);
+      return;
+    }
+    for (const nested of Object.values(value)) walk(nested);
+  }
+  walk(data);
+  return [...found].sort().slice(0, MAX_MEDIA_REFS);
+}
+function retargetMediaUrls(data, mediaId, url) {
+  let changed = false;
+  function walk(value) {
+    if (Array.isArray(value)) return value.map(walk);
+    if (!isPlainObject(value)) return value;
+    const record = value;
+    if (record["mediaId"] === mediaId) {
+      if (record["url"] === url) return record;
+      changed = true;
+      return { ...record, url };
+    }
+    const next = {};
+    for (const [key, nested] of Object.entries(record)) next[key] = walk(nested);
+    return next;
+  }
+  const result = walk(data);
+  return changed ? result : null;
+}
+function isPlainObject(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const proto = Object.getPrototypeOf(value);
+  return proto === Object.prototype || proto === null;
+}
+
+export { ALLOWED_MEDIA_TYPES, DEFAULT_PAGE_SIZE, FIRESTORE_DOCUMENT_BYTES, INITIAL_SCHEMA_VERSION, MAX_ARRAY_ITEMS, MAX_CONTENT_TYPE_FIELDS, MAX_ENTRY_FIELDS, MAX_FIELD_PURGE, MAX_IMAGE_BYTES, MAX_MEDIA_BYTES, MAX_MEDIA_REFS, MAX_NESTING_DEPTH, MAX_PAGE_SIZE, MAX_SETTINGS_FIELDS, MAX_WRITE_BYTES, MEDIA_ACCEPT_ATTRIBUTE, MEDIA_REFS_KEY, MEDIA_USAGE_LIMIT, MIN_WRITE_INTERVAL_MS, WRITE_BURST_LIMIT, WRITE_BURST_WINDOW_MS, addField, approximateBytes, assertSchemaWritable, buildRegistry, checkMediaFile, checkWritePayload, collectMediaIds, createWriteRateLimiter, fieldKeyState, fieldMapSignature, fileExtension, forgetRemovedField, isSchemaReadOnly, mediaTypeRule, nextSchemaVersion, normalizeLimit, normalizeMediaType, removeField, removedFieldEntries, restoreField, retargetMediaUrls, safeFileName, schemaVersionOf, slugFieldKey, storageShapeChanged, storageSignature, storageSignatureOf, storesTheSameWay };
+//# sourceMappingURL=chunk-JAE7HHMM.js.map
+//# sourceMappingURL=chunk-JAE7HHMM.js.map