@fncts/schema 0.0.4 → 0.0.6

package/Schema/derivations.d.ts

@@ -0,0 +1,70 @@
+import { Brand, Validation } from "@fncts/base/data/Branded";
+import { Check } from "@fncts/typelevel";
+import { Schema } from "@fncts/schema/Schema/definition";
+import { LiteralValue, AST } from "@fncts/schema/AST";
+import { Maybe } from "@fncts/base/data/Maybe/definition";
+import { Vector } from "@fncts/base/collection/immutable/Vector";
+import type { OptionalKeys, RequiredKeys } from "@fncts/typelevel/Object";
+/**
+ * @tsplus derive fncts.schema.Schema<_> 10
+ * @tsplus location "@fncts/schema/Schema/derivations"
+ */
+export declare function deriveValidation<A extends Brand.Valid<any, any>>(...[base, brands]: Check<Brand.IsValidated<A>> extends Check.True ? [
+    base: Schema<Brand.Unbranded<A>>,
+    brands: {
+        [K in keyof A[Brand.valid] & string]: Validation<A[Brand.valid][K], K>;
+    }
+] : never): Schema<A>;
+/**
+ * @tsplus derive fncts.schema.Schema<_> 20
+ * @tsplus location "@fncts/schema/Schema/derivations"
+ */
+export declare function deriveLiteral<A extends LiteralValue>(...[value]: Check<Check.IsLiteral<A> & Check.Not<Check.IsUnion<A>>> extends Check.True ? [value: A] : never): Schema<A>;
+type MaybeKeys<A> = {
+    [K in keyof A]: A[K] extends Maybe<any> ? K : never;
+}[keyof A];
+/**
+ * @tsplus derive fncts.schema.Schema<_> 20
+ * @tsplus location "@fncts/schema/Schema/derivations"
+ */
+export declare function deriveStruct<A extends Record<string, any>>(...[requiredFields, optionalFields, maybeFields]: Check<Check.IsStruct<A>> extends Check.True ? [
+    ...[
+        requiredFields: {
+            [k in Exclude<RequiredKeys<A>, MaybeKeys<A>>]: Schema<A[k]>;
+        }
+    ],
+    ...([OptionalKeys<A>] extends [never] ? [optionalFields: {}] : [
+        optionalFields: {
+            [k in OptionalKeys<A>]: Schema<NonNullable<A[k]>>;
+        }
+    ]),
+    ...([MaybeKeys<A>] extends [never] ? [] : [
+        maybeFields: {
+            [k in MaybeKeys<A>]: [A[k]] extends [Maybe<infer _A>] ? Schema<_A> : never;
+        }
+    ])
+] : never): Schema<A>;
+/**
+ * @tsplus derive fncts.schema.Schema<_> 10
+ * @tsplus location "@fncts/schema/Schema/derivations"
+ */
+export declare function deriveTuple<A extends ReadonlyArray<unknown>>(...[components]: Check<Check.IsTuple<A>> extends Check.True ? [components: {
+    [K in keyof A]: Schema<A[K]>;
+}] : never): Schema<A>;
+/**
+ * @tsplus derive fncts.schema.Schema lazy
+ * @tsplus location "@fncts/schema/Schema/derivations"
+ */
+export declare function deriveLazy<A>(f: (_: Schema<A>) => Schema<A>): Schema<A>;
+/**
+ * @tsplus derive fncts.schema.Schema[fncts.Array]<_> 10
+ * @tsplus derive fncts.schema.Schema[fncts.ReadonlyArray]<_> 10
+ * @tsplus location "@fncts/schema/Schema/derivations"
+ */
+export declare function deriveArray<A extends ReadonlyArray<any>>(...[element]: [A] extends [ReadonlyArray<infer _A>] ? Check<Check.IsEqual<A, ReadonlyArray<_A>>> extends Check.True ? [element: Schema<_A>] : never : never): Schema<A>;
+/**
+ * @tsplus derive fncts.schema.Schema<_> 15
+ * @tsplus location "@fncts/schema/Schema/derivations"
+ */
+export declare function deriveRecord<A extends Record<string | symbol, any>>(...[keySchema, valueSchema]: [A] extends [Record<infer X, infer Y>] ? Check<Check.Not<Check.IsUnion<A>> & Check.IsEqual<A, Record<X, Y>>> extends Check.True ? [keySchema: Schema<X>, valueSchema: Schema<Y>] : never : never): Schema<A>;
+export {};

package/Schema.d.ts

@@ -1,144 +1,2 @@
-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 SchemaVariance: unique symbol;
-export type SchemaVariance = typeof SchemaVariance;
-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 [SchemaTypeId]: SchemaTypeId;
-    [SchemaVariance]: {
-        _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>;
+export * from "./Schema/api.js";
+export * from "./Schema/definition.js";