@tsed/schema 8.11.1 → 8.11.2-rc.1

package/lib/browser/domain/JsonSchema.js

@@ -1,625 +0,0 @@
-var J = (i) => {
-  throw TypeError(i);
-};
-var L = (i, u, e) => u.has(i) || J("Cannot " + e);
-var s = (i, u, e) => (L(i, u, "read from private field"), e ? e.call(i) : u.get(i)), p = (i, u, e) => u.has(i) ? J("Cannot add the same private member more than once") : u instanceof WeakSet ? u.add(i) : u.set(i, e), r = (i, u, e, t) => (L(i, u, "write to private field"), t ? t.call(i, e) : u.set(i, e), e);
-import { isClass as q, ancestorsOf as v, isArray as k, isFunction as b, uniq as z, nameOf as B, classOf as A, isObject as F, isPrimitiveClass as H } from "@tsed/core";
-import { Hooks as W } from "@tsed/hooks";
-import { enumsRegistry as R } from "../registries/enumRegistries.js";
-import { execMapper as Q } from "../registries/JsonSchemaMapperContainer.js";
-import { getComputedType as U } from "../utils/getComputedType.js";
-import { getJsonType as D } from "../utils/getJsonType.js";
-import { serializeEnumValues as X } from "../utils/serializeEnumValues.js";
-import { toJsonRegex as G } from "../utils/toJsonRegex.js";
-import { Discriminator as I } from "./JsonDiscriminator.js";
-import { JsonEntityStore as M } from "./JsonEntityStore.js";
-function T(i) {
-  return i instanceof S ? i : Object.entries(i).reduce((u, [e, t]) => (u[G(e)] = m(t), u), {});
-}
-function m(i) {
-  return k(i) ? i.map(m) : i.isStore || i.$isJsonDocument || i.isLazyRef ? i : A(i) !== Object && q(i) ? M.from(i).schema : F(i) ? S.from(i) : H(i) ? S.from({ type: i }) : i;
-}
-var O, c, $, x, a, f, h, w, d, g;
-const y = class y extends Map {
-  constructor(e = {}) {
-    super();
-    p(this, O);
-    p(this, c);
-    p(this, $);
-    p(this, x);
-    p(this, a);
-    p(this, f);
-    p(this, h);
-    p(this, w);
-    p(this, d);
-    p(this, g);
-    this.$kind = "schema", this.$isJsonDocument = !0, this.$hooks = new W(), this.$required = /* @__PURE__ */ new Set(), this.$allow = [], this.$forwardGroups = !1, this.$ignore = !1, this.isDiscriminatorKey = !1, this.isDiscriminator = !1, r(this, O, !1), r(this, c, null), r(this, x, []), r(this, a, /* @__PURE__ */ new Map()), r(this, w, !1), r(this, d, !1), r(this, g, !1), e && this.assign(e);
-  }
-  get alias() {
-    return s(this, a);
-  }
-  get nestedGenerics() {
-    return s(this, x);
-  }
-  set nestedGenerics(e) {
-    r(this, x, e);
-  }
-  get genericLabels() {
-    return s(this, $);
-  }
-  set genericLabels(e) {
-    r(this, $, e);
-  }
-  get isClass() {
-    return q(this.class) && ![Map, Array, Set, Object, Date, Boolean, Number, String].includes(s(this, h));
-  }
-  /**
-   * Current schema is a collection
-   */
-  get isCollection() {
-    return s(this, d);
-  }
-  /**
-   * Current schema is a generic
-   */
-  get isGeneric() {
-    return s(this, w);
-  }
-  get discriminatorAncestor() {
-    const t = v(s(this, h)).find((n) => M.from(n).schema.isDiscriminator);
-    return t && M.from(t).schema;
-  }
-  /**
-   * Current schema has generics items
-   */
-  get hasGenerics() {
-    return !!(this.nestedGenerics && this.nestedGenerics.length);
-  }
-  get genericType() {
-    return this.get("$ref");
-  }
-  get class() {
-    return this.getComputedType();
-  }
-  get canRef() {
-    return s(this, g);
-  }
-  get isNullable() {
-    return s(this, O);
-  }
-  get isReadOnly() {
-    return this.get("readOnly");
-  }
-  get isWriteOnly() {
-    return this.get("writeOnly");
-  }
-  get hasDiscriminator() {
-    return !!s(this, c);
-  }
-  static from(e = {}) {
-    return new y(e);
-  }
-  nullable(e) {
-    r(this, O, e);
-  }
-  itemSchema(e = {}) {
-    return r(this, f, s(this, f) || m(e)), s(this, f).assign(e), s(this, f);
-  }
-  getAliasOf(e) {
-    return s(this, a).get(e);
-  }
-  addAlias(e, t) {
-    return s(this, a).set(e, t), s(this, a).set(t, e), this;
-  }
-  removeAlias(e) {
-    const t = s(this, a).get(e);
-    return t && s(this, a).delete(t), s(this, a).delete(e), this;
-  }
-  $id(e) {
-    return super.set("$id", e), this;
-  }
-  $ref(e) {
-    return super.set("$ref", e), this;
-  }
-  $schema(e) {
-    return super.set("$schema", e), this;
-  }
-  /**
-   * Create a ref and use name to sharing schema
-   * @param name
-   */
-  label(e) {
-    return r(this, g, !0), super.set("name", e), this;
-  }
-  name(e) {
-    return super.set("name", e), this;
-  }
-  ignore(e) {
-    return typeof e != "boolean" && this.$hooks.on("ignore", e), this.$ignore = e, this;
-  }
-  /**
-   * This keyword can be used to supply a default JSON value associated with a particular schema.
-   * It is RECOMMENDED that a default value be valid against the associated schema.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.3
-   */
-  default(e) {
-    return super.set("default", e), this;
-  }
-  /**
-   * More readible form of a one-element "enum"
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.24
-   */
-  const(e) {
-    return super.set("const", e), this;
-  }
-  /**
-   * This attribute is a string that provides a full description of the of purpose the instance property.
-   *
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
-   */
-  description(e) {
-    return super.set("description", e), this;
-  }
-  discriminator() {
-    return this.isDiscriminator = !0, r(this, c, s(this, c) || new I({
-      base: s(this, h)
-    }));
-  }
-  discriminatorKey(e) {
-    return this.discriminator().propertyName = e, this.isDiscriminator = !0, this;
-  }
-  discriminatorValue(...e) {
-    const t = this.discriminatorAncestor.discriminator();
-    t.add(s(this, h), e), this.isDiscriminator = !0;
-    const n = this.get("properties"), o = n[t.propertyName] || new y({
-      type: "string"
-    });
-    return e.length === 1 ? (o.const(e[0]), o.examples([e[0]])) : (o.enum(...e), o.examples(e)), n[t.propertyName] = o, this.set("properties", n), this;
-  }
-  /**
-   * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
-   * If "items" is an array of schemas, validation succeeds if every instance element
-   * at a position greater than the size of "items" validates against "additionalItems".
-   * Otherwise, "additionalItems" MUST be ignored, as the "items" schema
-   * (possibly the default value of an empty schema) is applied to all elements.
-   * Omitting this keyword has the same behavior as an empty schema.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.10
-   */
-  additionalItems(e) {
-    return super.set("additionalItems", m(e)), this;
-  }
-  /**
-   * An array instance is valid against "contains" if at least one of its elements is valid against the given schema.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.14
-   */
-  contains(e) {
-    return super.set("contains", m(e)), this;
-  }
-  /**
-   * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4
-   */
-  examples(e) {
-    return super.set("examples", e), this;
-  }
-  /**
-   * Array of examples with no validation effect the value of "default" is usable as an example without repeating it under this keyword
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.4
-   */
-  example(...e) {
-    return this.examples(e);
-  }
-  /**
-   * This keyword determines how child instances validate for arrays, and does not directly validate the immediate instance itself.
-   * Omitting this keyword has the same behavior as an empty schema.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.9
-   */
-  items(e) {
-    return super.set("items", r(this, f, m(e))), this;
-  }
-  /**
-   * Must be a non-negative integer.
-   * An array instance is valid against "maxItems" if its size is less than, or equal to, the value of this keyword.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.11
-   */
-  maxItems(e) {
-    return super.set("maxItems", e), this;
-  }
-  /**
-   * Must be a non-negative integer.
-   * An array instance is valid against "maxItems" if its size is greater than, or equal to, the value of this keyword.
-   * Omitting this keyword has the same behavior as a value of 0.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.12
-   */
-  minItems(e) {
-    return super.set("minItems", e), this;
-  }
-  /**
-   * If this keyword has boolean value false, the instance validates successfully.
-   * If it has boolean value true, the instance validates successfully if all of its elements are unique.
-   * Omitting this keyword has the same behavior as a value of false.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.13
-   */
-  uniqueItems(e) {
-    return super.set("uniqueItems", e), this;
-  }
-  /**
-   * Must be a non-negative integer.
-   * An object instance is valid against "maxProperties" if its number of properties is less than, or equal to, the value of this keyword.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.15
-   */
-  maxProperties(e) {
-    return super.set("maxProperties", e), this;
-  }
-  /**
-   * Must be a non-negative integer.
-   * An object instance is valid against "maxProperties" if its number of properties is greater than,
-   * or equal to, the value of this keyword.
-   * Omitting this keyword has the same behavior as a value of 0.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.16
-   */
-  minProperties(e) {
-    return super.set("minProperties", e), this;
-  }
-  allow(...e) {
-    return [].concat(this.getJsonType()).includes("string") && !this.has("minLength") && this.minLength(1), e.forEach((t) => {
-      switch (t) {
-        case "":
-          this.set("minLength", void 0);
-          break;
-        case null:
-          this.any(
-            ...["null"].concat(
-              this.getJsonType(),
-              this.$allow.map((n) => typeof n)
-            )
-          );
-          break;
-      }
-    }), this.$allow.push(...e), this;
-  }
-  /**
-   * Elements of this array must be unique.
-   * An object instance is valid against this keyword if every item in the array is the name of a property in the instance.
-   * Omitting this keyword has the same behavior as an empty array.
-   *
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.17
-   */
-  required(e = !0) {
-    if (k(e))
-      this.$required.clear(), e.forEach((t) => this.$required.add(t));
-    else {
-      const t = this.clone();
-      return t.$selfRequired = e, [].concat(t.getJsonType()).includes("string") && t.minLength(1), t;
-    }
-    return this;
-  }
-  addRequired(e) {
-    return this.$required.add(e), this;
-  }
-  removeRequired(e) {
-    return this.$required.delete(e), this;
-  }
-  isRequired(e) {
-    return this.$required.has(e);
-  }
-  /**
-   * This keyword determines how child instances validate for objects, and does not directly validate the immediate instance itself.
-   * Validation succeeds if, for each name that appears in both the instance and as a name within this keyword's value,
-   * the child instance for that name successfully validates against the corresponding schema.
-   * Omitting this keyword has the same behavior as an empty object.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.18
-   */
-  properties(e) {
-    return super.set("properties", T(e)), this;
-  }
-  addProperty(e, t) {
-    const n = this.get("properties") || {};
-    return n[e] = t, super.set("properties", T(n)), this;
-  }
-  /**
-   * This attribute is an object that defines the schema for a set of property names of an object instance.
-   * The name of each property of this attribute's object is a regular expression pattern in the ECMA 262, while the value is a schema.
-   * If the pattern matches the name of a property on the instance object, the value of the instance's property
-   * MUST be valid against the pattern name's schema value.
-   * Omitting this keyword has the same behavior as an empty object.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.19
-   */
-  patternProperties(e) {
-    return super.set("patternProperties", T(e)), this;
-  }
-  /**
-   * This attribute defines a schema for all properties that are not explicitly defined in an object type definition.
-   * If specified, the value MUST be a schema or a boolean.
-   * If false is provided, no additional properties are allowed beyond the properties defined in the schema.
-   * The default value is an empty schema which allows any value for additional properties.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20
-   */
-  additionalProperties(e) {
-    return super.set("additionalProperties", m(e)), this;
-  }
-  /**
-   * This attribute defines a schema for all properties that are not explicitly defined in an object type definition.
-   * If specified, the value MUST be a schema or a boolean.
-   * If false is provided, no additional properties are allowed beyond the properties defined in the schema.
-   * The default value is an empty schema which allows any value for additional properties.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.20
-   * @alias additionalProperties
-   * @param unknown
-   */
-  unknown(e = !0) {
-    return this.additionalProperties(e);
-  }
-  /**
-   * This keyword specifies rules that are evaluated if the instance is an object and contains a certain property.
-   * Each property specifies a dependency.
-   * If the dependency value is an array, each element in the array must be unique.
-   * Omitting this keyword has the same behavior as an empty object.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.21
-   */
-  dependencies(e) {
-    return super.set("dependencies", T(e)), this;
-  }
-  /**
-   * Takes a schema which validates the names of all properties rather than their values.
-   * Note the property name that the schema is testing will always be a string.
-   * Omitting this keyword has the same behavior as an empty schema.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.22
-   */
-  propertyNames(e) {
-    return super.set("propertyNames", m(e)), this;
-  }
-  enum(e, ...t) {
-    if (R.has(e))
-      return this.enum(R.get(e));
-    if (e instanceof y)
-      e.getName() ? super.set("enum", e) : super.set("enum", e.get("enum")).any(...e.get("enum").map((n) => typeof n));
-    else {
-      const { values: n, types: o } = X([e, t].flat());
-      super.set("enum", n).any(...o);
-    }
-    return this;
-  }
-  /**
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.1
-   */
-  definitions(e) {
-    return super.set("definitions", T(e)), this;
-  }
-  /**
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.26
-   */
-  allOf(e) {
-    return this.setManyOf("allOf", e), this;
-  }
-  /**
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.27
-   */
-  anyOf(e) {
-    return this.setManyOf("anyOf", e), this;
-  }
-  /*
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.28
-   */
-  oneOf(e) {
-    return this.setManyOf("oneOf", e), this;
-  }
-  /**
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.29
-   */
-  not(e) {
-    return super.set("not", m(e)), this;
-  }
-  /**
-   * Must be strictly greater than 0.
-   * A numeric instance is valid only if division by this keyword's value results in an integer.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.1
-   */
-  multipleOf(e) {
-    return super.set("multipleOf", e), this;
-  }
-  /**
-   * Representing an inclusive upper limit for a numeric instance.
-   * This keyword validates only if the instance is less than or exactly equal to "maximum".
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.2
-   */
-  maximum(e) {
-    return super.set("maximum", e), this;
-  }
-  /**
-   * Representing an exclusive upper limit for a numeric instance.
-   * This keyword validates only if the instance is strictly less than (not equal to) to "exclusiveMaximum".
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.3
-   */
-  exclusiveMaximum(e) {
-    return super.set("exclusiveMaximum", e), this;
-  }
-  /**
-   * Representing an inclusive lower limit for a numeric instance.
-   * This keyword validates only if the instance is greater than or exactly equal to "minimum".
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.4
-   */
-  minimum(e) {
-    return super.set("minimum", e), this;
-  }
-  /**
-   * Representing an exclusive lower limit for a numeric instance.
-   * This keyword validates only if the instance is strictly greater than (not equal to) to "exclusiveMinimum".
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.5
-   */
-  exclusiveMinimum(e) {
-    return super.set("exclusiveMinimum", e), this;
-  }
-  /**
-   * Must be a non-negative integer.
-   * A string instance is valid against this keyword if its length is less than, or equal to, the value of this keyword.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.6
-   */
-  maxLength(e) {
-    return super.set("maxLength", e), this;
-  }
-  /**
-   * Must be a non-negative integer.
-   * A string instance is valid against this keyword if its length is greater than, or equal to, the value of this keyword.
-   * Omitting this keyword has the same behavior as a value of 0.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.7
-   */
-  minLength(e) {
-    return super.set("minLength", e), this;
-  }
-  /**
-   * Should be a valid regular expression, according to the ECMA 262 regular expression dialect.
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.8
-   */
-  pattern(e) {
-    return super.set("pattern", G(e)), this;
-  }
-  /**
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-8
-   */
-  format(e) {
-    return super.set("format", e), this;
-  }
-  /**
-   * A single type, or a union of simple types
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-6.25
-   */
-  type(e) {
-    switch (e) {
-      case "map":
-      case Map:
-        super.set("type", D(e)), r(this, h, e), r(this, d, !0), this.has("additionalProperties") || super.set("additionalProperties", this.itemSchema({}));
-        break;
-      case "array":
-      case Array:
-        super.set("type", D(e)), r(this, h, e), r(this, d, !0), this.has("items") || super.set("items", this.itemSchema({}));
-        break;
-      case "set":
-      case Set:
-        super.set("type", D(e)), r(this, h, e), r(this, d, !0), this.uniqueItems(!0), this.has("items") || super.set("items", this.itemSchema({}));
-        break;
-      case "integer":
-        this.integer();
-        break;
-      case "number":
-      case "string":
-      case "boolean":
-      case "object":
-      case Object:
-      case Date:
-      case Boolean:
-      case Number:
-      case String:
-        super.set("type", D(e)), r(this, h, e), this.has("properties") || super.set("properties", {});
-        break;
-      default:
-        if (q(e) || b(e))
-          super.set("type", void 0), r(this, h, e), this.has("properties") || super.set("properties", {});
-        else {
-          const t = D(e);
-          t === "generic" ? (r(this, w, !0), super.set("$ref", e)) : super.set("type", t);
-        }
-    }
-    return this;
-  }
-  any(...e) {
-    var t;
-    return e = e.length ? e : ["integer", "number", "string", "boolean", "array", "object", "null"], e = z(e).map((n) => q(n) ? n : { type: D(n) }), e.length > 1 ? this.anyOf(e) : this.type(((t = e[0]) == null ? void 0 : t.type) || e[0]), this;
-  }
-  integer() {
-    return super.set("type", "integer"), super.set("multipleOf", 1), this;
-  }
-  /**
-   * This attribute is a string that provides a short description of the instance property.
-   *
-   * @see https://tools.ietf.org/html/draft-wright-json-schema-validation-01#section-7.2
-   */
-  title(e) {
-    return super.set("title", e), this;
-  }
-  readOnly(e) {
-    return super.set("readOnly", e), this;
-  }
-  writeOnly(e) {
-    return super.set("writeOnly", e), this;
-  }
-  customKey(e, t) {
-    return super.set(`#${e}`, t), this;
-  }
-  toObject(e) {
-    return this.toJSON(e);
-  }
-  toJSON(e) {
-    return Q("schema", [this], e);
-  }
-  assign(e = {}) {
-    return (e instanceof y ? [...e.entries()] : Object.entries(e)).forEach(([n, o]) => {
-      this.set(n, o);
-    }), e instanceof y && (this.$selfRequired = e.$selfRequired, this.$allow.push(...e.$allow), e.$required.forEach((n) => {
-      this.$required.add(n);
-    }), r(this, c, s(this, c) ? new I(s(this, c)) : null), this.isDiscriminator = e.isDiscriminator, this.isDiscriminatorKey = e.isDiscriminatorKey, r(this, g, s(e, g)), r(this, a, new Map(s(this, a).entries())), s(e, $) && r(this, $, [...s(e, $)]), r(this, x, s(e, x).map((n) => [...n])), r(this, h, s(e, h)), r(this, w, s(e, w)), r(this, d, s(e, d)), r(this, g, s(e, g)), r(this, O, s(e, O)), super.set("type", e.get("type"))), this;
-  }
-  set(e, t) {
-    return e in this ? b(this[e]) && this[e](t) : super.set(e, t), this;
-  }
-  /**
-   * Return the itemSchema computed type.
-   * If the type is a function used for recursive model,
-   * the function will be called to get the right type.
-   */
-  getComputedType() {
-    return U(s(this, h));
-  }
-  getComputedItemType() {
-    return s(this, f) ? s(this, f).getComputedType() : this.getComputedType();
-  }
-  /**
-   * Return the Json type as string
-   */
-  getJsonType() {
-    return this.get("anyOf") ? this.get("anyOf").map((e) => e.getJsonType()) : this.get("type") || D(this.getComputedType());
-  }
-  getTarget() {
-    return s(this, h);
-  }
-  /**
-   * Get the symbolic name of the entity
-   */
-  getName() {
-    return this.get("name") || (q(s(this, h)) ? B(A(this.getComputedType())) : "");
-  }
-  clone() {
-    return new y(this);
-  }
-  setManyOf(e, t) {
-    let n = t.filter((l) => (l == null ? void 0 : l.type) === "null" ? (this.nullable(!0), !1) : !0).map(m);
-    if (n.length === 1 && !(t[0] instanceof y) && !this.isNullable) {
-      if (!n[0].hasDiscriminator)
-        return this.type(t[0]);
-      const l = n[0].discriminator().children();
-      if (!l.length)
-        return this.type(t[0]);
-      n = l.map(m);
-    }
-    super.set(e, n);
-    const o = n[0];
-    if (o.isDiscriminator) {
-      const l = o.discriminatorAncestor.discriminator(), { propertyName: E } = l;
-      super.set("discriminator", {
-        propertyName: E,
-        mapping: n.reduce((N, P) => {
-          var C;
-          return (C = l.types.get(P.getTarget())) == null || C.forEach((K) => {
-            N[K] = P;
-          }), N;
-        }, {})
-      }), this.isDiscriminator = !0, r(this, c, l);
-    }
-  }
-};
-O = new WeakMap(), c = new WeakMap(), $ = new WeakMap(), x = new WeakMap(), a = new WeakMap(), f = new WeakMap(), h = new WeakMap(), w = new WeakMap(), d = new WeakMap(), g = new WeakMap();
-let S = y;
-export {
-  S as JsonSchema
-};
-//# sourceMappingURL=JsonSchema.js.map