@lucania/schema 1.0.7 → 2.0.0

package/build/builder.d.ts

@@ -0,0 +1,48 @@
+import { BaseSchemaAny } from "./typing/extended";
+import { DefaultValue, ModelValue, TypedMembers } from "./typing/toolbox";
+import { AnySchema } from "./schema/AnySchema";
+import { ArraySchema, ArraySource } from "./schema/ArraySchema";
+import { BooleanSchema, BooleanSource } from "./schema/BooleanSchema";
+import { DateSchema, DateSource } from "./schema/DateSchema";
+import { DynamicObjectSchema, DynamicObjectSource } from "./schema/DynamicObjectSchema";
+import { EnumerationSchema } from "./schema/EnumerationSchema";
+import { NumberSchema, NumberSource } from "./schema/NumberSchema";
+import { ObjectSchema, ObjectSource, ObjectSubschema } from "./schema/ObjectSchema";
+import { OrSetSchema, OrSetSchemaSource } from "./schema/OrSetSchema";
+import { StringSchema, StringSource } from "./schema/StringSchema";
+import { BaseSchema, SourceValue } from ".";
+export declare namespace Schema {
+    function String(): StringSchema<true, undefined>;
+    function String<Required extends boolean>(required: Required): StringSchema<Required, undefined>;
+    function String<Required extends boolean, Default extends DefaultValue<StringSource>>(required: Required, defaultValue: Default): StringSchema<Required, Default>;
+    function Number(): NumberSchema<true, undefined>;
+    function Number<Required extends boolean>(required: Required): NumberSchema<Required, undefined>;
+    function Number<Required extends boolean, Default extends DefaultValue<NumberSource>>(required: Required, defaultValue: Default): NumberSchema<Required, Default>;
+    function Boolean(): BooleanSchema<true, undefined>;
+    function Boolean<Required extends boolean>(required: Required): BooleanSchema<Required, undefined>;
+    function Boolean<Required extends boolean, Default extends DefaultValue<BooleanSource>>(required: Required, defaultValue: Default): BooleanSchema<Required, Default>;
+    function Date(): DateSchema<true, undefined>;
+    function Date<Required extends boolean>(required: Required): DateSchema<Required, undefined>;
+    function Date<Required extends boolean, Default extends DefaultValue<DateSource>>(required: Required, defaultValue: Default): DateSchema<Required, Default>;
+    function Any(): AnySchema<true, undefined>;
+    function Any<Required extends boolean>(required: Required): AnySchema<Required, undefined>;
+    function Any<Required extends boolean, Default extends DefaultValue<any>>(required: Required, defaultValue: Default): AnySchema<Required, Default>;
+    function Object<Subschema extends ObjectSubschema>(subschema: Subschema): ObjectSchema<Subschema, true, undefined>;
+    function Object<Subschema extends ObjectSubschema, Required extends boolean>(subschema: Subschema, required: Required): ObjectSchema<Subschema, Required, undefined>;
+    function Object<Subschema extends ObjectSubschema, Required extends boolean, Default extends DefaultValue<ObjectSource<Subschema>>>(subschema: Subschema, required: Required, defaultValue: Default): ObjectSchema<Subschema, Required, Default>;
+    function Array<Subschema extends BaseSchemaAny>(subschema: Subschema): ArraySchema<Subschema, true, undefined>;
+    function Array<Subschema extends BaseSchemaAny, Required extends boolean>(subschema: Subschema, required: Required): ArraySchema<Subschema, Required, undefined>;
+    function Array<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<ArraySource<Subschema>>>(subschema: Subschema, required: Required, defaultValue: Default): ArraySchema<Subschema, Required, Default>;
+    function Enumeration<Members extends string[]>(subschema: TypedMembers<Members>): EnumerationSchema<Members, true, undefined>;
+    function Enumeration<Members extends string[], Required extends boolean>(subschema: TypedMembers<Members>, required: Required): EnumerationSchema<Members, Required, undefined>;
+    function Enumeration<Members extends string[], Required extends boolean, Default extends DefaultValue<Members[number]>>(subschema: TypedMembers<Members>, required: Required, defaultValue: Default): EnumerationSchema<Members, Required, Default>;
+    function DynamicObject<Subschema extends BaseSchemaAny>(subschema: Subschema): DynamicObjectSchema<Subschema, true, undefined>;
+    function DynamicObject<Subschema extends BaseSchemaAny, Required extends boolean>(subschema: Subschema, required: Required): DynamicObjectSchema<Subschema, Required, undefined>;
+    function DynamicObject<Subschema extends BaseSchemaAny, Required extends boolean, Default extends DefaultValue<DynamicObjectSource<Subschema>>>(subschema: Subschema, required: Required, defaultValue: Default): DynamicObjectSchema<Subschema, Required, Default>;
+    function OrSet<MemberSchemas extends BaseSchemaAny[]>(subschema: TypedMembers<MemberSchemas>): OrSetSchema<MemberSchemas, true, undefined>;
+    function OrSet<MemberSchemas extends BaseSchemaAny[], Required extends boolean>(subschema: TypedMembers<MemberSchemas>, required: Required): OrSetSchema<MemberSchemas, Required, undefined>;
+    function OrSet<MemberSchemas extends BaseSchemaAny[], Required extends boolean, Default extends DefaultValue<OrSetSchemaSource<MemberSchemas>>>(subschema: TypedMembers<MemberSchemas>, required: Required, defaultValue: Default): OrSetSchema<MemberSchemas, Required, Default>;
+    function Members<Members extends any[]>(...members: Members): TypedMembers<Members>;
+    type Model<Schema extends BaseSchemaAny> = Schema extends BaseSchema<infer Source, infer Model, infer Require, infer Default> ? (ModelValue<Source, Model, Require, Default>) : never;
+    type Source<Schema extends BaseSchemaAny> = Schema extends BaseSchema<infer Source, any, infer Require, infer Default> ? (SourceValue<Source, Require, Default>) : never;
+}

package/build/error/ValidationError.d.ts

@@ -0,0 +1,5 @@
+import { ValidationPass } from "./ValidationPass";
+export declare class ValidationError extends Error {
+    readonly pass: ValidationPass;
+    constructor(pass: ValidationPass, message: string);
+}

package/build/error/ValidationPass.d.ts

@@ -0,0 +1,17 @@
+import { DefaultValue, SourceValue } from "../typing/toolbox";
+import { BaseSchemaAny } from "../typing/extended";
+import { ValidationError } from "./ValidationError";
+export declare class ValidationPass {
+    readonly originalSchema: BaseSchemaAny;
+    readonly originalSource: SourceValue<any, boolean, DefaultValue<any>>;
+    private _path;
+    private _schema;
+    private _source;
+    constructor(originalSchema: BaseSchemaAny, originalSource: SourceValue<any, boolean, DefaultValue<any>>);
+    get path(): string[];
+    get schema(): BaseSchemaAny;
+    get source(): any;
+    next(path: string[], schema: BaseSchemaAny, source: SourceValue<any, boolean, DefaultValue<any>>): ValidationPass;
+    assert(condition: boolean, message: string): void;
+    getError(message?: string): ValidationError;
+}

package/build/index.d.ts

@@ -1,100 +1,17 @@
-export declare namespace Schema {
-    interface Map {
-        undefined: undefined;
-        boolean: boolean;
-        number: number;
-        bigint: bigint;
-        string: string;
-        symbol: symbol;
-        any: any;
-        Date: Date;
-    }
-    type Converter<From, To> = (from: From) => To;
-    interface ConversionMap {
-        boolean: [number, bigint, string];
-        number: [boolean, bigint, string, Date];
-        bigint: [number, string];
-        string: [boolean, number, bigint, any, Date];
-        any: [string];
-        Date: [number, bigint, string];
-    }
-    type Primitive = keyof Map;
-    type OrCompound = [Any, "or", Any];
-    type AndCompound = [Any, "and", Any];
-    type Dynamic = {
-        $: Any;
-    };
-    type Array = [Any];
-    type Hierarchy = {
-        [Key: string]: Any;
-    };
-    type Most = Primitive | OrCompound | AndCompound | Dynamic | Array | Hierarchy;
-    type TypedMeta<Schema extends Most> = {
-        type: Schema;
-        required: boolean;
-        validate?: Validator<Model<Schema>>;
-        default?: Model<Schema> | (() => Model<Schema>);
-    };
-    type Meta = TypedMeta<Most>;
-    type Any = Primitive | OrCompound | AndCompound | Meta | Dynamic | Array | Hierarchy;
-    type Validator<Type> = (value: Type, data: any) => Type;
-    type Merge<ObjectA, ObjectB> = (keyof ObjectA extends never ? ObjectB : keyof ObjectB extends never ? ObjectA : ObjectA & ObjectB);
-    type Model<Schema extends Schema.Any> = (Schema.Any extends Schema ? unknown : Schema extends Primitive ? Map[Schema] : Schema extends OrCompound ? Model<Schema[0]> | Model<Schema[2]> : Schema extends AndCompound ? Model<Schema[0]> & Model<Schema[2]> : Schema extends Meta ? (Schema extends TypedMeta<infer MetaType> ? (Schema.Most extends MetaType ? unknown : Schema["required"] extends false ? Model<MetaType> | undefined : Model<MetaType>) : never) : Schema extends Dynamic ? {
-        [Key: string]: Model<Schema["$"]>;
-    } : Schema extends Array ? Model<Schema[0]>[] : Schema extends Hierarchy ? Merge<{
-        [Key in keyof Schema as Existent<Schema[Key]> extends true ? Key : never]: Model<Schema[Key]>;
-    }, {
-        [Key in keyof Schema as Existent<Schema[Key]> extends true ? never : Key]?: Model<Schema[Key]>;
-    }> : any);
-    type Source<Schema extends Schema.Any> = (Schema.Any extends Schema ? unknown : Schema extends Primitive ? Converted<Schema> : Schema extends OrCompound ? Source<Schema[0]> | Source<Schema[2]> : Schema extends AndCompound ? Source<Schema[0]> & Source<Schema[2]> : Schema extends Meta ? Source<Schema["type"]> : Schema extends Dynamic ? {
-        [Key: string]: Source<Schema["$"]>;
-    } : Schema extends Array ? Source<Schema[0]>[] : Schema extends Hierarchy ? Merge<{
-        [Key in keyof Schema as Optionality<Schema[Key]> extends true ? never : Key]: Source<Schema[Key]>;
-    }, {
-        [Key in keyof Schema as Optionality<Schema[Key]> extends true ? Key : never]?: Source<Schema[Key]>;
-    }> : any);
-    type Converted<Schema extends Schema.Primitive> = (Schema extends keyof ConversionMap ? ConversionMap[Schema][number] | Map[Schema] : Map[Schema]);
-    type Existent<Schema extends Schema.Any> = (Schema.Any extends Schema ? unknown : Schema extends Schema.Meta ? (Schema["required"] extends true ? true : (Schema extends {
-        default: any;
-    } ? true : false)) : Schema extends Schema.Array ? Existent<Schema[0]> : true);
-    type Optionality<Schema extends Schema.Any> = (Schema.Any extends Schema ? unknown : Schema extends Schema.Meta ? (Schema["required"] extends true ? (Schema extends {
-        default: any;
-    } ? true : false) : true) : Schema extends Schema.Array ? Optionality<Schema[0]> : false);
-    function registerConverter<FromTypeName extends keyof ConversionMap, ToTypeName extends keyof Map>(fromTypeName: FromTypeName, toTypeName: ToTypeName, converter: Converter<Map[FromTypeName], Map[ToTypeName]>): void;
-    function registerPrimitive<TypeName extends keyof Map>(typeName: TypeName): void;
-    function isSchemaPrimitive(value: any): value is Schema.Primitive;
-    function isSchemaOrCompound(value: any): value is Schema.OrCompound;
-    function isSchemaAndCompound(value: any): value is Schema.AndCompound;
-    function isSchemaMeta(value: any): value is Schema.Meta;
-    function isSchemaDynamic(value: any): value is Schema.Dynamic;
-    function isSchemaArray(value: any): value is Schema.Array;
-    function isSchemaHierarchy(value: any): value is Schema.Hierarchy;
-    function isSchema(value: any): value is Schema.Any;
-    function getType(value: any): string;
-    function build<Schema extends Schema.Any>(schema: Schema): Schema;
-    function validate<Schema extends Any>(schema: Schema, source: Source<Schema>): Model<Schema>;
-    function clone<Schema extends Schema.Any>(schema: Schema): Schema;
-    function assert(condition: boolean, message?: string): asserts condition;
-    type ValidationErrorType = "missing" | "incorrectType" | "invalidSchema" | "failedCustomValidator";
-    class Error extends globalThis.Error {
-        constructor(message?: string);
-    }
-    class ValidationError extends Error {
-        readonly type: ValidationErrorType;
-        readonly source: any;
-        readonly schema: Schema.Any;
-        readonly originalSource: any;
-        readonly originalSchema: Schema.Any;
-        readonly path: string[];
-        readonly customMessage?: string;
-        /**
-         * @param message The error message.
-         * @param type The type of validation error.
-         * @param source The data that failed validation.
-         * @param path The path to the value that failed validation.
-         */
-        constructor(type: ValidationErrorType, schema: Schema.Any, source: any, path: string[], originalSchema: Schema.Any, originalSource: any, customMessage?: string);
-        static getExpectedString(schema: Schema.Any): string;
-        static getMessage(type: ValidationErrorType, source: any, schema: Schema.Any, path: string[]): string;
-    }
-}
+export * from "./builder";
+export { Schema as $ } from "./builder";
+export * from "./error/ValidationError";
+export * from "./error/ValidationPass";
+export * from "./schema/AnySchema";
+export * from "./schema/ArraySchema";
+export * from "./schema/BaseSchema";
+export * from "./schema/BooleanSchema";
+export * from "./schema/DateSchema";
+export * from "./schema/DynamicObjectSchema";
+export * from "./schema/EnumerationSchema";
+export * from "./schema/NumberSchema";
+export * from "./schema/ObjectSchema";
+export * from "./schema/OrSetSchema";
+export * from "./schema/StringSchema";
+export * from "./typing/extended";
+export * from "./typing/toolbox";