@regle/core 0.0.5-beta.0 → 0.0.6

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 import * as vue from 'vue';
-import { MaybeRef, Ref } from 'vue';
-import { PartialDeep } from 'type-fest';
+import { MaybeRef, Ref, ComputedRef } from 'vue';
+import { DeepMaybeRef as DeepMaybeRef$1 } from 'types/utils';
 
 type ArrayElement<T> = T extends Array<infer U> ? U : never;
 type ExcludeFromTuple<T extends readonly any[], E> = T extends [infer F, ...infer R] ? [NonNullable<F>] extends [E] ? ExcludeFromTuple<R, E> : [Exclude<F, E>, ...ExcludeFromTuple<R, E>] : [];
@@ -27,6 +27,21 @@ type DefaultValidators = {
     maxLength: RegleRuleWithParamsDefinition<string, [count: number]>;
     required: RegleRuleDefinition<unknown, []>;
     requiredIf: RegleRuleWithParamsDefinition<unknown, [condition: boolean]>;
+    alpha: RegleRuleDefinition<string>;
+    alphaNum: RegleRuleDefinition<string | number>;
+    between: RegleRuleWithParamsDefinition<number, [min: number, max: number]>;
+    decimal: RegleRuleDefinition<number | string>;
+    email: RegleRuleDefinition<string>;
+    integer: RegleRuleDefinition<number | string>;
+    maxValue: RegleRuleWithParamsDefinition<number, [count: number]>;
+    minLength: RegleRuleWithParamsDefinition<string | Record<PropertyKey, any> | any[], [
+        count: number
+    ]>;
+    minValue: RegleRuleWithParamsDefinition<number, [count: number]>;
+    numeric: RegleRuleDefinition<number | string>;
+    requireUnless: RegleRuleWithParamsDefinition<unknown, [condition: boolean]>;
+    sameAs: RegleRuleWithParamsDefinition<unknown, [target: unknown]>;
+    url: RegleRuleDefinition<string>;
 };
 
 type ParamDecl<T = any> = MaybeRef<T> | (() => T);
@@ -170,7 +185,21 @@ type RegleCollectionErrors<TRule extends RegleFormPropertyType<any, any> | undef
     readonly $errors: string[];
     readonly $each: RegleValidationErrors<TRule>[];
 };
-type PossibleRegleErrors = RegleCollectionErrors<any> | string[] | RegleErrorTree<any>;
+/**
+ * @internal
+ */
+type $InternalRegleErrors = RegleCollectionErrors<any> | string[] | RegleErrorTree<any>;
+type RegleExternalErrorTree<TState extends Record<string, any> = Record<string, any>> = {
+    [K in keyof TState]?: RegleExternalValidationErrors<TState[K]>;
+};
+type RegleExternalValidationErrors<TValue extends any> = [NonNullable<TValue>] extends [
+    never
+] ? string[] : TValue extends Array<infer U> ? RegleExternalCollectionErrors<U> : NonNullable<TValue> extends Date ? string[] : NonNullable<TValue> extends File ? string[] : TValue extends Record<string, any> ? RegleExternalErrorTree<TValue> : string[];
+type RegleExternalCollectionErrors<TValue extends any = any> = {
+    $errors?: string[];
+    $each?: RegleExternalValidationErrors<TValue>[];
+};
+type $InternalExternalRegleErrors = RegleExternalCollectionErrors<any> | string[] | RegleExternalErrorTree<any>;
 type DataType = string | number | Record<string, any> | File | Array<any> | Date | null | undefined;
 
 /**
@@ -204,6 +233,7 @@ type $InternalRegleStatusType = $InternalRegleCollectionStatus | RegleCommonStat
  */
 interface RegleFieldStatus<TRules extends RegleFormPropertyType<any, Partial<AllRulesDeclarations>> = Record<string, any>, TState extends Record<PropertyKey, any> = any, TKey extends PropertyKey = string> extends RegleCommonStatus<TState> {
     $value: TState[TKey];
+    readonly $externalErrors?: string[];
     readonly $rules: {
         readonly [TRuleKey in keyof TRules]: RegleRuleStatus<TState[TKey], TRules[TRuleKey] extends RegleRuleDefinition<any, infer TParams> ? TParams : []>;
     };
@@ -215,6 +245,7 @@ interface RegleFieldStatus<TRules extends RegleFormPropertyType<any, Partial<All
 interface $InternalRegleFieldStatus extends RegleCommonStatus {
     $value: any;
     $rules: Record<string, $InternalRegleRuleStatus>;
+    $externalErrors?: string[];
 }
 /**
  * @public
@@ -233,6 +264,7 @@ interface RegleCommonStatus<TValue = any> {
     $validate(): Promise<boolean>;
     $unwatch(): void;
     $watch(): void;
+    $clearExternalErrors(): void;
 }
 /**
  * @public
@@ -254,17 +286,19 @@ type RegleRuleStatus<TValue = any, TParams extends any[] = any[]> = {
  * @reference {@link RegleRuleStatus}
  */
 interface $InternalRegleRuleStatus {
-    readonly $type: string;
-    readonly $message: string;
-    readonly $active: boolean;
-    readonly $valid: boolean;
-    readonly $pending: boolean;
-    readonly $path: string;
+    $type: string;
+    $message: string;
+    $active: boolean;
+    $valid: boolean;
+    $pending: boolean;
+    $path: string;
+    $externalErrors?: string[];
+    $params?: any[];
     $validator(value: any, ...args: any[]): boolean | Promise<boolean>;
     $validate(): Promise<boolean>;
     $unwatch(): void;
     $watch(): void;
-    readonly $params?: any[];
+    $clearExternalErrors(): void;
 }
 /**
  * @public
@@ -287,13 +321,249 @@ interface $InternalRegleCollectionStatus extends Omit<$InternalRegleStatus, '$fi
     };
 }
 
+/**
+Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+
+@category Type
+*/
+type Primitive =
+	| null
+	| undefined
+	| string
+	| number
+	| boolean
+	| symbol
+	| bigint;
+
+declare global {
+	// eslint-disable-next-line @typescript-eslint/consistent-type-definitions -- It has to be an `interface` so that it can be merged.
+	interface SymbolConstructor {
+		readonly observable: symbol;
+	}
+}
+
+/**
+Matches any primitive, `Date`, or `RegExp` value.
+*/
+type BuiltIns = Primitive | Date | RegExp;
+
+/**
+Test if the given function has multiple call signatures.
+
+Needed to handle the case of a single call signature with properties.
+
+Multiple call signatures cannot currently be supported due to a TypeScript limitation.
+@see https://github.com/microsoft/TypeScript/issues/29732
+*/
+type HasMultipleCallSignatures<T extends (...arguments_: any[]) => unknown> =
+	T extends {(...arguments_: infer A): unknown; (...arguments_: any[]): unknown}
+		? unknown[] extends A
+			? false
+			: true
+		: false;
+
+/**
+@see PartialDeep
+*/
+type PartialDeepOptions = {
+	/**
+	Whether to affect the individual elements of arrays and tuples.
+
+	@default false
+	*/
+	readonly recurseIntoArrays?: boolean;
+};
+
+/**
+Create a type from another type with all keys and nested keys set to optional.
+
+Use-cases:
+- Merging a default settings/config object with another object, the second object would be a deep partial of the default object.
+- Mocking and testing complex entities, where populating an entire object with its keys would be redundant in terms of the mock or test.
+
+@example
+```
+import type {PartialDeep} from 'type-fest';
+
+const settings: Settings = {
+	textEditor: {
+		fontSize: 14;
+		fontColor: '#000000';
+		fontWeight: 400;
+	}
+	autocomplete: false;
+	autosave: true;
+};
+
+const applySavedSettings = (savedSettings: PartialDeep<Settings>) => {
+	return {...settings, ...savedSettings};
+}
+
+settings = applySavedSettings({textEditor: {fontWeight: 500}});
+```
+
+By default, this does not affect elements in array and tuple types. You can change this by passing `{recurseIntoArrays: true}` as the second type argument:
+
+```
+import type {PartialDeep} from 'type-fest';
+
+interface Settings {
+	languages: string[];
+}
+
+const partialSettings: PartialDeep<Settings, {recurseIntoArrays: true}> = {
+	languages: [undefined]
+};
+```
+
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type PartialDeep<T, Options extends PartialDeepOptions = {}> = T extends BuiltIns
+	? T
+	: T extends Map<infer KeyType, infer ValueType>
+		? PartialMapDeep<KeyType, ValueType, Options>
+		: T extends Set<infer ItemType>
+			? PartialSetDeep<ItemType, Options>
+			: T extends ReadonlyMap<infer KeyType, infer ValueType>
+				? PartialReadonlyMapDeep<KeyType, ValueType, Options>
+				: T extends ReadonlySet<infer ItemType>
+					? PartialReadonlySetDeep<ItemType, Options>
+					: T extends ((...arguments_: any[]) => unknown)
+						? T | undefined
+						: T extends object
+							? T extends ReadonlyArray<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+								? Options['recurseIntoArrays'] extends true
+									? ItemType[] extends T // Test for arrays (non-tuples) specifically
+										? readonly ItemType[] extends T // Differentiate readonly and mutable arrays
+											? ReadonlyArray<PartialDeep<ItemType | undefined, Options>>
+											: Array<PartialDeep<ItemType | undefined, Options>>
+										: PartialObjectDeep<T, Options> // Tuples behave properly
+									: T // If they don't opt into array testing, just use the original type
+								: PartialObjectDeep<T, Options>
+							: unknown;
+
+/**
+Same as `PartialDeep`, but accepts only `Map`s and as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & Map<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `Set`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialSetDeep<T, Options extends PartialDeepOptions> = {} & Set<PartialDeep<T, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlyMap`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlyMapDeep<KeyType, ValueType, Options extends PartialDeepOptions> = {} & ReadonlyMap<PartialDeep<KeyType, Options>, PartialDeep<ValueType, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `ReadonlySet`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialReadonlySetDeep<T, Options extends PartialDeepOptions> = {} & ReadonlySet<PartialDeep<T, Options>>;
+
+/**
+Same as `PartialDeep`, but accepts only `object`s as inputs. Internal helper for `PartialDeep`.
+*/
+type PartialObjectDeep<ObjectType extends object, Options extends PartialDeepOptions> = {
+	[KeyType in keyof ObjectType]?: PartialDeep<ObjectType[KeyType], Options>
+};
+
+type ExcludeUndefined<T> = Exclude<T, undefined>;
+
+/**
+Create a type from another type with all keys and nested keys set to required.
+
+Use-cases:
+- Creating optional configuration interfaces where the underlying implementation still requires all options to be fully specified.
+- Modeling the resulting type after a deep merge with a set of defaults.
+
+@example
+```
+import type {RequiredDeep} from 'type-fest';
+
+type Settings = {
+	textEditor?: {
+		fontSize?: number | undefined;
+		fontColor?: string | undefined;
+		fontWeight?: number | undefined;
+	}
+	autocomplete?: boolean | undefined;
+	autosave?: boolean | undefined;
+};
+
+type RequiredSettings = RequiredDeep<Settings>;
+// type RequiredSettings = {
+// 	textEditor: {
+// 		fontSize: number;
+// 		fontColor: string;
+// 		fontWeight: number;
+// 	}
+// 	autocomplete: boolean;
+// 	autosave: boolean;
+// }
+```
+
+Note that types containing overloaded functions are not made deeply required due to a [TypeScript limitation](https://github.com/microsoft/TypeScript/issues/29732).
+
+@category Utilities
+@category Object
+@category Array
+@category Set
+@category Map
+*/
+type RequiredDeep<T, E extends ExcludeUndefined<T> = ExcludeUndefined<T>> = E extends BuiltIns
+	? E
+	: E extends Map<infer KeyType, infer ValueType>
+		? Map<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+		: E extends Set<infer ItemType>
+			? Set<RequiredDeep<ItemType>>
+			: E extends ReadonlyMap<infer KeyType, infer ValueType>
+				? ReadonlyMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+				: E extends ReadonlySet<infer ItemType>
+					? ReadonlySet<RequiredDeep<ItemType>>
+					: E extends WeakMap<infer KeyType, infer ValueType>
+						? WeakMap<RequiredDeep<KeyType>, RequiredDeep<ValueType>>
+						: E extends WeakSet<infer ItemType>
+							? WeakSet<RequiredDeep<ItemType>>
+							: E extends Promise<infer ValueType>
+								? Promise<RequiredDeep<ValueType>>
+								: E extends (...arguments_: any[]) => unknown
+									? {} extends RequiredObjectDeep<E>
+										? E
+										: HasMultipleCallSignatures<E> extends true
+											? E
+											: ((...arguments_: Parameters<E>) => ReturnType<E>) & RequiredObjectDeep<E>
+									: E extends object
+										? E extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
+											? ItemType[] extends E // Test for arrays (non-tuples) specifically
+												? Array<RequiredDeep<ItemType>> // Recreate relevant array type to prevent eager evaluation of circular reference
+												: RequiredObjectDeep<E> // Tuples behave properly
+											: RequiredObjectDeep<E>
+										: unknown;
+
+type RequiredObjectDeep<ObjectType extends object> = {
+	[KeyType in keyof ObjectType]-?: RequiredDeep<ObjectType[KeyType]>
+};
+
 interface Regle<TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree>> {
-    state: Ref<PartialDeep<TState>>;
+    $state: Ref<PartialDeep<TState>>;
     $regle: RegleStatus<TState, TRules>;
-    errors: RegleErrorTree<TRules>;
+    /** Show active errors based on your behaviour options (lazy, autoDirty)
+     * It allow you to skip scouting the `$regle` object
+     */
+    $errors: RegleErrorTree<TRules>;
+    $valid: ComputedRef<boolean>;
+    $invalid: ComputedRef<boolean>;
     resetForm: () => void;
     validateForm: () => Promise<false | DeepSafeFormState<TState, TRules>>;
 }
+type DeepReactiveState<T extends Record<string, any>> = {
+    [K in keyof T]: MaybeRef<T[K]>;
+};
 type DeepSafeFormState<TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree>> = {
     [K in keyof TState as [SafeProperty<TState[K], TRules[K]>] extends [never] ? K : never]?: [
         SafeProperty<TState[K], TRules[K]>
@@ -320,6 +590,10 @@ interface RegleBehaviourOptions {
      */
     rewardEarly?: boolean;
 }
+interface LocalRegleBehaviourOptions<TState extends Record<string, any>> {
+    $externalErrors?: MaybeRef<RegleExternalErrorTree<TState>>;
+}
+type ResolvedRegleBehaviourOptions = DeepMaybeRef$1<RequiredDeep<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<Record<string, any>>;
 
 declare function createRule<TValue extends any, TParams extends any[] = [], TType extends string = string>(definition: RegleRuleInit<TValue, TParams, TType>): InferRegleRule<TValue, TParams>;
 
@@ -339,6 +613,6 @@ declare function unwrapRuleParameters<TParams extends any[]>(params: ParamDecl[]
 declare function defineRegleOptions<TCustomRules extends Partial<AllRulesDeclarations>>({ rules, options, }: {
     rules?: () => TCustomRules;
     options?: RegleBehaviourOptions;
-}): <TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, Partial<AllRulesDeclarations> & TCustomRules>>(state: vue.Ref<TState>, rulesFactory: vue.ComputedRef<TRules> | (() => TRules), options?: Partial<DeepMaybeRef<Required<RegleBehaviourOptions>>> | undefined) => Regle<TState, TRules>;
+}): <TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, Partial<AllRulesDeclarations> & TCustomRules>>(state: vue.Ref<TState> | DeepReactiveState<TState>, rulesFactory: vue.ComputedRef<TRules> | (() => TRules), options?: (Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<TState>) | undefined) => Regle<TState, TRules>;
 
-export { $InternalFormPropertyTypes, $InternalRegleCollectionRuleDecl, $InternalRegleCollectionStatus, $InternalRegleFieldStatus, $InternalReglePartialValidationTree, $InternalRegleRuleDecl, $InternalRegleRuleStatus, $InternalRegleStatus, $InternalRegleStatusType, AllRulesDeclarations, ArrayElement, CustomRulesDeclarationTree, DataType, DeepMaybeRef, ExcludeFromTuple, FormRuleDeclaration, InferRegleRule, InferRegleStatusType, InlineRuleDeclaration, InternalRuleType, Maybe, MaybeNull, ParamDecl, PossibleRegleErrors, Regle, RegleBehaviourOptions, RegleCollectionErrors, RegleCollectionRuleDecl, RegleCollectionRuleDefinition, RegleCollectionStatus, RegleCommonStatus, RegleErrorTree, RegleFieldStatus, RegleFormPropertyType, RegleInternalRuleDefs, ReglePartialValidationTree, RegleRuleDecl, RegleRuleDefinition, RegleRuleDefinitionProcessor, RegleRuleInit, RegleRuleRaw, RegleRuleStatus, RegleRuleWithParamsDefinition, RegleStatus, RegleUniversalParams, RegleValidationErrors, UnrefTuple, UnwrapRegleUniversalParams, createRule, defineRegleOptions, unwrapRuleParameters };
+export { $InternalExternalRegleErrors, $InternalFormPropertyTypes, $InternalRegleCollectionRuleDecl, $InternalRegleCollectionStatus, $InternalRegleErrors, $InternalRegleFieldStatus, $InternalReglePartialValidationTree, $InternalRegleRuleDecl, $InternalRegleRuleStatus, $InternalRegleStatus, $InternalRegleStatusType, AllRulesDeclarations, ArrayElement, CustomRulesDeclarationTree, DataType, DeepMaybeRef, ExcludeFromTuple, FormRuleDeclaration, InferRegleRule, InferRegleStatusType, InlineRuleDeclaration, InternalRuleType, LocalRegleBehaviourOptions, Maybe, MaybeNull, ParamDecl, Regle, RegleBehaviourOptions, RegleCollectionErrors, RegleCollectionRuleDecl, RegleCollectionRuleDefinition, RegleCollectionStatus, RegleCommonStatus, RegleErrorTree, RegleExternalCollectionErrors, RegleExternalErrorTree, RegleExternalValidationErrors, RegleFieldStatus, RegleFormPropertyType, RegleInternalRuleDefs, ReglePartialValidationTree, RegleRuleDecl, RegleRuleDefinition, RegleRuleDefinitionProcessor, RegleRuleInit, RegleRuleRaw, RegleRuleStatus, RegleRuleWithParamsDefinition, RegleStatus, RegleUniversalParams, RegleValidationErrors, ResolvedRegleBehaviourOptions, UnrefTuple, UnwrapRegleUniversalParams, createRule, defineRegleOptions, unwrapRuleParameters };