@orkestrel/validator 0.0.1

package/dist/index.cjs

@@ -0,0 +1,781 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const VALIDATION_RULE_NAMES = [
+  "required",
+  "minimum",
+  "maximum",
+  "pattern",
+  "email",
+  "url",
+  "numeric",
+  "integer",
+  "alphanumeric",
+  "custom"
+];
+const EMAIL_PATTERN = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+const URL_PATTERN = /^https?:\/\/.+/;
+const NUMERIC_PATTERN = /^-?\d+(\.\d+)?$/;
+const INTEGER_PATTERN = /^-?\d+$/;
+const ALPHANUMERIC_PATTERN = /^[a-zA-Z0-9]+$/;
+class ValidatorError extends Error {
+  code;
+  context;
+  constructor(code, message, context = {}) {
+    super(message);
+    this.name = "ValidatorError";
+    this.code = code;
+    this.context = { ...context };
+  }
+}
+function isValidatorError(value) {
+  return value instanceof ValidatorError;
+}
+function isMap(value) {
+  return value instanceof Map;
+}
+function isSet(value) {
+  return value instanceof Set;
+}
+function isWeakMap(value) {
+  return value instanceof WeakMap;
+}
+function isWeakSet(value) {
+  return value instanceof WeakSet;
+}
+function isObject(value) {
+  return typeof value === "object" && value !== null;
+}
+function isRecord(value) {
+  return isObject(value) && !Array.isArray(value);
+}
+function isNull(value) {
+  return value === null;
+}
+function isUndefined(value) {
+  return value === void 0;
+}
+function isDefined(value) {
+  return value !== null && value !== void 0;
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isBoolean(value) {
+  return typeof value === "boolean";
+}
+function isBigInt(value) {
+  return typeof value === "bigint";
+}
+function isSymbol(value) {
+  return typeof value === "symbol";
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isDate(value) {
+  return value instanceof Date;
+}
+function isRegExp(value) {
+  return value instanceof RegExp;
+}
+function isError(value) {
+  return value instanceof Error;
+}
+function isPromiseLike(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  const thenValue = Reflect.get(value, "then");
+  const catchValue = Reflect.get(value, "catch");
+  const finallyValue = Reflect.get(value, "finally");
+  return typeof thenValue === "function" && typeof catchValue === "function" && typeof finallyValue === "function";
+}
+function isPromise(value) {
+  return value instanceof Promise;
+}
+function isArrayBuffer(value) {
+  return value instanceof ArrayBuffer;
+}
+function isSharedArrayBuffer(value) {
+  return typeof SharedArrayBuffer !== "undefined" && value instanceof SharedArrayBuffer;
+}
+function isIterable(value) {
+  if (typeof value === "string") {
+    return true;
+  }
+  if (!isObject(value)) {
+    return false;
+  }
+  return typeof Reflect.get(value, Symbol.iterator) === "function";
+}
+function isAsyncIterator(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  return typeof Reflect.get(value, Symbol.asyncIterator) === "function";
+}
+function recordValue(record, key) {
+  return Reflect.get(record, key);
+}
+function ruleValue(rules, ruleName) {
+  switch (ruleName) {
+    case "required":
+      return rules.required;
+    case "minimum":
+      return rules.minimum;
+    case "maximum":
+      return rules.maximum;
+    case "pattern":
+      return rules.pattern;
+    case "email":
+      return rules.email;
+    case "url":
+      return rules.url;
+    case "numeric":
+      return rules.numeric;
+    case "integer":
+      return rules.integer;
+    case "alphanumeric":
+      return rules.alphanumeric;
+    case "custom":
+      return rules.custom;
+  }
+}
+function isBooleanRuleValue(value) {
+  return value === void 0 || typeof value === "boolean" || isValidatorFunction(value);
+}
+function isNumberRuleValue(value) {
+  if (value === void 0 || isValidatorFunction(value)) {
+    return true;
+  }
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+function isPatternRuleValue(value) {
+  return value === void 0 || typeof value === "string" || isValidatorFunction(value);
+}
+function isRuleValue(ruleName, value) {
+  switch (ruleName) {
+    case "required":
+    case "email":
+    case "url":
+    case "numeric":
+    case "integer":
+    case "alphanumeric":
+      return isBooleanRuleValue(value);
+    case "minimum":
+    case "maximum":
+      return isNumberRuleValue(value);
+    case "pattern":
+      return isPatternRuleValue(value);
+    case "custom":
+      return value === void 0 || isValidatorFunction(value);
+  }
+}
+function enumerableSymbolCount(value) {
+  let count = 0;
+  for (const symbolKey of Object.getOwnPropertySymbols(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, symbolKey);
+    if (descriptor?.enumerable === true) {
+      count += 1;
+    }
+  }
+  return count;
+}
+function ensurePickedShape(value, shape, keys) {
+}
+function ensureOmittedShape(value, shape, keys) {
+}
+function isValidatorFunction(value) {
+  return typeof value === "function";
+}
+function isValidationRuleName(value) {
+  return typeof value === "string" && VALIDATION_RULE_NAMES.some((ruleName) => ruleName === value);
+}
+function isValidationRules(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  for (const key of Object.keys(value)) {
+    if (!isValidationRuleName(key)) {
+      return false;
+    }
+    if (!isRuleValue(key, recordValue(value, key))) {
+      return false;
+    }
+  }
+  return true;
+}
+function isValidationError(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return isValidationRuleName(recordValue(value, "rule")) && isString(recordValue(value, "message"));
+}
+function isValidationResult(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  const valid = recordValue(value, "valid");
+  const errors = recordValue(value, "errors");
+  if (!isBoolean(valid) || !Array.isArray(errors)) {
+    return false;
+  }
+  for (const error of errors) {
+    if (!isValidationError(error)) {
+      return false;
+    }
+  }
+  return true;
+}
+function assertValidationRules(rules) {
+  if (!isValidationRules(rules)) {
+    throw new ValidatorError(
+      "INVALID_RULES",
+      "Validation rules must contain only supported rule values"
+    );
+  }
+  const minimum = rules.minimum;
+  if (typeof minimum === "number" && minimum < 0) {
+    throw new ValidatorError("INVALID_RULE_VALUE", "Minimum must be zero or greater", {
+      rule: "minimum",
+      value: minimum
+    });
+  }
+  const maximum = rules.maximum;
+  if (typeof maximum === "number" && maximum < 0) {
+    throw new ValidatorError("INVALID_RULE_VALUE", "Maximum must be zero or greater", {
+      rule: "maximum",
+      value: maximum
+    });
+  }
+  if (typeof minimum === "number" && typeof maximum === "number" && minimum > maximum) {
+    throw new ValidatorError("INVALID_RULE_VALUE", "Minimum cannot be greater than maximum", {
+      rule: "minimum",
+      value: minimum
+    });
+  }
+  const pattern = rules.pattern;
+  if (typeof pattern === "string") {
+    try {
+      void new RegExp(pattern);
+    } catch {
+      throw new ValidatorError("INVALID_PATTERN", "Pattern must be a valid regular expression", {
+        rule: "pattern",
+        value: pattern
+      });
+    }
+  }
+}
+function cloneValidationRules(rules) {
+  assertValidationRules(rules);
+  return {
+    ...rules.required !== void 0 ? { required: rules.required } : {},
+    ...rules.minimum !== void 0 ? { minimum: rules.minimum } : {},
+    ...rules.maximum !== void 0 ? { maximum: rules.maximum } : {},
+    ...rules.pattern !== void 0 ? { pattern: rules.pattern } : {},
+    ...rules.email !== void 0 ? { email: rules.email } : {},
+    ...rules.url !== void 0 ? { url: rules.url } : {},
+    ...rules.numeric !== void 0 ? { numeric: rules.numeric } : {},
+    ...rules.integer !== void 0 ? { integer: rules.integer } : {},
+    ...rules.alphanumeric !== void 0 ? { alphanumeric: rules.alphanumeric } : {},
+    ...rules.custom !== void 0 ? { custom: rules.custom } : {}
+  };
+}
+function evaluateRule(ruleName, check, input) {
+  if (typeof check === "function") {
+    const result = check(input);
+    if (result === true) {
+      return void 0;
+    }
+    return typeof result === "string" ? result : "Invalid input";
+  }
+  switch (ruleName) {
+    case "required":
+      if (check === true && input.trim().length === 0) {
+        return "This field is required";
+      }
+      break;
+    case "minimum":
+      if (typeof check === "number" && input.length < check) {
+        return `Must be at least ${String(check)} characters`;
+      }
+      break;
+    case "maximum":
+      if (typeof check === "number" && input.length > check) {
+        return `Must be at most ${String(check)} characters`;
+      }
+      break;
+    case "pattern":
+      if (typeof check === "string" && !new RegExp(check).test(input)) {
+        return `Must match pattern: ${check}`;
+      }
+      break;
+    case "email":
+      if (check === true && !EMAIL_PATTERN.test(input)) {
+        return "Must be a valid email address";
+      }
+      break;
+    case "url":
+      if (check === true && !URL_PATTERN.test(input)) {
+        return "Must be a valid URL";
+      }
+      break;
+    case "numeric":
+      if (check === true && !NUMERIC_PATTERN.test(input)) {
+        return "Must be a numeric value";
+      }
+      break;
+    case "integer":
+      if (check === true && !INTEGER_PATTERN.test(input)) {
+        return "Must be an integer";
+      }
+      break;
+    case "alphanumeric":
+      if (check === true && !ALPHANUMERIC_PATTERN.test(input)) {
+        return "Must contain only letters and digits";
+      }
+      break;
+  }
+  return void 0;
+}
+function validateInput(input, rules) {
+  assertValidationRules(rules);
+  const errors = [];
+  for (const ruleName of VALIDATION_RULE_NAMES) {
+    const check = ruleValue(rules, ruleName);
+    if (check === void 0 || check === false) {
+      continue;
+    }
+    const message = evaluateRule(ruleName, check, input);
+    if (message !== void 0) {
+      errors.push({ rule: ruleName, message });
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function testInput(input, rules) {
+  return validateInput(input, rules).valid;
+}
+function createEnumValues(enumeration) {
+  const values = [];
+  for (const key of Object.keys(enumeration)) {
+    const value = enumeration[key];
+    if (typeof value === "number") {
+      values.push(value);
+      continue;
+    }
+    const numericKey = Number(key);
+    const keyIsNumeric = Number.isInteger(numericKey) && String(numericKey) === key;
+    const reverseValue = enumeration[value];
+    if (!(keyIsNumeric && typeof reverseValue === "number")) {
+      values.push(value);
+    }
+  }
+  return values;
+}
+function createShapeGuard(shape, optional) {
+  const allowed = /* @__PURE__ */ new Set();
+  for (const key in shape) {
+    if (Object.prototype.hasOwnProperty.call(shape, key)) {
+      allowed.add(key);
+    }
+  }
+  const optionalSet = new Set(
+    optional === true ? [...allowed] : Array.isArray(optional) ? optional.map((key) => String(key)) : []
+  );
+  return (value) => {
+    if (!isRecord(value)) {
+      return false;
+    }
+    for (const key of Object.keys(value)) {
+      if (!allowed.has(key)) {
+        return false;
+      }
+    }
+    for (const key in shape) {
+      if (!Object.prototype.hasOwnProperty.call(shape, key)) {
+        continue;
+      }
+      const present = key in value;
+      if (!optionalSet.has(key) && !present) {
+        return false;
+      }
+      if (present && !shape[key](recordValue(value, key))) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function isArray(value) {
+  return Array.isArray(value);
+}
+function isDataView(value) {
+  return value instanceof DataView;
+}
+function isArrayBufferView(value) {
+  return ArrayBuffer.isView(value);
+}
+function isInt8Array(value) {
+  return value instanceof Int8Array;
+}
+function isUint8Array(value) {
+  return value instanceof Uint8Array;
+}
+function isUint8ClampedArray(value) {
+  return value instanceof Uint8ClampedArray;
+}
+function isInt16Array(value) {
+  return value instanceof Int16Array;
+}
+function isUint16Array(value) {
+  return value instanceof Uint16Array;
+}
+function isInt32Array(value) {
+  return value instanceof Int32Array;
+}
+function isUint32Array(value) {
+  return value instanceof Uint32Array;
+}
+function isFloat32Array(value) {
+  return value instanceof Float32Array;
+}
+function isFloat64Array(value) {
+  return value instanceof Float64Array;
+}
+function isBigInt64Array(value) {
+  return typeof BigInt64Array !== "undefined" && value instanceof BigInt64Array;
+}
+function isBigUint64Array(value) {
+  return typeof BigUint64Array !== "undefined" && value instanceof BigUint64Array;
+}
+function isEmptyString(value) {
+  return value === "";
+}
+function isEmptyArray(value) {
+  return Array.isArray(value) && value.length === 0;
+}
+function isEmptyObject(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return Object.keys(value).length === 0 && enumerableSymbolCount(value) === 0;
+}
+function isEmptyMap(value) {
+  return value instanceof Map && value.size === 0;
+}
+function isEmptySet(value) {
+  return value instanceof Set && value.size === 0;
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function isNonEmptyArray(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+function isNonEmptyObject(value) {
+  if (!isRecord(value)) {
+    return false;
+  }
+  return Object.keys(value).length > 0 || enumerableSymbolCount(value) > 0;
+}
+function isNonEmptyMap(value) {
+  return value instanceof Map && value.size > 0;
+}
+function isNonEmptySet(value) {
+  return value instanceof Set && value.size > 0;
+}
+function isZeroArg(value) {
+  return value.length === 0;
+}
+function isAsyncFunction(value) {
+  return isFunction(value) && value.constructor.name === "AsyncFunction";
+}
+function isGeneratorFunction(value) {
+  return isFunction(value) && value.constructor.name === "GeneratorFunction";
+}
+function isAsyncGeneratorFunction(value) {
+  return isFunction(value) && value.constructor.name === "AsyncGeneratorFunction";
+}
+function isZeroArgAsync(value) {
+  return isFunction(value) && isZeroArg(value) && isAsyncFunction(value);
+}
+function isZeroArgGenerator(value) {
+  return isFunction(value) && isZeroArg(value) && isGeneratorFunction(value);
+}
+function isZeroArgAsyncGenerator(value) {
+  return isFunction(value) && isZeroArg(value) && isAsyncGeneratorFunction(value);
+}
+function arrayOf(elementGuard) {
+  return (value) => isArray(value) && value.every(elementGuard);
+}
+function tupleOf(...guards) {
+  return (value) => {
+    if (!Array.isArray(value) || value.length !== guards.length) {
+      return false;
+    }
+    for (let index = 0; index < guards.length; index += 1) {
+      const guard = guards[index];
+      if (!guard(value[index])) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function objectOf(shape, optional) {
+  return createShapeGuard(shape, optional);
+}
+function literalOf(...literals) {
+  return (value) => literals.some((literal) => Object.is(literal, value));
+}
+function instanceOf(constructor) {
+  return (value) => isObject(value) && value instanceof constructor;
+}
+function enumOf(enumeration) {
+  const values = createEnumValues(enumeration);
+  return (value) => {
+    if (!isString(value) && !isNumber(value)) {
+      return false;
+    }
+    for (const enumValue of values) {
+      if (Object.is(enumValue, value)) {
+        return true;
+      }
+    }
+    return false;
+  };
+}
+function setOf(elementGuard) {
+  return (value) => {
+    if (!isSet(value)) {
+      return false;
+    }
+    for (const entry of value) {
+      if (!elementGuard(entry)) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function mapOf(keyGuard, valueGuard) {
+  return (value) => {
+    if (!isMap(value)) {
+      return false;
+    }
+    for (const [key, entryValue] of value) {
+      if (!keyGuard(key) || !valueGuard(entryValue)) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function recordOf(shape, optional) {
+  return createShapeGuard(shape, optional);
+}
+function iterableOf(elementGuard) {
+  return (value) => {
+    if (!isIterable(value)) {
+      return false;
+    }
+    for (const entry of value) {
+      if (!elementGuard(entry)) {
+        return false;
+      }
+    }
+    return true;
+  };
+}
+function keyOf(value) {
+  return (entry) => (isString(entry) || isSymbol(entry) || isNumber(entry)) && entry in value;
+}
+function pickOf(shape, keys) {
+  const result = {};
+  for (const key of keys) {
+    if (Object.prototype.hasOwnProperty.call(shape, key)) {
+      result[key] = shape[key];
+    }
+  }
+  return result;
+}
+function omitOf(shape, keys) {
+  const skipped = /* @__PURE__ */ new Set();
+  for (const key of keys) {
+    skipped.add(key);
+  }
+  const result = {};
+  for (const key in shape) {
+    if (!Object.prototype.hasOwnProperty.call(shape, key)) {
+      continue;
+    }
+    if (!skipped.has(key)) {
+      result[key] = shape[key];
+    }
+  }
+  return result;
+}
+function andOf(left, right) {
+  return (value) => left(value) && right(value);
+}
+function orOf(left, right) {
+  return (value) => left(value) || right(value);
+}
+function notOf(guard) {
+  return (value) => !guard(value);
+}
+function complementOf(base, excluded) {
+  return (value) => {
+    if (!base(value)) {
+      return false;
+    }
+    return !excluded(value);
+  };
+}
+function unionOf(...guards) {
+  return (value) => guards.some((guard) => guard(value));
+}
+function intersectionOf(...guards) {
+  return (value) => guards.every((guard) => guard(value));
+}
+function composedOf(...guards) {
+  return (value) => guards.every((guard) => guard(value));
+}
+function whereOf(base, predicate) {
+  return (value) => {
+    if (!base(value)) {
+      return false;
+    }
+    return predicate(value);
+  };
+}
+function lazyOf(thunk) {
+  return (value) => thunk()(value);
+}
+function transformOf(base, project, target) {
+  return (value) => {
+    if (!base(value)) {
+      return false;
+    }
+    return target(project(value));
+  };
+}
+function nullableOf(guard) {
+  return (value) => value === null || guard(value);
+}
+exports.ALPHANUMERIC_PATTERN = ALPHANUMERIC_PATTERN;
+exports.EMAIL_PATTERN = EMAIL_PATTERN;
+exports.INTEGER_PATTERN = INTEGER_PATTERN;
+exports.NUMERIC_PATTERN = NUMERIC_PATTERN;
+exports.URL_PATTERN = URL_PATTERN;
+exports.VALIDATION_RULE_NAMES = VALIDATION_RULE_NAMES;
+exports.ValidatorError = ValidatorError;
+exports.andOf = andOf;
+exports.arrayOf = arrayOf;
+exports.assertValidationRules = assertValidationRules;
+exports.cloneValidationRules = cloneValidationRules;
+exports.complementOf = complementOf;
+exports.composedOf = composedOf;
+exports.createEnumValues = createEnumValues;
+exports.createShapeGuard = createShapeGuard;
+exports.ensureOmittedShape = ensureOmittedShape;
+exports.ensurePickedShape = ensurePickedShape;
+exports.enumOf = enumOf;
+exports.enumerableSymbolCount = enumerableSymbolCount;
+exports.evaluateRule = evaluateRule;
+exports.instanceOf = instanceOf;
+exports.intersectionOf = intersectionOf;
+exports.isArray = isArray;
+exports.isArrayBuffer = isArrayBuffer;
+exports.isArrayBufferView = isArrayBufferView;
+exports.isAsyncFunction = isAsyncFunction;
+exports.isAsyncGeneratorFunction = isAsyncGeneratorFunction;
+exports.isAsyncIterator = isAsyncIterator;
+exports.isBigInt = isBigInt;
+exports.isBigInt64Array = isBigInt64Array;
+exports.isBigUint64Array = isBigUint64Array;
+exports.isBoolean = isBoolean;
+exports.isBooleanRuleValue = isBooleanRuleValue;
+exports.isDataView = isDataView;
+exports.isDate = isDate;
+exports.isDefined = isDefined;
+exports.isEmptyArray = isEmptyArray;
+exports.isEmptyMap = isEmptyMap;
+exports.isEmptyObject = isEmptyObject;
+exports.isEmptySet = isEmptySet;
+exports.isEmptyString = isEmptyString;
+exports.isError = isError;
+exports.isFloat32Array = isFloat32Array;
+exports.isFloat64Array = isFloat64Array;
+exports.isFunction = isFunction;
+exports.isGeneratorFunction = isGeneratorFunction;
+exports.isInt16Array = isInt16Array;
+exports.isInt32Array = isInt32Array;
+exports.isInt8Array = isInt8Array;
+exports.isIterable = isIterable;
+exports.isMap = isMap;
+exports.isNonEmptyArray = isNonEmptyArray;
+exports.isNonEmptyMap = isNonEmptyMap;
+exports.isNonEmptyObject = isNonEmptyObject;
+exports.isNonEmptySet = isNonEmptySet;
+exports.isNonEmptyString = isNonEmptyString;
+exports.isNull = isNull;
+exports.isNumber = isNumber;
+exports.isNumberRuleValue = isNumberRuleValue;
+exports.isObject = isObject;
+exports.isPatternRuleValue = isPatternRuleValue;
+exports.isPromise = isPromise;
+exports.isPromiseLike = isPromiseLike;
+exports.isRecord = isRecord;
+exports.isRegExp = isRegExp;
+exports.isRuleValue = isRuleValue;
+exports.isSet = isSet;
+exports.isSharedArrayBuffer = isSharedArrayBuffer;
+exports.isString = isString;
+exports.isSymbol = isSymbol;
+exports.isUint16Array = isUint16Array;
+exports.isUint32Array = isUint32Array;
+exports.isUint8Array = isUint8Array;
+exports.isUint8ClampedArray = isUint8ClampedArray;
+exports.isUndefined = isUndefined;
+exports.isValidationError = isValidationError;
+exports.isValidationResult = isValidationResult;
+exports.isValidationRuleName = isValidationRuleName;
+exports.isValidationRules = isValidationRules;
+exports.isValidatorError = isValidatorError;
+exports.isValidatorFunction = isValidatorFunction;
+exports.isWeakMap = isWeakMap;
+exports.isWeakSet = isWeakSet;
+exports.isZeroArg = isZeroArg;
+exports.isZeroArgAsync = isZeroArgAsync;
+exports.isZeroArgAsyncGenerator = isZeroArgAsyncGenerator;
+exports.isZeroArgGenerator = isZeroArgGenerator;
+exports.iterableOf = iterableOf;
+exports.keyOf = keyOf;
+exports.lazyOf = lazyOf;
+exports.literalOf = literalOf;
+exports.mapOf = mapOf;
+exports.notOf = notOf;
+exports.nullableOf = nullableOf;
+exports.objectOf = objectOf;
+exports.omitOf = omitOf;
+exports.orOf = orOf;
+exports.pickOf = pickOf;
+exports.recordOf = recordOf;
+exports.recordValue = recordValue;
+exports.ruleValue = ruleValue;
+exports.setOf = setOf;
+exports.testInput = testInput;
+exports.transformOf = transformOf;
+exports.tupleOf = tupleOf;
+exports.unionOf = unionOf;
+exports.validateInput = validateInput;
+exports.whereOf = whereOf;
+//# sourceMappingURL=index.cjs.map