@fncts/schema 0.0.1

package/Decoder.d.ts

@@ -0,0 +1,3 @@
+import type { DecoderF } from "@fncts/base/data/Decoder";
+import type { Schemable as S } from "@fncts/schema/Schemable";
+export declare const Schemable: S<DecoderF>;

package/Encoder.d.ts

@@ -0,0 +1,4 @@
+import { Encoder } from "@fncts/base/data/Encoder/definition";
+import type { EncoderF } from "@fncts/base/data/Encoder";
+import type { Schemable as S } from "@fncts/schema/Schemable";
+export declare const Schemable: S<EncoderF>;

package/Guard.d.ts

@@ -0,0 +1,3 @@
+import type { GuardF } from "@fncts/base/data/Guard";
+import type { Schemable as S } from "@fncts/schema/Schemable";
+export declare const Schemable: S<GuardF>;

package/Schema.d.ts

@@ -0,0 +1,140 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import type { Brand, Validation } from "@fncts/base/data/Branded";
+import type { Schemable as S, SchemableKind } from "@fncts/schema/Schemable";
+import type { Literal } from "@fncts/typelevel/Any";
+export declare const SchemaTypeId: unique symbol;
+export type SchemaTypeId = typeof SchemaTypeId;
+export declare const enum SchemaTag {
+    Unknown = 0,
+    String = 1,
+    Number = 2,
+    Boolean = 3,
+    BigInt = 4,
+    Literal = 5,
+    Nullable = 6,
+    Struct = 7,
+    Partial = 8,
+    Array = 9,
+    Record = 10,
+    Tuple = 11,
+    Lazy = 12,
+    Validation = 13,
+    Union = 14
+}
+export interface SchemaF extends HKT {
+    readonly type: Schema<this["A"]>;
+}
+export declare abstract class Schema<in out A> {
+    readonly _typeId: SchemaTypeId;
+    _A: (_: A) => A;
+}
+export declare class UnknownSchema extends Schema<unknown> {
+    readonly _tag = SchemaTag.Unknown;
+}
+export declare class StringSchema extends Schema<string> {
+    readonly _tag = SchemaTag.String;
+}
+export declare class NumberSchema extends Schema<number> {
+    readonly _tag = SchemaTag.Number;
+}
+export declare class BooleanSchema extends Schema<boolean> {
+    readonly _tag = SchemaTag.Boolean;
+}
+export declare class BigIntSchema extends Schema<bigint> {
+    readonly _tag = SchemaTag.BigInt;
+}
+export declare class LiteralSchema<A extends Literal> extends Schema<A> {
+    readonly value: A;
+    readonly _tag = SchemaTag.Literal;
+    constructor(value: A);
+}
+export declare class NullableSchema<A> extends Schema<A | null | undefined> {
+    readonly base: Schema<A>;
+    readonly _tag = SchemaTag.Nullable;
+    constructor(base: Schema<A>);
+}
+export declare class StructSchema<A extends Record<string, any>> extends Schema<A> {
+    readonly fields: {
+        [K in keyof A]: Schema<A[K]>;
+    };
+    readonly _tag = SchemaTag.Struct;
+    constructor(fields: {
+        [K in keyof A]: Schema<A[K]>;
+    });
+}
+export declare class PartialSchema<A extends Record<string, any>> extends Schema<Partial<A>> {
+    readonly fields: {
+        [K in keyof A]: Schema<A[K]>;
+    };
+    readonly _tag = SchemaTag.Partial;
+    constructor(fields: {
+        [K in keyof A]: Schema<A[K]>;
+    });
+}
+export declare class ArraySchema<A> extends Schema<ReadonlyArray<A>> {
+    readonly base: Schema<A>;
+    readonly _tag = SchemaTag.Array;
+    constructor(base: Schema<A>);
+}
+export declare class RecordSchema<A> extends Schema<Record<string, A>> {
+    readonly base: Schema<A>;
+    readonly _tag = SchemaTag.Record;
+    constructor(base: Schema<A>);
+}
+export declare class TupleSchema<A extends ReadonlyArray<any>> extends Schema<A> {
+    readonly components: {
+        [K in keyof A]: Schema<A[K]>;
+    };
+    readonly _tag = SchemaTag.Tuple;
+    constructor(components: {
+        [K in keyof A]: Schema<A[K]>;
+    });
+}
+export declare class LazySchema<A> extends Schema<A> {
+    readonly make: () => Schema<A>;
+    readonly _tag = SchemaTag.Lazy;
+    constructor(make: () => Schema<A>);
+}
+export declare class ValidationSchema<A, B extends ReadonlyArray<Validation<A, any>>> extends Schema<A & {
+    [K in keyof B]: B[K] extends Validation<any, infer S> ? Brand.Valid<A, S> : never;
+}[number]> {
+    readonly base: Schema<A>;
+    readonly validations: readonly [...B];
+    readonly _tag = SchemaTag.Validation;
+    constructor(base: Schema<A>, validations: readonly [...B]);
+}
+export declare class UnionSchema<A extends ReadonlyArray<any>> extends Schema<A[number]> {
+    readonly members: {
+        [K in keyof A]: Schema<A[K]>;
+    };
+    readonly _tag = SchemaTag.Union;
+    constructor(members: {
+        [K in keyof A]: Schema<A[K]>;
+    });
+}
+export declare const unknown: Schema<unknown>;
+export declare const string: Schema<string>;
+export declare const number: Schema<number>;
+export declare const boolean: Schema<boolean>;
+export declare const bigint: Schema<bigint>;
+export declare function literal<A extends Literal>(value: A): Schema<A>;
+export declare function nullable<A>(base: Schema<A>): Schema<A | null | undefined>;
+export declare function struct<A extends Record<string, any>>(fields: {
+    [K in keyof A]: Schema<A[K]>;
+}): Schema<A>;
+export declare function partial<A extends Record<string, any>>(fields: {
+    [K in keyof A]: Schema<A[K]>;
+}): Schema<Partial<A>>;
+export declare function array<A>(base: Schema<A>): Schema<ReadonlyArray<A>>;
+export declare function record<A>(base: Schema<A>): Schema<Record<string, A>>;
+export declare function tuple<A extends ReadonlyArray<any>>(...components: {
+    [K in keyof A]: Schema<A[K]>;
+}): Schema<A>;
+export declare function lazy<A>(make: () => Schema<A>): Schema<A>;
+export declare function validation<A, B extends ReadonlyArray<Validation<A, any>>>(...validations: B): (base: Schema<A>) => Schema<A & { [K in keyof B]: B[K] extends Validation<any, infer S_1 extends string> ? Brand.Valid<A, S_1> : never; }[number]>;
+export declare function union<A extends ReadonlyArray<any>>(...members: {
+    [K in keyof A]: Schema<A[K]>;
+}): Schema<A[number]>;
+export type Concrete = UnknownSchema | StringSchema | NumberSchema | BooleanSchema | BigIntSchema | LiteralSchema<any> | NullableSchema<any> | StructSchema<Record<string, any>> | PartialSchema<Record<string, any>> | ArraySchema<any> | RecordSchema<any> | TupleSchema<ReadonlyArray<any>> | LazySchema<any> | ValidationSchema<any, ReadonlyArray<Validation<any, any>>> | UnionSchema<ReadonlyArray<any>>;
+export declare function concrete(_: Schema<any>): asserts _ is Concrete;
+export declare function interpret<F extends HKT>(S: S<F>): <A>(schema: Schema<A>) => SchemableKind<F, A>;

package/Schemable.d.ts

@@ -0,0 +1,39 @@
+import { HKT } from "@fncts/typelevel/HKT";
+import type { Brand, Validation } from "@fncts/base/data/Branded";
+import type { UnionSchema } from "@fncts/schema/Schema";
+import type { Literal } from "@fncts/typelevel/Any";
+export type SchemableKind<F extends HKT, A> = F extends {
+    readonly type: unknown;
+} ? (F & {
+    readonly A: A;
+})["type"] : {
+    readonly _F: F;
+    readonly _A: A;
+};
+export interface Schemable<F extends HKT> {
+    readonly unknown: SchemableKind<F, unknown>;
+    readonly string: SchemableKind<F, string>;
+    readonly number: SchemableKind<F, number>;
+    readonly boolean: SchemableKind<F, boolean>;
+    readonly bigint: SchemableKind<F, bigint>;
+    readonly literal: <A extends Literal>(literal: A) => SchemableKind<F, A>;
+    readonly nullable: <A>(or: SchemableKind<F, A>) => SchemableKind<F, A | null | undefined>;
+    readonly struct: <P extends Record<string, any>>(properties: {
+        [K in keyof P]: SchemableKind<F, P[K]>;
+    }) => SchemableKind<F, P>;
+    readonly partial: <P extends Record<string, any>>(properties: {
+        [K in keyof P]: SchemableKind<F, P[K]>;
+    }) => SchemableKind<F, Partial<P>>;
+    readonly array: <A>(item: SchemableKind<F, A>) => SchemableKind<F, ReadonlyArray<A>>;
+    readonly record: <A>(codomain: SchemableKind<F, A>) => SchemableKind<F, Record<string, A>>;
+    readonly tuple: <C extends ReadonlyArray<any>>(...components: {
+        [K in keyof C]: SchemableKind<F, C[K]>;
+    }) => SchemableKind<F, C>;
+    readonly lazy: <A>(f: () => SchemableKind<F, A>) => SchemableKind<F, A>;
+    readonly validation: <A, B extends ReadonlyArray<Validation<A, any>>>(...validations: B) => (base: SchemableKind<F, A>) => SchemableKind<F, A & {
+        [K in keyof B]: B[K] extends Validation<any, infer S> ? Brand.Valid<A, S> : never;
+    }[number]>;
+    readonly union: <A extends ReadonlyArray<any>>(members: {
+        [K in keyof A]: SchemableKind<F, A[K]>;
+    }, schema: UnionSchema<A>) => SchemableKind<F, A[number]>;
+}

package/_cjs/Decoder.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Schemable = void 0;
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Decoder/api"));
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/function/api"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const Schemable = {
+  unknown: tsplus_module_1.unknown,
+  string: tsplus_module_1.string,
+  number: tsplus_module_1.number,
+  boolean: tsplus_module_1.boolean,
+  bigint: tsplus_module_1.bigint,
+  literal: tsplus_module_1.literal,
+  nullable: tsplus_module_1.nullable,
+  struct: tsplus_module_1.struct,
+  partial: tsplus_module_1.partial,
+  array: tsplus_module_1.readonlyArray,
+  record: tsplus_module_1.record,
+  tuple: tsplus_module_1.tuple,
+  lazy: tsplus_module_1.deriveLazy,
+  validation: tsplus_module_1.validation,
+  union: members => tsplus_module_1.union(...members)
+};
+exports.Schemable = Schemable;
+//# sourceMappingURL=Decoder.cjs.map

package/_cjs/Decoder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decoder.cjs","mappings":";;;;;;;;;;AAGO,MAAMA,SAAS,GAAgB;EACpCC,OAAO,yBAAiB;EACxBC,MAAM,wBAAU;EAChBC,MAAM,wBAAU;EAChBC,OAAO,yBAAU;EACjBC,MAAM,wBAAU;EAChBC,OAAO,yBAAiB;EACxBC,QAAQ,0BAAkB;EAC1BC,MAAM,wBAAgB;EACtBC,OAAO,yBAAiB;EACxBC,KAAK,+BAAuB;EAC5BC,MAAM,wBAAgB;EACtBC,KAAK,uBAA6B;EAClCC,IAAI,4BAAc;EAClBC,UAAU,4BAAkC;EAC5CC,KAAK,EAAGC,OAAO,IAAKC,sBAAc,GAAGD,OAAO;CAC7C;AAAC","names":["Schemable","unknown","string","number","boolean","bigint","literal","nullable","struct","partial","array","record","tuple","lazy","validation","union","members","tsplus_module_1"],"sourceRoot":"","sources":["../_src/Decoder.ts"],"sourcesContent":[null]}

package/_cjs/Encoder.cjs

@@ -0,0 +1,45 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Schemable = void 0;
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Encoder/api"));
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/function/api"));
+var _Schema = /*#__PURE__*/require("@fncts/schema/Schema");
+var G = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("./Guard.cjs"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const Schemable = {
+  unknown: tsplus_module_1.unknown,
+  string: tsplus_module_1.string,
+  number: tsplus_module_1.number,
+  boolean: tsplus_module_1.boolean,
+  bigint: tsplus_module_1.bigint,
+  literal: tsplus_module_1.literal,
+  nullable: tsplus_module_1.nullable,
+  struct: tsplus_module_1.struct,
+  partial: tsplus_module_1.partial,
+  array: tsplus_module_1.readonlyArray,
+  record: tsplus_module_1.record,
+  tuple: tsplus_module_1.tuple,
+  lazy: tsplus_module_1.deriveLazy,
+  validation: tsplus_module_1.validation,
+  union: (members, schema) => {
+    const guards = schema.members.map((0, _Schema.interpret)(G.Schemable));
+    return tsplus_module_1.makeEncoder(inp => {
+      let encoder;
+      for (let i = 0; i < guards.length; i++) {
+        if (guards[i].is(inp)) {
+          encoder = members[i];
+        }
+      }
+      if (!encoder) {
+        throw new Error("BUG: Encoder not found for union");
+      }
+      return encoder.encode(inp);
+    });
+  }
+};
+exports.Schemable = Schemable;
+//# sourceMappingURL=Encoder.cjs.map

package/_cjs/Encoder.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Encoder.cjs","mappings":";;;;;;;;AAGA;AAEA;AAAgC;AAAA;AAEzB,MAAMA,SAAS,GAAgB;EACpCC,OAAO,yBAAiB;EACxBC,MAAM,wBAAU;EAChBC,MAAM,wBAAU;EAChBC,OAAO,yBAAU;EACjBC,MAAM,wBAAU;EAChBC,OAAO,yBAAiB;EACxBC,QAAQ,0BAAkB;EAC1BC,MAAM,wBAAgB;EACtBC,OAAO,yBAAiB;EACxBC,KAAK,+BAAuB;EAC5BC,MAAM,wBAAgB;EACtBC,KAAK,uBAA6B;EAClCC,IAAI,4BAAc;EAClBC,UAAU,4BAAkC;EAC5CC,KAAK,EAAE,CAACC,OAAO,EAAEC,MAAM,KAAI;IACzB,MAAMC,MAAM,GAAGD,MAAM,CAACD,OAAO,CAACG,GAAG,CAAC,qBAAS,EAACC,CAAC,CAACpB,SAAS,CAAC,CAAC;IACzD,OAAOqB,4BAASC,GAAG,IAAI;MACrB,IAAIC,OAAiC;MACrC,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGN,MAAM,CAACO,MAAM,EAAED,CAAC,EAAE,EAAE;QACtC,IAAIN,MAAM,CAACM,CAAC,CAAE,CAACE,EAAE,CAACJ,GAAG,CAAC,EAAE;UACtBC,OAAO,GAAGP,OAAO,CAACQ,CAAC,CAAE;;;MAGzB,IAAI,CAACD,OAAO,EAAE;QACZ,MAAM,IAAII,KAAK,CAAC,kCAAkC,CAAC;;MAErD,OAAOJ,OAAO,CAACK,MAAM,CAACN,GAAG,CAAC;IAC5B,CAAC,CAAC;EACJ;CACD;AAAC","names":["Schemable","unknown","string","number","boolean","bigint","literal","nullable","struct","partial","array","record","tuple","lazy","validation","union","members","schema","guards","map","G","tsplus_module_1","inp","encoder","i","length","is","Error","encode"],"sourceRoot":"","sources":["../_src/Encoder.ts"],"sourcesContent":[null]}

package/_cjs/Guard.cjs

@@ -0,0 +1,29 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Schemable = void 0;
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/Guard/api"));
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/data/function/api"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const Schemable = {
+  unknown: tsplus_module_1.unknown,
+  string: tsplus_module_1.string,
+  number: tsplus_module_1.number,
+  boolean: tsplus_module_1.boolean,
+  bigint: tsplus_module_1.bigint,
+  literal: tsplus_module_1.literal,
+  nullable: tsplus_module_1.nullable,
+  struct: tsplus_module_1.struct,
+  partial: tsplus_module_1.partial,
+  array: tsplus_module_1.readonlyArray,
+  record: tsplus_module_1.record,
+  tuple: tsplus_module_1.tuple,
+  lazy: tsplus_module_1.deriveLazy,
+  validation: tsplus_module_1.validation,
+  union: members => tsplus_module_1.deriveUnion(...members)
+};
+exports.Schemable = Schemable;
+//# sourceMappingURL=Guard.cjs.map

package/_cjs/Guard.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Guard.cjs","mappings":";;;;;;;;;;AAGO,MAAMA,SAAS,GAAc;EAClCC,OAAO,yBAAe;EACtBC,MAAM,wBAAU;EAChBC,MAAM,wBAAU;EAChBC,OAAO,yBAAU;EACjBC,MAAM,wBAAU;EAChBC,OAAO,yBAAe;EACtBC,QAAQ,0BAAgB;EACxBC,MAAM,wBAAc;EACpBC,OAAO,yBAAe;EACtBC,KAAK,+BAAqB;EAC1BC,MAAM,wBAAc;EACpBC,KAAK,uBAA2B;EAChCC,IAAI,4BAAY;EAChBC,UAAU,4BAAgC;EAC1CC,KAAK,EAAGC,OAAO,IAAKC,4BAAY,GAAGD,OAAO;CAC3C;AAAC","names":["Schemable","unknown","string","number","boolean","bigint","literal","nullable","struct","partial","array","record","tuple","lazy","validation","union","members","tsplus_module_1"],"sourceRoot":"","sources":["../_src/Guard.ts"],"sourcesContent":[null]}

package/_cjs/Schema.cjs

@@ -0,0 +1,241 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ValidationSchema = exports.UnknownSchema = exports.UnionSchema = exports.TupleSchema = exports.StructSchema = exports.StringSchema = exports.SchemaTypeId = exports.Schema = exports.RecordSchema = exports.PartialSchema = exports.NumberSchema = exports.NullableSchema = exports.LiteralSchema = exports.LazySchema = exports.BooleanSchema = exports.BigIntSchema = exports.ArraySchema = void 0;
+exports.array = array;
+exports.boolean = exports.bigint = void 0;
+exports.concrete = concrete;
+exports.interpret = interpret;
+exports.lazy = lazy;
+exports.literal = literal;
+exports.nullable = nullable;
+exports.number = void 0;
+exports.partial = partial;
+exports.record = record;
+exports.string = void 0;
+exports.struct = struct;
+exports.tuple = tuple;
+exports.union = union;
+exports.unknown = void 0;
+exports.validation = validation;
+var tsplus_module_1 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Dictionary/definition"));
+var tsplus_module_2 = /*#__PURE__*/_interopRequireWildcard( /*#__PURE__*/require("@fncts/base/collection/immutable/Dictionary/api"));
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+const SchemaTypeId = /*#__PURE__*/Symbol.for("fncts.schema.Schema");
+exports.SchemaTypeId = SchemaTypeId;
+class Schema {
+  constructor() {
+    this._typeId = SchemaTypeId;
+  }
+}
+exports.Schema = Schema;
+class UnknownSchema extends Schema {
+  constructor() {
+    super(...arguments);
+    this._tag = 0 /* SchemaTag.Unknown */;
+  }
+}
+exports.UnknownSchema = UnknownSchema;
+class StringSchema extends Schema {
+  constructor() {
+    super(...arguments);
+    this._tag = 1 /* SchemaTag.String */;
+  }
+}
+exports.StringSchema = StringSchema;
+class NumberSchema extends Schema {
+  constructor() {
+    super(...arguments);
+    this._tag = 2 /* SchemaTag.Number */;
+  }
+}
+exports.NumberSchema = NumberSchema;
+class BooleanSchema extends Schema {
+  constructor() {
+    super(...arguments);
+    this._tag = 3 /* SchemaTag.Boolean */;
+  }
+}
+exports.BooleanSchema = BooleanSchema;
+class BigIntSchema extends Schema {
+  constructor() {
+    super(...arguments);
+    this._tag = 4 /* SchemaTag.BigInt */;
+  }
+}
+exports.BigIntSchema = BigIntSchema;
+class LiteralSchema extends Schema {
+  constructor(value) {
+    super();
+    this.value = value;
+    this._tag = 5 /* SchemaTag.Literal */;
+  }
+}
+exports.LiteralSchema = LiteralSchema;
+class NullableSchema extends Schema {
+  constructor(base) {
+    super();
+    this.base = base;
+    this._tag = 6 /* SchemaTag.Nullable */;
+  }
+}
+exports.NullableSchema = NullableSchema;
+class StructSchema extends Schema {
+  constructor(fields) {
+    super();
+    this.fields = fields;
+    this._tag = 7 /* SchemaTag.Struct */;
+  }
+}
+exports.StructSchema = StructSchema;
+class PartialSchema extends Schema {
+  constructor(fields) {
+    super();
+    this.fields = fields;
+    this._tag = 8 /* SchemaTag.Partial */;
+  }
+}
+exports.PartialSchema = PartialSchema;
+class ArraySchema extends Schema {
+  constructor(base) {
+    super();
+    this.base = base;
+    this._tag = 9 /* SchemaTag.Array */;
+  }
+}
+exports.ArraySchema = ArraySchema;
+class RecordSchema extends Schema {
+  constructor(base) {
+    super();
+    this.base = base;
+    this._tag = 10 /* SchemaTag.Record */;
+  }
+}
+exports.RecordSchema = RecordSchema;
+class TupleSchema extends Schema {
+  constructor(components) {
+    super();
+    this.components = components;
+    this._tag = 11 /* SchemaTag.Tuple */;
+  }
+}
+exports.TupleSchema = TupleSchema;
+class LazySchema extends Schema {
+  constructor(make) {
+    super();
+    this.make = make;
+    this._tag = 12 /* SchemaTag.Lazy */;
+  }
+}
+exports.LazySchema = LazySchema;
+class ValidationSchema extends Schema {
+  constructor(base, validations) {
+    super();
+    this.base = base;
+    this.validations = validations;
+    this._tag = 13 /* SchemaTag.Validation */;
+  }
+}
+exports.ValidationSchema = ValidationSchema;
+class UnionSchema extends Schema {
+  constructor(members) {
+    super();
+    this.members = members;
+    this._tag = 14 /* SchemaTag.Union */;
+  }
+}
+exports.UnionSchema = UnionSchema;
+const unknown = /*#__PURE__*/new UnknownSchema();
+exports.unknown = unknown;
+const string = /*#__PURE__*/new StringSchema();
+exports.string = string;
+const number = /*#__PURE__*/new NumberSchema();
+exports.number = number;
+const boolean = /*#__PURE__*/new BooleanSchema();
+exports.boolean = boolean;
+const bigint = /*#__PURE__*/new BigIntSchema();
+exports.bigint = bigint;
+function literal(value) {
+  return new LiteralSchema(value);
+}
+function nullable(base) {
+  return new NullableSchema(base);
+}
+function struct(fields) {
+  return new StructSchema(fields);
+}
+function partial(fields) {
+  return new PartialSchema(fields);
+}
+function array(base) {
+  return new ArraySchema(base);
+}
+function record(base) {
+  return new RecordSchema(base);
+}
+function tuple(...components) {
+  return new TupleSchema(components).unsafeCoerce();
+}
+function lazy(make) {
+  return new LazySchema(make);
+}
+function validation(...validations) {
+  return base => new ValidationSchema(base, validations).unsafeCoerce();
+}
+function union(...members) {
+  return new UnionSchema(members);
+}
+function concrete(_) {
+  //
+}
+function cacheThunk(f) {
+  let cached;
+  return () => {
+    if (!cached) {
+      cached = f();
+    }
+    return cached;
+  };
+}
+function interpret(S) {
+  return schema => {
+    concrete(schema);
+    switch (schema._tag) {
+      case 0 /* SchemaTag.Unknown */:
+        return S.unknown;
+      case 1 /* SchemaTag.String */:
+        return S.string;
+      case 2 /* SchemaTag.Number */:
+        return S.number;
+      case 3 /* SchemaTag.Boolean */:
+        return S.boolean;
+      case 4 /* SchemaTag.BigInt */:
+        return S.bigint;
+      case 5 /* SchemaTag.Literal */:
+        return S.literal(schema.value);
+      case 12 /* SchemaTag.Lazy */:
+        const cached = cacheThunk(schema.make);
+        return S.lazy(() => interpret(S)(cached()));
+      case 6 /* SchemaTag.Nullable */:
+        return S.nullable(interpret(S)(schema.base));
+      case 7 /* SchemaTag.Struct */:
+        return S.struct(tsplus_module_1.Dictionary.reverseGet(tsplus_module_2.map(interpret(S))(tsplus_module_1.Dictionary.get(schema.fields))));
+      case 8 /* SchemaTag.Partial */:
+        return S.partial(tsplus_module_1.Dictionary.reverseGet(tsplus_module_2.map(interpret(S))(tsplus_module_1.Dictionary.get(schema.fields))));
+      case 9 /* SchemaTag.Array */:
+        return S.array(interpret(S)(schema.base));
+      case 10 /* SchemaTag.Record */:
+        return S.record(interpret(S)(schema.base));
+      case 11 /* SchemaTag.Tuple */:
+        return S.tuple(...schema.components.map(interpret(S)));
+      case 13 /* SchemaTag.Validation */:
+        return S.validation(...schema.validations)(interpret(S)(schema.base));
+      case 14 /* SchemaTag.Union */:
+        return S.union(schema.members.map(interpret(S)), schema);
+    }
+  };
+}
+//# sourceMappingURL=Schema.cjs.map

package/_cjs/Schema.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schema.cjs","mappings":"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","names":["SchemaTypeId","Symbol","for","Schema","constructor","UnknownSchema","StringSchema","NumberSchema","BooleanSchema","BigIntSchema","LiteralSchema","value","NullableSchema","base","StructSchema","fields","PartialSchema","ArraySchema","RecordSchema","TupleSchema","components","LazySchema","make","ValidationSchema","validations","UnionSchema","members","unknown","string","number","boolean","bigint","literal","nullable","struct","partial","array","record","tuple","unsafeCoerce","lazy","validation","union","concrete","_","cacheThunk","f","cached","interpret","S","schema","_tag","tsplus_module_1","reverseGet","tsplus_module_2","get","map"],"sourceRoot":"","sources":["../_src/Schema.ts"],"sourcesContent":[null]}

package/_cjs/Schemable.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=Schemable.cjs.map

package/_cjs/Schemable.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Schemable.cjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/_cjs/global.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=global.cjs.map

package/_cjs/global.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"global.cjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/_cjs/index.cjs

@@ -0,0 +1,6 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+//# sourceMappingURL=index.cjs.map

package/_cjs/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","mappings":"","names":[],"sourceRoot":"","sources":[],"sourcesContent":[]}

package/_mjs/Decoder.mjs

@@ -0,0 +1,20 @@
+import * as tsplus_module_1 from "@fncts/base/data/Decoder/api";
+import * as tsplus_module_2 from "@fncts/base/data/function/api";
+export const Schemable = {
+  unknown: tsplus_module_1.unknown,
+  string: tsplus_module_1.string,
+  number: tsplus_module_1.number,
+  boolean: tsplus_module_1.boolean,
+  bigint: tsplus_module_1.bigint,
+  literal: tsplus_module_1.literal,
+  nullable: tsplus_module_1.nullable,
+  struct: tsplus_module_1.struct,
+  partial: tsplus_module_1.partial,
+  array: tsplus_module_1.readonlyArray,
+  record: tsplus_module_1.record,
+  tuple: tsplus_module_1.tuple,
+  lazy: tsplus_module_1.deriveLazy,
+  validation: tsplus_module_1.validation,
+  union: members => tsplus_module_1.union(...members)
+};
+//# sourceMappingURL=Decoder.mjs.map

package/_mjs/Decoder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Decoder.mjs","mappings":";;AAGA,OAAO,MAAMA,SAAS,GAAgB;EACpCC,OAAO,yBAAiB;EACxBC,MAAM,wBAAU;EAChBC,MAAM,wBAAU;EAChBC,OAAO,yBAAU;EACjBC,MAAM,wBAAU;EAChBC,OAAO,yBAAiB;EACxBC,QAAQ,0BAAkB;EAC1BC,MAAM,wBAAgB;EACtBC,OAAO,yBAAiB;EACxBC,KAAK,+BAAuB;EAC5BC,MAAM,wBAAgB;EACtBC,KAAK,uBAA6B;EAClCC,IAAI,4BAAc;EAClBC,UAAU,4BAAkC;EAC5CC,KAAK,EAAGC,OAAO,IAAKC,sBAAc,GAAGD,OAAO;CAC7C","names":["Schemable","unknown","string","number","boolean","bigint","literal","nullable","struct","partial","array","record","tuple","lazy","validation","union","members","tsplus_module_1"],"sourceRoot":"","sources":["../_src/Decoder.ts"],"sourcesContent":[null]}