@regle/core 0.1.5 → 0.1.7

package/dist/index.d.cts

@@ -0,0 +1,485 @@
+import * as vue from 'vue';
+import { MaybeRef, Ref, ComputedRef, UnwrapNestedRefs } from 'vue';
+
+type Maybe<T = any> = T | null | undefined;
+type MaybeGetter<T, V = any> = T | ((value: Ref<V>, index: number) => T);
+type ExtractFromGetter<T extends MaybeGetter<any, any>> = T extends MaybeGetter<infer U, any> ? U : never;
+type DeepMaybeRef<T extends Record<string, any>> = {
+    [K in keyof T]: MaybeRef<T[K]>;
+};
+type ExcludeByType<T, U> = {
+    [K in keyof T as T[K] extends U ? never : K]: T[K] extends U ? never : T[K];
+};
+type NonPresentKeys<TSource extends Record<string, any>, Target extends Record<string, any>> = Omit<Target, keyof TSource>;
+
+type ArrayElement<T> = T extends Array<infer U> ? U : never;
+
+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;
+	}
+}
+
+declare const emptyObjectSymbol: unique symbol;
+
+/**
+Represents a strictly empty plain object, the `{}` value.
+
+When you annotate something as the type `{}`, it can be anything except `null` and `undefined`. This means that you cannot use `{}` to represent an empty plain object ([read more](https://stackoverflow.com/questions/47339869/typescript-empty-object-and-any-difference/52193484#52193484)).
+
+@example
+```
+import type {EmptyObject} from 'type-fest';
+
+// The following illustrates the problem with `{}`.
+const foo1: {} = {}; // Pass
+const foo2: {} = []; // Pass
+const foo3: {} = 42; // Pass
+const foo4: {} = {a: 1}; // Pass
+
+// With `EmptyObject` only the first case is valid.
+const bar1: EmptyObject = {}; // Pass
+const bar2: EmptyObject = 42; // Fail
+const bar3: EmptyObject = []; // Fail
+const bar4: EmptyObject = {a: 1}; // Fail
+```
+
+Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<never, never>` do not work. See {@link https://github.com/sindresorhus/type-fest/issues/395 #395}.
+
+@category Object
+*/
+type EmptyObject = {[emptyObjectSymbol]?: never};
+
+interface RegleBehaviourOptions {
+    /**
+     * Only display error when calling `validateState()`
+     * @default false
+     */
+    lazy?: boolean;
+    /**
+     * Automaticaly set the dirty set without the need of `$value` or `$touch`
+     * @default true
+     */
+    autoDirty?: boolean;
+    /**
+     * The fields will turn valid when they are, but not invalid unless calling `validateState()`
+     * @default false
+     *
+     * @experimental report any bug
+     */
+    rewardEarly?: boolean;
+}
+interface LocalRegleBehaviourOptions<TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree>, TExternal extends RegleExternalErrorTree<TState>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>> {
+    externalErrors?: MaybeRef<TExternal>;
+    validationGroups?: (fields: RegleStatus<TState, TRules>['$fields']) => TValidationGroups;
+}
+type RegleValidationGroupEntry = RegleFieldStatus<any, any, any>;
+interface RegleValidationGroupOutput {
+    $invalid: boolean;
+    $error: boolean;
+    $pending: boolean;
+    $dirty: boolean;
+    $valid: boolean;
+    $errors: string[];
+    $silentErrors: string[];
+}
+type FieldRegleBehaviourOptions = AddDollarToOptions<RegleBehaviourOptions> & {
+    $debounce?: number;
+};
+type AddDollarToOptions<T extends Record<string, any>> = {
+    [K in keyof T as `$${string & K}`]: T[K];
+};
+
+interface Regle<TState extends Record<string, any> = EmptyObject, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree> = EmptyObject, TExternal extends RegleExternalErrorTree<TState> = never, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = never> {
+    regle: RegleStatus<TState, TRules, TValidationGroups>;
+    r$: RegleStatus<TState, TRules, TValidationGroups>;
+    /** Show active errors based on your behaviour options (lazy, autoDirty)
+     * It allow you to skip scouting the `regle` object
+     */
+    errors: RegleErrorTree<TRules, TExternal>;
+    ready: ComputedRef<boolean>;
+    resetAll: () => void;
+    validateState: () => Promise<false | DeepSafeFormState<TState, TRules>>;
+    state: Ref<TState>;
+}
+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>> = [unknown] extends [TState] ? {} : {
+    [K in keyof TState as [SafeProperty<TState[K], TRules[K]>] extends [never] ? K : never]?: [
+        SafeProperty<TState[K], TRules[K]>
+    ] extends [never] ? TState[K] : SafeProperty<TState[K], TRules[K]>;
+} & {
+    [K in keyof TState as [SafeProperty<TState[K], TRules[K]>] extends [never] ? never : K]-?: SafeProperty<TState[K], TRules[K]>;
+};
+type SafeProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends RegleCollectionRuleDefinition<any, any> ? TState extends Array<any> ? SafeProperty<TState[number], ExtractFromGetter<TRule['$each']>>[] : never : TRule extends ReglePartialValidationTree<any, any> ? TState extends Record<string, any> ? DeepSafeFormState<TState, TRule> : TRule extends RegleRuleDecl<any, any> ? unknown extends TRule['required'] ? never : TRule['required'] extends undefined ? never : TRule['required'] extends RegleRuleDefinition<any, infer Params, any, any, any> ? Params extends never[] ? TState : never : never : never : never;
+
+type ParamDecl<T = any> = MaybeRef<Maybe<T>> | (() => Maybe<T>);
+type CreateFn<T extends any[]> = (...args: T) => any;
+/**
+ * Transform normal parameters tuple declaration to a rich tuple declaration
+ *
+ * [foo: string, bar?: number] => [foo: MaybeRef<string> | (() => string), bar?: MaybeRef<number | undefined> | (() => number) | undefined]
+ */
+type RegleUniversalParams<T extends any[] = [], F = CreateFn<T>> = [T] extends [[]] ? [] : Parameters<F extends (...args: infer Args) => any ? (...args: {
+    [K in keyof Args]: ParamDecl<Args[K]>;
+}) => any : never>;
+type UnwrapRegleUniversalParams<T extends ParamDecl[] = [], F = CreateFn<T>> = [T] extends [
+    [
+    ]
+] ? [] : Parameters<F extends (...args: infer Args) => any ? (...args: {
+    [K in keyof Args]: Args[K] extends ParamDecl<infer U> ? U : Args[K];
+}) => any : never>;
+
+/**
+ * Internal definition of the rule, can be used to reset or patch the rule
+ */
+interface RegleInternalRuleDefs<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean> {
+    _validator: (value: Maybe<TValue>, ...args: TParams) => TAsync extends false ? TMetadata : Promise<TMetadata>;
+    _message: string | string[] | ((value: Maybe<TValue>, metadata: PossibleRegleRuleMetadataConsumer) => string | string[]);
+    _active?: boolean | ((value: Maybe<TValue>, metadata: PossibleRegleRuleMetadataConsumer) => boolean);
+    _type?: string;
+    _patched: boolean;
+    _params?: RegleUniversalParams<TParams>;
+    _async: TAsync;
+}
+declare enum InternalRuleType {
+    Inline = "__inline",
+    Async = "__async"
+}
+
+/**
+ * Returned typed of rules created with `createRule`
+ * */
+interface RegleRuleDefinition<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = boolean, TMetaData extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TFilteredValue extends any = TValue extends Date & File & infer M ? M : TValue> extends RegleInternalRuleDefs<TFilteredValue, TParams, TAsync, TMetaData> {
+    validator: RegleRuleDefinitionProcessor<TFilteredValue, TParams, TAsync extends false ? TMetaData : Promise<TMetaData>>;
+    message: RegleRuleDefinitionWithMetadataProcessor<TFilteredValue, PossibleRegleRuleMetadataConsumer, string | string[]>;
+    active: RegleRuleDefinitionWithMetadataProcessor<TFilteredValue, PossibleRegleRuleMetadataConsumer, boolean>;
+    type?: string;
+    exec: (value: Maybe<TFilteredValue>) => TAsync extends false ? TMetaData : Promise<TMetaData>;
+}
+/**
+ * Rules with params created with `createRules` are callable while being customizable
+ */
+interface RegleRuleWithParamsDefinition<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean> extends RegleRuleCore<TValue, TParams, TAsync, TMetadata>, RegleInternalRuleDefs<TValue, TParams, TAsync, TMetadata> {
+    (...params: RegleUniversalParams<TParams>): RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;
+}
+type RegleRuleMetadataExtended = {
+    $valid: boolean;
+    [x: string]: any;
+};
+/**
+ * Define a rule Metadata definition
+ */
+type RegleRuleMetadataDefinition = RegleRuleMetadataExtended | boolean;
+type DefaultMetadataProperties = Pick<ExcludeByType<RegleCommonStatus, Function>, '$invalid'>;
+/**
+ * Will be used to consumme metadata on related helpers and rule status
+ */
+type RegleRuleMetadataConsumer<TParams extends any[] = never, TMetadata extends RegleRuleMetadataDefinition = boolean> = DefaultMetadataProperties & (TParams extends never ? {} : {
+    $params: TParams;
+}) & (Exclude<TMetadata, boolean> extends RegleRuleMetadataExtended ? TMetadata extends boolean ? Partial<Omit<Exclude<TMetadata, boolean>, '$valid'>> : Omit<Exclude<TMetadata, boolean>, '$valid'> : {});
+/**
+ * Will be used to consumme metadata on related helpers and rule status
+ */
+type PossibleRegleRuleMetadataConsumer = DefaultMetadataProperties & {
+    $params?: any[];
+};
+/**
+ * Generic types for a created RegleRule
+ */
+type RegleRuleRaw<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetaData extends RegleRuleMetadataDefinition = boolean> = RegleRuleDefinition<TValue, TParams, TAsync, TMetaData> | RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetaData>;
+/**
+ * Process the type of a created rule with `createRule`.
+ * For a rule with params it will return a function
+ * Otherwise it will return the rule definition
+ */
+type InferRegleRule<TValue extends any = any, TParams extends any[] = [], TAsync extends boolean = false, TMetaData extends RegleRuleMetadataDefinition = boolean> = [TParams] extends [[]] ? RegleRuleDefinition<TValue, TParams, TAsync, TMetaData> : RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetaData>;
+type RegleRuleDefinitionProcessor<TValue extends any = any, TParams extends any[] = [], TReturn = any> = (value: Maybe<TValue>, ...params: TParams) => TReturn;
+type RegleRuleDefinitionWithMetadataProcessor<TValue extends any, TMetadata extends RegleRuleMetadataConsumer<any, any>, TReturn = any> = ((value: Maybe<TValue>, metadata: TMetadata) => TReturn) | TReturn;
+type RegleCollectionRuleDefinition<TValue = any[], TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = (RegleRuleDecl<NonNullable<TValue>, TCustomRules> & {
+    $each: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>>;
+}) | {
+    $each: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>>;
+};
+
+/**
+ * @argument
+ * createRule arguments options
+ */
+interface RegleRuleInit<TValue extends any, TParams extends [...any[]] = [], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = boolean, TMetadata extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TAsync extends boolean = TReturn extends Promise<any> ? true : false> {
+    type?: string;
+    validator: (value: Maybe<TValue>, ...args: TParams) => TReturn;
+    message: string | string[] | ((value: Maybe<TValue>, metadata: RegleRuleMetadataConsumer<TParams, TMetadata>) => string | string[]);
+    active?: boolean | ((value: Maybe<TValue>, metadata: RegleRuleMetadataConsumer<TParams, TMetadata>) => boolean);
+}
+/**
+ * @argument
+ * Rule core
+ */
+interface RegleRuleCore<TValue extends any, TParams extends any[] = [], TAsync extends boolean = false, TMetadata extends RegleRuleMetadataDefinition = boolean> {
+    validator: (value: Maybe<TValue>, ...args: TParams) => TAsync extends false ? TMetadata : Promise<TMetadata>;
+    message: string | ((value: Maybe<TValue>, metadata: RegleRuleMetadataConsumer<TParams, TMetadata>) => string | string[]);
+    active?: boolean | ((value: Maybe<TValue>, metadata: RegleRuleMetadataConsumer<TParams, TMetadata>) => boolean);
+    type?: string;
+}
+
+type DefaultValidators = {
+    alpha: RegleRuleDefinition<string>;
+    alphaNum: RegleRuleDefinition<string | number>;
+    between: RegleRuleWithParamsDefinition<number, [min: Maybe<number>, max: Maybe<number>]>;
+    checked: RegleRuleDefinition<boolean, [], false, boolean, boolean>;
+    contains: RegleRuleWithParamsDefinition<string, [part: Maybe<string>], false, boolean>;
+    dateAfter: RegleRuleWithParamsDefinition<string | Date, [
+        after: Maybe<string | Date>
+    ], false, true | {
+        $valid: false;
+        error: 'date-not-after';
+    } | {
+        $valid: false;
+        error: 'value-or-paramater-not-a-date';
+    }>;
+    dateBefore: RegleRuleWithParamsDefinition<string | Date, [
+        before: Maybe<string | Date>
+    ], false, true | {
+        $valid: false;
+        error: 'date-not-before';
+    } | {
+        $valid: false;
+        error: 'value-or-paramater-not-a-date';
+    }>;
+    dateBetween: RegleRuleWithParamsDefinition<string | Date, [
+        before: Maybe<string | Date>,
+        after: Maybe<string | Date>
+    ], false, boolean>;
+    decimal: RegleRuleDefinition<string | number, [], false, boolean, string | number>;
+    email: RegleRuleDefinition<string, [], false, boolean, string>;
+    endsWith: RegleRuleWithParamsDefinition<string, [part: Maybe<string>], false, boolean>;
+    exactLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [
+        count: number
+    ], false, boolean>;
+    integer: RegleRuleDefinition<string | number, [], false, boolean, string | number>;
+    ipAddress: RegleRuleDefinition<string, [], false, boolean, string>;
+    macAddress: RegleRuleWithParamsDefinition<string, [
+        separator?: string | undefined
+    ], false, boolean>;
+    maxLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [
+        count: number
+    ], false, boolean>;
+    maxValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean>;
+    minLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [
+        count: number
+    ], false, boolean>;
+    minValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean>;
+    numeric: RegleRuleDefinition<string | number, [], false, boolean, string | number>;
+    regex: RegleRuleWithParamsDefinition<string, [regexp: RegExp], false, boolean>;
+    required: RegleRuleDefinition<unknown, []>;
+    sameAs: RegleRuleWithParamsDefinition<unknown, [target: unknown], false, boolean>;
+    startsWith: RegleRuleWithParamsDefinition<string, [part: Maybe<string>], false, boolean>;
+    url: RegleRuleDefinition<string, [], false, boolean, string>;
+};
+
+type CustomRulesDeclarationTree = {
+    [x: string]: RegleRuleRaw<any, any, boolean, any> | undefined;
+};
+type AllRulesDeclarations = CustomRulesDeclarationTree & DefaultValidators;
+
+/**
+ * @public
+ */
+type ReglePartialValidationTree<TForm extends Record<string, any>, TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = {
+    [TKey in keyof TForm]?: RegleFormPropertyType<TForm[TKey], TCustomRules>;
+};
+/**
+ * @public
+ */
+type RegleValidationTree<TForm extends Record<string, any>, TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = {
+    [TKey in keyof TForm]: RegleFormPropertyType<TForm[TKey], TCustomRules>;
+};
+/**
+ * @public
+ */
+type RegleComputedRules<TForm extends MaybeRef<Record<string, any>>, TCustomRules extends Partial<AllRulesDeclarations> | Regle<any, any> = Partial<AllRulesDeclarations>, TState = TForm extends Ref<infer R> ? R : TForm, TCustom = TCustomRules extends Regle<any, infer R> ? R extends ReglePartialValidationTree<any, infer C> ? C : Partial<AllRulesDeclarations> : TCustomRules> = {
+    [TKey in keyof TState]?: RegleFormPropertyType<TState[TKey], TCustom extends Partial<AllRulesDeclarations> ? TCustom : {}>;
+};
+/**
+ * @public
+ */
+type RegleFormPropertyType<TValue = any, TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = [NonNullable<TValue>] extends [never] ? RegleRuleDecl<TValue, TCustomRules> : NonNullable<TValue> extends Array<any> ? RegleCollectionRuleDecl<TValue, TCustomRules> : NonNullable<TValue> extends Date ? RegleRuleDecl<NonNullable<TValue>, TCustomRules> : NonNullable<TValue> extends File ? RegleRuleDecl<NonNullable<TValue>, TCustomRules> : NonNullable<TValue> extends Ref<infer V> ? RegleFormPropertyType<V, TCustomRules> : NonNullable<TValue> extends Record<string, any> ? ReglePartialValidationTree<NonNullable<TValue>, TCustomRules> : RegleRuleDecl<NonNullable<TValue>, TCustomRules>;
+/**
+ * @public
+ * Rule tree for a form property
+ */
+type RegleRuleDecl<TValue extends any = any, TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = FieldRegleBehaviourOptions & {
+    [TKey in keyof TCustomRules]?: NonNullable<TCustomRules[TKey]> extends RegleRuleWithParamsDefinition<any, infer TParams> ? RegleRuleDefinition<TValue, TParams, boolean> : NonNullable<TCustomRules[TKey]> extends RegleRuleDefinition<any, any, any, any> ? FormRuleDeclaration<TValue, any> : FormRuleDeclaration<TValue, any> | FieldRegleBehaviourOptions[keyof FieldRegleBehaviourOptions];
+};
+/**
+ * @public
+ */
+type RegleCollectionRuleDeclKeyProperty = {
+    $key?: PropertyKey;
+};
+/**
+ * @public
+ */
+type RegleCollectionRuleDecl<TValue = any[], TCustomRules extends Partial<AllRulesDeclarations> = Partial<AllRulesDeclarations>> = (RegleRuleDecl<NonNullable<TValue>, TCustomRules> & {
+    $each?: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules> & RegleCollectionRuleDeclKeyProperty, ArrayElement<TValue>>;
+}) | {
+    $each?: MaybeGetter<RegleFormPropertyType<ArrayElement<NonNullable<TValue>>, TCustomRules>, ArrayElement<TValue>>;
+};
+/**
+ * @public
+ */
+type InlineRuleDeclaration<TValue extends any = any, TParams extends any[] = any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>> = (value: Maybe<TValue>, ...args: UnwrapRegleUniversalParams<TParams>) => TReturn;
+/**
+ * @public
+ * Regroup inline and registered rules
+ * */
+type FormRuleDeclaration<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn, TAsync extends boolean = boolean> = InlineRuleDeclaration<TValue, TParams, TReturn> | RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;
+
+type RegleErrorTree<TRules extends ReglePartialValidationTree<any, any>, TExternal extends RegleExternalErrorTree<Record<string, unknown>> = never> = {
+    readonly [K in keyof TRules]: RegleValidationErrors<TRules[K], K extends keyof TExternal ? TExternal[K] : never>;
+} & {
+    readonly [K in keyof NonPresentKeys<TRules, TExternal>]: RegleExternalValidationErrorsReport<TExternal[K]>;
+};
+type RegleValidationErrors<TRule extends RegleFormPropertyType<any, any> | undefined = never, TExternalError extends RegleExternalValidationErrors<any> | undefined = never> = TRule extends RegleCollectionRuleDefinition ? RegleCollectionErrors<ExtractFromGetter<TRule['$each']>, TExternalError extends RegleExternalCollectionErrors ? ArrayElement<TExternalError['$each']> : never> : TRule extends RegleRuleDecl<any, any> ? string[] : TRule extends ReglePartialValidationTree<any, any> ? RegleErrorTree<TRule, TExternalError extends RegleExternalErrorTree ? TExternalError : never> : string[];
+type RegleCollectionErrors<TRule extends RegleFormPropertyType<any, any> | undefined = never, TExternalError extends RegleExternalValidationErrors<any> | undefined = never> = {
+    readonly $errors: string[];
+    readonly $each: RegleValidationErrors<TRule, TExternalError>[];
+};
+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 RegleExternalValidationErrorsReport<TExternalError extends RegleExternalValidationErrors<any> | undefined = never> = TExternalError extends RegleExternalCollectionErrors ? RegleCollectionErrors<TExternalError['$each']> : TExternalError extends string[] ? string[] : TExternalError extends RegleExternalErrorTree<any> ? RegleErrorTree<TExternalError> : string[];
+
+/**
+ * @public
+ */
+type RegleStatus<TState extends Record<string, any> = Record<string, any>, TRules extends ReglePartialValidationTree<TState> = Record<string, any>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = never> = RegleCommonStatus<TState> & {
+    readonly $fields: {
+        readonly [TKey in keyof TRules]: InferRegleStatusType<NonNullable<TRules[TKey]>, TState, TKey>;
+    };
+    readonly $errors: RegleErrorTree<TRules>;
+    readonly $silentErrors: RegleErrorTree<TRules>;
+} & ([TValidationGroups] extends [never] ? {} : {
+    $groups: {
+        readonly [TKey in keyof TValidationGroups]: RegleValidationGroupOutput;
+    };
+});
+/**
+ * @public
+ */
+type InferRegleStatusType<TRule extends RegleCollectionRuleDecl | RegleRuleDecl | ReglePartialValidationTree<any>, TState extends Record<PropertyKey, any> = any, TKey extends PropertyKey = string> = TRule extends RegleCollectionRuleDefinition<any, any> ? NonNullable<TState[TKey]> extends Array<Record<string, any> | any> ? ExtractFromGetter<TRule['$each']> extends RegleRuleDecl | ReglePartialValidationTree<any> ? RegleCollectionStatus<ExtractFromGetter<TRule['$each']>, TState[TKey], TRule> : never : RegleFieldStatus<TRule, TState, TKey> : TRule extends ReglePartialValidationTree<any> ? NonNullable<TState[TKey]> extends Array<any> ? RegleCommonStatus<TState[TKey]> : NonNullable<TState[TKey]> extends Record<PropertyKey, any> ? RegleStatus<TState[TKey], TRule> : RegleFieldStatus<TRule, TState, TKey> : RegleFieldStatus<TRule, TState, TKey>;
+/**
+ * @public
+ */
+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: UnwrapNestedRefs<TState[TKey]>;
+    readonly $errors: string[];
+    readonly $silentErrors: string[];
+    readonly $externalErrors?: string[];
+    readonly $rules: {
+        readonly [TRuleKey in keyof Omit<TRules, '$each' | keyof FieldRegleBehaviourOptions>]: RegleRuleStatus<TState[TKey], TRules[TRuleKey] extends RegleRuleDefinition<any, infer TParams, any> ? TParams : [], TRules[TRuleKey] extends RegleRuleDefinition<any, any, any, infer TMetadata> ? TMetadata : TRules[TRuleKey] extends InlineRuleDeclaration<any, any[], infer TMetadata> ? TMetadata extends Promise<infer P> ? P : TMetadata : never>;
+    };
+}
+/**
+ * @public
+ */
+interface RegleCommonStatus<TValue = any> {
+    readonly $valid: boolean;
+    readonly $invalid: boolean;
+    readonly $dirty: boolean;
+    readonly $anyDirty: boolean;
+    readonly $pending: boolean;
+    readonly $error: boolean;
+    $id?: string;
+    $value: UnwrapNestedRefs<TValue>;
+    $touch(): void;
+    $reset(): void;
+    $validate(): Promise<boolean>;
+    $unwatch(): void;
+    $watch(): void;
+    $clearExternalErrors(): void;
+}
+/**
+ * @public
+ */
+type RegleRuleStatus<TValue = any, TParams extends any[] = any[], TMetadata extends RegleRuleMetadataDefinition = never> = {
+    readonly $type: string;
+    readonly $message: string | string[];
+    readonly $active: boolean;
+    readonly $valid: boolean;
+    readonly $pending: boolean;
+    readonly $path: string;
+    readonly $metadata: TMetadata;
+    $validator: (value: TValue, ...args: TParams) => boolean | Promise<boolean>;
+    $validate(): Promise<boolean>;
+    $reset(): void;
+} & ([TParams] extends [[]] ? {} : {
+    readonly $params: TParams;
+});
+/**
+ * @public
+ */
+interface RegleCollectionStatus<TRules extends RegleRuleDecl | ReglePartialValidationTree<any>, TState extends any[], TFieldRule extends RegleCollectionRuleDecl<any, any> = never> extends Omit<RegleFieldStatus<TRules, TState>, '$errors' | '$silentErrors'> {
+    readonly $each: Array<InferRegleStatusType<NonNullable<TRules>, NonNullable<TState>, number>>;
+    readonly $field: RegleFieldStatus<TFieldRule, TState>;
+    readonly $errors: RegleErrorTree<TRules>;
+    readonly $silentErrors: RegleErrorTree<TRules>;
+}
+
+/**
+ * @description
+ * Create a typed custom rule that can be used like default rules.
+ * It can also be declared in the global options
+ *
+ * It will automatically detect if the rule is async
+ *
+ * @typeParam TValue - The input value the rule should receive
+ * @typeParam TParams - Tuple declaration of the rule parameters (if any)
+ *
+ * @param definition - The rule processors object
+ *
+ * @returns A rule definition that can be callable depending on params presence
+ *
+ * @exemple
+ *
+ * ```ts
+ * // Create a simple rule with no params
+ * import {ruleHelpers} from '@regle/rules';
+ *
+ * export const isFoo = createRule({
+ *   validator(value: string) {
+ *       if (ruleHelpers.isFilled(value)) {
+ *           return value === 'foo';
+ *       }
+ *       return true
+ *   },
+ *   message: "The value should be 'foo'"
+ * })
+ * ```
+ */
+declare function createRule<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn, TAsync extends boolean = TReturn extends Promise<any> ? true : false>(definition: RegleRuleInit<TValue, TParams, TReturn, TMetadata, TAsync>): InferRegleRule<TValue, TParams, TAsync, TMetadata>;
+
+/**
+ * Returns a clean list of parameters
+ * Removing Ref and executing function to return the unwraped value
+ */
+declare function unwrapRuleParameters<TParams extends any[]>(params: ParamDecl[]): TParams;
+
+declare const useRegle: <TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, Partial<AllRulesDeclarations>>, TExternal extends RegleExternalErrorTree<TState>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TValid = keyof TRules extends keyof TState ? true : false>(state: MaybeRef<TState> | DeepReactiveState<TState>, rulesFactory: TValid extends true ? TRules | ComputedRef<TRules> | (() => TRules) : never, options?: (Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<TState, TRules, TExternal, TValidationGroups>) | undefined) => Regle<TState, TRules, TExternal, TValidationGroups>;
+
+declare function defineRegleConfig<TCustomRules extends Partial<AllRulesDeclarations>>({ rules, modifiers, }: {
+    rules?: () => TCustomRules;
+    modifiers?: RegleBehaviourOptions;
+}): <TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, Partial<AllRulesDeclarations> & TCustomRules>, TExternal extends RegleExternalErrorTree<TState>, TValidationGroups extends Record<string, RegleValidationGroupEntry[]>, TValid = keyof TRules extends keyof TState ? true : false>(state: vue.MaybeRef<TState> | DeepReactiveState<TState>, rulesFactory: TValid extends true ? TRules | vue.ComputedRef<TRules> | (() => TRules) : never, options?: (Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<TState, TRules, TExternal, TValidationGroups>) | undefined) => Regle<TState, TRules, TExternal, TValidationGroups>;
+
+export { type DeepMaybeRef, type FormRuleDeclaration, type InlineRuleDeclaration, InternalRuleType, type LocalRegleBehaviourOptions, type Maybe, type ParamDecl, type Regle, type RegleBehaviourOptions, type RegleCollectionErrors, type RegleCollectionRuleDecl, type RegleCollectionRuleDefinition, type RegleCollectionStatus, type RegleCommonStatus, type RegleComputedRules, type RegleErrorTree, type RegleExternalCollectionErrors, type RegleExternalErrorTree, type RegleExternalValidationErrors, type RegleExternalValidationErrorsReport, type RegleFieldStatus, type RegleFormPropertyType, type RegleInternalRuleDefs, type ReglePartialValidationTree, type RegleRuleCore, type RegleRuleDecl, type RegleRuleDefinition, type RegleRuleDefinitionProcessor, type RegleRuleDefinitionWithMetadataProcessor, type RegleRuleInit, type RegleRuleMetadataConsumer, type RegleRuleMetadataDefinition, type RegleRuleRaw, type RegleRuleStatus, type RegleRuleWithParamsDefinition, type RegleStatus, type RegleUniversalParams, type RegleValidationErrors, type RegleValidationGroupEntry, type RegleValidationGroupOutput, type RegleValidationTree, type UnwrapRegleUniversalParams, createRule, defineRegleConfig, unwrapRuleParameters, useRegle };

package/dist/index.d.ts

@@ -93,6 +93,7 @@ type AddDollarToOptions<T extends Record<string, any>> = {
 
 interface Regle<TState extends Record<string, any> = EmptyObject, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree> = EmptyObject, TExternal extends RegleExternalErrorTree<TState> = never, TValidationGroups extends Record<string, RegleValidationGroupEntry[]> = never> {
     regle: RegleStatus<TState, TRules, TValidationGroups>;
+    r$: RegleStatus<TState, TRules, TValidationGroups>;
     /** Show active errors based on your behaviour options (lazy, autoDirty)
      * It allow you to skip scouting the `regle` object
      */
@@ -105,14 +106,14 @@ interface Regle<TState extends Record<string, any> = EmptyObject, TRules extends
 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>> = [unknown] extends [TState] ? object : {
+type DeepSafeFormState<TState extends Record<string, any>, TRules extends ReglePartialValidationTree<TState, CustomRulesDeclarationTree>> = [unknown] extends [TState] ? {} : {
     [K in keyof TState as [SafeProperty<TState[K], TRules[K]>] extends [never] ? K : never]?: [
         SafeProperty<TState[K], TRules[K]>
     ] extends [never] ? TState[K] : SafeProperty<TState[K], TRules[K]>;
 } & {
     [K in keyof TState as [SafeProperty<TState[K], TRules[K]>] extends [never] ? never : K]-?: SafeProperty<TState[K], TRules[K]>;
 };
-type SafeProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends RegleCollectionRuleDefinition ? TState extends Array<any> ? SafeProperty<TState[number], ExtractFromGetter<TRule['$each']>>[] : never : TRule extends ReglePartialValidationTree<any, any> ? TState extends Record<string, any> ? DeepSafeFormState<TState, TRule> : never : TRule extends RegleRuleDecl<any, any> ? unknown extends TRule['required'] ? never : TRule['required'] extends undefined ? never : TRule['required'] extends RegleRuleDefinition<any, infer Params> ? Params extends never[] ? TState : never : never : never;
+type SafeProperty<TState, TRule extends RegleFormPropertyType<any, any> | undefined = never> = TRule extends RegleCollectionRuleDefinition<any, any> ? TState extends Array<any> ? SafeProperty<TState[number], ExtractFromGetter<TRule['$each']>>[] : never : TRule extends ReglePartialValidationTree<any, any> ? TState extends Record<string, any> ? DeepSafeFormState<TState, TRule> : TRule extends RegleRuleDecl<any, any> ? unknown extends TRule['required'] ? never : TRule['required'] extends undefined ? never : TRule['required'] extends RegleRuleDefinition<any, infer Params, any, any, any> ? Params extends never[] ? TState : never : never : never : never;
 
 type ParamDecl<T = any> = MaybeRef<Maybe<T>> | (() => Maybe<T>);
 type CreateFn<T extends any[]> = (...args: T) => any;
@@ -272,6 +273,7 @@ type DefaultValidators = {
     ], false, boolean>;
     minValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean>;
     numeric: RegleRuleDefinition<string | number, [], false, boolean, string | number>;
+    regex: RegleRuleWithParamsDefinition<string, [regexp: RegExp], false, boolean>;
     required: RegleRuleDefinition<unknown, []>;
     sameAs: RegleRuleWithParamsDefinition<unknown, [target: unknown], false, boolean>;
     startsWith: RegleRuleWithParamsDefinition<string, [part: Maybe<string>], false, boolean>;
@@ -367,7 +369,7 @@ type RegleStatus<TState extends Record<string, any> = Record<string, any>, TRule
     };
     readonly $errors: RegleErrorTree<TRules>;
     readonly $silentErrors: RegleErrorTree<TRules>;
-} & ([TValidationGroups] extends [never] ? object : {
+} & ([TValidationGroups] extends [never] ? {} : {
     $groups: {
         readonly [TKey in keyof TValidationGroups]: RegleValidationGroupOutput;
     };
@@ -421,7 +423,7 @@ type RegleRuleStatus<TValue = any, TParams extends any[] = any[], TMetadata exte
     $validator: (value: TValue, ...args: TParams) => boolean | Promise<boolean>;
     $validate(): Promise<boolean>;
     $reset(): void;
-} & ([TParams] extends [[]] ? object : {
+} & ([TParams] extends [[]] ? {} : {
     readonly $params: TParams;
 });
 /**