sanity-advanced-validators/dist/index.cjs

Advanced input validation tools for Sanity CMS.

"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,
  getSibling: () => getSibling,
  maxDepth: () => maxDepth,
  minDimensions: () => minDimensions,
  referencedDocumentRequires: () => referencedDocumentRequires,
  requiredIfSiblingEq: () => requiredIfSiblingEq,
  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/requiredIfSiblingEq.ts
var requiredIfSiblingEq = (key, comparison, message = "Required if {key} equals {value}.") => (value, context) => {
  var _a;
  const sibling = getSibling(key, context);
  const comparisons = Array.isArray(comparison) ? comparison : [comparison];
  if (!value && comparisons.includes(sibling)) {
    return message.replace("{key}", key).replace("{value}", (_a = comparisons.join(", or ")) != null ? _a : "null");
  }
  return true;
};

// src/lib/getSibling.ts
var import_lodash_es = require("lodash-es");
var getSibling = (key, context) => {
  const pathToParentObject = context.path.slice(0, -1);
  const sibling = (0, import_lodash_es.get)(context.document, [...pathToParentObject, key]);
  return sibling;
};
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  fileExtension,
  getSibling,
  maxDepth,
  minDimensions,
  referencedDocumentRequires,
  requiredIfSiblingEq,
  requiredIfSlugEq
});
//# sourceMappingURL=index.cjs.map