dilswer/dist/cjs/data-types/Type.cjs

Blazingly fast data validation library with TypeScript integration.

"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/data-types/Type.ts
var Type_exports = {};
__export(Type_exports, {
  Type: () => Type
});
module.exports = __toCommonJS(Type_exports);
var import_array = require("./types/array.cjs");
var import_boolean = require("./types/boolean.cjs");
var import_custom = require("./types/custom.cjs");
var import_dict = require("./types/dict.cjs");
var import_enum = require("./types/enum.cjs");
var import_enum_member = require("./types/enum-member.cjs");
var import_function = require("./types/function.cjs");
var import_instance = require("./types/instance.cjs");
var import_integer = require("./types/integer.cjs");
var import_intersection = require("./types/intersection.cjs");
var import_literal = require("./types/literal.cjs");
var import_null = require("./types/null.cjs");
var import_number = require("./types/number.cjs");
var import_record = require("./types/record.cjs");
var import_recursive = require("./types/recursive.cjs");
var import_set = require("./types/set.cjs");
var import_string = require("./types/string.cjs");
var import_symbol = require("./types/symbol.cjs");
var import_tuple = require("./types/tuple.cjs");
var import_undefined = require("./types/undefined.cjs");
var import_union = require("./types/union.cjs");
var import_unknown = require("./types/unknown.cjs");
var Type = {
  get Unknown() {
    return new import_unknown.UnknownType();
  },
  get String() {
    return new import_string.StringType();
  },
  get Number() {
    return new import_number.NumberType();
  },
  get Int() {
    return new import_integer.IntegerType();
  },
  get Boolean() {
    return new import_boolean.BooleanType();
  },
  get Symbol() {
    return new import_symbol.SymbolType();
  },
  get Function() {
    return new import_function.FunctionType();
  },
  get Null() {
    return new import_null.NullType();
  },
  get Undefined() {
    return new import_undefined.UndefinedType();
  },
  Record(args) {
    return new import_record.RecordType(args);
  },
  Dict(...args) {
    return new import_dict.DictType(args);
  },
  Array(...args) {
    return new import_array.ArrayType(args);
  },
  Tuple(...args) {
    return new import_tuple.TupleType(args);
  },
  Set(...args) {
    return new import_set.SetType(args);
  },
  OneOf(...args) {
    return new import_union.UnionType(args);
  },
  AllOf(...args) {
    return new import_intersection.IntersectionType(args);
  },
  Literal(...values) {
    if (values.length === 1) return new import_literal.LiteralType(values[0]);
    return Type.OneOf(...values.map((v) => new import_literal.LiteralType(v)));
  },
  EnumMember(enumMember) {
    return new import_enum_member.EnumMemberType(enumMember);
  },
  Enum(enumInstance) {
    return new import_enum.EnumType(enumInstance);
  },
  InstanceOf(instanceOf) {
    return new import_instance.InstanceOfType(instanceOf);
  },
  Custom(validateFunction) {
    return new import_custom.CustomType(validateFunction);
  },
  Recursive(getDataType) {
    return new import_recursive.RecursiveType(getDataType);
  },
  Option(type) {
    return {
      type,
      required: false
    };
  }
};