cms-renderer 0.7.0 → 0.8.1

package/dist/lib/custom-schemas.js

@@ -2584,14 +2584,14 @@ var require_buffer_from = __commonJS({
       }
       return isModern ? Buffer.from(obj.slice(byteOffset, byteOffset + length)) : new Buffer(new Uint8Array(obj.slice(byteOffset, byteOffset + length)));
     }
-    function fromString(string, encoding) {
+    function fromString(string2, encoding) {
       if (typeof encoding !== "string" || encoding === "") {
         encoding = "utf8";
       }
       if (!Buffer.isEncoding(encoding)) {
         throw new TypeError('"encoding" must be a valid string encoding');
       }
-      return isModern ? Buffer.from(string, encoding) : new Buffer(string, encoding);
+      return isModern ? Buffer.from(string2, encoding) : new Buffer(string2, encoding);
     }
     function bufferFrom(value, encodingOrOffset, length) {
       if (typeof value === "number") {
@@ -213877,10 +213877,10 @@ var LanguageSchema = z3.object({
 });
 
 // ../../packages/cms-schema/src/documents/unified-registry.ts
-import { z as z8 } from "zod";
+import { z as z10 } from "zod";
 
 // ../../packages/cms-schema/src/documents/rehydration.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 
 // ../../packages/cms-schema/src/fields/complex/media.ts
 import { z as z5 } from "zod";
@@ -213990,6 +213990,66 @@ function richtext(options) {
   return result.meta(meta);
 }
 
+// ../../packages/cms-schema/src/fields/primitives/select.ts
+import { z as z7 } from "zod";
+function normalizeChoices(choices) {
+  return choices.map(
+    (choice) => typeof choice === "string" ? { value: choice, label: choice } : choice
+  );
+}
+function select(options) {
+  const normalizedChoices = normalizeChoices(options.choices);
+  const values = normalizedChoices.map((c) => c.value);
+  const schema = z7.enum(values);
+  const meta = {
+    label: options.label,
+    component: "select",
+    required: options.required,
+    description: options.description,
+    options: {
+      choices: normalizedChoices
+    }
+  };
+  const result = options.required ? schema : schema.optional();
+  return result.meta(meta);
+}
+
+// ../../packages/cms-schema/src/fields/primitives/string.ts
+import { z as z8 } from "zod";
+function string(options) {
+  let schema = z8.string();
+  if (options.minLength) {
+    schema = schema.min(options.minLength);
+  }
+  if (options.maxLength) {
+    schema = schema.max(options.maxLength);
+  }
+  if (options.pattern) {
+    schema = schema.regex(options.pattern, options.patternMessage);
+  }
+  if (options.format === "email") {
+    schema = schema.email();
+  }
+  if (options.format === "url") {
+    schema = schema.url();
+  }
+  if (options.format === "uuid") {
+    schema = schema.uuid();
+  }
+  const meta = {
+    label: options.label,
+    component: options.multiline ? "textarea" : "input",
+    required: options.required,
+    description: options.description,
+    placeholder: options.placeholder,
+    options: {
+      rows: options.rows
+    }
+  };
+  const result = options.required ? schema : schema.optional();
+  return result.meta(meta);
+}
+
 // ../../packages/cms-schema/src/utils/safe-regex.ts
 var import_safe_regex2 = __toESM(require_safe_regex2(), 1);
 function validateSafeRegex(pattern) {
@@ -214008,6 +214068,25 @@ function validateSafeRegex(pattern) {
 }
 
 // ../../packages/cms-schema/src/documents/rehydration.ts
+var LAYOUT_VALUES = ["middle", "left", "right"];
+var HEX_COLOR_PATTERN = /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/;
+var DEFAULT_COMPONENT_FIELDS = {
+  layout: select({
+    label: "Layout",
+    description: "Horizontal alignment of the component.",
+    choices: LAYOUT_VALUES.map((value) => ({
+      value,
+      label: value.charAt(0).toUpperCase() + value.slice(1)
+    }))
+  }),
+  background: string({
+    label: "Background",
+    description: "Background color as a hex value, e.g. #1a2b3c.",
+    placeholder: "#000000",
+    pattern: HEX_COLOR_PATTERN,
+    patternMessage: "Must be a hex color like #fff or #1a2b3c"
+  })
+};
 var RehydrationError = class extends Error {
   constructor(message, fieldName, fieldType) {
     super(message);
@@ -214036,41 +214115,41 @@ function rehydrateField(field) {
 function createBaseSchema(type, constraints) {
   switch (type) {
     case "string":
-      return applyStringConstraints(z7.string(), constraints);
+      return applyStringConstraints(z9.string(), constraints);
     case "richtext":
       return richtext({ label: "Rich Text", required: true });
     case "number":
-      return applyNumberConstraints(z7.number(), constraints);
+      return applyNumberConstraints(z9.number(), constraints);
     case "boolean":
-      return z7.boolean();
+      return z9.boolean();
     case "image":
       return ImageReferenceSchema;
     case "icon":
-      return z7.string().max(50);
+      return z9.string().max(50);
     case "date":
-      return z7.iso.date("Invalid date format. Expected YYYY-MM-DD");
+      return z9.iso.date("Invalid date format. Expected YYYY-MM-DD");
     case "datetime":
-      return z7.iso.datetime({
+      return z9.iso.datetime({
         offset: true,
         message: "Invalid datetime format. Expected ISO 8601"
       });
     case "url":
-      return applyStringConstraints(z7.string(), constraints).pipe(z7.url("Invalid URL format"));
+      return applyStringConstraints(z9.string(), constraints).pipe(z9.url("Invalid URL format"));
     case "email":
-      return applyStringConstraints(z7.string(), constraints).pipe(z7.email("Invalid email format"));
+      return applyStringConstraints(z9.string(), constraints).pipe(z9.email("Invalid email format"));
     case "enum": {
       const values = constraints?.enumValues;
       if (!values || values.length === 0) {
         throw new Error("Enum field requires at least one enumValues in constraints");
       }
-      return z7.enum(values);
+      return z9.enum(values);
     }
     case "reference":
-      return z7.record(z7.string(), z7.unknown());
+      return z9.record(z9.string(), z9.unknown());
     case "array": {
       const itemType = constraints?.arrayItemType ?? "string";
-      const itemSchema = itemType === "reference" ? z7.record(z7.string(), z7.unknown()) : createPrimitiveSchema(itemType);
-      return applyArrayConstraints(z7.array(itemSchema), constraints);
+      const itemSchema = itemType === "reference" ? z9.record(z9.string(), z9.unknown()) : createPrimitiveSchema(itemType);
+      return applyArrayConstraints(z9.array(itemSchema), constraints);
     }
     default:
       throw new Error(`Unknown field type: ${type}`);
@@ -214079,11 +214158,11 @@ function createBaseSchema(type, constraints) {
 function createPrimitiveSchema(type) {
   switch (type) {
     case "string":
-      return z7.string();
+      return z9.string();
     case "number":
-      return z7.number();
+      return z9.number();
     case "boolean":
-      return z7.boolean();
+      return z9.boolean();
     default:
       throw new Error(`Unsupported array item type: ${type}`);
   }
@@ -214175,7 +214254,12 @@ function rehydrateSchema(fields) {
     }
     shape[field.name] = rehydrateField(field);
   }
-  return z7.object(shape);
+  for (const [name, fieldSchema] of Object.entries(DEFAULT_COMPONENT_FIELDS)) {
+    if (!seenNames.has(name)) {
+      shape[name] = fieldSchema;
+    }
+  }
+  return z9.object(shape);
 }
 
 // ../../packages/cms-schema/src/documents/schema-hash.ts
@@ -214185,24 +214269,24 @@ import hash from "object-hash";
 import { TRPCError } from "@trpc/server";
 
 // ../../packages/cms-schema/src/documents/parse-field-definitions-json.ts
-import { z as z9 } from "zod";
+import { z as z11 } from "zod";
 var SNAKE_CASE = /^[a-z][a-z0-9_]*$/;
-var fieldConstraintsSchema = z9.object({
-  minLength: z9.number().int().min(0).optional(),
-  maxLength: z9.number().int().min(0).optional(),
-  pattern: z9.string().max(500).optional(),
-  min: z9.number().optional(),
-  max: z9.number().optional(),
-  integer: z9.boolean().optional(),
-  enumValues: z9.array(z9.string()).optional(),
-  arrayItemType: z9.enum(["string", "number", "boolean", "reference"]).optional(),
-  minItems: z9.number().int().min(0).optional(),
-  maxItems: z9.number().int().min(0).optional(),
-  refSchema: z9.string().regex(SNAKE_CASE, "refSchema must be snake_case").optional()
+var fieldConstraintsSchema = z11.object({
+  minLength: z11.number().int().min(0).optional(),
+  maxLength: z11.number().int().min(0).optional(),
+  pattern: z11.string().max(500).optional(),
+  min: z11.number().optional(),
+  max: z11.number().optional(),
+  integer: z11.boolean().optional(),
+  enumValues: z11.array(z11.string()).optional(),
+  arrayItemType: z11.enum(["string", "number", "boolean", "reference"]).optional(),
+  minItems: z11.number().int().min(0).optional(),
+  maxItems: z11.number().int().min(0).optional(),
+  refSchema: z11.string().regex(SNAKE_CASE, "refSchema must be snake_case").optional()
 });
-var fieldDefinitionSchema = z9.object({
-  name: z9.string().regex(SNAKE_CASE, "must be snake_case (lowercase letters, digits, underscores only)"),
-  type: z9.enum([
+var fieldDefinitionSchema = z11.object({
+  name: z11.string().regex(SNAKE_CASE, "must be snake_case (lowercase letters, digits, underscores only)"),
+  type: z11.enum([
     "string",
     "richtext",
     "number",
@@ -214217,14 +214301,14 @@ var fieldDefinitionSchema = z9.object({
     "image",
     "icon"
   ]),
-  displayName: z9.string().optional(),
-  description: z9.string().optional(),
-  required: z9.boolean(),
+  displayName: z11.string().optional(),
+  description: z11.string().optional(),
+  required: z11.boolean(),
   constraints: fieldConstraintsSchema.optional()
 });
-var fieldArraySchema = z9.array(fieldDefinitionSchema).min(1, "Schema must have at least one field");
-var multiSchemaFieldDefSchema = z9.record(
-  z9.string().regex(SNAKE_CASE, "schema name must be snake_case"),
+var fieldArraySchema = z11.array(fieldDefinitionSchema).min(1, "Schema must have at least one field");
+var multiSchemaFieldDefSchema = z11.record(
+  z11.string().regex(SNAKE_CASE, "schema name must be snake_case"),
   fieldArraySchema
 );