@hanzo/ui 8.0.24 → 8.0.25

package/README.md

@@ -34,6 +34,65 @@ Both layers are **presentational + data-injected**: the host supplies rows and p
 
 > Each layer owns a `DataTable` — the product one is a generic typed `<T>` list; the data one is the field-driven record grid. Keeping the record layer on the `./data` subpath keeps each name unambiguous.
 
+## The DocType renderer — one UI for every business app
+
+`@hanzo/ui/framework` renders the **Hanzo Framework** DocType engine (`hanzoai/cloud
+clients/framework`, live at `/v1/framework/*`; also published as
+[`hanzoai/framework`](https://github.com/hanzoai/framework) over
+[`hanzoai/doctype`](https://github.com/hanzoai/doctype)). The engine is
+metadata-driven: a CMS Page, an ERP Sales Order, a Helpdesk Ticket and a CRM
+Company are the same kind of thing — a DocType with typed fields. So they get the
+same renderer. An **app lane is a `module` filter** over the DocType registry plus
+its own copy; there is no per-lane list, form, detail or builder to drift.
+
+```tsx
+import { createFrameworkClient } from '@hanzo/ui/framework/core'      // transport only
+import { CollectionsBrowser, DocTypeRecords, DocTypeDetail } from '@hanzo/ui/framework'
+
+// The HOST owns transport: paths are relative to the framework root, so the app
+// decides the origin + the credential. Nothing in the library picks a URL.
+const client = createFrameworkClient({
+  get: (p) => api.get(`/v1/framework/${p}`),
+  post: (p, b) => api.post(`/v1/framework/${p}`, b),
+  put: (p, b) => api.put(`/v1/framework/${p}`, b),
+  del: (p) => api.del(`/v1/framework/${p}`),
+})
+
+<CollectionsBrowser client={client} module="erp" label="ERP" … onOpen={openCollection} />
+<DocTypeRecords client={client} doctype="erp-sales" onOpen={…} onCreate={…} />
+<DocTypeDetail  client={client} doctype="erp-sales" name={name} onBack={…} onView={…} />
+```
+
+**Mobile first — a rule, not a fallback.** The layout is decided from the
+CONTAINER's measured width (`onLayout`, so a narrow pane on a wide screen is still
+a phone), and the answer to "not measured yet" is PHONE. So the first paint —
+SSR included — is a stacked **card** per record; the `@hanzo/data` table is the
+enhancement applied once the box proves it can hold one. Every control meets the
+44px tap floor (WCAG 2.5.5) at phone width, and the table honors the DocType's own
+`inListView` projection so a twelve-field document does not become a horizontal
+scroll wall.
+
+**Two entries, because they are two different things.** `./framework/core` is the
+contract — wire types, the client, the metadata↔render mapping, the builder
+projection, the media model. It imports no React and no `@hanzo/gui`, so a data
+layer, a server route or a plain node test can bind the engine without loading a
+component tree. `./framework` re-exports all of it plus the views.
+
+**Ports, not bindings.** The client takes a `FrameworkTransport`; the DAM takes a
+`MediaStore` (ensure-bucket / presign / put / delete) and a **bucket parameter**,
+so ERP attachments never land in a bucket named after the CMS. Routing is
+`onOpen`/`onCreate`/`onBack`/`onView` callbacks — no router import anywhere.
+
+**One entry, not two.** 8.0.24 shipped a first `./framework` lift with the same
+`createFrameworkClient(Transport)` shape but no builder, no DAM and no mobile
+layout, injecting `renderBuilder`/`renderMedia` instead. 8.0.25 is the convergence:
+the same entry, a superset implementation, and every 8.0.24 name still resolves —
+`Transport` aliases `FrameworkTransport`, `Loader` aliases the in-flow `Loading`,
+`setupDescription`/`setupBullets` stay optional (they now fall back to copy DERIVED
+FROM THE LANE, which is the actual fix — the old default was one lane's words), and
+`renderBuilder`/`renderMedia` still win when supplied. A host that passes neither
+now gets the real built-in `CollectionBuilder`/`MediaGrid` instead of nothing.
+
 ## Motion
 
 The calm motion vocabulary (`FadeIn`, drawer/backdrop transitions, skeleton shimmer, live pulse) ships as one stylesheet. Import it once at the app root:

package/dist/chunk-3NG33DV2.cjs

@@ -0,0 +1,607 @@
+'use client';
+'use strict';
+
+// src/framework/types.ts
+var DRAFT = 0;
+var SUBMITTED = 1;
+var CANCELLED = 2;
+var REDACTED_MARKER = "__set__";
+
+// src/framework/client.ts
+var enc = encodeURIComponent;
+var asRecord = (v) => v && typeof v === "object" && !Array.isArray(v) ? v : {};
+function rows(payload) {
+  if (Array.isArray(payload)) {
+    return payload.filter((x) => x && typeof x === "object");
+  }
+  const o = asRecord(payload);
+  for (const k of ["data", "items", "rows"]) {
+    if (Array.isArray(o[k])) {
+      return o[k].filter((x) => x && typeof x === "object");
+    }
+  }
+  return [];
+}
+var asDoc = (v) => asRecord(v);
+var asDocType = (v) => {
+  const r = asRecord(v);
+  return {
+    ...r,
+    name: String(r.name ?? ""),
+    fields: Array.isArray(r.fields) ? r.fields : []
+  };
+};
+function listQuery(q) {
+  if (!q) return "";
+  const p = new URLSearchParams();
+  if (q.filters && Object.keys(q.filters).length) p.set("filters", JSON.stringify(q.filters));
+  if (q.fields && q.fields.length) p.set("fields", q.fields.join(","));
+  if (q.orderBy) p.set("order_by", q.orderBy);
+  if (q.limit) p.set("limit", String(q.limit));
+  const s = p.toString();
+  return s ? `?${s}` : "";
+}
+function createFrameworkClient(t) {
+  return {
+    doctypes: {
+      list: () => t.get("doctypes").then((r) => rows(r).map(asDocType)),
+      get: (name) => t.get(`doctypes/${enc(name)}`).then(asDocType),
+      create: (dt) => t.post("doctypes", dt).then(asDocType),
+      update: (name, dt) => t.put(`doctypes/${enc(name)}`, dt).then(asDocType),
+      remove: (name) => t.del(`doctypes/${enc(name)}`)
+    },
+    records: {
+      list: (doctype, q) => t.get(`${enc(doctype)}${listQuery(q)}`).then((r) => rows(r).map(asDoc)),
+      get: (doctype, name) => t.get(`${enc(doctype)}/${enc(name)}`).then(asDoc),
+      create: (doctype, data) => t.post(enc(doctype), data).then(asDoc),
+      update: (doctype, name, data) => t.put(`${enc(doctype)}/${enc(name)}`, data).then(asDoc),
+      remove: (doctype, name) => t.del(`${enc(doctype)}/${enc(name)}`),
+      submit: (doctype, name) => t.post(`${enc(doctype)}/${enc(name)}/submit`).then(asDoc),
+      cancel: (doctype, name) => t.post(`${enc(doctype)}/${enc(name)}/cancel`).then(asDoc)
+    },
+    modules: {
+      list: () => t.get("modules").then(
+        (r) => rows(r).map((m) => ({
+          module: String(m.module ?? ""),
+          doctypes: Array.isArray(m.doctypes) ? m.doctypes : []
+        }))
+      ),
+      get: (module) => t.get(`modules/${enc(module)}`).then((v) => {
+        const r = asRecord(v);
+        return {
+          module: String(r.module ?? module),
+          doctypes: Array.isArray(r.doctypes) ? r.doctypes : [],
+          installed: Array.isArray(r.installed) ? r.installed : []
+        };
+      }),
+      install: (module) => t.post(`modules/${enc(module)}/install`).then((v) => {
+        const r = asRecord(v);
+        return {
+          module: String(r.module ?? module),
+          created: Array.isArray(r.created) ? r.created : [],
+          existing: Array.isArray(r.existing) ? r.existing : []
+        };
+      })
+    },
+    roles: {
+      list: () => t.get("roles").then(
+        (r) => rows(r).map((x) => ({ user: String(x.user ?? ""), role: String(x.role ?? "") }))
+      ),
+      assign: (user, role) => t.post("roles", { user, role }).then(() => void 0),
+      revoke: (user, role) => t.del(`roles/${enc(user)}/${enc(role)}`)
+    },
+    summary: () => t.get("summary").then(asRecord)
+  };
+}
+
+// src/framework/fields.ts
+var TYPE_MAP = {
+  Data: "text",
+  SmallText: "text",
+  Text: "longText",
+  LongText: "longText",
+  RichText: "richText",
+  Int: "number",
+  Float: "number",
+  Currency: "currency",
+  Check: "boolean",
+  Date: "date",
+  Datetime: "dateTime",
+  Select: "select",
+  Link: "relation",
+  Table: "json",
+  Attach: "url",
+  JSON: "json",
+  Password: "text"
+};
+var ACRONYMS = /* @__PURE__ */ new Set(["id", "url", "seo", "api", "ip"]);
+function humanize(name) {
+  return name.replace(/[_-]+/g, " ").replace(/([a-z0-9])([A-Z])/g, "$1 $2").trim().split(/\s+/).filter(Boolean).map((w) => ACRONYMS.has(w.toLowerCase()) ? w.toUpperCase() : w.charAt(0).toUpperCase() + w.slice(1)).join(" ");
+}
+function selectOptions(options) {
+  return (options ?? "").split("\n").map((s) => s.replace(/\r$/, "").trim()).filter(Boolean).map((v) => ({ value: v, label: v }));
+}
+function metadataFor(f) {
+  switch (f.fieldtype) {
+    case "Select":
+      return { options: selectOptions(f.options) };
+    case "Currency":
+      return { currencyCode: "USD" };
+    case "Int":
+      return { decimals: 0 };
+    case "Link":
+      return { objectName: f.options };
+    default:
+      return void 0;
+  }
+}
+function autonameSource(dt) {
+  const a = (dt.autoname ?? "").trim();
+  return a.startsWith("field:") ? a.slice("field:".length).trim() : "";
+}
+function docTypeToFields(dt, opts = {}) {
+  const src = autonameSource(dt);
+  return (dt.fields ?? []).filter((f) => !f.hidden).map((f) => {
+    const readOnly = f.readOnly || opts.editing && f.fieldname === src || void 0;
+    const metadata = metadataFor(f);
+    return {
+      name: f.fieldname,
+      label: f.label || humanize(f.fieldname),
+      type: TYPE_MAP[f.fieldtype] ?? "text",
+      ...metadata ? { metadata } : {},
+      ...readOnly ? { readOnly: true } : {}
+    };
+  });
+}
+function statusField(dt) {
+  const f = (dt.fields ?? []).find(
+    (x) => x.fieldtype === "Select" && x.fieldname === "status" && (x.options ?? "").includes("Published")
+  );
+  return f ? f.fieldname : "";
+}
+function listHiddenFields(dt) {
+  const anyListed = (dt.fields ?? []).some((f) => f.inListView);
+  if (!anyListed) return [];
+  return (dt.fields ?? []).filter((f) => !f.inListView && !f.hidden).map((f) => f.fieldname);
+}
+function cardFields(dt, fields, max = 4) {
+  const title = dt.titleField ?? "";
+  const listed = new Set(listedFieldNames(dt));
+  const pick = listed.size ? fields.filter((f) => listed.has(f.name)) : fields;
+  return pick.filter((f) => f.name !== title).slice(0, max);
+}
+function listedFieldNames(dt) {
+  return (dt.fields ?? []).filter((f) => f.inListView && !f.hidden).map((f) => f.fieldname);
+}
+function isMediaDoctype(dt) {
+  return (dt.fields ?? []).some((f) => f.fieldtype === "Attach" && f.reqd);
+}
+function mediaFileField(dt) {
+  const f = (dt.fields ?? []).find((x) => x.fieldtype === "Attach" && x.reqd) ?? (dt.fields ?? []).find((x) => x.fieldtype === "Attach");
+  return f ? f.fieldname : "";
+}
+function mediaDocPayload(dt, facts) {
+  const declared = new Set((dt.fields ?? []).map((f) => f.fieldname));
+  const out = {};
+  const fileField = mediaFileField(dt);
+  if (fileField) out[fileField] = facts.fileRef;
+  const titleF = dt.titleField && declared.has(dt.titleField) ? dt.titleField : declared.has("title") ? "title" : "";
+  if (titleF && titleF !== fileField) out[titleF] = facts.filename;
+  const optional = [
+    ["mime", facts.mime],
+    ["size", facts.size],
+    ["width", facts.width],
+    ["height", facts.height]
+  ];
+  for (const [k, v] of optional) if (declared.has(k) && k !== fileField && k !== titleF) out[k] = v;
+  return out;
+}
+function moduleDoctypes(dts, module) {
+  return dts.filter((dt) => (dt.module ?? "") === module);
+}
+var PROJECT_FIELD = "project";
+function hasProjectField(dt) {
+  return (dt.fields ?? []).some((f) => f.fieldname === PROJECT_FIELD);
+}
+function isDraft(record) {
+  return Number(record?.docstatus ?? DRAFT) === DRAFT;
+}
+function titleOf(doc, dt) {
+  if (dt.titleField && typeof doc[dt.titleField] === "string" && doc[dt.titleField]) {
+    return String(doc[dt.titleField]);
+  }
+  return typeof doc.name === "string" && doc.name ? doc.name : "(untitled)";
+}
+function slugify(s) {
+  return String(s ?? "").normalize("NFKD").replace(/[\u0300-\u036f]/g, "").toLowerCase().trim().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "");
+}
+function isValidDoctypeName(name) {
+  return /^[A-Za-z0-9][A-Za-z0-9_-]*$/.test(name.trim());
+}
+var secToMs = (v) => {
+  const n = Number(v);
+  return Number.isFinite(n) && n > 0 ? n * 1e3 : void 0;
+};
+var numOrNull = (v) => {
+  const n = Number(v);
+  return Number.isFinite(n) ? n : null;
+};
+function coerceForDisplay(f, v) {
+  switch (f.fieldtype) {
+    case "Currency":
+      return { amount: numOrNull(v), currencyCode: "USD" };
+    case "Check":
+      return v === 1 || v === true || v === "1";
+    case "Datetime":
+      return typeof v === "string" ? v.replace(" ", "T") : v;
+    case "Password":
+      return v === REDACTED_MARKER ? "" : v;
+    // never surface the marker
+    default:
+      return v;
+  }
+}
+function toRecord(doc, dt) {
+  const rec = {
+    id: doc.name,
+    name: doc.name,
+    doctype: doc.doctype,
+    docstatus: doc.docstatus,
+    createdAt: secToMs(doc.createdAt),
+    updatedAt: secToMs(doc.updatedAt)
+  };
+  for (const f of dt.fields ?? []) {
+    if (!(f.fieldname in doc)) continue;
+    rec[f.fieldname] = coerceForDisplay(f, doc[f.fieldname]);
+  }
+  return rec;
+}
+function coerceForWrite(f, v) {
+  switch (f.fieldtype) {
+    case "Currency":
+      return v && typeof v === "object" && "amount" in v ? Number(v.amount) : Number(v);
+    case "Check":
+      return Boolean(v);
+    case "Int":
+    case "Float":
+      return Number(v);
+    case "Datetime":
+      if (v instanceof Date) return v.toISOString();
+      if (typeof v === "number" && Number.isFinite(v)) return new Date(v).toISOString();
+      return v;
+    case "Link":
+      if (v == null || v === "") return "";
+      if (typeof v === "object") {
+        return String(v.id ?? v.value ?? "");
+      }
+      return v;
+    default:
+      return v;
+  }
+}
+function enrichLinks(record, dt, optionsByField) {
+  const out = { ...record };
+  for (const f of dt.fields ?? []) {
+    if (f.fieldtype !== "Link") continue;
+    const raw = out[f.fieldname];
+    if (typeof raw === "string" && raw) {
+      const opt = (optionsByField[f.fieldname] ?? []).find((o) => o.value === raw);
+      out[f.fieldname] = { id: raw, label: opt?.label ?? raw };
+    }
+  }
+  return out;
+}
+function linkFields(dt) {
+  return (dt.fields ?? []).filter((f) => f.fieldtype === "Link");
+}
+function newDraft(dt) {
+  const out = {};
+  for (const f of dt.fields ?? []) {
+    if (f.default === void 0 || f.default === "") continue;
+    out[f.fieldname] = f.fieldtype === "Check" ? f.default === "1" || f.default === "true" : f.default;
+  }
+  return out;
+}
+function savePayload(draft, dt) {
+  const src = autonameSource(dt);
+  const out = {};
+  for (const f of dt.fields ?? []) {
+    if (f.readOnly) continue;
+    let v = draft[f.fieldname];
+    if (v === void 0) continue;
+    v = coerceForWrite(f, v);
+    if (f.fieldname === src && typeof v === "string") v = slugify(v);
+    out[f.fieldname] = v;
+  }
+  return out;
+}
+
+// src/framework/builder-logic.ts
+var BUILDER_FIELD_TYPES = [
+  { type: "Data", label: "Text", hint: "Single line of text" },
+  { type: "RichText", label: "Rich text", hint: "Formatted body (WYSIWYG)" },
+  { type: "LongText", label: "Long text", hint: "Multi-line plain text" },
+  { type: "Int", label: "Number", hint: "Whole number" },
+  { type: "Float", label: "Decimal", hint: "Decimal number" },
+  { type: "Currency", label: "Currency", hint: "Money amount" },
+  { type: "Check", label: "Checkbox", hint: "True / false" },
+  { type: "Date", label: "Date", hint: "Calendar date" },
+  { type: "Datetime", label: "Date & time", hint: "Date with time" },
+  { type: "Select", label: "Select", hint: "One of a list of options" },
+  { type: "Link", label: "Relation", hint: "Reference another collection" },
+  { type: "Attach", label: "Attachment", hint: "A file / image URL" },
+  { type: "Table", label: "Table", hint: "Repeatable child rows (JSON)" },
+  { type: "JSON", label: "JSON", hint: "Arbitrary JSON" }
+];
+var LABELS = Object.fromEntries(
+  BUILDER_FIELD_TYPES.map((t) => [t.type, t.label])
+);
+function fieldTypeLabel(t) {
+  return LABELS[t] ?? t;
+}
+function fieldNeedsOptions(t) {
+  return t === "Select" || t === "Link" || t === "Table";
+}
+var seq = 0;
+function newKey() {
+  seq += 1;
+  return `f${seq}_${Math.random().toString(36).slice(2, 8)}`;
+}
+function blankField(type = "Data") {
+  return { key: newKey(), label: "", type, required: false, inListView: false, options: "" };
+}
+function starterFields() {
+  return [
+    { key: newKey(), label: "Title", type: "Data", required: true, inListView: true, options: "" },
+    { key: newKey(), label: "Slug", type: "Data", required: true, inListView: true, options: "" },
+    { key: newKey(), label: "Body", type: "RichText", required: false, inListView: false, options: "" },
+    { key: newKey(), label: "Status", type: "Select", required: false, inListView: true, options: "Draft\nPublished" },
+    // Optional project scope — lets a host's org→project switcher filter this collection.
+    { key: newKey(), label: "Project", type: "Data", required: false, inListView: false, options: "" }
+  ];
+}
+function fieldsFromDocType(dt) {
+  return (dt.fields ?? []).map((f) => ({
+    key: newKey(),
+    label: f.label || f.fieldname,
+    type: f.fieldtype,
+    required: Boolean(f.reqd),
+    inListView: Boolean(f.inListView),
+    options: f.options ?? ""
+  }));
+}
+function fieldNameFromLabel(label) {
+  const slug = slugify(label).replace(/-/g, "_");
+  return /^[0-9]/.test(slug) ? `f_${slug}` : slug;
+}
+function validateBuilder(name, fields) {
+  const fieldErrors = {};
+  let formError = null;
+  if (!isValidDoctypeName(name.trim())) {
+    formError = "Enter a collection name with letters, digits, dashes or underscores (no spaces).";
+  } else if (fields.length === 0) {
+    formError = "Add at least one field.";
+  }
+  const seen = /* @__PURE__ */ new Set();
+  for (const f of fields) {
+    const label = f.label.trim();
+    if (!label) {
+      fieldErrors[f.key] = "Name this field.";
+      continue;
+    }
+    const fname = fieldNameFromLabel(label);
+    if (!fname) {
+      fieldErrors[f.key] = "Use letters or digits in the field name.";
+      continue;
+    }
+    if (seen.has(fname)) {
+      fieldErrors[f.key] = `Duplicate field "${fname}".`;
+      continue;
+    }
+    seen.add(fname);
+    if ((f.type === "Link" || f.type === "Table") && !f.options.trim()) {
+      fieldErrors[f.key] = f.type === "Link" ? "Choose the collection to relate to." : "Name the child collection.";
+    } else if (f.type === "Select" && !f.options.trim()) {
+      fieldErrors[f.key] = "Add at least one option.";
+    }
+  }
+  return { ok: !formError && Object.keys(fieldErrors).length === 0, fieldErrors, formError };
+}
+function toDocField(f) {
+  const fieldname = fieldNameFromLabel(f.label);
+  const field = {
+    fieldname,
+    fieldtype: f.type,
+    label: f.label.trim()
+  };
+  if (f.required) field.reqd = true;
+  if (f.inListView) field.inListView = true;
+  if (fieldNeedsOptions(f.type) && f.options.trim()) field.options = f.options.trim();
+  return field;
+}
+function moveField(fields, key, dir) {
+  const i = fields.findIndex((f) => f.key === key);
+  const j = i + dir;
+  if (i < 0 || j < 0 || j >= fields.length) return fields;
+  const next = [...fields];
+  [next[i], next[j]] = [next[j], next[i]];
+  return next;
+}
+function toDocType(name, module, fields) {
+  const docFields = fields.map(toDocField);
+  const byName = new Set(docFields.map((f) => f.fieldname));
+  const dt = { name: name.trim(), module, fields: docFields };
+  if (byName.has("slug")) dt.autoname = "field:slug";
+  if (byName.has("title")) dt.titleField = "title";
+  return dt;
+}
+
+// src/framework/media.ts
+var REF_PREFIX = "s3://";
+function mediaRef(bucket, key) {
+  return `${REF_PREFIX}${bucket}/${key}`;
+}
+function isRef(value) {
+  return typeof value === "string" && value.startsWith(REF_PREFIX);
+}
+function parseRef(ref) {
+  if (!ref.startsWith(REF_PREFIX)) return null;
+  const rest = ref.slice(REF_PREFIX.length);
+  const slash = rest.indexOf("/");
+  if (slash <= 0) return null;
+  return { bucket: rest.slice(0, slash), key: rest.slice(slash + 1) };
+}
+function joinKey(...parts) {
+  return parts.filter(Boolean).join("/");
+}
+function mediaKey(filename, folder = "") {
+  const dot = filename.lastIndexOf(".");
+  const ext = dot > 0 ? filename.slice(dot + 1).toLowerCase().replace(/[^a-z0-9]/g, "") : "";
+  const base = slugify(dot > 0 ? filename.slice(0, dot) : filename) || "file";
+  const stamp = `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+  const name = ext ? `${base}-${stamp}.${ext}` : `${base}-${stamp}`;
+  return folder ? joinKey(slugify(folder), name) : name;
+}
+function looksLikeImage(value) {
+  return /\.(png|jpe?g|gif|webp|svg|avif)(\?|#|$)/i.test(value) || value.startsWith("data:image/");
+}
+function createMediaUploader(store, bucket) {
+  return {
+    bucket,
+    async upload(file, folder = "") {
+      await store.ensureBucket(bucket).catch(() => void 0);
+      const key = mediaKey(file.name, folder);
+      const presigned = await store.presignUpload(bucket, key);
+      if (!presigned || (presigned.method ?? "PUT") !== "PUT" || !presigned.url) {
+        throw new Error("Could not start the upload (object storage not configured).");
+      }
+      await store.put(presigned.url, file);
+      const { width, height } = await imageDimensions(file);
+      return {
+        fileRef: mediaRef(bucket, key),
+        filename: file.name,
+        mime: file.type || "application/octet-stream",
+        size: file.size,
+        width,
+        height
+      };
+    },
+    async resolveUrl(value) {
+      if (typeof value !== "string" || value === "") return "";
+      if (!isRef(value)) return value;
+      const parsed = parseRef(value);
+      if (!parsed) return "";
+      const presigned = await store.presignDownload(parsed.bucket, parsed.key).catch(() => null);
+      return presigned?.url ?? "";
+    },
+    async remove(value) {
+      if (!isRef(value)) return;
+      const parsed = parseRef(value);
+      if (!parsed) return;
+      await store.deleteObject(parsed.bucket, parsed.key).catch(() => void 0);
+    }
+  };
+}
+function imageDimensions(file) {
+  return new Promise((resolve) => {
+    if (typeof window === "undefined" || typeof Image === "undefined" || !file.type.startsWith("image/")) {
+      resolve({ width: 0, height: 0 });
+      return;
+    }
+    const url = URL.createObjectURL(file);
+    const img = new Image();
+    img.onload = () => {
+      resolve({ width: img.naturalWidth, height: img.naturalHeight });
+      URL.revokeObjectURL(url);
+    };
+    img.onerror = () => {
+      resolve({ width: 0, height: 0 });
+      URL.revokeObjectURL(url);
+    };
+    img.src = url;
+  });
+}
+
+// src/framework/data.ts
+async function loadLinkOptions(client, dt) {
+  const links = linkFields(dt);
+  const out = {};
+  await Promise.all(
+    links.map(async (f) => {
+      const target = f.options;
+      if (!target) return;
+      const [tdt, docs] = await Promise.all([
+        client.doctypes.get(target).catch(() => null),
+        client.records.list(target, { limit: 200 }).catch(() => [])
+      ]);
+      out[f.fieldname] = docs.map((d) => ({
+        value: String(d.name),
+        label: tdt ? titleOf(d, tdt) : String(d.name)
+      }));
+    })
+  );
+  return out;
+}
+function makeFieldOptions(linkOptions) {
+  return (field) => {
+    if (field.type === "relation") return linkOptions[field.name] ?? [];
+    if (field.type === "select" || field.type === "multiSelect") {
+      return field.metadata?.options;
+    }
+    return void 0;
+  };
+}
+
+exports.BUILDER_FIELD_TYPES = BUILDER_FIELD_TYPES;
+exports.CANCELLED = CANCELLED;
+exports.DRAFT = DRAFT;
+exports.PROJECT_FIELD = PROJECT_FIELD;
+exports.REDACTED_MARKER = REDACTED_MARKER;
+exports.SUBMITTED = SUBMITTED;
+exports.autonameSource = autonameSource;
+exports.blankField = blankField;
+exports.cardFields = cardFields;
+exports.createFrameworkClient = createFrameworkClient;
+exports.createMediaUploader = createMediaUploader;
+exports.docTypeToFields = docTypeToFields;
+exports.enrichLinks = enrichLinks;
+exports.fieldNameFromLabel = fieldNameFromLabel;
+exports.fieldNeedsOptions = fieldNeedsOptions;
+exports.fieldTypeLabel = fieldTypeLabel;
+exports.fieldsFromDocType = fieldsFromDocType;
+exports.hasProjectField = hasProjectField;
+exports.humanize = humanize;
+exports.imageDimensions = imageDimensions;
+exports.isDraft = isDraft;
+exports.isMediaDoctype = isMediaDoctype;
+exports.isRef = isRef;
+exports.isValidDoctypeName = isValidDoctypeName;
+exports.joinKey = joinKey;
+exports.linkFields = linkFields;
+exports.listHiddenFields = listHiddenFields;
+exports.listQuery = listQuery;
+exports.listedFieldNames = listedFieldNames;
+exports.loadLinkOptions = loadLinkOptions;
+exports.looksLikeImage = looksLikeImage;
+exports.makeFieldOptions = makeFieldOptions;
+exports.mediaDocPayload = mediaDocPayload;
+exports.mediaFileField = mediaFileField;
+exports.mediaKey = mediaKey;
+exports.mediaRef = mediaRef;
+exports.moduleDoctypes = moduleDoctypes;
+exports.moveField = moveField;
+exports.newDraft = newDraft;
+exports.newKey = newKey;
+exports.parseRef = parseRef;
+exports.rows = rows;
+exports.savePayload = savePayload;
+exports.slugify = slugify;
+exports.starterFields = starterFields;
+exports.statusField = statusField;
+exports.titleOf = titleOf;
+exports.toDocField = toDocField;
+exports.toDocType = toDocType;
+exports.toRecord = toRecord;
+exports.validateBuilder = validateBuilder;
+//# sourceMappingURL=chunk-3NG33DV2.cjs.map
+//# sourceMappingURL=chunk-3NG33DV2.cjs.map