@blinkk/root-cms 3.0.1-beta.3 → 3.0.1-beta.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blinkk/root-cms",
-  "version": "3.0.1-beta.3",
+  "version": "3.0.1-beta.4",
   "author": "s@blinkk.com",
   "license": "MIT",
   "engines": {
@@ -152,10 +152,10 @@
     "vite": "8.0.3",
     "vitest": "4.1.2",
     "yjs": "13.6.27",
-    "@blinkk/root": "3.0.1-beta.3"
+    "@blinkk/root": "3.0.1-beta.4"
   },
   "peerDependencies": {
-    "@blinkk/root": "3.0.1-beta.3",
+    "@blinkk/root": "3.0.1-beta.4",
     "firebase-admin": ">=11",
     "firebase-functions": ">=4"
   },

package/dist/chunk-CRK7N6RR.js

@@ -1,298 +0,0 @@
-// core/validation.ts
-function validateFields(fieldsData, schema) {
-  if (fieldsData === null || fieldsData === void 0) {
-    return [];
-  }
-  if (typeof fieldsData !== "object" || Array.isArray(fieldsData)) {
-    return [
-      {
-        path: "",
-        message: "Expected object for fields data",
-        expected: "object",
-        received: getType(fieldsData)
-      }
-    ];
-  }
-  const errors = [];
-  for (const field of schema.fields) {
-    if (!field.id) {
-      continue;
-    }
-    if (!(field.id in fieldsData)) {
-      continue;
-    }
-    const value = fieldsData[field.id];
-    errors.push(...validateValue(value, field, field.id));
-  }
-  return errors;
-}
-function validateValue(value, field, path) {
-  if (value === void 0) {
-    return [];
-  }
-  switch (field.type) {
-    case "string":
-    case "select":
-      if (typeof value !== "string") {
-        return [createError(path, "string", value)];
-      }
-      return [];
-    case "number":
-      if (typeof value !== "number") {
-        return [createError(path, "number", value)];
-      }
-      if (isNaN(value)) {
-        return [createError(path, "number", value)];
-      }
-      return [];
-    case "boolean":
-      if (typeof value !== "boolean") {
-        return [createError(path, "boolean", value)];
-      }
-      return [];
-    case "date":
-    case "datetime": {
-      if (typeof value !== "object" || Array.isArray(value)) {
-        return [createError(path, "object", value)];
-      }
-      const errors = [];
-      const seconds = value.seconds;
-      const nanoseconds = value.nanoseconds;
-      if (seconds === void 0) {
-        errors.push({
-          path: `${path}.seconds`,
-          message: "Required",
-          expected: "number",
-          received: "undefined"
-        });
-      } else if (typeof seconds !== "number") {
-        errors.push(createError(`${path}.seconds`, "number", seconds));
-      }
-      if (nanoseconds === void 0) {
-        errors.push({
-          path: `${path}.nanoseconds`,
-          message: "Required",
-          expected: "number",
-          received: "undefined"
-        });
-      } else if (typeof nanoseconds !== "number") {
-        errors.push(createError(`${path}.nanoseconds`, "number", nanoseconds));
-      }
-      return errors;
-    }
-    case "multiselect":
-      if (!Array.isArray(value)) {
-        return [createError(path, "array", value)];
-      }
-      return value.flatMap((item, index) => {
-        if (typeof item !== "string") {
-          return [createError(`${path}.${index}`, "string", item)];
-        }
-        return [];
-      });
-    case "image":
-    case "file": {
-      if (typeof value !== "object" || Array.isArray(value)) {
-        return [createError(path, "object", value)];
-      }
-      const errors = [];
-      if (value.src === void 0) {
-        errors.push({
-          path: `${path}.src`,
-          message: "Required",
-          expected: "string",
-          received: "undefined"
-        });
-      } else if (typeof value.src !== "string") {
-        errors.push(createError(`${path}.src`, "string", value.src));
-      }
-      if (value.alt !== void 0 && typeof value.alt !== "string") {
-        errors.push(createError(`${path}.alt`, "string", value.alt));
-      }
-      return errors;
-    }
-    case "object": {
-      if (typeof value !== "object" || Array.isArray(value)) {
-        return [createError(path, "object", value)];
-      }
-      const objectField = field;
-      const errors = [];
-      for (const nestedField of objectField.fields) {
-        if (!nestedField.id || !(nestedField.id in value)) {
-          continue;
-        }
-        errors.push(
-          ...validateValue(
-            value[nestedField.id],
-            nestedField,
-            `${path}.${nestedField.id}`
-          )
-        );
-      }
-      return errors;
-    }
-    case "array": {
-      if (!Array.isArray(value)) {
-        return [createError(path, "array", value)];
-      }
-      const arrayField = field;
-      const itemField = arrayField.of;
-      return value.flatMap((item, index) => {
-        return validateValue(item, itemField, `${path}.${index}`);
-      });
-    }
-    case "oneof": {
-      if (typeof value !== "object" || Array.isArray(value)) {
-        return [createError(path, "object", value)];
-      }
-      const oneOfField = field;
-      const typeName = value._type;
-      const typeMap = /* @__PURE__ */ new Map();
-      const typeNames = [];
-      for (const type of oneOfField.types) {
-        if (typeof type === "string") {
-          typeNames.push(type);
-          continue;
-        }
-        typeMap.set(type.name, type);
-        typeNames.push(type.name);
-      }
-      if (!typeNames.includes(typeName)) {
-        const expectedStr = typeNames.map((t) => `'${t}'`).join(" | ");
-        return [
-          {
-            path: `${path}._type`,
-            message: `Invalid discriminator value. Expected ${expectedStr}`,
-            expected: "valid discriminator value",
-            received: typeName
-          }
-        ];
-      }
-      const matchedSchema = typeMap.get(typeName);
-      if (!matchedSchema) {
-        return [];
-      }
-      const errors = [];
-      for (const nestedField of matchedSchema.fields) {
-        if (!nestedField.id || !(nestedField.id in value)) {
-          continue;
-        }
-        errors.push(
-          ...validateValue(
-            value[nestedField.id],
-            nestedField,
-            `${path}.${nestedField.id}`
-          )
-        );
-      }
-      return errors;
-    }
-    case "richtext": {
-      if (typeof value !== "object" || Array.isArray(value)) {
-        return [createError(path, "object", value)];
-      }
-      const errors = [];
-      if (value.blocks === void 0) {
-        errors.push({
-          path: `${path}.blocks`,
-          message: "Required",
-          expected: "array",
-          received: "undefined"
-        });
-      } else if (!Array.isArray(value.blocks)) {
-        errors.push(createError(`${path}.blocks`, "array", value.blocks));
-      } else {
-        value.blocks.forEach((block, index) => {
-          if (typeof block !== "object" || block === null) {
-            errors.push(
-              createError(`${path}.blocks.${index}`, "object", block)
-            );
-            return;
-          }
-          if (block.type === void 0) {
-            errors.push({
-              path: `${path}.blocks.${index}.type`,
-              message: "Required",
-              expected: "string",
-              received: "undefined"
-            });
-          } else if (typeof block.type !== "string") {
-            errors.push(
-              createError(`${path}.blocks.${index}.type`, "string", block.type)
-            );
-          }
-        });
-      }
-      return errors;
-    }
-    case "reference": {
-      if (typeof value !== "object" || Array.isArray(value)) {
-        return [createError(path, "object", value)];
-      }
-      const errors = [];
-      const requiredFields = ["id", "collection", "slug"];
-      for (const req of requiredFields) {
-        if (value[req] === void 0) {
-          errors.push({
-            path: `${path}.${req}`,
-            message: "Required",
-            expected: "string",
-            received: "undefined"
-          });
-        } else if (typeof value[req] !== "string") {
-          errors.push(createError(`${path}.${req}`, "string", value[req]));
-        }
-      }
-      return errors;
-    }
-    case "references": {
-      if (!Array.isArray(value)) {
-        return [createError(path, "array", value)];
-      }
-      return value.flatMap((item, index) => {
-        if (typeof item !== "object" || item === null || Array.isArray(item)) {
-          return [createError(`${path}.${index}`, "object", item)];
-        }
-        const errors = [];
-        const requiredFields = ["id", "collection", "slug"];
-        for (const req of requiredFields) {
-          if (item[req] === void 0) {
-            errors.push({
-              path: `${path}.${index}.${req}`,
-              message: "Required",
-              expected: "string",
-              received: "undefined"
-            });
-          } else if (typeof item[req] !== "string") {
-            errors.push(
-              createError(`${path}.${index}.${req}`, "string", item[req])
-            );
-          }
-        }
-        return errors;
-      });
-    }
-    default:
-      console.warn(`Unknown field type: ${field.type}`);
-      return [];
-  }
-}
-function getType(value) {
-  if (value === null) return "null";
-  if (Array.isArray(value)) return "array";
-  if (typeof value === "number" && Number.isNaN(value)) return "nan";
-  return typeof value;
-}
-function createError(path, expected, receivedValue) {
-  const received = getType(receivedValue);
-  return {
-    path,
-    message: `Expected ${expected}, received ${received}`,
-    expected,
-    received
-  };
-}
-
-export {
-  validateFields
-};