dune-react 0.0.32 → 0.0.34

package/dist/components/puck-core/core/puck-fields-to-zod.d.ts

@@ -0,0 +1,40 @@
+import { z } from "zod";
+type PuckFieldOption = {
+    label: string;
+    value: string;
+};
+type PuckField = {
+    type: string;
+    options?: PuckFieldOption[];
+    objectFields?: Record<string, PuckField>;
+    arrayFields?: Record<string, PuckField>;
+    max?: number;
+    ai?: {
+        instructions?: string;
+        exclude?: boolean;
+        stream?: boolean;
+    };
+    [key: string]: unknown;
+};
+/**
+ * Registry for custom field schemas.
+ * Key: custom field render component name or identifier.
+ * Value: Zod schema for that field.
+ *
+ * Pre-registered:
+ *   - IconPickerField  → string (icon name)
+ *   - ActionField      → Action object
+ *   - MediaUploadField → string (URL)
+ *   - LocationField    → MapLocation object
+ */
+export declare const customSchemaRegistry: Map<string, z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+/**
+ * Convert a Puck component's `fields` config into a Zod schema at runtime.
+ *
+ * @example
+ *   const schema = puckFieldsToZod(conf.fields);
+ *   // Use with AI structured output:
+ *   const result = schema.parse(aiOutput);
+ */
+export declare function puckFieldsToZod(fields: Record<string, PuckField>): z.ZodObject<Record<string, z.ZodType>>;
+export {};

package/dist/components/puck-core/core/puck-fields-to-zod.js

@@ -0,0 +1,113 @@
+import { object, string, enum as _enum, number, array, record, any, unknown } from "../../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.js";
+const actionTypeValues = [
+  "page",
+  "external",
+  "scroll",
+  "email",
+  "phone",
+  "section",
+  "download",
+  "none"
+];
+const actionSchema = object({
+  type: _enum(actionTypeValues).optional(),
+  pageUrl: string().optional(),
+  externalUrl: string().optional(),
+  openInNewTab: string().optional(),
+  email: string().optional(),
+  subject: string().optional(),
+  phone: string().optional(),
+  sectionId: string().optional(),
+  downloadUrl: string().optional()
+}).optional();
+const iconSchema = string().optional();
+const mediaUploadSchema = string().optional();
+const locationSchema = object({
+  address: string(),
+  lat: number(),
+  lng: number(),
+  zoom: number().optional(),
+  placeId: string().optional()
+}).optional();
+const customSchemaRegistry = /* @__PURE__ */ new Map([
+  ["IconPickerField", iconSchema],
+  ["ActionField", actionSchema],
+  ["MediaUploadField", mediaUploadSchema],
+  ["LocationField", locationSchema]
+]);
+function resolveCustomField(field) {
+  const render = field.render;
+  const name = render == null ? void 0 : render.name;
+  if (name && customSchemaRegistry.has(name)) {
+    return customSchemaRegistry.get(name);
+  }
+  return any();
+}
+function withDescribe(schema, field) {
+  var _a;
+  const desc = (_a = field.ai) == null ? void 0 : _a.instructions;
+  return desc ? schema.describe(desc) : schema;
+}
+function puckFieldToZod(field) {
+  var _a, _b;
+  let schema;
+  switch (field.type) {
+    case "text":
+    case "textarea":
+      schema = string().optional();
+      break;
+    case "select":
+    case "radio": {
+      const values = (field.options ?? []).map((o) => o.value);
+      schema = values.length === 0 ? string().optional() : _enum(values).optional();
+      break;
+    }
+    case "object": {
+      if (!field.objectFields || Object.keys(field.objectFields).length === 0) {
+        schema = record(string(), unknown()).optional();
+      } else {
+        const shape = {};
+        for (const [k, v] of Object.entries(field.objectFields)) {
+          if ((_a = v.ai) == null ? void 0 : _a.exclude) continue;
+          shape[k] = puckFieldToZod(v);
+        }
+        schema = object(shape).optional();
+      }
+      break;
+    }
+    case "array": {
+      if (!field.arrayFields || Object.keys(field.arrayFields).length === 0) {
+        schema = array(unknown()).optional();
+      } else {
+        const itemShape = {};
+        for (const [k, v] of Object.entries(field.arrayFields)) {
+          if ((_b = v.ai) == null ? void 0 : _b.exclude) continue;
+          itemShape[k] = puckFieldToZod(v);
+        }
+        let arraySchema = array(object(itemShape));
+        if (field.max) arraySchema = arraySchema.max(field.max);
+        schema = arraySchema.optional();
+      }
+      break;
+    }
+    case "custom":
+      schema = resolveCustomField(field);
+      break;
+    default:
+      schema = any();
+  }
+  return withDescribe(schema, field);
+}
+function puckFieldsToZod(fields) {
+  var _a;
+  const shape = {};
+  for (const [key, field] of Object.entries(fields)) {
+    if ((_a = field.ai) == null ? void 0 : _a.exclude) continue;
+    shape[key] = puckFieldToZod(field);
+  }
+  return object(shape);
+}
+export {
+  customSchemaRegistry,
+  puckFieldsToZod
+};

package/dist/components/puck-core/index.d.ts

@@ -3,6 +3,7 @@ export { ActionField, ACTION_TYPE_FIELD_MAP, ACTION_TYPE_OPTIONS, PageActionFiel
 export { type IconName, type Feature, type ActionType, type Action, resolveActionUrl, } from "./core/types";
 export { withEditable } from "./core/with-editable";
 export { findComponentById, getRandomAdjective } from "./core/utils";
+export { puckFieldsToZod, customSchemaRegistry } from "./core/puck-fields-to-zod";
 export { ErrorBoundary } from "./error-boundary";
 export { InlineEditable } from "./inline-editable";
 export { usePuckDispatch, usePuckAppState, usePuckHistory, usePuckConfig, usePuckGetSelectorForId, type PuckComponentInfo, } from "./core/hooks";

package/dist/index.js

@@ -202,6 +202,7 @@ import { buildComponents, categories, confMap, getComponentDefaultProps, section
 import { cardField, cardsField, descriptionField, featuresField, headingField } from "./components/puck-core/core/props/content.js";
 import { cn, liquidGlass } from "./utils/css-utils.js";
 import { contentFields, contentFieldsWithFeatures } from "./components/puck-core/core/props/index.js";
+import { customSchemaRegistry, puckFieldsToZod } from "./components/puck-core/core/puck-fields-to-zod.js";
 import { downloadImage, downloadImageClient, fetchHasOnlineFile, getBase64Client, isValidFileSize, isValidFileType } from "./utils/utils-image.js";
 import { formFieldField, formFieldDefaults, formField, formDefaults } from "./components/puck-core/core/props/form.js";
 import { filterEmptyValues } from "./utils/utils-common.js";
@@ -700,6 +701,7 @@ export {
   contentFields,
   contentFieldsWithFeatures,
   convertBase64ToBlob,
+  customSchemaRegistry,
   descriptionField as description,
   downloadImage,
   downloadImageClient,
@@ -738,6 +740,7 @@ export {
   padding,
   paddingDefaults,
   paddingLevel,
+  puckFieldsToZod,
   resolveActionUrl,
   sectionOverlay,
   sectionStyle,

package/dist/node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/errors.js

@@ -0,0 +1,44 @@
+import { $constructor } from "../core/core.js";
+import { $ZodError, flattenError, formatError } from "../core/errors.js";
+import { jsonStringifyReplacer } from "../core/util.js";
+import "../core/registries.js";
+const initializer = (inst, issues) => {
+  $ZodError.init(inst, issues);
+  inst.name = "ZodError";
+  Object.defineProperties(inst, {
+    format: {
+      value: (mapper) => formatError(inst, mapper)
+      // enumerable: false,
+    },
+    flatten: {
+      value: (mapper) => flattenError(inst, mapper)
+      // enumerable: false,
+    },
+    addIssue: {
+      value: (issue) => {
+        inst.issues.push(issue);
+        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+      }
+      // enumerable: false,
+    },
+    addIssues: {
+      value: (issues2) => {
+        inst.issues.push(...issues2);
+        inst.message = JSON.stringify(inst.issues, jsonStringifyReplacer, 2);
+      }
+      // enumerable: false,
+    },
+    isEmpty: {
+      get() {
+        return inst.issues.length === 0;
+      }
+      // enumerable: false,
+    }
+  });
+};
+const ZodRealError = $constructor("ZodError", initializer, {
+  Parent: Error
+});
+export {
+  ZodRealError
+};

package/dist/node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/iso.js

@@ -0,0 +1,43 @@
+import { $constructor } from "../core/core.js";
+import { $ZodISODateTime, $ZodISODate, $ZodISOTime, $ZodISODuration } from "../core/schemas.js";
+import "../core/registries.js";
+import { _isoDateTime, _isoDate, _isoTime, _isoDuration } from "../core/api.js";
+import { ZodStringFormat } from "./schemas.js";
+const ZodISODateTime = /* @__PURE__ */ $constructor("ZodISODateTime", (inst, def) => {
+  $ZodISODateTime.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function datetime(params) {
+  return _isoDateTime(ZodISODateTime, params);
+}
+const ZodISODate = /* @__PURE__ */ $constructor("ZodISODate", (inst, def) => {
+  $ZodISODate.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function date(params) {
+  return _isoDate(ZodISODate, params);
+}
+const ZodISOTime = /* @__PURE__ */ $constructor("ZodISOTime", (inst, def) => {
+  $ZodISOTime.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function time(params) {
+  return _isoTime(ZodISOTime, params);
+}
+const ZodISODuration = /* @__PURE__ */ $constructor("ZodISODuration", (inst, def) => {
+  $ZodISODuration.init(inst, def);
+  ZodStringFormat.init(inst, def);
+});
+function duration(params) {
+  return _isoDuration(ZodISODuration, params);
+}
+export {
+  ZodISODate,
+  ZodISODateTime,
+  ZodISODuration,
+  ZodISOTime,
+  date,
+  datetime,
+  duration,
+  time
+};

package/dist/node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/parse.js

@@ -0,0 +1,29 @@
+import { _parse, _safeParse, _parseAsync, _safeParseAsync, _encode, _decode, _encodeAsync, _decodeAsync, _safeEncode, _safeDecode, _safeEncodeAsync, _safeDecodeAsync } from "../core/parse.js";
+import "../core/registries.js";
+import { ZodRealError } from "./errors.js";
+const parse = /* @__PURE__ */ _parse(ZodRealError);
+const parseAsync = /* @__PURE__ */ _parseAsync(ZodRealError);
+const safeParse = /* @__PURE__ */ _safeParse(ZodRealError);
+const safeParseAsync = /* @__PURE__ */ _safeParseAsync(ZodRealError);
+const encode = /* @__PURE__ */ _encode(ZodRealError);
+const decode = /* @__PURE__ */ _decode(ZodRealError);
+const encodeAsync = /* @__PURE__ */ _encodeAsync(ZodRealError);
+const decodeAsync = /* @__PURE__ */ _decodeAsync(ZodRealError);
+const safeEncode = /* @__PURE__ */ _safeEncode(ZodRealError);
+const safeDecode = /* @__PURE__ */ _safeDecode(ZodRealError);
+const safeEncodeAsync = /* @__PURE__ */ _safeEncodeAsync(ZodRealError);
+const safeDecodeAsync = /* @__PURE__ */ _safeDecodeAsync(ZodRealError);
+export {
+  decode,
+  decodeAsync,
+  encode,
+  encodeAsync,
+  parse,
+  parseAsync,
+  safeDecode,
+  safeDecodeAsync,
+  safeEncode,
+  safeEncodeAsync,
+  safeParse,
+  safeParseAsync
+};