@dzeio/schema 0.4.3 → 0.6.0

package/dist/Schema.d.mts

@@ -1,14 +1,9 @@
 import { StandardSchemaV1 } from '@standard-schema/spec';
 
-declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type> {
-    '~standard': StandardSchemaV1.Props<Type>;
-    /**
-     * keep public ?
-     */
-    validations: Array<{
-        fn: (input: Type) => boolean;
-        error?: string | undefined;
-    }>;
+declare abstract class SchemaItem<Output = any, Input = Output> implements StandardSchemaV1<Input, Output> {
+    readonly _output: Output;
+    readonly _input: Input;
+    '~standard': StandardSchemaV1.Props<Input, Output>;
     /**
      * Function calls saved for serialization
      */
@@ -16,6 +11,17 @@ declare abstract class SchemaItem<Type = any> implements StandardSchemaV1<Type>
         name: string;
         args: Array<string> | IArguments | undefined;
     }>;
+    /**
+     * list of attributes for custom works
+     */
+    readonly attributes: Array<string>;
+    /**
+     * keep public ?
+     */
+    protected readonly validations: Array<{
+        fn: (input: Output) => boolean;
+        error?: string | undefined;
+    }>;
     /**
      * Pre process the variable for various reasons
      *
@@ -23,7 +29,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 +37,26 @@ 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>;
-    /**
-     * list of attributes for custom works
-     */
-    readonly attributes: Array<string>;
-    private readonly items?;
+    protected readonly postProcess: Array<(input: Output) => Output>;
+    protected readonly items?: Array<unknown>;
     private invalidError;
     constructor(items?: Array<unknown> | IArguments);
-    defaultValue(value: Type, strict?: boolean): this;
+    parseJSON(): 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 +65,37 @@ 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>;
+    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;
+    /** 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>;
+    };
+    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>>>;
     isOfType(input: unknown): input is Record<SchemaInfer<Keys>, SchemaInfer<Values>>;
+    protected parseSubItems(input: unknown, options?: ValidationOptions): {
+        input: unknown;
+        errors?: Array<ValidationError>;
+    };
 }
 
-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>>;
+    unwrap(): Child;
+    isOfType(input: unknown): input is Array<Output>;
+    protected getSubInputs(input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
 }
 
 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;
+    isOfType(input: unknown): input is Output | undefined;
+    protected getSubInputs(input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
+    protected parseSubItems(input: unknown, options?: ValidationOptions): {
+        input: unknown;
+        errors?: Array<ValidationError>;
+    };
 }
 
 declare class SchemaNumber extends SchemaItem<number> {
@@ -244,10 +285,12 @@ 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>>;
     isOfType(input: unknown): input is ModelInfer<T>;
+    protected getSubInputs(input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
 }
 
 declare class SchemaString extends SchemaItem<string> {
@@ -285,26 +328,97 @@ 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);
+    isOfType(input: unknown): input is Outputs;
+    protected parseSubItems(input: unknown, options?: ValidationOptions): {
+        input: unknown;
+        errors?: Array<ValidationError>;
+    };
+}
+
+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);
+    isOfType(input: unknown): input is Outputs;
+    protected parseSubItems(input: unknown, options?: ValidationOptions): {
+        input: unknown;
+        errors?: Array<ValidationError>;
+    };
+}
+
+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;
+    isOfType(input: unknown): input is Output;
+    protected getSubInputs(input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
+}
+
+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 Array<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 Array<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);
+    isOfType(input: unknown): input is Outputs;
+    protected getSubInputs(input: unknown): Array<{
+        item: SchemaItem;
+        value: unknown;
+        path: string | undefined;
+    }>;
+}
+
+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 parseQuery<T extends SchemaItem>(schema: T, query: URLSearchParams, opts?: Parameters<T['parse']>[1]): ReturnType<T['parse']>;
+/**
+ * (Note: be carefull : missing key/value associated to schema "s.boolean().nullable" or "s.boolean()" will be transform into false)
+ */
+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 +428,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 +458,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 Array<SchemaItem>>(...inputs: ConstructorParameters<typeof SchemaIntersection<Type>>): SchemaIntersection<Type>;
+    static tuple<Items extends Array<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 +488,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 };