cms-renderer 0.5.2 → 0.6.0

package/dist/lib/custom-schemas.js

@@ -850,10 +850,10 @@ var LanguageSchema = z3.object({
 });
 
 // ../../packages/cms-schema/src/documents/unified-registry.ts
-import { z as z7 } from "zod";
+import { z as z8 } from "zod";
 
 // ../../packages/cms-schema/src/documents/rehydration.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // ../../packages/cms-schema/src/fields/complex/media.ts
 import { z as z5 } from "zod";
@@ -931,6 +931,38 @@ var fileSchema = z5.object({
   type: z5.string()
 });
 
+// ../../packages/cms-schema/src/fields/complex/richtext.ts
+import { z as z6 } from "zod";
+var textNodeSchema = z6.object({
+  type: z6.literal("text"),
+  text: z6.string(),
+  marks: z6.array(z6.string()).optional()
+});
+var blockSchema = z6.lazy(
+  () => z6.object({
+    type: z6.string(),
+    children: z6.array(z6.union([textNodeSchema, blockSchema])).optional(),
+    marks: z6.array(z6.string()).optional(),
+    level: z6.number().optional(),
+    url: z6.string().optional()
+  })
+);
+var richtextSchema = z6.union([z6.array(blockSchema), z6.string()]);
+function richtext(options) {
+  const meta = {
+    label: options.label,
+    component: "richtext",
+    required: options.required,
+    description: options.description,
+    options: {
+      formatting: options.formatting ?? ["bold", "italic", "link", "heading", "list"],
+      format: "markdown"
+    }
+  };
+  const result = options.required ? richtextSchema : richtextSchema.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) {
@@ -975,34 +1007,39 @@ function rehydrateField(field) {
 function createBaseSchema(type, constraints) {
   switch (type) {
     case "string":
-      return applyStringConstraints(z6.string(), constraints);
+      return applyStringConstraints(z7.string(), constraints);
+    case "richtext":
+      return richtext({ label: "Rich Text", required: true });
     case "number":
-      return applyNumberConstraints(z6.number(), constraints);
+      return applyNumberConstraints(z7.number(), constraints);
     case "boolean":
-      return z6.boolean();
+      return z7.boolean();
     case "image":
       return ImageReferenceSchema;
     case "date":
-      return z6.string().date("Invalid date format. Expected YYYY-MM-DD");
+      return z7.iso.date("Invalid date format. Expected YYYY-MM-DD");
     case "datetime":
-      return z6.string().datetime({ offset: true, message: "Invalid datetime format. Expected ISO 8601" });
+      return z7.iso.datetime({
+        offset: true,
+        message: "Invalid datetime format. Expected ISO 8601"
+      });
     case "url":
-      return applyStringConstraints(z6.string().url("Invalid URL format"), constraints);
+      return applyStringConstraints(z7.string(), constraints).pipe(z7.url("Invalid URL format"));
     case "email":
-      return applyStringConstraints(z6.string().email("Invalid email format"), constraints);
+      return applyStringConstraints(z7.string(), constraints).pipe(z7.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 z6.enum(values);
+      return z7.enum(values);
     }
     case "reference":
-      return z6.record(z6.string(), z6.unknown());
+      return z7.record(z7.string(), z7.unknown());
     case "array": {
       const itemType = constraints?.arrayItemType ?? "string";
-      const itemSchema = itemType === "reference" ? z6.record(z6.string(), z6.unknown()) : createPrimitiveSchema(itemType);
-      return applyArrayConstraints(z6.array(itemSchema), constraints);
+      const itemSchema = itemType === "reference" ? z7.record(z7.string(), z7.unknown()) : createPrimitiveSchema(itemType);
+      return applyArrayConstraints(z7.array(itemSchema), constraints);
     }
     default:
       throw new Error(`Unknown field type: ${type}`);
@@ -1011,11 +1048,11 @@ function createBaseSchema(type, constraints) {
 function createPrimitiveSchema(type) {
   switch (type) {
     case "string":
-      return z6.string();
+      return z7.string();
     case "number":
-      return z6.number();
+      return z7.number();
     case "boolean":
-      return z6.boolean();
+      return z7.boolean();
     default:
       throw new Error(`Unsupported array item type: ${type}`);
   }
@@ -1107,7 +1144,7 @@ function rehydrateSchema(fields) {
     }
     shape[field.name] = rehydrateField(field);
   }
-  return z6.object(shape);
+  return z7.object(shape);
 }
 
 // ../../packages/cms-schema/src/documents/schema-hash.ts
@@ -1117,25 +1154,26 @@ import hash from "object-hash";
 import { TRPCError } from "@trpc/server";
 
 // ../../packages/cms-schema/src/documents/parse-field-definitions-json.ts
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 var SNAKE_CASE = /^[a-z][a-z0-9_]*$/;
-var fieldConstraintsSchema = z8.object({
-  minLength: z8.number().int().min(0).optional(),
-  maxLength: z8.number().int().min(0).optional(),
-  pattern: z8.string().max(500).optional(),
-  min: z8.number().optional(),
-  max: z8.number().optional(),
-  integer: z8.boolean().optional(),
-  enumValues: z8.array(z8.string()).optional(),
-  arrayItemType: z8.enum(["string", "number", "boolean", "reference"]).optional(),
-  minItems: z8.number().int().min(0).optional(),
-  maxItems: z8.number().int().min(0).optional(),
-  refSchema: z8.string().regex(SNAKE_CASE, "refSchema must be snake_case").optional()
+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 fieldDefinitionSchema = z8.object({
-  name: z8.string().regex(SNAKE_CASE, "must be snake_case (lowercase letters, digits, underscores only)"),
-  type: z8.enum([
+var fieldDefinitionSchema = z9.object({
+  name: z9.string().regex(SNAKE_CASE, "must be snake_case (lowercase letters, digits, underscores only)"),
+  type: z9.enum([
     "string",
+    "richtext",
     "number",
     "boolean",
     "date",
@@ -1147,14 +1185,14 @@ var fieldDefinitionSchema = z8.object({
     "array",
     "image"
   ]),
-  displayName: z8.string().optional(),
-  description: z8.string().optional(),
-  required: z8.boolean(),
+  displayName: z9.string().optional(),
+  description: z9.string().optional(),
+  required: z9.boolean(),
   constraints: fieldConstraintsSchema.optional()
 });
-var fieldArraySchema = z8.array(fieldDefinitionSchema).min(1, "Schema must have at least one field");
-var multiSchemaFieldDefSchema = z8.record(
-  z8.string().regex(SNAKE_CASE, "schema name must be snake_case"),
+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"),
   fieldArraySchema
 );