@regle/schemas 1.1.0-beta.1 → 1.1.0-beta.3

package/dist/regle-schemas.d.cts

@@ -1,360 +0,0 @@
-import { Maybe, PrimitiveTypes, RegleShortcutDefinition, RegleFieldStatus, RegleCommonStatus, JoinDiscriminatedUnions, RegleRuleStatus, RegleCollectionErrors, RegleErrorTree, DeepMaybeRef, RegleBehaviourOptions, MismatchInfo, DeepReactiveState, LocalRegleBehaviourOptions, NoInferLegacy } from '@regle/core';
-import { StandardSchemaV1 } from '@standard-schema/spec';
-import { Raw, MaybeRef, MaybeRefOrGetter, UnwrapNestedRefs } from 'vue';
-
-/**
-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;
-	}
-}
-
-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};
-
-/**
-Extract the element of an array that also works for array union.
-
-Returns `never` if T is not an array.
-
-It creates a type-safe way to access the element type of `unknown` type.
-*/
-type ArrayElement<T> = T extends readonly unknown[] ? T[0] : never;
-
-/**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
-*/
-type BuiltIns = Primitive | void | Date | RegExp;
-
-/**
-@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 | (((...arguments_: any[]) => unknown)) | (new (...arguments_: any[]) => unknown)
-	? 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 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>
-};
-
-interface RegleSchema<TState extends Record<string, any>, TSchema extends Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> {
-    /**
-     * r$ is a reactive object containing the values, errors, dirty state and all the necessary validations properties you'll need to display informations.
-     *
-     * To see the list of properties: {@link https://reglejs.dev/core-concepts/validation-properties}
-     */
-    r$: Raw<RegleSchemaStatus<TState, TSchema, TShortcuts, true>>;
-}
-interface RegleSingleFieldSchema<TState extends Maybe<PrimitiveTypes>, TSchema extends Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}> {
-    /**
-     * r$ is a reactive object containing the values, errors, dirty state and all the necessary validations properties you'll need to display informations.
-     *
-     * To see the list of properties: {@link https://reglejs.dev/core-concepts/validation-properties}
-     */
-    r$: Raw<RegleFieldStatus<TState, TSchema, TShortcuts>>;
-}
-type RegleSchemaResult<TSchema extends unknown> = {
-    valid: false;
-    data: PartialDeep<TSchema>;
-} | {
-    valid: true;
-    data: TSchema;
-};
-/**
- * @public
- */
-type RegleSchemaStatus<TState extends Record<string, any> = Record<string, any>, TSchema extends Record<string, any> = Record<string, any>, TShortcuts extends RegleShortcutDefinition = {}, IsRoot extends boolean = false> = Omit<RegleCommonStatus<TState>, IsRoot extends false ? '$pending' : ''> & {
-    /** Represents all the children of your object. You can access any nested child at any depth to get the relevant data you need for your form. */
-    readonly $fields: {
-        readonly [TKey in keyof JoinDiscriminatedUnions<TState>]: TKey extends keyof JoinDiscriminatedUnions<TSchema> ? InferRegleSchemaStatusType<NonNullable<JoinDiscriminatedUnions<TSchema>[TKey]>, JoinDiscriminatedUnions<TState>[TKey], TShortcuts> : never;
-    } & {
-        readonly [TKey in keyof JoinDiscriminatedUnions<TState> as TKey extends keyof JoinDiscriminatedUnions<TSchema> ? JoinDiscriminatedUnions<TSchema>[TKey] extends NonNullable<JoinDiscriminatedUnions<TSchema>[TKey]> ? TKey : never : never]-?: TKey extends keyof JoinDiscriminatedUnions<TSchema> ? InferRegleSchemaStatusType<NonNullable<JoinDiscriminatedUnions<TSchema>[TKey]>, JoinDiscriminatedUnions<TState>[TKey], TShortcuts> : never;
-    };
-    /** Collection of all the error messages, collected for all children properties and nested forms.
-     *
-     * Only contains errors from properties where $dirty equals true. */
-    readonly $errors: RegleErrorTree<TState>;
-    /** Collection of all the error messages, collected for all children properties. */
-    readonly $silentErrors: RegleErrorTree<TState>;
-    /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-    $extractDirtyFields: (filterNullishValues?: boolean) => PartialDeep<TState>;
-} & (IsRoot extends true ? {
-    /** Sets all properties as dirty, triggering all rules. It returns a promise that will either resolve to false or a type safe copy of your form state. Values that had the required rule will be transformed into a non-nullable value (type only). */
-    $validate: () => Promise<RegleSchemaResult<TSchema>>;
-} : {}) & ([TShortcuts['nested']] extends [never] ? {} : {
-    [K in keyof TShortcuts['nested']]: ReturnType<NonNullable<TShortcuts['nested']>[K]>;
-});
-/**
- * @public
- */
-type InferRegleSchemaStatusType<TSchema extends unknown, TState extends unknown, TShortcuts extends RegleShortcutDefinition = {}> = NonNullable<TSchema> extends Array<infer A extends Record<string, any>> ? RegleSchemaCollectionStatus<A, TState extends Array<any> ? TState : [], TShortcuts> : NonNullable<TState> extends Date | File ? RegleSchemaFieldStatus<TSchema, TState, TShortcuts> : unknown extends TState ? RegleSchemaFieldStatus<TSchema extends EmptyObject ? unknown : TSchema, TState, TShortcuts> : NonNullable<TSchema> extends Record<string, any> ? RegleSchemaStatus<NonNullable<TState> extends Record<string, any> ? NonNullable<TState> : {}, NonNullable<TSchema>, TShortcuts> : RegleSchemaFieldStatus<TSchema, TState, TShortcuts>;
-/**
- * @public
- */
-type RegleSchemaFieldStatus<TSchema extends unknown, TState = any, TShortcuts extends RegleShortcutDefinition = {}> = Omit<RegleCommonStatus<TState>, '$pending'> & {
-    /** Collection of all the error messages, collected for all children properties and nested forms.
-     *
-     * Only contains errors from properties where $dirty equals true. */
-    readonly $errors: string[];
-    /** Collection of all the error messages, collected for all children properties and nested forms.  */
-    readonly $silentErrors: string[];
-    /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-    readonly $externalErrors?: string[];
-    /** Represents the inactive status. Is true when this state have empty rules */
-    readonly $inactive: boolean;
-    /** This is reactive tree containing all the declared rules of your field. To know more about the rule properties check the rules properties section */
-    readonly $rules: {
-        [`~validator`]: RegleRuleStatus<TState, []>;
-    };
-    /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-    $extractDirtyFields: (filterNullishValues?: boolean) => PartialDeep<TState>;
-} & ([TShortcuts['fields']] extends [never] ? {} : {
-    [K in keyof TShortcuts['fields']]: ReturnType<NonNullable<TShortcuts['fields']>[K]>;
-});
-/**
- * @public
- */
-type RegleSchemaCollectionStatus<TSchema extends Record<string, any>, TState extends any[], TShortcuts extends RegleShortcutDefinition = {}> = Omit<RegleSchemaFieldStatus<TSchema, TState, TShortcuts>, '$errors' | '$silentErrors' | '$validate'> & {
-    /** Collection of status of every item in your collection. Each item will be a field you can access, or map on it to display your elements. */
-    readonly $each: Array<InferRegleSchemaStatusType<NonNullable<TSchema>, ArrayElement<TState>, TShortcuts>>;
-    /** Represents the status of the collection itself. You can have validation rules on the array like minLength, this field represents the isolated status of the collection. */
-    readonly $self: RegleSchemaFieldStatus<TSchema, TState, TShortcuts>;
-    /** Collection of all the error messages, collected for all children properties and nested forms.
-     *
-     * Only contains errors from properties where $dirty equals true. */
-    readonly $errors: RegleCollectionErrors<TSchema>;
-    /** Collection of all the error messages, collected for all children properties and nested forms.  */
-    readonly $silentErrors: RegleCollectionErrors<TSchema>;
-    /** Will return a copy of your state with only the fields that are dirty. By default it will filter out nullish values or objects, but you can override it with the first parameter $extractDirtyFields(false). */
-    $extractDirtyFields: (filterNullishValues?: boolean) => PartialDeep<TState>;
-} & ([TShortcuts['collections']] extends [never] ? {} : {
-    [K in keyof TShortcuts['collections']]: ReturnType<NonNullable<TShortcuts['collections']>[K]>;
-});
-
-interface useRegleSchemaFn<TShortcuts extends RegleShortcutDefinition<any> = never> {
-    /**
-     * Primitive parameter
-     * */
-    <TState extends Maybe<PrimitiveTypes>, TRules extends StandardSchemaV1<TState>>(state: MaybeRef<TState>, rulesFactory: MaybeRefOrGetter<TRules>, options?: Partial<DeepMaybeRef<RegleBehaviourOptions>>): RegleSingleFieldSchema<TState, TRules, TShortcuts>;
-    /**
-     * Object parameter
-     * */
-    <TState extends Record<string, any>, TSchema extends StandardSchemaV1<Record<string, any>> & TValid, TValid = StandardSchemaV1.InferInput<TSchema> extends PartialDeep<UnwrapNestedRefs<TState>, {
-        recurseIntoArrays: true;
-    }> ? {} : MismatchInfo<UnwrapNestedRefs<TState>, PartialDeep<StandardSchemaV1.InferInput<TSchema>, {
-        recurseIntoArrays: true;
-    }>>>(state: MaybeRef<TState> | DeepReactiveState<TState>, schema: MaybeRef<TSchema>, options?: Partial<DeepMaybeRef<RegleBehaviourOptions>> & LocalRegleBehaviourOptions<UnwrapNestedRefs<TState>, {}, never>): RegleSchema<UnwrapNestedRefs<TState>, StandardSchemaV1.InferInput<TSchema>, TShortcuts>;
-}
-/**
- * useRegle serves as the foundation for validation logic.
- *
- * It accepts the following inputs:
- *
- * @param state - This can be a plain object, a ref, a reactive object, or a structure containing nested refs.
- * @param schema - These should align with the structure of your state.
- * @param modifiers - customize regle behaviour
- *
- * ```ts
- * import { useRegleSchema } from '@regle/schemas';
-  import * as v from 'valibot';
-
-  const { r$ } = useRegleSchema({ name: '' }, v.object({
-    name: v.pipe(v.string(), v.minLength(3))
-  }))
- * ```
- * Docs: {@link https://reglejs.dev/integrations/valibot#usage}
- */
-declare const useRegleSchema: useRegleSchemaFn<RegleShortcutDefinition<any>>;
-
-/**
- *
- * Force dependency on any RPC schema
- * ```ts
- * const foo = ref('');
- *
- * const schema = computed(() => v.object({
- *    name: withDeps(
- *       v.pipe(v.string(), v.check((value) => value === foo.value)),
- *       [foo.value]
- *    )
- * }))
- *
- * useRegleSchema({name: ''}, schema)
- * ```
- */
-declare function withDeps<TSchema extends StandardSchemaV1, TParams extends unknown[] = []>(schema: TSchema, depsArray: [...TParams]): TSchema;
-
-interface inferSchemaFn {
-    <TState extends Record<string, any>, TSchema extends StandardSchemaV1<Record<string, any>> & TValid, TValid = UnwrapNestedRefs<TState> extends PartialDeep<StandardSchemaV1.InferInput<TSchema>, {
-        recurseIntoArrays: true;
-    }> ? {} : MismatchInfo<UnwrapNestedRefs<TState>, PartialDeep<StandardSchemaV1.InferInput<TSchema>, {
-        recurseIntoArrays: true;
-    }>>>(state: MaybeRef<TState> | DeepReactiveState<TState> | undefined, rulesFactory: TSchema): NoInferLegacy<TSchema>;
-    <TState extends PrimitiveTypes, TSchema extends StandardSchemaV1 & TValid, TValid = TState extends StandardSchemaV1.InferInput<TSchema> ? {} : MismatchInfo<TState, StandardSchemaV1.InferInput<TSchema>>>(state: MaybeRef<TState>, rulesFactory: TSchema): NoInferLegacy<TSchema>;
-}
-/**
- * Rule type helper to provide autocomplete and typecheck to your form rules or part of your form rules
- * It will just return the rules without any processing.
- *
- * @param state - The state reference
- * @param schema - Your schema
- */
-declare const inferSchema: inferSchemaFn;
-
-/**
- * Define a global regle configuration, where you can:
- * - Define global modifiers
- * - Define shortcuts
- *
- * It will return:
- *
- * - a `useRegleSchema` composable that can typecheck your custom rules
- * - an `inferSchema` helper that can typecheck your custom rules
- */
-declare function defineRegleSchemaConfig<TShortcuts extends RegleShortcutDefinition>({ modifiers, shortcuts, }: {
-    modifiers?: RegleBehaviourOptions;
-    shortcuts?: TShortcuts;
-}): {
-    useRegleSchema: useRegleSchemaFn<TShortcuts>;
-    inferSchema: inferSchemaFn;
-};
-
-export { type InferRegleSchemaStatusType, type RegleSchema, type RegleSchemaCollectionStatus, type RegleSchemaFieldStatus, type RegleSchemaResult, type RegleSchemaStatus, type RegleSingleFieldSchema, defineRegleSchemaConfig, inferSchema, useRegleSchema, withDeps };

package/dist/regle-schemas.min.cjs

@@ -1 +0,0 @@
-'use strict';var core=require('@regle/core'),vue=require('vue');function C(e){if(typeof e.source.flags=="string")return e.source.flags;{let t=[];return e.global&&t.push("g"),e.ignoreCase&&t.push("i"),e.multiline&&t.push("m"),e.sticky&&t.push("y"),e.unicode&&t.push("u"),t.join("")}}function f(e){let t=e,r={}.toString.call(e).slice(8,-1);if(r=="Set"&&(t=new Set([...e].map(a=>f(a)))),r=="Map"&&(t=new Map([...e].map(a=>[f(a[0]),f(a[1])]))),r=="Date"&&(t=new Date(e.getTime())),r=="RegExp"&&(t=RegExp(e.source,C(e))),r=="Array"||r=="Object"){t=Array.isArray(e)?[]:{};for(let a in e)t[a]=f(e[a]);}return t}function S(e){return e&&(e instanceof Date||e.constructor.name=="File"||e.constructor.name=="FileList")?false:typeof e=="object"&&e!==null&&!Array.isArray(e)}function v(e,t,r,a){var n,s;if(Array.isArray(t)&&(n=t.slice(0)),typeof t=="string"&&(n=t.split(".")),typeof t=="symbol"&&(n=[t]),!Array.isArray(n))throw new Error("props arg must be an array, a string or a symbol");if(s=n.pop(),!s)return  false;w(s);for(var o;o=n.shift();)if(w(o),isNaN(parseInt(o))?(typeof e[o]>"u"&&(e[o]={}),e=e[o]):((e.$each??=[])[o]={},e=e.$each[o]),!e||typeof e!="object")return  false;return a?e[s]?e[s].$self=(e[s].$self??=[]).concat(r):e[s]={...e[s],$self:r}:Array.isArray(e[s])?e[s]=e[s].concat(r):e[s]=r,true}function I(e,t,r){if(!e)return r;var a,n;if(Array.isArray(t)&&(a=t.slice(0)),typeof t=="string"&&(a=t.split(".")),typeof t=="symbol"&&(a=[t]),!Array.isArray(a))throw new Error("props arg must be an array, a string or a symbol");for(;a.length;)if(n=a.shift(),!e||!n||(e=e[n],e===void 0))return r;return e}function w(e){if(e=="__proto__"||e=="constructor"||e=="prototype")throw new Error("setting of prototype values not supported")}function R(e,t){let r={autoDirty:e?.autoDirty,lazy:e?.lazy,rewardEarly:e?.rewardEarly,clearExternalErrorsOnChange:e?.clearExternalErrorsOnChange};function a(n,s,o){let E=vue.ref({}),p=vue.computed(()=>vue.unref(s)),V={...r,...o},N=vue.computed(()=>!S(l.value)),l=vue.isRef(n)?n:vue.ref(n),A=vue.ref(S(l.value)?{...f(l.value)}:f(l.value)),y=vue.ref({}),T;if(!p.value?.["~standard"])throw new Error('Only "standard-schema" compatible libraries are supported');function B(i){let m={};return i.issues&&i.issues.map(c=>{let x=c.path?.map(d=>typeof d=="object"?d.key:d.toString()).join(".")??"",h=c.path?.[c.path.length-1],U=(typeof h=="object"&&"value"in h?Array.isArray(h.value):false)||("type"in c?c.type==="array":false)||Array.isArray(I(l.value,x));return {path:x,message:c.message,isArray:U}}).forEach(c=>{v(m,c.path,[c.message],c.isArray);}),m}async function D(){let i=p.value["~standard"].validate(l.value);return i instanceof Promise&&(i=await i),N.value?y.value=i.issues?.map(m=>m.message)??[]:y.value=B(i),i}return vue.watch([l,p],D,{deep:true,immediate:true}),T=async()=>{try{return {valid:!(await D()).issues?.length,data:l.value}}catch(i){return Promise.reject(i)}},{r$:core.useRootStorage({scopeRules:E,state:l,options:V,schemaErrors:y,initialState:A,shortcuts:t,schemaMode:true,onValidate:T}).regle}}return a}var M=R();function O(e,t){return e}function g(){function e(t,r){return r}return e}var b=g();function F({modifiers:e,shortcuts:t}){let r=R(e,t),a=g();return {useRegleSchema:r,inferSchema:a}}exports.defineRegleSchemaConfig=F;exports.inferSchema=b;exports.useRegleSchema=M;exports.withDeps=O;

package/index.cjs

@@ -1,7 +0,0 @@
-'use strict';
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./dist/regle-schemas.min.cjs');
-} else {
-  module.exports = require('./dist/regle-schemas.cjs');
-}

package/index.js

@@ -1,7 +0,0 @@
-'use strict';
-
-if (process.env.NODE_ENV === 'production') {
-  module.exports = require('./dist/regle-schemas.min.cjs');
-} else {
-  module.exports = require('./dist/regle-schemas.cjs');
-}