@tstdl/base 0.87.13 → 0.88.0-alpha1

package/schema/coercers/regexp.coercer.js

@@ -1,43 +1,20 @@
-"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);
-var regexp_coercer_exports = {};
-__export(regexp_coercer_exports, {
-  RegExpCoercer: () => RegExpCoercer,
-  regExpCoercer: () => regExpCoercer
-});
-module.exports = __toCommonJS(regexp_coercer_exports);
-var import_schema_error = require("../schema.error.js");
-var import_types = require("../types/index.js");
-class RegExpCoercer extends import_types.SchemaValueCoercer {
-  sourceType = String;
-  targetType = RegExp;
-  flags;
-  constructor(flags = "u") {
-    super();
-    this.flags = flags;
-  }
-  coerce(value, path, context) {
-    try {
-      return { success: true, value: RegExp(value, this.flags) };
-    } catch (error) {
-      return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(this.targetType, "invalid regexp pattern", path, { fast: context.options.fastErrors, customMessage: error.message }) };
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueCoercer } from '../types/index.js';
+export class RegExpCoercer extends SchemaValueCoercer {
+    sourceType = String;
+    targetType = RegExp;
+    flags;
+    constructor(flags = 'u') {
+        super();
+        this.flags = flags;
+    }
+    coerce(value, path, context) {
+        try {
+            return { success: true, value: RegExp(value, this.flags) };
+        }
+        catch (error) {
+            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, 'invalid regexp pattern', path, { fast: context.options.fastErrors, customMessage: error.message }) };
+        }
     }
-  }
 }
-const regExpCoercer = new RegExpCoercer();
+export const regExpCoercer = new RegExpCoercer();

package/schema/coercers/string.coercer.js

@@ -1,38 +1,14 @@
-"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);
-var string_coercer_exports = {};
-__export(string_coercer_exports, {
-  StringCoercer: () => StringCoercer,
-  stringCoercer: () => stringCoercer
-});
-module.exports = __toCommonJS(string_coercer_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_schema_error = require("../schema.error.js");
-var import_types = require("../types/index.js");
-class StringCoercer extends import_types.SchemaValueCoercer {
-  sourceType = [Number, Boolean, BigInt, Date];
-  targetType = String;
-  coerce(value, path, context) {
-    if ((0, import_type_guards.isDate)(value) && !(0, import_type_guards.isValidDate)(value)) {
-      return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(this.targetType, "invalid date", path, { fast: context.options.fastErrors }) };
+import { isDate, isValidDate } from '../../utils/type-guards.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueCoercer } from '../types/index.js';
+export class StringCoercer extends SchemaValueCoercer {
+    sourceType = [Number, Boolean, BigInt, Date];
+    targetType = String;
+    coerce(value, path, context) {
+        if (isDate(value) && !isValidDate(value)) {
+            return { success: false, error: SchemaError.couldNotCoerce(this.targetType, 'invalid date', path, { fast: context.options.fastErrors }) };
+        }
+        return { success: true, value: value.toString() };
     }
-    return { success: true, value: value.toString() };
-  }
 }
-const stringCoercer = new StringCoercer();
+export const stringCoercer = new StringCoercer();

package/schema/coercers/uint8-array.coercer.js

@@ -1,46 +1,22 @@
-"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);
-var uint8_array_coercer_exports = {};
-__export(uint8_array_coercer_exports, {
-  Uint8ArrayCoercer: () => Uint8ArrayCoercer,
-  uint8ArrayCoercer: () => uint8ArrayCoercer
-});
-module.exports = __toCommonJS(uint8_array_coercer_exports);
-var import_lazy_property = require("../../utils/object/lazy-property.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema = require("../schema.js");
-var import_array = require("../schemas/array.js");
-var import_number = require("../schemas/number.js");
-var import_types = require("../types/index.js");
-class Uint8ArrayCoercer extends import_types.SchemaValueCoercer {
-  static byteNumberArraySchema;
-  static {
-    (0, import_lazy_property.lazyProperty)(this, "byteNumberArraySchema", () => (0, import_array.array)((0, import_number.number)({ integer: true, minimum: 0, maximum: 255 })));
-  }
-  sourceType = Array;
-  targetType = Uint8Array;
-  coerce(value, path, { options }) {
-    const testResult = (0, import_schema.testSchema)(Uint8ArrayCoercer.byteNumberArraySchema, value, options, path);
-    if (!testResult.valid) {
-      return { success: false, error: import_schema_error.SchemaError.couldNotCoerce(Uint8Array, Array, path, { inner: testResult.error, fast: options.fastErrors }) };
+import { lazyProperty } from '../../utils/object/lazy-property.js';
+import { SchemaError } from '../schema.error.js';
+import { testSchema } from '../schema.js';
+import { array } from '../schemas/array.js';
+import { number } from '../schemas/number.js';
+import { SchemaValueCoercer } from '../types/index.js';
+export class Uint8ArrayCoercer extends SchemaValueCoercer {
+    static byteNumberArraySchema;
+    static {
+        lazyProperty(this, 'byteNumberArraySchema', () => array(number({ integer: true, minimum: 0, maximum: 255 })));
+    }
+    sourceType = Array;
+    targetType = Uint8Array;
+    coerce(value, path, { options }) {
+        const testResult = testSchema(Uint8ArrayCoercer.byteNumberArraySchema, value, options, path);
+        if (!testResult.valid) {
+            return { success: false, error: SchemaError.couldNotCoerce(Uint8Array, Array, path, { inner: testResult.error, fast: options.fastErrors }) };
+        }
+        return { success: true, value: Uint8Array.from(testResult.value) };
     }
-    return { success: true, value: Uint8Array.from(testResult.value) };
-  }
 }
-const uint8ArrayCoercer = new Uint8ArrayCoercer();
+export const uint8ArrayCoercer = new Uint8ArrayCoercer();

package/schema/constraints/enumeration.js

@@ -1,51 +1,29 @@
-"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);
-var enumeration_exports = {};
-__export(enumeration_exports, {
-  EnumerationConstraint: () => EnumerationConstraint
-});
-module.exports = __toCommonJS(enumeration_exports);
-var import_enum = require("../../utils/enum.js");
-var import_distinct = require("../../utils/iterable-helpers/distinct.js");
-var import_type_guards = require("../../utils/type-guards.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-var import_value_type = require("../utils/value-type.js");
-class EnumerationConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  allowedValuesString;
-  enumeration;
-  allowedValuesSet;
-  suitableTypes;
-  expects;
-  constructor(enumeration) {
-    super();
-    this.enumeration = enumeration;
-    const allowedValues = (0, import_type_guards.isArray)(enumeration) ? enumeration : (0, import_enum.enumValues)(enumeration);
-    this.allowedValuesSet = new Set(allowedValues);
-    this.allowedValuesString = allowedValues.map((value) => (0, import_type_guards.isString)(value) ? `"${value}"` : value).join(", ");
-    this.suitableTypes = [...(0, import_distinct.distinct)(allowedValues.map((value) => (0, import_value_type.getValueType)(value)))];
-    this.expects = `one of [${this.allowedValuesString}]`;
-  }
-  validate(value, path, context) {
-    if (!this.allowedValuesSet.has(value)) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { enumValues } from '../../utils/enum.js';
+import { distinct } from '../../utils/iterable-helpers/distinct.js';
+import { isArray, isString } from '../../utils/type-guards.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+import { getValueType } from '../utils/value-type.js';
+export class EnumerationConstraint extends SchemaValueConstraint {
+    allowedValuesString;
+    enumeration;
+    allowedValuesSet;
+    suitableTypes;
+    expects;
+    constructor(enumeration) {
+        super();
+        this.enumeration = enumeration;
+        const allowedValues = isArray(enumeration) ? enumeration : enumValues(enumeration);
+        this.allowedValuesSet = new Set(allowedValues);
+        this.allowedValuesString = allowedValues.map((value) => (isString(value) ? `"${value}"` : value)).join(', ');
+        this.suitableTypes = [...distinct(allowedValues.map((value) => getValueType(value)))];
+        this.expects = `one of [${this.allowedValuesString}]`;
+    }
+    validate(value, path, context) {
+        if (!this.allowedValuesSet.has(value)) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }

package/schema/constraints/generic.js

@@ -1,43 +1,23 @@
-"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);
-var generic_exports = {};
-__export(generic_exports, {
-  GenericConstraint: () => GenericConstraint
-});
-module.exports = __toCommonJS(generic_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-class GenericConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  suitableTypes = Number;
-  expects;
-  constraintFunction;
-  constructor(constraintFunction, expects = "valid value") {
-    super();
-    this.constraintFunction = constraintFunction;
-    this.expects = expects;
-  }
-  validate(value, path, context) {
-    const result = this.constraintFunction(value, path);
-    if ((0, import_type_guards.isBoolean)(result)) {
-      return result ? { valid: true } : { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, "invalid value", path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { isBoolean } from '../../utils/type-guards.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+export class GenericConstraint extends SchemaValueConstraint {
+    suitableTypes = Number;
+    expects;
+    constraintFunction;
+    constructor(constraintFunction, expects = 'valid value') {
+        super();
+        this.constraintFunction = constraintFunction;
+        this.expects = expects;
+    }
+    validate(value, path, context) {
+        const result = this.constraintFunction(value, path);
+        if (isBoolean(result)) {
+            return result
+                ? { valid: true }
+                : { valid: false, error: SchemaError.expectedButGot(this.expects, 'invalid value', path, { fast: context.options.fastErrors }) };
+        }
+        return result;
     }
-    return result;
-  }
 }

package/schema/constraints/index.js

@@ -1,29 +1,12 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var constraints_exports = {};
-module.exports = __toCommonJS(constraints_exports);
-__reExport(constraints_exports, require("./enumeration.js"), module.exports);
-__reExport(constraints_exports, require("./generic.js"), module.exports);
-__reExport(constraints_exports, require("./integer.js"), module.exports);
-__reExport(constraints_exports, require("./length.js"), module.exports);
-__reExport(constraints_exports, require("./literal.js"), module.exports);
-__reExport(constraints_exports, require("./maximum.js"), module.exports);
-__reExport(constraints_exports, require("./maximum-date.js"), module.exports);
-__reExport(constraints_exports, require("./maximum-length.js"), module.exports);
-__reExport(constraints_exports, require("./minimum.js"), module.exports);
-__reExport(constraints_exports, require("./minimum-date.js"), module.exports);
-__reExport(constraints_exports, require("./minimum-length.js"), module.exports);
-__reExport(constraints_exports, require("./pattern.js"), module.exports);
+export * from './enumeration.js';
+export * from './generic.js';
+export * from './integer.js';
+export * from './length.js';
+export * from './literal.js';
+export * from './maximum.js';
+export * from './maximum-date.js';
+export * from './maximum-length.js';
+export * from './minimum.js';
+export * from './minimum-date.js';
+export * from './minimum-length.js';
+export * from './pattern.js';

package/schema/constraints/integer.js

@@ -1,47 +1,23 @@
-"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);
-var integer_exports = {};
-__export(integer_exports, {
-  Integer: () => Integer,
-  IntegerConstraint: () => IntegerConstraint,
-  integerConstraint: () => integerConstraint
-});
-module.exports = __toCommonJS(integer_exports);
-var import_utils = require("../decorators/utils.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-var import_types = require("../types/types.js");
-class IntegerConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  suitableTypes = Number;
-  expects;
-  constructor() {
-    super();
-    this.expects = "an integer";
-  }
-  validate(value, path, context) {
-    if (!Number.isInteger(value)) {
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+import { typeSchema } from '../types/types.js';
+export class IntegerConstraint extends SchemaValueConstraint {
+    suitableTypes = Number;
+    expects;
+    constructor() {
+        super();
+        this.expects = 'an integer';
+    }
+    validate(value, path, context) {
+        if (!Number.isInteger(value)) {
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, value.toString(), path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }
-const integerConstraint = new IntegerConstraint();
-function Integer() {
-  return (0, import_utils.createSchemaValueConstraintDecorator)(integerConstraint, { schema: (0, import_types.typeSchema)(Number) });
+export const integerConstraint = new IntegerConstraint();
+export function Integer() {
+    return createSchemaValueConstraintDecorator(integerConstraint, { schema: typeSchema(Number) });
 }

package/schema/constraints/length.js

@@ -1,37 +1,15 @@
-"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);
-var length_exports = {};
-__export(length_exports, {
-  Length: () => Length
-});
-module.exports = __toCommonJS(length_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_utils = require("../decorators/utils.js");
-var import_maximum_length = require("./maximum-length.js");
-var import_minimum_length = require("./minimum-length.js");
-function Length(options) {
-  const constraints = [];
-  if ((0, import_type_guards.isDefined)(options.minimum)) {
-    constraints.push(new import_minimum_length.MinimumLengthConstraint(options.minimum));
-  }
-  if ((0, import_type_guards.isDefined)(options.maximum)) {
-    constraints.push(new import_maximum_length.MaximumLengthConstraint(options.maximum));
-  }
-  return (0, import_utils.createSchemaValueConstraintDecorator)(constraints);
+/* eslint-disable @typescript-eslint/naming-convention */
+import { isDefined } from '../../utils/type-guards.js';
+import { createSchemaValueConstraintDecorator } from '../decorators/utils.js';
+import { MaximumLengthConstraint } from './maximum-length.js';
+import { MinimumLengthConstraint } from './minimum-length.js';
+export function Length(options) {
+    const constraints = [];
+    if (isDefined(options.minimum)) {
+        constraints.push(new MinimumLengthConstraint(options.minimum));
+    }
+    if (isDefined(options.maximum)) {
+        constraints.push(new MaximumLengthConstraint(options.maximum));
+    }
+    return createSchemaValueConstraintDecorator(constraints);
 }

package/schema/constraints/literal.js

@@ -1,46 +1,24 @@
-"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);
-var literal_exports = {};
-__export(literal_exports, {
-  LiteralConstraint: () => LiteralConstraint
-});
-module.exports = __toCommonJS(literal_exports);
-var import_type_guards = require("../../utils/type-guards.js");
-var import_schema_error = require("../schema.error.js");
-var import_schema_value_constraint = require("../types/schema-value-constraint.js");
-var import_value_type = require("../utils/value-type.js");
-class LiteralConstraint extends import_schema_value_constraint.SchemaValueConstraint {
-  literal;
-  suitableTypes;
-  expects;
-  constructor(literal) {
-    super();
-    this.literal = literal;
-    this.suitableTypes = (0, import_value_type.getValueType)(literal);
-    const literalName = (0, import_type_guards.isPrimitive)(literal) ? String(literal) : (0, import_value_type.getValueTypeName)(this.suitableTypes);
-    this.expects = `literal ${literalName}`;
-  }
-  validate(value, path, context) {
-    if (value !== this.literal) {
-      const valueType = (0, import_value_type.getValueType)(value);
-      return { valid: false, error: import_schema_error.SchemaError.expectedButGot(this.expects, (0, import_value_type.getValueTypeName)(valueType), path, { fast: context.options.fastErrors }) };
+/* eslint-disable @typescript-eslint/naming-convention */
+import { isPrimitive } from '../../utils/type-guards.js';
+import { SchemaError } from '../schema.error.js';
+import { SchemaValueConstraint } from '../types/schema-value-constraint.js';
+import { getValueType, getValueTypeName } from '../utils/value-type.js';
+export class LiteralConstraint extends SchemaValueConstraint {
+    literal;
+    suitableTypes;
+    expects;
+    constructor(literal) {
+        super();
+        this.literal = literal;
+        this.suitableTypes = getValueType(literal);
+        const literalName = isPrimitive(literal) ? String(literal) : getValueTypeName(this.suitableTypes);
+        this.expects = `literal ${literalName}`;
+    }
+    validate(value, path, context) {
+        if (value !== this.literal) {
+            const valueType = getValueType(value);
+            return { valid: false, error: SchemaError.expectedButGot(this.expects, getValueTypeName(valueType), path, { fast: context.options.fastErrors }) };
+        }
+        return { valid: true };
     }
-    return { valid: true };
-  }
 }