@regle/rules 0.1.5 → 0.1.7

package/dist/index.d.cts

@@ -0,0 +1,202 @@
+import { RegleRuleMetadataDefinition, InlineRuleDeclaration, RegleRuleDefinitionWithMetadataProcessor, RegleRuleMetadataConsumer, RegleRuleDefinition, RegleRuleWithParamsDefinition, UnwrapRegleUniversalParams, ParamDecl, Maybe, FormRuleDeclaration } from '@regle/core';
+import { Ref, MaybeRef } from 'vue';
+
+declare function withMessage<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TAsync extends boolean = TReturn extends Promise<any> ? true : false>(rule: InlineRuleDeclaration<TValue, TParams, TReturn>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TParams, TReturn extends Promise<infer M> ? M : TReturn>, string | string[]>): RegleRuleDefinition<TValue, [], TAsync, TReturn extends Promise<infer M> ? M : TReturn>;
+declare function withMessage<TValue extends any, TParams extends any[], TMetadata extends RegleRuleMetadataDefinition, TReturn extends TMetadata | Promise<TMetadata>, TAsync extends boolean = TReturn extends Promise<any> ? true : false>(rule: RegleRuleWithParamsDefinition<TValue, TParams, TAsync, TMetadata>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TParams, TMetadata>, string | string[]>): RegleRuleWithParamsDefinition<TValue, TParams, TAsync>;
+declare function withMessage<TValue extends any, TParams extends any[], TMetadata extends RegleRuleMetadataDefinition, TReturn extends TMetadata | Promise<TMetadata>, TAsync extends boolean>(rule: RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TParams, TMetadata>, string | string[]>): RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;
+
+declare function withAsync<TValue, TParams extends (Ref<unknown> | (() => unknown))[] = [], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn>(rule: InlineRuleDeclaration<TValue, TParams, TReturn>, depsArray?: [...TParams]): RegleRuleDefinition<TValue, UnwrapRegleUniversalParams<TParams>, true, TMetadata>;
+
+declare function withParams<TValue, TParams extends (Ref<unknown> | (() => unknown))[] = [], TReturn extends RegleRuleMetadataDefinition = RegleRuleMetadataDefinition, TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn>(rule: InlineRuleDeclaration<TValue, TParams, TReturn>, depsArray: [...TParams]): RegleRuleDefinition<TValue, UnwrapRegleUniversalParams<TParams>, true, TMetadata>;
+
+declare function applyIf<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition, TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn, TAsync extends boolean = TReturn extends Promise<any> ? true : false>(_condition: ParamDecl<boolean>, rule: InlineRuleDeclaration<TValue, TParams, TReturn> | RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>): RegleRuleDefinition<TValue, [], TAsync, TMetadata>;
+
+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};
+
+declare function isEmpty(value: unknown): value is null | undefined | [] | EmptyObject;
+
+declare function isFilled<T extends unknown>(value: T): value is NonNullable<T>;
+
+declare function isNumber(value: unknown): value is number;
+
+declare function regex$1(_value: string | number | null | undefined, ...expr: RegExp[]): boolean;
+
+declare function size(value: MaybeRef<string | any[] | Record<string, any> | number>): number;
+
+declare function isDate(value: unknown): value is Date;
+
+declare function toDate(argument: Maybe<Date | number | string>): Date;
+
+/**
+ * @returns ⚠️ Warning, returned value can be NaN
+ */
+declare function toNumber<T extends number | string | undefined>(argument: T): number;
+
+declare const ruleHelpers: {
+    isEmpty: typeof isEmpty;
+    isFilled: typeof isFilled;
+    size: typeof size;
+    regex: typeof regex$1;
+    isNumber: typeof isNumber;
+    isDate: typeof isDate;
+    toDate: typeof toDate;
+    toNumber: typeof toNumber;
+};
+
+type ExtractValueFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<infer V, any, any, any> ? [V, ...ExtractValueFromRules<R>] : F extends InlineRuleDeclaration<infer V, any> ? [V, ...ExtractValueFromRules<R>] : [F, ...ExtractValueFromRules<R>] : [];
+type ExtractAsyncStatesFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<any, any, infer A, any> ? [A, ...ExtractValueFromRules<R>] : F extends InlineRuleDeclaration<any, any> ? [ReturnType<F> extends Promise<any> ? true : false, ...ExtractValueFromRules<R>] : [F, ...ExtractValueFromRules<R>] : [];
+type ExtractAsync<T extends [...any[]]> = T extends [infer F, ...infer R] ? F extends true ? true : F extends false ? ExtractAsync<R> : false : false;
+type GuessAsyncFromRules<T extends any[]> = ExtractAsync<ExtractAsyncStatesFromRules<T>>;
+type ExtractParamsFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<any, infer P, any, any> ? [P, ...ExtractParamsFromRules<R>] : [F, ...ExtractParamsFromRules<R>] : [];
+type MetadataBase = {
+    $valid: boolean;
+    [x: string]: any;
+};
+type ExtractMetaDataFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<any, any, any, infer M extends MetadataBase> ? [M, ...ExtractMetaDataFromRules<R>] : F extends InlineRuleDeclaration<any, any[], infer M extends MetadataBase | Promise<MetadataBase>> ? [M, ...ExtractMetaDataFromRules<R>] : [...ExtractMetaDataFromRules<R>] : [];
+type ExtractMetadata<T extends [...any[]]> = T extends [infer F, ...infer R] ? F & ExtractMetadata<R> : {};
+type GuessMetadataFromRules<T extends any[], TMeta = ExtractMetadata<ExtractMetaDataFromRules<T>>> = TMeta extends EmptyObject ? boolean : TMeta;
+type CreateFn<T extends any[]> = (...args: T) => any;
+type FilterTuple<T extends any[]> = T extends [infer F, ...infer R] ? [F] extends [[]] ? [...FilterTuple<R>] : [F, ...FilterTuple<R>] : [];
+type UnwrapTuplesRaw<T extends any[] = [], F = CreateFn<T>> = [T] extends [[]] ? [] : Parameters<F extends (...args: infer Args) => any ? (...args: {
+    [K in keyof Args]: Args[K] extends Array<infer U> ? U : never;
+}) => any : never>;
+type UnwrapTuples<T extends any[]> = FilterTuple<UnwrapTuplesRaw<T>>;
+
+declare function and<TRules extends FormRuleDeclaration<any, any>[]>(...rules: [...TRules]): RegleRuleDefinition<ExtractValueFromRules<TRules>[number], UnwrapTuples<ExtractParamsFromRules<TRules>>, GuessAsyncFromRules<TRules>, GuessMetadataFromRules<TRules>>;
+
+declare function or<TRules extends FormRuleDeclaration<any, any>[]>(...rules: [...TRules]): RegleRuleDefinition<ExtractValueFromRules<TRules>[number], UnwrapTuples<ExtractParamsFromRules<TRules>>, GuessAsyncFromRules<TRules>, GuessMetadataFromRules<TRules>>;
+
+declare function not<TValue, TParams extends any[] = [], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition, TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn, TAsync extends boolean = TReturn extends Promise<any> ? true : false>(rule: RegleRuleDefinition<TValue, TParams, TAsync, TMetadata> | InlineRuleDeclaration<TValue, TParams, TReturn>, message?: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TParams, TMetadata>, string | string[]>): RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>;
+
+declare const required: RegleRuleDefinition<unknown, [], false, boolean, unknown>;
+
+declare const maxLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [
+    count: number
+], false, boolean>;
+
+declare const requiredIf: RegleRuleWithParamsDefinition<unknown, [
+    condition: boolean
+], false, boolean>;
+
+declare const alpha: RegleRuleDefinition<string, [], false, boolean, string>;
+
+declare const alphaNum: RegleRuleDefinition<string | number, [], false, boolean, string | number>;
+
+declare const between: RegleRuleWithParamsDefinition<number, [
+    min: number,
+    max: number
+], false, boolean>;
+
+declare const decimal: RegleRuleDefinition<string | number, [], false, boolean, string | number>;
+
+declare const email: RegleRuleDefinition<string, [], false, boolean, string>;
+
+declare const integer: RegleRuleDefinition<string | number, [], false, boolean, string | number>;
+
+declare const maxValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean>;
+
+declare const minLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [
+    count: number
+], false, boolean>;
+
+declare const minValue: RegleRuleWithParamsDefinition<number, [count: number], false, boolean>;
+
+declare const exactLength: RegleRuleWithParamsDefinition<string | any[] | Record<PropertyKey, any>, [
+    count: number
+], false, boolean>;
+
+declare const numeric: RegleRuleDefinition<string | number, [], false, boolean, string | number>;
+
+declare const requiredUnless: RegleRuleWithParamsDefinition<unknown, [
+    condition: boolean
+], false, boolean>;
+
+declare const sameAs: RegleRuleWithParamsDefinition<unknown, [target: unknown], false, boolean>;
+
+declare const url: RegleRuleDefinition<string, [], false, boolean, string>;
+
+declare const 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';
+}>;
+
+declare const 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';
+}>;
+
+declare const dateBetween: RegleRuleWithParamsDefinition<string | Date, [
+    before: Maybe<string | Date>,
+    after: Maybe<string | Date>
+], false, boolean>;
+
+declare const ipAddress: RegleRuleDefinition<string, [], false, boolean, string>;
+
+declare const macAddress: RegleRuleWithParamsDefinition<string, [
+    separator?: string | undefined
+], false, boolean>;
+
+declare const checked: RegleRuleDefinition<boolean, [], false, boolean, boolean>;
+
+declare const contains: RegleRuleWithParamsDefinition<string, [
+    part: Maybe<string>
+], false, boolean>;
+
+declare const startsWith: RegleRuleWithParamsDefinition<string, [
+    part: Maybe<string>
+], false, boolean>;
+
+declare const endsWith: RegleRuleWithParamsDefinition<string, [
+    part: Maybe<string>
+], false, boolean>;
+
+declare const regex: RegleRuleWithParamsDefinition<string | number, [
+    regexp: RegExp
+], false, boolean>;
+
+export { alpha, alphaNum, and, applyIf, between, checked, contains, dateAfter, dateBefore, dateBetween, decimal, email, endsWith, exactLength, integer, ipAddress, macAddress, maxLength, maxValue, minLength, minValue, not, numeric, or, regex, required, requiredIf, requiredUnless, ruleHelpers, sameAs, startsWith, url, withAsync, withMessage, withParams };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { RegleRuleMetadataDefinition, InlineRuleDeclaration, RegleRuleDefinitionWithMetadataProcessor, RegleRuleMetadataConsumer, RegleRuleDefinition, RegleRuleWithParamsDefinition, UnwrapRegleUniversalParams, ParamDecl, FormRuleDeclaration, Maybe } from '@regle/core';
+import { RegleRuleMetadataDefinition, InlineRuleDeclaration, RegleRuleDefinitionWithMetadataProcessor, RegleRuleMetadataConsumer, RegleRuleDefinition, RegleRuleWithParamsDefinition, UnwrapRegleUniversalParams, ParamDecl, Maybe, FormRuleDeclaration } from '@regle/core';
 import { Ref, MaybeRef } from 'vue';
 
 declare function withMessage<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition>, TAsync extends boolean = TReturn extends Promise<any> ? true : false>(rule: InlineRuleDeclaration<TValue, TParams, TReturn>, newMessage: RegleRuleDefinitionWithMetadataProcessor<TValue, RegleRuleMetadataConsumer<TParams, TReturn extends Promise<infer M> ? M : TReturn>, string | string[]>): RegleRuleDefinition<TValue, [], TAsync, TReturn extends Promise<infer M> ? M : TReturn>;
@@ -11,33 +11,6 @@ declare function withParams<TValue, TParams extends (Ref<unknown> | (() => unkno
 
 declare function applyIf<TValue extends any, TParams extends any[], TReturn extends RegleRuleMetadataDefinition | Promise<RegleRuleMetadataDefinition> = RegleRuleMetadataDefinition, TMetadata extends RegleRuleMetadataDefinition = TReturn extends Promise<infer M> ? M : TReturn, TAsync extends boolean = TReturn extends Promise<any> ? true : false>(_condition: ParamDecl<boolean>, rule: InlineRuleDeclaration<TValue, TParams, TReturn> | RegleRuleDefinition<TValue, TParams, TAsync, TMetadata>): RegleRuleDefinition<TValue, [], TAsync, TMetadata>;
 
-declare function isEmpty(value: unknown): value is null | undefined;
-
-declare function isFilled<T extends unknown>(value: T): value is NonNullable<T>;
-
-declare function isNumber(value: unknown): value is number;
-
-declare function regex(_value: string | number | null | undefined, ...expr: RegExp[]): boolean;
-
-declare function size(value: MaybeRef<string | any[] | Record<string, any> | number>): number;
-
-declare function isDate(value: unknown): value is Date;
-
-declare function toDate(argument: Date): Date;
-
-declare function toNumber(argument: number | string): number | null;
-
-declare const ruleHelpers: {
-    isEmpty: typeof isEmpty;
-    isFilled: typeof isFilled;
-    size: typeof size;
-    regex: typeof regex;
-    isNumber: typeof isNumber;
-    isDate: typeof isDate;
-    toDate: typeof toDate;
-    toNumber: typeof toNumber;
-};
-
 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 {
@@ -75,6 +48,36 @@ Unfortunately, `Record<string, never>`, `Record<keyof any, never>` and `Record<n
 */
 type EmptyObject = {[emptyObjectSymbol]?: never};
 
+declare function isEmpty(value: unknown): value is null | undefined | [] | EmptyObject;
+
+declare function isFilled<T extends unknown>(value: T): value is NonNullable<T>;
+
+declare function isNumber(value: unknown): value is number;
+
+declare function regex$1(_value: string | number | null | undefined, ...expr: RegExp[]): boolean;
+
+declare function size(value: MaybeRef<string | any[] | Record<string, any> | number>): number;
+
+declare function isDate(value: unknown): value is Date;
+
+declare function toDate(argument: Maybe<Date | number | string>): Date;
+
+/**
+ * @returns ⚠️ Warning, returned value can be NaN
+ */
+declare function toNumber<T extends number | string | undefined>(argument: T): number;
+
+declare const ruleHelpers: {
+    isEmpty: typeof isEmpty;
+    isFilled: typeof isFilled;
+    size: typeof size;
+    regex: typeof regex$1;
+    isNumber: typeof isNumber;
+    isDate: typeof isDate;
+    toDate: typeof toDate;
+    toNumber: typeof toNumber;
+};
+
 type ExtractValueFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<infer V, any, any, any> ? [V, ...ExtractValueFromRules<R>] : F extends InlineRuleDeclaration<infer V, any> ? [V, ...ExtractValueFromRules<R>] : [F, ...ExtractValueFromRules<R>] : [];
 type ExtractAsyncStatesFromRules<T extends any[]> = T extends [infer F, ...infer R] ? F extends RegleRuleDefinition<any, any, infer A, any> ? [A, ...ExtractValueFromRules<R>] : F extends InlineRuleDeclaration<any, any> ? [ReturnType<F> extends Promise<any> ? true : false, ...ExtractValueFromRules<R>] : [F, ...ExtractValueFromRules<R>] : [];
 type ExtractAsync<T extends [...any[]]> = T extends [infer F, ...infer R] ? F extends true ? true : F extends false ? ExtractAsync<R> : false : false;
@@ -192,4 +195,8 @@ declare const endsWith: RegleRuleWithParamsDefinition<string, [
     part: Maybe<string>
 ], false, boolean>;
 
-export { alpha, alphaNum, and, applyIf, between, checked, contains, dateAfter, dateBefore, dateBetween, decimal, email, endsWith, exactLength, integer, ipAddress, macAddress, maxLength, maxValue, minLength, minValue, not, numeric, or, required, requiredIf, requiredUnless, ruleHelpers, sameAs, startsWith, url, withAsync, withMessage, withParams };
+declare const regex: RegleRuleWithParamsDefinition<string | number, [
+    regexp: RegExp
+], false, boolean>;
+
+export { alpha, alphaNum, and, applyIf, between, checked, contains, dateAfter, dateBefore, dateBetween, decimal, email, endsWith, exactLength, integer, ipAddress, macAddress, maxLength, maxValue, minLength, minValue, not, numeric, or, regex, required, requiredIf, requiredUnless, ruleHelpers, sameAs, startsWith, url, withAsync, withMessage, withParams };