sanity-advanced-validators 0.0.1

package/dist/index.cjs

@@ -0,0 +1,128 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  fileExtension: () => fileExtension,
+  getPeer: () => getPeer,
+  maxDepth: () => maxDepth,
+  minDimensions: () => minDimensions,
+  referencedDocumentRequires: () => referencedDocumentRequires,
+  requiredIfPeerEq: () => requiredIfPeerEq,
+  requiredIfSlugEq: () => requiredIfSlugEq
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/referencedDocumentRequires.ts
+var referencedDocumentRequires = (documentType, field, message = `{documentType}\u2019s {field} must be filled.`) => async (value, context) => {
+  if (!(value == null ? void 0 : value._ref)) {
+    return true;
+  }
+  const client = context.getClient({ apiVersion: "2022-08-12" });
+  const data = await client.fetch(`
+    *[_type == "${documentType}" && _id == "${value._ref}"]{
+      ${field}
+    }[0]
+  `);
+  if (!data[field]) {
+    return message.replace("{documentType}", documentType).replace("{field}", field);
+  }
+  return true;
+};
+
+// src/fileExtension.ts
+var import_asset_utils = require("@sanity/asset-utils");
+var fileExtension = (validFileExtension, message = `Image must be of type {validFileExtension}`) => (value) => {
+  if (!value || !value.asset) {
+    return true;
+  }
+  const validExtensions = typeof validFileExtension === "string" ? [validFileExtension] : validFileExtension;
+  const filetype = (0, import_asset_utils.getExtension)(value.asset._ref);
+  if (!validExtensions.includes(filetype)) {
+    return message.replace("{validFileExtension}", validExtensions.join(", or "));
+  }
+  return true;
+};
+
+// src/minDimensions.ts
+var import_asset_utils2 = require("@sanity/asset-utils");
+var minDimensions = ({ x, y }, message) => (value) => {
+  if (!value || !value.asset) {
+    return true;
+  }
+  const { width, height } = (0, import_asset_utils2.getImageDimensions)(value.asset._ref);
+  if (!!x && width < x) {
+    return message ? message.replace("{x}", x.toString()).replace("{y}", !y ? "(any)" : y.toString()) : `Image must be at least ${x} pixels wide.`;
+  }
+  if (!!y && height < y) {
+    return message ? message.replace("{x}", !x ? "(any)" : x.toString()).replace("{y}", y.toString()) : `Image must be at least ${y} pixels tall.`;
+  }
+  return true;
+};
+
+// src/maxDepth.ts
+var maxDepth = (maxDepth2, nestedValueName, message = `Error: You can only nest {nestedValueName} {maxDepth} levels deep.`) => (_, context) => {
+  let regex = new RegExp(String.raw`topLevelItems|${nestedValueName}`);
+  const paths = context.path.filter((e) => typeof e === "string" && e.match(regex));
+  if (paths.length > maxDepth2) {
+    return message.replace("{nestedValueName}", nestedValueName).replace("{maxDepth}", maxDepth2.toString());
+  }
+  return true;
+};
+
+// src/requiredIfSlugEq.ts
+var requiredIfSlugEq = (slug, slugKey = "slug", message = `This is a required field.`) => (value, context) => {
+  var _a, _b;
+  const slugs = typeof slug === "string" ? [slug] : slug;
+  const currentSlugValue = (_b = (_a = context.parent) == null ? void 0 : _a[slugKey]) == null ? void 0 : _b.current;
+  if (!value && !!currentSlugValue && slugs.includes(currentSlugValue)) {
+    return message.replace("{slugKey}", slugKey).replace("{slug}", slugs.join(", or "));
+  }
+  return true;
+};
+
+// src/requiredIfPeerEq.ts
+var requiredIfPeerEq = (key, comparison, message = "Required if {key} equals {value}.") => (value, context) => {
+  var _a;
+  const peer = getPeer(key, context);
+  const comparisons = Array.isArray(comparison) ? comparison : [comparison];
+  if (!value && comparisons.includes(peer)) {
+    return message.replace("{key}", key).replace("{value}", (_a = comparisons.join(", or ")) != null ? _a : "null");
+  }
+  return true;
+};
+
+// src/lib/getPeer.ts
+var import_lodash_es = require("lodash-es");
+var getPeer = (key, context) => {
+  const pathToParentObject = context.path.slice(0, -1);
+  const peer = (0, import_lodash_es.get)(context.document, [...pathToParentObject, key]);
+  return peer;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  fileExtension,
+  getPeer,
+  maxDepth,
+  minDimensions,
+  referencedDocumentRequires,
+  requiredIfPeerEq,
+  requiredIfSlugEq
+});