@dzeio/schema 0.4.2 → 0.5.0

package/dist/Schema.d.mts

@@ -1,12 +1,14 @@
 import { StandardSchemaV1 } from '@standard-schema/spec';
 
-declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type> {
-    '~standard': StandardSchemaV1.Props<Type>;
+declare abstract class SchemaItem<Output = any, Input = Output> implements StandardSchemaV1<Input, Output> {
+    readonly _output: Output;
+    readonly _input: Input;
+    '~standard': StandardSchemaV1.Props<Input, Output>;
     /**
      * keep public ?
      */
-    validations: Array<{
-        fn: (input: Type) => boolean;
+    protected readonly validations: Array<{
+        fn: (input: Output) => boolean;
         error?: string | undefined;
     }>;
     /**
@@ -23,7 +25,7 @@ declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type>
      *
      * note: The type of the final Pre-Process MUST be valid
      */
-    preProcess: Array<(input: unknown) => Type | unknown>;
+    protected readonly preProcess: Array<(input: unknown) => Input | unknown>;
     /**
      * post process the variable after it being validated
      *
@@ -31,25 +33,29 @@ declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type>
      *
      * note: the type of the final post-process MUST be valid
      */
-    postProcess: Array<(input: Type) => Type>;
+    protected readonly postProcess: Array<(input: Output) => Output>;
     /**
      * list of attributes for custom works
      */
     readonly attributes: Array<string>;
-    private readonly items?;
+    protected readonly items?: Array<unknown>;
     private invalidError;
     constructor(items?: Array<unknown> | IArguments);
-    defaultValue(value: Type, strict?: boolean): this;
     /**
     * make sure the value is one of the `values`
     * @param values the values the item MUST contains
     */
-    in(...values: Array<Type>): this;
+    in(...values: Array<Output>): this;
     attrs(...attributes: Array<string>): this;
     attr(...attributes: Array<string>): this;
     setInvalidError(err: string): this;
     clone(): this;
+    defaultValue(value: Output, strict?: boolean): SchemaDefault<this>;
+    default: (value: Output, strict?: boolean) => SchemaDefault<this>;
     nullable(): SchemaNullable<this>;
+    or<Other extends SchemaItem>(other: Other): SchemaUnion<[this, Other]>;
+    and<Type extends SchemaItem>(other: Type): SchemaIntersection<[this, Type]>;
+    array(): SchemaArray<this>;
     /**
      * schemas implementing unwrap can return their child component (mostly the value)
      *
@@ -58,21 +64,38 @@ declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type>
      * es2: s.nullable(s.string()) returns s.string()
      */
     unwrap?(): SchemaItem;
-    parse(input: unknown, options?: {
-        fast?: boolean;
-    }): ValidationResult<Type>;
+    /** Returns the sub values of the input, the schema item to handle them, and the path to it */
+    protected getSubInputs(_input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
+    /** Sets the "part" of the input that this sub schema handles. Overrides the input with the result */
+    protected updateSubItemInput(path: string | undefined, input: unknown, value: unknown): unknown;
+    protected parseSubItems(input: unknown, options?: ValidationOptions): {
+        input: unknown;
+        errors?: Array<ValidationError>;
+    };
+    parse(input: unknown, options?: ValidationOptions): ValidationResult<Output>;
     toJSON(): SchemaJSON;
-    protected addValidation(fn: ((input: Type) => boolean) | {
-        fn: (input: Type) => boolean;
+    addValidation(fn: ((input: Output) => boolean) | {
+        fn: (input: Output) => boolean;
         error?: string;
     }, error?: string): this;
-    protected addPreProcess(fn: (input: unknown) => Type | unknown): this;
-    protected addPostProcess(fn: (input: Type) => Type): this;
-    abstract isOfType(input: unknown): input is Type;
+    addPreProcess(fn: (input: unknown) => Input | unknown): this;
+    addPostProcess(fn: (input: Output) => Output): this;
+    parseJSON(): this;
+    abstract isOfType(input: unknown): input is Output;
 }
 
-type SchemaInfer<Type extends SchemaItem> = Type extends SchemaItem<infer X> ? X : never
+type SchemaInfer<Type extends SchemaItem> = Type["_output"]
 type Infer<Type extends SchemaItem> = SchemaInfer<Type>
+type SchemaInputInfer<Type extends SchemaItem> = Type["_input"]
+type InputInfer<Type extends SchemaItem> = SchemaInputInfer<Type>
+
+interface ValidationOptions {
+	fast?: boolean
+}
 
 interface ValidationError {
 	message: string
@@ -100,12 +123,21 @@ type ValidationResultOld<T> = {
 	error: Array<ValidationError>
 }
 
+/**
+ * JSON Schema used for client side validation
+ */
 interface SchemaJSON {
+	/** Id of the schema item (name of the constructor) */
 	i: string
+	/** Attributes */
 	a?: Array<string> | undefined
+	/** Children schema items */
 	c?: Array<unknown> | undefined
+	/** Functions called to modify the behavior of the item */
 	f?: Array<{
+		/** Name of the function */
 		n: string
+		/** Arguments for the function */
 		a?: Array<unknown> | undefined
 	}> | undefined
 }
@@ -128,27 +160,29 @@ type ModelInfer$1<M extends Model> = {
 }
 
 declare class SchemaAny extends SchemaItem {
-    isOfType(input: unknown): input is any;
+    isOfType(_input: unknown): _input is any;
 }
 
+type DateFormat = 'default' | 'iso8601' | 'yy-mm-dd' | 'jj/mm/yy';
 declare class SchemaDate extends SchemaItem<Date> {
-    parseString(format?: 'iso8601' | 'yy-mm-dd' | 'jj/mm/yy'): this;
+    parseString(format?: DateFormat): this;
     isOfType(input: unknown): input is Date;
 }
 
-declare class SchemaRecord<Keys extends SchemaItem, Values extends SchemaItem> extends SchemaItem<Record<SchemaInfer<Keys>, SchemaInfer<Values>>> {
+declare class SchemaRecord<Keys extends SchemaItem<string | number | symbol>, Values extends SchemaItem> extends SchemaItem<Record<SchemaInfer<Keys>, SchemaInfer<Values>>> {
     private readonly keys;
     private readonly values;
     constructor(keys: Keys, values: Values);
-    parse(input: unknown, options?: {
-        fast?: boolean;
-    }): ValidationResult<Record<SchemaInfer<Keys>, SchemaInfer<Values>>>;
+    protected parseSubItems(input: unknown, options?: ValidationOptions): {
+        input: unknown;
+        errors?: ValidationError[];
+    };
     isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
 }
 
-declare class SchemaArray<Type extends SchemaItem> extends SchemaItem<Array<SchemaInfer<Type>>> {
-    readonly values: Type;
-    constructor(values: Type);
+declare class SchemaArray<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Array<Output>, Array<Input>> {
+    readonly values: Child;
+    constructor(values: Child);
     /**
      * transform the array so it only contains one of each elements
      */
@@ -158,11 +192,13 @@ declare class SchemaArray<Type extends SchemaItem> extends SchemaItem<Array<Sche
     * @param [separator] default:`,` the separator to use
     */
     split(separator?: string): this;
-    parse(input: unknown, options?: {
-        fast?: boolean;
-    }): ValidationResult<Array<SchemaInfer<Type>>>;
-    unwrap(): Type;
-    isOfType(input: unknown): input is Array<SchemaInfer<Type>>;
+    protected getSubInputs(input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
+    unwrap(): Child;
+    isOfType(input: unknown): input is Array<Output>;
 }
 
 declare class SchemaBoolean extends SchemaItem<boolean> {
@@ -179,8 +215,8 @@ interface EnumLike {
     [n: number]: string;
 }
 declare class SchemaEnum<E extends EnumLike> extends SchemaItem<E[keyof E]> {
-    private templateEnum;
-    private type;
+    private readonly templateEnum;
+    private readonly type;
     constructor(templateEnum: E);
     isOfType(input: unknown): input is E[keyof E];
 }
@@ -191,16 +227,21 @@ declare class SchemaLiteral<Type> extends SchemaItem<Type> {
     isOfType(input: unknown): input is Type;
 }
 
-declare class SchemaNullable<Type extends SchemaItem> extends SchemaItem<SchemaInfer<Type> | undefined> {
-    readonly child: Type;
-    constructor(child: Type);
-    falthyAsNull(): this;
-    unwrap(): Type;
-    parse(input: unknown, options?: {
-        fast?: boolean;
-    }): ValidationResult<SchemaInfer<Type> | undefined>;
-    isOfType(input: unknown): input is SchemaInfer<Type> | undefined;
-    private isNull;
+declare class SchemaNullable<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Output | undefined, Input | null | undefined> {
+    private readonly child;
+    constructor(child: Child);
+    falsyAsNull(): this;
+    unwrap(): Child;
+    protected getSubInputs(input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
+    protected parseSubItems(input: unknown, options?: ValidationOptions): {
+        input: unknown;
+        errors?: Array<ValidationError>;
+    };
+    isOfType(input: unknown): input is Output | undefined;
 }
 
 declare class SchemaNumber extends SchemaItem<number> {
@@ -244,9 +285,11 @@ declare class SchemaObject<T extends Record<string, SchemaItem> = any> extends S
     readonly model: T;
     id: string;
     constructor(model: T);
-    parse(input: unknown, options?: {
-        fast?: boolean;
-    }): ValidationResult<ModelInfer<T>>;
+    protected getSubInputs(input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
     isOfType(input: unknown): input is ModelInfer<T>;
 }
 
@@ -285,26 +328,94 @@ declare class SchemaString extends SchemaItem<string> {
     isOfType(input: unknown): input is string;
 }
 
-type ItemType<T extends Array<SchemaItem>> = SchemaInfer<T[number]>;
-declare class SchemaUnion<T extends Array<SchemaItem>> extends SchemaItem<ItemType<T>> {
-    private schemas;
-    constructor(...schemas: T);
-    parse(input: unknown, options?: {
-        fast?: boolean;
-    }): ValidationResult<SchemaInfer<T[number]>>;
-    isOfType(input: unknown): input is ItemType<T>;
+declare class SchemaUnion<Children extends Array<SchemaItem>, Outputs = SchemaInfer<Children[number]>, Inputs = SchemaInputInfer<Children[number]>> extends SchemaItem<Outputs, Inputs> {
+    private readonly schemas;
+    constructor(...schemas: Children);
+    protected parseSubItems(input: unknown, options?: ValidationOptions): {
+        input: unknown;
+        errors?: Array<ValidationError>;
+    };
+    isOfType(input: unknown): input is Outputs;
+}
+
+type Prettify<T> = T extends unknown ? {
+    [K in keyof T]: T[K];
+} : never;
+type UnionToIntersection<U> = (U extends U ? (x: U) => void : never) extends ((x: infer I) => void) ? I : never;
+declare class SchemaIntersection<Children extends Array<SchemaItem>, Outputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>, Inputs = Prettify<UnionToIntersection<SchemaInfer<Children[number]>>>> extends SchemaItem<Outputs, Inputs> {
+    private readonly schemas;
+    constructor(...schemas: Children);
+    protected parseSubItems(input: unknown, options?: ValidationOptions): {
+        input: unknown;
+        errors?: Array<ValidationError>;
+    };
+    isOfType(input: unknown): input is Outputs;
+}
+
+declare class SchemaDefault<Child extends SchemaItem, Output = SchemaInfer<Child>, Input = SchemaInputInfer<Child>> extends SchemaItem<Output, Input | null | undefined> {
+    private readonly child;
+    private readonly defaultVal;
+    private readonly strict;
+    constructor(child: Child, defaultVal: Output, strict?: boolean);
+    unwrap(): Child;
+    protected getSubInputs(input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
+    isOfType(input: unknown): input is Output;
+}
+
+declare class SchemaFile extends SchemaItem<File> {
+    constructor();
+    extension(ext: string, error?: string): this;
+    maxSize(size: number, error?: string): this;
+    isOfType(input: unknown): input is File;
+}
+
+type TupleToOutputs<Tuple extends Array<SchemaItem>, Result extends any[] = []> = number extends Tuple["length"] ? Array<SchemaInfer<Tuple[number]>> : Tuple[Result["length"]] extends undefined ? Result : TupleToOutputs<Tuple, [...Result, SchemaInfer<Tuple[Result["length"]]>]>;
+type TupleToInputs<Tuple extends Array<SchemaItem>, Result extends any[] = []> = number extends Tuple["length"] ? Array<SchemaInputInfer<Tuple[number]>> : Tuple[Result["length"]] extends undefined ? Result : TupleToInputs<Tuple, [...Result, SchemaInputInfer<Tuple[Result["length"]]>]>;
+declare class SchemaTuple<Children extends Array<SchemaItem>, Outputs = TupleToOutputs<Children>, Inputs = TupleToInputs<Children>> extends SchemaItem<Outputs, Inputs> {
+    private readonly children;
+    constructor(...children: Children);
+    protected getSubInputs(input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
+    isOfType(input: unknown): input is Outputs;
+}
+
+declare class SchemaUndefined extends SchemaItem<undefined> {
+    isOfType(input: unknown): input is undefined;
+}
+declare class SchemaNull extends SchemaItem<null> {
+    isOfType(input: unknown): input is null;
+}
+declare class SchemaVoid extends SchemaItem<void> {
+    isOfType(input: unknown): input is void;
+}
+declare class SchemaNullish extends SchemaItem<null | undefined> {
+    isOfType(input: unknown): input is null | undefined;
+}
+declare class SchemaNever extends SchemaItem<never> {
+    isOfType(_input: unknown): _input is never;
 }
 
 declare function isNull(value: unknown): value is undefined | null;
 declare function parseQuery<T extends SchemaItem>(model: T, query: URLSearchParams, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
-declare function parseFormData<T extends SchemaItem>(model: T, data: FormData, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+declare function parseFormData<T extends SchemaItem>(schema: T, data: FormData, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
 declare function parseForm<T extends SchemaItem>(model: T, form: HTMLFormElement, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
 
-declare function parceable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
+/**
+ * Decorator for modifier functions on SchemaItems to save them in the "savedCalls" property for the serialization
+ */
+declare function parsable(): (target: object, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<any>) => TypedPropertyDescriptor<any>;
 type SchemaItemStatic = new (...args: Array<any>) => SchemaItem;
 declare const Types: {
     readonly Any: typeof SchemaAny;
     readonly Array: typeof SchemaArray;
+    readonly Tuple: typeof SchemaTuple;
     readonly Boolean: typeof SchemaBoolean;
     readonly Date: typeof SchemaDate;
     readonly Enum: typeof SchemaEnum;
@@ -314,9 +425,15 @@ declare const Types: {
     readonly Record: typeof SchemaRecord;
     readonly String: typeof SchemaString;
     readonly Union: typeof SchemaUnion;
+    readonly Intersection: typeof SchemaIntersection;
+    readonly Default: typeof SchemaDefault;
+    readonly Undefined: typeof SchemaUndefined;
+    readonly Void: typeof SchemaVoid;
+    readonly Null: typeof SchemaNull;
+    readonly Nullish: typeof SchemaNullish;
 };
 declare class Schema<T extends Record<string, SchemaItem> = Record<string, SchemaItem>> extends SchemaObject<T> {
-    private static registeredModules;
+    private static readonly registeredModules;
     static register(module: SchemaItemStatic): void;
     static getModule(name: string): SchemaItemStatic | undefined;
     static any(): SchemaAny;
@@ -338,7 +455,15 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
      * See {@link SchemaString}
      */
     static string(...inputs: ConstructorParameters<typeof SchemaString>): SchemaString;
+    static file(...inputs: ConstructorParameters<typeof SchemaFile>): SchemaFile;
     static union<Type extends Array<SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaUnion<Type>>): SchemaUnion<Type>;
+    static intersection<Type extends SchemaItem[]>(...inputs: ConstructorParameters<typeof SchemaIntersection<Type>>): SchemaIntersection<Type>;
+    static tuple<Items extends SchemaItem[]>(...inputs: ConstructorParameters<typeof SchemaTuple<Items>>): SchemaTuple<Items>;
+    static undefined(...inputs: ConstructorParameters<typeof SchemaUndefined>): SchemaUndefined;
+    static null(...inputs: ConstructorParameters<typeof SchemaNull>): SchemaNull;
+    static nullish(...inputs: ConstructorParameters<typeof SchemaNullish>): SchemaNullish;
+    static void(...inputs: ConstructorParameters<typeof SchemaVoid>): SchemaVoid;
+    static never(...inputs: ConstructorParameters<typeof SchemaNever>): SchemaNever;
     static fromJSON(json: SchemaJSON): SchemaItem;
     static isSchemaJSON(data: unknown): data is SchemaJSON;
     /**
@@ -360,4 +485,4 @@ declare class Schema<T extends Record<string, SchemaItem> = Record<string, Schem
 }
 declare const s: typeof Schema;
 
-export { type Infer, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaEnum, type SchemaInfer, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNullable, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUnion, Types, type ValidationError, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parceable, parseForm, parseFormData, parseQuery, s };
+export { type Infer, type InputInfer, type Model, type ModelInfer$1 as ModelInfer, SchemaAny, SchemaArray, SchemaBoolean, SchemaDate, SchemaDefault, SchemaEnum, SchemaFile, type SchemaInfer, type SchemaInputInfer, SchemaIntersection, SchemaItem, type SchemaItemJSON, type SchemaJSON, SchemaLiteral, SchemaNever, SchemaNull, SchemaNullable, SchemaNullish, SchemaNumber, SchemaObject, SchemaRecord, SchemaString, SchemaUndefined, SchemaUnion, SchemaVoid, Types, type ValidationError, type ValidationOptions, type ValidationResult, type ValidationResultOld, Schema as default, isNull, parsable, parseForm, parseFormData, parseQuery, s };