cms-renderer 0.3.0 → 0.3.2

package/dist/lib/custom-schemas.js

@@ -4,13 +4,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-var __commonJS = (cb, mod) => function __require2() {
+var __commonJS = (cb, mod) => function __require() {
   return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
 };
 var __copyProps = (to, from, except, desc) => {
@@ -801,387 +795,174 @@ var require_safe_regex2 = __commonJS({
   }
 });
 
-// ../../node_modules/object-hash/index.js
-var require_object_hash = __commonJS({
-  "../../node_modules/object-hash/index.js"(exports, module) {
-    "use strict";
-    var crypto = __require("crypto");
-    exports = module.exports = objectHash;
-    function objectHash(object, options) {
-      options = applyDefaults(object, options);
-      return hash2(object, options);
-    }
-    exports.sha1 = function(object) {
-      return objectHash(object);
-    };
-    exports.keys = function(object) {
-      return objectHash(object, { excludeValues: true, algorithm: "sha1", encoding: "hex" });
-    };
-    exports.MD5 = function(object) {
-      return objectHash(object, { algorithm: "md5", encoding: "hex" });
-    };
-    exports.keysMD5 = function(object) {
-      return objectHash(object, { algorithm: "md5", encoding: "hex", excludeValues: true });
-    };
-    var hashes = crypto.getHashes ? crypto.getHashes().slice() : ["sha1", "md5"];
-    hashes.push("passthrough");
-    var encodings = ["buffer", "hex", "binary", "base64"];
-    function applyDefaults(object, sourceOptions) {
-      sourceOptions = sourceOptions || {};
-      var options = {};
-      options.algorithm = sourceOptions.algorithm || "sha1";
-      options.encoding = sourceOptions.encoding || "hex";
-      options.excludeValues = sourceOptions.excludeValues ? true : false;
-      options.algorithm = options.algorithm.toLowerCase();
-      options.encoding = options.encoding.toLowerCase();
-      options.ignoreUnknown = sourceOptions.ignoreUnknown !== true ? false : true;
-      options.respectType = sourceOptions.respectType === false ? false : true;
-      options.respectFunctionNames = sourceOptions.respectFunctionNames === false ? false : true;
-      options.respectFunctionProperties = sourceOptions.respectFunctionProperties === false ? false : true;
-      options.unorderedArrays = sourceOptions.unorderedArrays !== true ? false : true;
-      options.unorderedSets = sourceOptions.unorderedSets === false ? false : true;
-      options.unorderedObjects = sourceOptions.unorderedObjects === false ? false : true;
-      options.replacer = sourceOptions.replacer || void 0;
-      options.excludeKeys = sourceOptions.excludeKeys || void 0;
-      if (typeof object === "undefined") {
-        throw new Error("Object argument required.");
-      }
-      for (var i = 0; i < hashes.length; ++i) {
-        if (hashes[i].toLowerCase() === options.algorithm.toLowerCase()) {
-          options.algorithm = hashes[i];
-        }
-      }
-      if (hashes.indexOf(options.algorithm) === -1) {
-        throw new Error('Algorithm "' + options.algorithm + '"  not supported. supported values: ' + hashes.join(", "));
-      }
-      if (encodings.indexOf(options.encoding) === -1 && options.algorithm !== "passthrough") {
-        throw new Error('Encoding "' + options.encoding + '"  not supported. supported values: ' + encodings.join(", "));
-      }
-      return options;
-    }
-    function isNativeFunction(f) {
-      if (typeof f !== "function") {
-        return false;
-      }
-      var exp = /^function\s+\w*\s*\(\s*\)\s*{\s+\[native code\]\s+}$/i;
-      return exp.exec(Function.prototype.toString.call(f)) != null;
-    }
-    function hash2(object, options) {
-      var hashingStream;
-      if (options.algorithm !== "passthrough") {
-        hashingStream = crypto.createHash(options.algorithm);
-      } else {
-        hashingStream = new PassThrough();
-      }
-      if (typeof hashingStream.write === "undefined") {
-        hashingStream.write = hashingStream.update;
-        hashingStream.end = hashingStream.update;
-      }
-      var hasher = typeHasher(options, hashingStream);
-      hasher.dispatch(object);
-      if (!hashingStream.update) {
-        hashingStream.end("");
-      }
-      if (hashingStream.digest) {
-        return hashingStream.digest(options.encoding === "buffer" ? void 0 : options.encoding);
-      }
-      var buf = hashingStream.read();
-      if (options.encoding === "buffer") {
-        return buf;
-      }
-      return buf.toString(options.encoding);
+// lib/custom-schemas.ts
+import { mkdir, writeFile } from "fs/promises";
+import { dirname } from "path";
+
+// ../../packages/cms-schema/src/documents/generate-zod-code.ts
+function generateZodSchemaCode(schemaName, fields) {
+  const lines = [];
+  lines.push(`import { z } from 'zod';`);
+  lines.push("");
+  const hasImageField = fields.some((f) => f.type === "image");
+  if (hasImageField) {
+    appendImageReferenceSchema(lines);
+    lines.push("");
+  }
+  appendSchemaBody(lines, schemaName, fields);
+  return lines.join("\n");
+}
+function generateCombinedZodSchemaCode(schemas) {
+  const lines = [];
+  lines.push("/* eslint-disable */");
+  lines.push("/* prettier-ignore */");
+  lines.push("/* biome-ignore format: auto-generated */");
+  lines.push("// This file is auto-generated by cms-renderer. Do not edit manually.");
+  lines.push("");
+  lines.push(`import { z } from 'zod';`);
+  lines.push("");
+  const hasImageField = schemas.some((s) => s.fields.some((f) => f.type === "image"));
+  if (hasImageField) {
+    appendImageReferenceSchema(lines);
+    lines.push("");
+  }
+  for (const [i, schema] of schemas.entries()) {
+    if (i > 0) lines.push("");
+    appendSchemaBody(lines, schema.name, schema.fields);
+  }
+  return lines.join("\n");
+}
+function appendSchemaBody(lines, schemaName, fields) {
+  const varName = `${toCamelCase(schemaName)}Schema`;
+  lines.push(`export const ${varName} = z.object({`);
+  for (const field of fields) {
+    const fieldCode = generateFieldCode(field);
+    if (field.description) {
+      lines.push(`  /** ${field.description} */`);
     }
-    exports.writeToStream = function(object, options, stream) {
-      if (typeof stream === "undefined") {
-        stream = options;
-        options = {};
+    lines.push(`  ${field.name}: ${fieldCode},`);
+  }
+  lines.push("});");
+  lines.push("");
+  lines.push(`export type ${toPascalCase(schemaName)} = z.infer<typeof ${varName}>;`);
+  lines.push("");
+}
+function appendImageReferenceSchema(lines) {
+  lines.push("const ImageReferenceSchema = z.object({");
+  lines.push("  alt: z.string().min(1, 'Alt text is required for accessibility'),");
+  lines.push("  caption: z.string().max(500).optional(),");
+  lines.push("  attribution: z.string().max(255).optional(),");
+  lines.push("  _asset: z.object({");
+  lines.push("    id: z.string().uuid(),");
+  lines.push("  }),");
+  lines.push("});");
+}
+function generateFieldCode(field) {
+  let code = generateBaseTypeCode(field.type, field.constraints);
+  if (!field.required) {
+    code += ".optional()";
+  }
+  return code;
+}
+function generateBaseTypeCode(type, constraints) {
+  switch (type) {
+    case "string":
+      return applyStringConstraintCode("z.string()", constraints);
+    case "number":
+      return applyNumberConstraintCode("z.number()", constraints);
+    case "boolean":
+      return "z.boolean()";
+    case "image":
+      return "ImageReferenceSchema";
+    case "date":
+      return "z.string().date('Invalid date format. Expected YYYY-MM-DD')";
+    case "datetime":
+      return "z.string().datetime({ offset: true, message: 'Invalid datetime format. Expected ISO 8601' })";
+    case "url":
+      return applyStringConstraintCode("z.string().url('Invalid URL format')", constraints);
+    case "email":
+      return applyStringConstraintCode("z.string().email('Invalid email format')", constraints);
+    case "enum": {
+      const values = constraints?.enumValues;
+      if (!values || values.length === 0) {
+        return "z.enum([''])";
       }
-      options = applyDefaults(object, options);
-      return typeHasher(options, stream).dispatch(object);
-    };
-    function typeHasher(options, writeTo, context) {
-      context = context || [];
-      var write = function(str) {
-        if (writeTo.update) {
-          return writeTo.update(str, "utf8");
-        } else {
-          return writeTo.write(str, "utf8");
-        }
-      };
-      return {
-        dispatch: function(value) {
-          if (options.replacer) {
-            value = options.replacer(value);
-          }
-          var type = typeof value;
-          if (value === null) {
-            type = "null";
-          }
-          return this["_" + type](value);
-        },
-        _object: function(object) {
-          var pattern = /\[object (.*)\]/i;
-          var objString = Object.prototype.toString.call(object);
-          var objType = pattern.exec(objString);
-          if (!objType) {
-            objType = "unknown:[" + objString + "]";
-          } else {
-            objType = objType[1];
-          }
-          objType = objType.toLowerCase();
-          var objectNumber = null;
-          if ((objectNumber = context.indexOf(object)) >= 0) {
-            return this.dispatch("[CIRCULAR:" + objectNumber + "]");
-          } else {
-            context.push(object);
-          }
-          if (typeof Buffer !== "undefined" && Buffer.isBuffer && Buffer.isBuffer(object)) {
-            write("buffer:");
-            return write(object);
-          }
-          if (objType !== "object" && objType !== "function" && objType !== "asyncfunction") {
-            if (this["_" + objType]) {
-              this["_" + objType](object);
-            } else if (options.ignoreUnknown) {
-              return write("[" + objType + "]");
-            } else {
-              throw new Error('Unknown object type "' + objType + '"');
-            }
-          } else {
-            var keys = Object.keys(object);
-            if (options.unorderedObjects) {
-              keys = keys.sort();
-            }
-            if (options.respectType !== false && !isNativeFunction(object)) {
-              keys.splice(0, 0, "prototype", "__proto__", "constructor");
-            }
-            if (options.excludeKeys) {
-              keys = keys.filter(function(key) {
-                return !options.excludeKeys(key);
-              });
-            }
-            write("object:" + keys.length + ":");
-            var self = this;
-            return keys.forEach(function(key) {
-              self.dispatch(key);
-              write(":");
-              if (!options.excludeValues) {
-                self.dispatch(object[key]);
-              }
-              write(",");
-            });
-          }
-        },
-        _array: function(arr, unordered) {
-          unordered = typeof unordered !== "undefined" ? unordered : options.unorderedArrays !== false;
-          var self = this;
-          write("array:" + arr.length + ":");
-          if (!unordered || arr.length <= 1) {
-            return arr.forEach(function(entry) {
-              return self.dispatch(entry);
-            });
-          }
-          var contextAdditions = [];
-          var entries = arr.map(function(entry) {
-            var strm = new PassThrough();
-            var localContext = context.slice();
-            var hasher = typeHasher(options, strm, localContext);
-            hasher.dispatch(entry);
-            contextAdditions = contextAdditions.concat(localContext.slice(context.length));
-            return strm.read().toString();
-          });
-          context = context.concat(contextAdditions);
-          entries.sort();
-          return this._array(entries, false);
-        },
-        _date: function(date) {
-          return write("date:" + date.toJSON());
-        },
-        _symbol: function(sym) {
-          return write("symbol:" + sym.toString());
-        },
-        _error: function(err2) {
-          return write("error:" + err2.toString());
-        },
-        _boolean: function(bool) {
-          return write("bool:" + bool.toString());
-        },
-        _string: function(string) {
-          write("string:" + string.length + ":");
-          write(string.toString());
-        },
-        _function: function(fn) {
-          write("fn:");
-          if (isNativeFunction(fn)) {
-            this.dispatch("[native]");
-          } else {
-            this.dispatch(fn.toString());
-          }
-          if (options.respectFunctionNames !== false) {
-            this.dispatch("function-name:" + String(fn.name));
-          }
-          if (options.respectFunctionProperties) {
-            this._object(fn);
-          }
-        },
-        _number: function(number) {
-          return write("number:" + number.toString());
-        },
-        _xml: function(xml) {
-          return write("xml:" + xml.toString());
-        },
-        _null: function() {
-          return write("Null");
-        },
-        _undefined: function() {
-          return write("Undefined");
-        },
-        _regexp: function(regex) {
-          return write("regex:" + regex.toString());
-        },
-        _uint8array: function(arr) {
-          write("uint8array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _uint8clampedarray: function(arr) {
-          write("uint8clampedarray:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _int8array: function(arr) {
-          write("int8array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _uint16array: function(arr) {
-          write("uint16array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _int16array: function(arr) {
-          write("int16array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _uint32array: function(arr) {
-          write("uint32array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _int32array: function(arr) {
-          write("int32array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _float32array: function(arr) {
-          write("float32array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _float64array: function(arr) {
-          write("float64array:");
-          return this.dispatch(Array.prototype.slice.call(arr));
-        },
-        _arraybuffer: function(arr) {
-          write("arraybuffer:");
-          return this.dispatch(new Uint8Array(arr));
-        },
-        _url: function(url) {
-          return write("url:" + url.toString(), "utf8");
-        },
-        _map: function(map) {
-          write("map:");
-          var arr = Array.from(map);
-          return this._array(arr, options.unorderedSets !== false);
-        },
-        _set: function(set) {
-          write("set:");
-          var arr = Array.from(set);
-          return this._array(arr, options.unorderedSets !== false);
-        },
-        _file: function(file) {
-          write("file:");
-          return this.dispatch([file.name, file.size, file.type, file.lastModfied]);
-        },
-        _blob: function() {
-          if (options.ignoreUnknown) {
-            return write("[blob]");
-          }
-          throw Error('Hashing Blob objects is currently not supported\n(see https://github.com/puleos/object-hash/issues/26)\nUse "options.replacer" or "options.ignoreUnknown"\n');
-        },
-        _domwindow: function() {
-          return write("domwindow");
-        },
-        _bigint: function(number) {
-          return write("bigint:" + number.toString());
-        },
-        /* Node.js standard native objects */
-        _process: function() {
-          return write("process");
-        },
-        _timer: function() {
-          return write("timer");
-        },
-        _pipe: function() {
-          return write("pipe");
-        },
-        _tcp: function() {
-          return write("tcp");
-        },
-        _udp: function() {
-          return write("udp");
-        },
-        _tty: function() {
-          return write("tty");
-        },
-        _statwatcher: function() {
-          return write("statwatcher");
-        },
-        _securecontext: function() {
-          return write("securecontext");
-        },
-        _connection: function() {
-          return write("connection");
-        },
-        _zlib: function() {
-          return write("zlib");
-        },
-        _context: function() {
-          return write("context");
-        },
-        _nodescript: function() {
-          return write("nodescript");
-        },
-        _httpparser: function() {
-          return write("httpparser");
-        },
-        _dataview: function() {
-          return write("dataview");
-        },
-        _signal: function() {
-          return write("signal");
-        },
-        _fsevent: function() {
-          return write("fsevent");
-        },
-        _tlswrap: function() {
-          return write("tlswrap");
-        }
-      };
+      const formatted = values.map((v) => `'${escapeString(v)}'`).join(", ");
+      return `z.enum([${formatted}])`;
     }
-    function PassThrough() {
-      return {
-        buf: "",
-        write: function(b) {
-          this.buf += b;
-        },
-        end: function(b) {
-          this.buf += b;
-        },
-        read: function() {
-          return this.buf;
-        }
-      };
+    case "reference":
+      return "z.record(z.string(), z.unknown())";
+    case "array": {
+      const itemType = constraints?.arrayItemType ?? "string";
+      const itemCode = generatePrimitiveCode(itemType);
+      return applyArrayConstraintCode(`z.array(${itemCode})`, constraints);
     }
+    default:
+      return "z.unknown()";
   }
-});
-
-// lib/custom-schemas.ts
-import { mkdir, writeFile } from "fs/promises";
-import { dirname } from "path";
+}
+function generatePrimitiveCode(type) {
+  switch (type) {
+    case "string":
+      return "z.string()";
+    case "number":
+      return "z.number()";
+    case "boolean":
+      return "z.boolean()";
+  }
+}
+function applyStringConstraintCode(base, constraints) {
+  if (!constraints) return base;
+  let code = base;
+  if (constraints.minLength !== void 0) {
+    code += `.min(${constraints.minLength}, 'Must be at least ${constraints.minLength} characters')`;
+  }
+  if (constraints.maxLength !== void 0) {
+    code += `.max(${constraints.maxLength}, 'Must be at most ${constraints.maxLength} characters')`;
+  }
+  if (constraints.pattern) {
+    code += `.regex(/${escapeRegex(constraints.pattern)}/, 'Invalid format')`;
+  }
+  return code;
+}
+function applyNumberConstraintCode(base, constraints) {
+  if (!constraints) return base;
+  let code = base;
+  if (constraints.integer) {
+    code += `.int('Must be an integer')`;
+  }
+  if (constraints.min !== void 0) {
+    code += `.min(${constraints.min}, 'Must be at least ${constraints.min}')`;
+  }
+  if (constraints.max !== void 0) {
+    code += `.max(${constraints.max}, 'Must be at most ${constraints.max}')`;
+  }
+  return code;
+}
+function applyArrayConstraintCode(base, constraints) {
+  if (!constraints) return base;
+  let code = base;
+  if (constraints.minItems !== void 0) {
+    code += `.min(${constraints.minItems}, 'Must have at least ${constraints.minItems} items')`;
+  }
+  if (constraints.maxItems !== void 0) {
+    code += `.max(${constraints.maxItems}, 'Must have at most ${constraints.maxItems} items')`;
+  }
+  return code;
+}
+function escapeString(str) {
+  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function escapeRegex(pattern) {
+  return pattern.replace(/\//g, "\\/");
+}
+function toCamelCase(str) {
+  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toPascalCase(str) {
+  const camel = toCamelCase(str);
+  return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
 
 // ../../packages/cms-schema/src/documents/registry.ts
 import { z } from "zod";
@@ -1493,172 +1274,11 @@ function rehydrateSchema(fields) {
 }
 
 // ../../packages/cms-schema/src/documents/schema-hash.ts
-var import_object_hash = __toESM(require_object_hash(), 1);
+import hash from "object-hash";
 
 // ../../packages/cms-schema/src/documents/validations/country.ts
 import { TRPCError } from "@trpc/server";
 
-// ../../packages/cms-schema/src/documents/generate-zod-code.ts
-function generateZodSchemaCode(schemaName, fields) {
-  const lines = [];
-  lines.push(`import { z } from 'zod';`);
-  lines.push("");
-  const hasImageField = fields.some((f) => f.type === "image");
-  if (hasImageField) {
-    appendImageReferenceSchema(lines);
-    lines.push("");
-  }
-  appendSchemaBody(lines, schemaName, fields);
-  return lines.join("\n");
-}
-function generateCombinedZodSchemaCode(schemas) {
-  const lines = [];
-  lines.push(`import { z } from 'zod';`);
-  lines.push("");
-  const hasImageField = schemas.some((s) => s.fields.some((f) => f.type === "image"));
-  if (hasImageField) {
-    appendImageReferenceSchema(lines);
-    lines.push("");
-  }
-  for (let i = 0; i < schemas.length; i++) {
-    const schema = schemas[i];
-    if (i > 0) lines.push("");
-    appendSchemaBody(lines, schema.name, schema.fields);
-  }
-  return lines.join("\n");
-}
-function appendSchemaBody(lines, schemaName, fields) {
-  const varName = toCamelCase(schemaName) + "Schema";
-  lines.push(`export const ${varName} = z.object({`);
-  for (const field of fields) {
-    const fieldCode = generateFieldCode(field);
-    if (field.description) {
-      lines.push(`  /** ${field.description} */`);
-    }
-    lines.push(`  ${field.name}: ${fieldCode},`);
-  }
-  lines.push("});");
-  lines.push("");
-  lines.push(`export type ${toPascalCase(schemaName)} = z.infer<typeof ${varName}>;`);
-  lines.push("");
-}
-function appendImageReferenceSchema(lines) {
-  lines.push("const ImageReferenceSchema = z.object({");
-  lines.push("  alt: z.string().min(1, 'Alt text is required for accessibility'),");
-  lines.push("  caption: z.string().max(500).optional(),");
-  lines.push("  attribution: z.string().max(255).optional(),");
-  lines.push("  _asset: z.object({");
-  lines.push("    id: z.string().uuid(),");
-  lines.push("  }),");
-  lines.push("});");
-}
-function generateFieldCode(field) {
-  let code = generateBaseTypeCode(field.type, field.constraints);
-  if (!field.required) {
-    code += ".optional()";
-  }
-  return code;
-}
-function generateBaseTypeCode(type, constraints) {
-  switch (type) {
-    case "string":
-      return applyStringConstraintCode("z.string()", constraints);
-    case "number":
-      return applyNumberConstraintCode("z.number()", constraints);
-    case "boolean":
-      return "z.boolean()";
-    case "image":
-      return "ImageReferenceSchema";
-    case "date":
-      return "z.string().date('Invalid date format. Expected YYYY-MM-DD')";
-    case "datetime":
-      return "z.string().datetime({ offset: true, message: 'Invalid datetime format. Expected ISO 8601' })";
-    case "url":
-      return applyStringConstraintCode("z.string().url('Invalid URL format')", constraints);
-    case "email":
-      return applyStringConstraintCode("z.string().email('Invalid email format')", constraints);
-    case "enum": {
-      const values = constraints?.enumValues;
-      if (!values || values.length === 0) {
-        return "z.enum([''])";
-      }
-      const formatted = values.map((v) => `'${escapeString(v)}'`).join(", ");
-      return `z.enum([${formatted}])`;
-    }
-    case "reference":
-      return "z.record(z.string(), z.unknown())";
-    case "array": {
-      const itemType = constraints?.arrayItemType ?? "string";
-      const itemCode = generatePrimitiveCode(itemType);
-      return applyArrayConstraintCode(`z.array(${itemCode})`, constraints);
-    }
-    default:
-      return "z.unknown()";
-  }
-}
-function generatePrimitiveCode(type) {
-  switch (type) {
-    case "string":
-      return "z.string()";
-    case "number":
-      return "z.number()";
-    case "boolean":
-      return "z.boolean()";
-  }
-}
-function applyStringConstraintCode(base, constraints) {
-  if (!constraints) return base;
-  let code = base;
-  if (constraints.minLength !== void 0) {
-    code += `.min(${constraints.minLength}, 'Must be at least ${constraints.minLength} characters')`;
-  }
-  if (constraints.maxLength !== void 0) {
-    code += `.max(${constraints.maxLength}, 'Must be at most ${constraints.maxLength} characters')`;
-  }
-  if (constraints.pattern) {
-    code += `.regex(/${escapeRegex(constraints.pattern)}/, 'Invalid format')`;
-  }
-  return code;
-}
-function applyNumberConstraintCode(base, constraints) {
-  if (!constraints) return base;
-  let code = base;
-  if (constraints.integer) {
-    code += `.int('Must be an integer')`;
-  }
-  if (constraints.min !== void 0) {
-    code += `.min(${constraints.min}, 'Must be at least ${constraints.min}')`;
-  }
-  if (constraints.max !== void 0) {
-    code += `.max(${constraints.max}, 'Must be at most ${constraints.max}')`;
-  }
-  return code;
-}
-function applyArrayConstraintCode(base, constraints) {
-  if (!constraints) return base;
-  let code = base;
-  if (constraints.minItems !== void 0) {
-    code += `.min(${constraints.minItems}, 'Must have at least ${constraints.minItems} items')`;
-  }
-  if (constraints.maxItems !== void 0) {
-    code += `.max(${constraints.maxItems}, 'Must have at most ${constraints.maxItems} items')`;
-  }
-  return code;
-}
-function escapeString(str) {
-  return str.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
-}
-function escapeRegex(pattern) {
-  return pattern.replace(/\//g, "\\/");
-}
-function toCamelCase(str) {
-  return str.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
-}
-function toPascalCase(str) {
-  const camel = toCamelCase(str);
-  return camel.charAt(0).toUpperCase() + camel.slice(1);
-}
-
 // lib/cms-api.ts
 import { createTRPCClient, httpBatchLink } from "@trpc/client";
 import superjson from "superjson";