ruler-factory/lib/index.cjs

A flexible, chainable validation rule factory for typeScript/javaScript.

"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, {
  rulerFactory: () => rulerFactory
});
module.exports = __toCommonJS(index_exports);
var import_rattail = require("rattail");
var EMAIL_REGEX = /^(?!\.)(?!.*\.\.)([a-z0-9_'+\-\\.]*)[a-z0-9_+-]@([a-z0-9][a-z0-9\\-]*\.)+[a-z]{2,}$/i;
function rulerFactory(generator, extend) {
  return function ruler() {
    var _a;
    const rules = [];
    const ctx = {
      // helpers
      rules,
      addRule,
      generator,
      getMessage,
      // type
      type: "string",
      string,
      number,
      array,
      boolean,
      object,
      symbol,
      bigint,
      null: _null,
      undefined: _undefined,
      true: _true,
      false: _false,
      // validation
      length,
      min,
      max,
      regex,
      required,
      startsWith,
      endsWith,
      includes,
      uppercase,
      lowercase,
      email,
      gt,
      gte,
      lt,
      lte,
      positive,
      negative,
      is,
      not,
      done,
      // transform
      transformer,
      transform,
      trim,
      shouldTrim: false,
      toLowerCase,
      shouldToLowerCase: false,
      toUpperCase,
      shouldToUpperCase: false
    };
    Object.assign(ctx, (_a = extend == null ? void 0 : extend(ctx)) != null ? _a : {});
    function string(message, params) {
      ctx.type = "string";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!(0, import_rattail.isString)(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function number(message, params) {
      ctx.type = "number";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!(0, import_rattail.isNumber)(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function object(message, params) {
      ctx.type = "object";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!(0, import_rattail.isPlainObject)(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function array(message, params) {
      ctx.type = "array";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!(0, import_rattail.isArray)(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function boolean(message, params) {
      ctx.type = "boolean";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!(0, import_rattail.isBoolean)(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function _true(message, params) {
      ctx.type = "boolean";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (value !== true) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function _false(message, params) {
      ctx.type = "boolean";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (value !== false) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function symbol(message, params) {
      ctx.type = "symbol";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (!(0, import_rattail.isSymbol)(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function _null(message, params) {
      ctx.type = "null";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (value !== null) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function _undefined(message, params) {
      ctx.type = "undefined";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (value !== void 0) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function bigint(message, params) {
      ctx.type = "bigint";
      addRule((value) => {
        if (message == null) {
          return;
        }
        if (typeof value !== "bigint") {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function required(message, params) {
      addRule((value) => {
        if ((0, import_rattail.isEmpty)(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function email(message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!(0, import_rattail.isString)(value) || !EMAIL_REGEX.test(value))) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function min(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!(0, import_rattail.isString)(value) || value.length < v)) {
          return new Error(getMessage(message));
        }
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!(0, import_rattail.isNumber)(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value < v) {
            return new Error(getMessage(message));
          }
        }
        if (ctx.type === "array" && (!(0, import_rattail.isArray)(value) || value.length < v)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function max(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!(0, import_rattail.isString)(value) || value.length > v)) {
          return new Error(getMessage(message));
        }
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!(0, import_rattail.isNumber)(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value > v) {
            return new Error(getMessage(message));
          }
        }
        if (ctx.type === "array" && (!(0, import_rattail.isArray)(value) || value.length > v)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function length(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!(0, import_rattail.isString)(value) || value.length !== v)) {
          return new Error(getMessage(message));
        }
        if (ctx.type === "array" && (!(0, import_rattail.isArray)(value) || value.length !== v)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function regex(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!(0, import_rattail.isString)(value) || !v.test(value))) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function startsWith(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!(0, import_rattail.isString)(value) || !value.startsWith(v))) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function endsWith(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!(0, import_rattail.isString)(value) || !value.endsWith(v))) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function includes(v, message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!(0, import_rattail.isString)(value) || !value.includes(v))) {
          return new Error(getMessage(message));
        }
        if (ctx.type === "array" && (!(0, import_rattail.isArray)(value) || !value.includes(v))) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function uppercase(message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!(0, import_rattail.isString)(value) || value !== value.toUpperCase())) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function lowercase(message, params) {
      addRule((value) => {
        if (ctx.type === "string" && (!(0, import_rattail.isString)(value) || value !== value.toLowerCase())) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function gt(v, message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!(0, import_rattail.isNumber)(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value <= v) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function gte(v, message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!(0, import_rattail.isNumber)(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value < v) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function lt(v, message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!(0, import_rattail.isNumber)(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value >= v) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function lte(v, message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!(0, import_rattail.isNumber)(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value > v) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function positive(message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!(0, import_rattail.isNumber)(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value <= 0) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function negative(message, params) {
      addRule((value) => {
        if (ctx.type === "number" || ctx.type === "bigint") {
          if (!(0, import_rattail.isNumber)(value) && typeof value !== "bigint") {
            return new Error(getMessage(message));
          }
          if (value >= 0) {
            return new Error(getMessage(message));
          }
        }
      }, params);
      return ctx;
    }
    function is(v, message, params) {
      addRule((value) => {
        if (!v(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function not(v, message, params) {
      addRule((value) => {
        if (v(value)) {
          return new Error(getMessage(message));
        }
      }, params);
      return ctx;
    }
    function trim() {
      ctx.shouldTrim = true;
      return ctx;
    }
    function toLowerCase() {
      ctx.shouldToLowerCase = true;
      return ctx;
    }
    function toUpperCase() {
      ctx.shouldToUpperCase = true;
      return ctx;
    }
    function transformer(value) {
      if (ctx.type === "string" && (0, import_rattail.isString)(value)) {
        ctx.shouldTrim && (value = value.trim());
        ctx.shouldToLowerCase && (value = value.toLowerCase());
        ctx.shouldToUpperCase && (value = value.toUpperCase());
      }
      return value;
    }
    function transform(v) {
      ctx.transformer = v;
    }
    function addRule(validator, params) {
      rules.push(
        generator((value) => {
          value = ctx.transformer(value);
          return validator(value);
        }, params)
      );
      return ctx;
    }
    function done() {
      return rules;
    }
    function getMessage(message) {
      return (0, import_rattail.isFunction)(message) ? message() : message;
    }
    return ctx;
  };
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
  rulerFactory
});