cross-state 0.53.3 → 0.54.0

package/dist/types/react/form/formField.d.ts

@@ -1,68 +0,0 @@
-import { type PathAsString, type Value } from '../../lib/path';
-import { type Component, type ComponentPropsWithoutRef, type ReactNode } from 'react';
-import { type Field, type Form, type FormContext, type FormInstance } from './form';
-export interface FormFieldComponentProps<TValue, TPath> {
-    name: TPath;
-    value: TValue;
-    onChange: (event: {
-        target: {
-            value: TValue;
-        };
-    } | TValue | undefined, ...args: any[]) => void;
-    onBlur: (...args: any[]) => void;
-}
-export type FormFieldInfos<TDraft, TOriginal, TPath extends string> = Field<TDraft, TOriginal, TPath> & {
-    hasTriggeredValidations: boolean;
-};
-type NativeInputType = 'input' | 'select' | 'textarea';
-type PartialComponentType<P> = (new (props: P, context?: any) => Component<P, any>) | ((props: P, context?: any) => ReactNode);
-export type FormFieldComponent = NativeInputType | PartialComponentType<any>;
-type FieldValue<T extends FormFieldComponent> = ComponentPropsWithoutRef<T>['value'];
-type FieldChangeValue<T extends FormFieldComponent> = ComponentPropsWithoutRef<T> extends {
-    onChange?: (update: infer U) => void;
-} ? U extends {
-    target: {
-        value: infer V;
-    };
-} ? V : U : never;
-type MakeOptional<T, Keys extends string> = Omit<T, Keys> & Partial<Pick<T, Keys & keyof T>>;
-export type FormFieldProps<TPath, TDraft> = {
-    name: TPath & PathAsString<TDraft>;
-    commitOnBlur?: boolean;
-    commitDebounce?: number;
-};
-export type FormFieldPropsWithRender<TDraft, TOriginal, TPath extends string> = FormFieldProps<TPath, TDraft> & NoInfer<{
-    component?: undefined;
-    render: (props: FormFieldComponentProps<Value<TDraft, TPath>, TPath>, info: FormFieldInfos<TDraft, TOriginal, TPath>, form: FormContext<TDraft, TOriginal>) => ReactNode;
-    inputFilter?: undefined;
-    defaultValue?: undefined;
-    serialize?: undefined;
-    deserialize?: undefined;
-    onChange?: undefined;
-    onBlur?: undefined;
-}>;
-type Serialize<TDraft, TOriginal, TPath, TComponent extends FormFieldComponent> = (value: Value<TDraft, TPath>, formState: FormInstance<TDraft, TOriginal>) => FieldValue<TComponent>;
-type Deserialize<TDraft, TOriginal, TPath, TComponent extends FormFieldComponent> = (value: FieldChangeValue<TComponent>, formState: FormInstance<TDraft, TOriginal>) => Value<TDraft, TPath>;
-export type FormFieldPropsWithComponent<TDraft, TOriginal, TPath extends string, TComponent extends FormFieldComponent> = FormFieldProps<TPath, TDraft> & {
-    component?: TComponent;
-    render?: undefined;
-} & NoInfer<{
-    inputFilter?: (value: FieldChangeValue<TComponent>) => boolean;
-} & MakeOptional<Omit<ComponentPropsWithoutRef<TComponent>, 'id' | 'name' | 'value' | 'defaultValue'>, 'onChange' | 'onBlur'> & (Value<TDraft, TPath> extends Exclude<FieldValue<TComponent>, undefined> ? {
-    defaultValue?: FieldValue<TComponent>;
-    serialize?: Serialize<TDraft, TOriginal, TPath, TComponent>;
-} : Value<TDraft, TPath> extends FieldValue<TComponent> ? {
-    defaultValue: FieldValue<TComponent>;
-    serialize?: Serialize<TDraft, TOriginal, TPath, TComponent>;
-} | {
-    defaultValue?: FieldValue<TComponent>;
-    serialize: Serialize<TDraft, TOriginal, TPath, TComponent>;
-} : {
-    serialize: Serialize<TDraft, TOriginal, TPath, TComponent>;
-}) & (FieldChangeValue<TComponent> extends Value<TDraft, TPath> ? {
-    deserialize?: Deserialize<TDraft, TOriginal, TPath, TComponent>;
-} : {
-    deserialize: Deserialize<TDraft, TOriginal, TPath, TComponent>;
-})>;
-export declare function FormField<TDraft, TOriginal, TPath extends string, TComponent extends FormFieldComponent>(this: Form<TDraft, any>, { name, component, commitOnBlur, commitDebounce, render, inputFilter, defaultValue, serialize, deserialize, onChange, onBlur, ...restProps }: FormFieldPropsWithRender<TDraft, TOriginal, TPath> | FormFieldPropsWithComponent<TDraft, TOriginal, TPath, TComponent>): JSX.Element | null;
-export {};

package/dist/types/react/form/formForEach.d.ts

@@ -1,19 +0,0 @@
-import { type GetKeys, type Join, type PathAsString, type Value } from '../../lib/path';
-import { type ReactNode } from 'react';
-import { type FieldHelperMethods, type Form } from './form';
-export type ElementName<TDraft, TPath extends string> = keyof {
-    [Path in TPath as Join<Path, GetKeys<NonNullable<Value<TDraft, Path>>> & (string | number)>]: 1;
-};
-export interface FormForEachProps<TDraft, TPath extends string> {
-    name: TPath & PathAsString<TDraft>;
-    renderElement?: (props: {
-        name: ElementName<TDraft, TPath>;
-        key: `${GetKeys<NonNullable<Value<TDraft, TPath>>> & (string | number)}`;
-        index: number;
-        remove: () => void;
-    }) => ReactNode;
-    children?: (props: {
-        setValue: (value: Value<TDraft, TPath> | ((value: Value<TDraft, TPath>) => Value<TDraft, TPath>)) => void;
-    } & FieldHelperMethods<TDraft, TPath>) => ReactNode;
-}
-export declare function FormForEach<TDraft, TPath extends string>(this: Form<TDraft, any>, { name, renderElement, children }: FormForEachProps<TDraft, TPath>): JSX.Element;

package/dist/types/react/form/index.d.ts

@@ -1,3 +0,0 @@
-export { CustomInput, type CustomInputProps } from './customInput';
-export { Form, createForm, type Field, type FormContext, type FormDerivedState, type FormInstance, type FormOptions, type FormState, type Transform, type Validation, type Validations, } from './form';
-export { type FormFieldComponent, type FormFieldProps } from './formField';

package/dist/types/react/form/useFormAutosave.d.ts

@@ -1,9 +0,0 @@
-import type { Duration } from '../../core';
-import type { MaybePromise } from '../../lib/maybePromise';
-import type { FormContext } from './form';
-export interface FormAutosaveOptions<TDraft, TOriginal> {
-    save: (draft: TDraft, form: FormContext<TDraft, TOriginal>) => MaybePromise<void>;
-    debounce?: Duration;
-    resetAfterSave?: boolean;
-}
-export declare function useFormAutosave<TDraft, TOriginal extends TDraft>(form: FormContext<TDraft, TOriginal>): void;

package/dist/types/react/index.d.ts

@@ -1,11 +0,0 @@
-export { cacheMethods } from './cacheMethods';
-export * from './form';
-export { LoadingBoundary, useLoadingBoundary, type LoadingBoundaryEntry, type LoadingBoundaryProps, } from './loadingBoundary';
-export { ScopeProvider, useScope, type ScopeProps } from './scope';
-export { scopeMethods } from './scopeMethods';
-export { storeMethods } from './storeMethods';
-export { useCache, type UseCacheArray, type UseCacheValue } from './useCache';
-export { useDecoupledState, type UseDecoupledStateOptions } from './useDecoupledState';
-export { useProp } from './useProp';
-export { useStore, type UseStoreOptions } from './useStore';
-export { useUrlParamScope } from './useUrlParamScope';

package/dist/types/react/loadingBoundary.d.ts

@@ -1,21 +0,0 @@
-import { type ReactNode } from 'react';
-export interface LoadingBoundaryEntry {
-    label?: ReactNode;
-}
-export interface LoadingBoundaryProps {
-    /**
-     * Fallback node to render when there are loading components within the boundary.
-     */
-    fallback?: ReactNode | ((entries: LoadingBoundaryEntry[]) => ReactNode);
-    /**
-     * Child node to render when there are no loading components within the boundary.
-     */
-    children?: ReactNode;
-    /**
-     * Add a loading state from outside the boundary. Useful for when you want to
-     * show a loading state for a component that is not a child of the boundary.
-     */
-    isLoading?: boolean;
-}
-export declare function LoadingBoundary({ fallback, children, isLoading: isLoadingExternal, }: LoadingBoundaryProps): JSX.Element;
-export declare function useLoadingBoundary(isLoading: boolean | undefined, label?: ReactNode): void;

package/dist/types/react/register.d.ts

@@ -1,15 +0,0 @@
-import { cacheMethods } from '../react/cacheMethods';
-import { scopeMethods } from '../react/scopeMethods';
-import { storeMethods } from './storeMethods';
-type StoreMethods = typeof storeMethods;
-type CacheMethods = typeof cacheMethods;
-type ScopeMethods = typeof scopeMethods;
-declare module '../core' {
-    interface Store<T> extends StoreMethods {
-    }
-    interface Cache<T> extends CacheMethods {
-    }
-    interface Scope<T> extends ScopeMethods {
-    }
-}
-export {};

package/dist/types/react/scope.d.ts

@@ -1,24 +0,0 @@
-import type { Scope, Selector, Update } from '../core';
-import { type Store } from '../core/store';
-import type { Constrain } from '../lib/constrain';
-import type { Path, Value } from '../lib/path';
-import { type Context, type ReactNode } from 'react';
-import { type UseStoreOptions } from './useStore';
-export type ScopeProps<T> = {
-    scope: Scope<T>;
-    store?: Store<T>;
-    children?: ReactNode;
-};
-declare module '../core' {
-    interface Scope<T> {
-        context?: Context<Store<T>>;
-    }
-}
-export declare function ScopeProvider<T>({ scope, store: inputStore, children, }: ScopeProps<T>): JSX.Element;
-export declare function useScope<T>(scope: Scope<T>): Store<T>;
-export declare function useScopeStore<T, S>(scope: Scope<T>, selector: Selector<T, S>, option?: UseStoreOptions<S>): S;
-export declare function useScopeStore<T, const P>(scope: Scope<T>, selector: Constrain<P, Path<T>>, option?: UseStoreOptions<Value<T, P>>): Value<T, P>;
-export declare function useScopeStore<T>(scope: Scope<T>, option?: UseStoreOptions<T>): T;
-export declare function useScopeProp<T, S>(scope: Scope<T>, selector: Selector<T, S>, updater: (value: S) => Update<T>, options?: UseStoreOptions<S>): [value: S, setValue: Store<S>['set']];
-export declare function useScopeProp<T, const P>(scope: Scope<T>, selector: Constrain<P, Path<T>>, options?: UseStoreOptions<Value<T, P>>): [value: Value<T, P>, setValue: Store<Value<T, P>>['set']];
-export declare function useScopeProp<T>(scope: Scope<T>, options?: UseStoreOptions<T>): [value: T, setValue: Store<T>['set']];

package/dist/types/react/scopeMethods.d.ts

@@ -1,20 +0,0 @@
-import type { Scope, Selector, Store, Update } from '../core';
-import type { Constrain } from '../lib/constrain';
-import type { Path, Value } from '../lib/path';
-import { type ScopeProps } from '../react/scope';
-import type { UseStoreOptions } from '../react/useStore';
-declare function boundUseScope<T>(this: Scope<T>): Store<T>;
-declare function boundUseScopeStore<T, S>(this: Scope<T>, selector: Selector<T, S>, option?: UseStoreOptions<S>): S;
-declare function boundUseScopeStore<T, const P>(this: Scope<T>, selector: Constrain<P, Path<T>>, option?: UseStoreOptions<Value<T, P>>): Value<T, P>;
-declare function boundUseScopeStore<T>(this: Scope<T>, option?: UseStoreOptions<T>): T;
-declare function boundUseScopeProp<T, S>(this: Scope<T>, selector: Selector<T, S>, updater: (value: S) => Update<T>, options?: UseStoreOptions<S>): [value: S, setValue: Store<S>['set']];
-declare function boundUseScopeProp<T, const P>(this: Scope<T>, selector: Constrain<P, Path<T>>, options?: UseStoreOptions<Value<T, P>>): [value: Value<T, P>, setValue: Store<Value<T, P>>['set']];
-declare function boundUseScopeProp<T>(this: Scope<T>, options?: UseStoreOptions<T>): [value: T, setValue: Store<T>['set']];
-declare function Provider<T>(this: Scope<T>, props: Omit<ScopeProps<T>, 'scope'>): JSX.Element;
-export declare const scopeMethods: {
-    useScope: typeof boundUseScope;
-    useStore: typeof boundUseScopeStore;
-    useProp: typeof boundUseScopeProp;
-    Provider: typeof Provider;
-};
-export {};

package/dist/types/react/storeMethods.d.ts

@@ -1,15 +0,0 @@
-import type { Selector, Store, Update } from '../core';
-import type { Constrain } from '../lib/constrain';
-import type { Path, Value } from '../lib/path';
-import { type UseStoreOptions } from '../react/useStore';
-declare function boundUseStore<T, S>(this: Store<T>, selector: Selector<T, S>, option?: UseStoreOptions<S>): S;
-declare function boundUseStore<T, const P>(this: Store<T>, selector: Constrain<P, Path<T>>, option?: UseStoreOptions<Value<T, P>>): Value<T, P>;
-declare function boundUseStore<T>(this: Store<T>, option?: UseStoreOptions<T>): T;
-declare function boundUseProp<T, S>(this: Store<T>, selector: Selector<T, S>, updater: (value: S) => Update<T>, options?: UseStoreOptions<S>): [value: S, setValue: Store<S>['set']];
-declare function boundUseProp<T, const P>(this: Store<T>, selector: Constrain<P, Path<T>>, options?: UseStoreOptions<Value<T, P>>): [value: Value<T, P>, setValue: Store<Value<T, P>>['set']];
-declare function boundUseProp<T>(this: Store<T>, options?: UseStoreOptions<T>): [value: T, setValue: Store<T>['set']];
-export declare const storeMethods: {
-    useStore: typeof boundUseStore;
-    useProp: typeof boundUseProp;
-};
-export {};

package/dist/types/react/useCache.d.ts

@@ -1,34 +0,0 @@
-import type { Cache } from '../core';
-import type { CacheState } from '../lib/cacheState';
-import { type UseStoreOptions } from './useStore';
-export type UseCacheArray<T> = [
-    value: T | undefined,
-    error: unknown | undefined,
-    isUpdating: boolean,
-    isStale: boolean
-];
-export type UseCacheValue<T> = UseCacheArray<T> & CacheState<T>;
-export interface UseCacheOptions<T> extends UseStoreOptions<UseCacheArray<T> & CacheState<T>> {
-    /**
-     * If true, will always return undefined as value and no fetch will be triggered.
-     * @default false
-     */
-    disabled?: boolean;
-    /**
-     * If true, the cache will be invalidated when the component mounts.
-     * @default false
-     */
-    updateOnMount?: boolean;
-    /**
-     * If true, `useCache` will throw a promise when the cache is pending. This can be used with React Suspense.
-     * @see https://react.dev/reference/react/Suspense
-     * @default false
-     */
-    suspense?: boolean;
-    /**
-     * If true, `useCache` will register its loading state with the nearest `LoadingBoundary`.
-     * @default false
-     */
-    loadingBoundary?: boolean;
-}
-export declare function useCache<T>(cache: Cache<T, any>, { passive, disabled, updateOnMount, withViewTransition, suspense, loadingBoundary, ...options }?: UseCacheOptions<T>): UseCacheValue<T>;

package/dist/types/react/useDecoupledState.d.ts

@@ -1,7 +0,0 @@
-import { type Duration } from '../core';
-export interface UseDecoupledStateOptions<T> {
-    debounce?: Duration;
-    throttle?: Duration;
-    onCommit?: (value: T) => void;
-}
-export declare function useDecoupledState<T>(value: T, onChange: (value: T) => void, options?: UseDecoupledStateOptions<T>): [state: T, setState: (value: T) => void];

package/dist/types/react/useProp.d.ts

@@ -1,8 +0,0 @@
-import { type Selector, type Update } from '../core/commonTypes';
-import type { Store } from '../core/store';
-import type { Constrain } from '../lib/constrain';
-import { type Path, type Value } from '../lib/path';
-import { type UseStoreOptions } from './useStore';
-export declare function useProp<T, S>(store: Store<T>, selector: Selector<T, S>, updater: (value: S) => Update<T>, options?: UseStoreOptions<S>): [value: S, setValue: Store<S>['set']];
-export declare function useProp<T, const P>(store: Store<T>, selector: Constrain<P, Path<T>>, options?: UseStoreOptions<Value<T, P>>): [value: Value<T, P>, setValue: Store<Value<T, P>>['set']];
-export declare function useProp<T>(store: Store<T>, options?: UseStoreOptions<T>): [value: T, setValue: Store<T>['set']];

package/dist/types/react/useStore.d.ts

@@ -1,16 +0,0 @@
-import type { Selector, SubscribeOptions } from '../core/commonTypes';
-import type { Store } from '../core/store';
-import type { Constrain } from '../lib/constrain';
-import { type Path, type Value } from '../lib/path';
-export interface UseStoreOptions<S> extends Omit<SubscribeOptions, 'runNow' | 'passive'> {
-    /**
-     * If true, the cache content can be consumed but no fetch will be triggered.
-     * @default false
-     */
-    passive?: boolean;
-    disableTrackingProxy?: boolean;
-    withViewTransition?: boolean | ((value: S) => unknown);
-}
-export declare function useStore<T, S>(store: Store<T>, selector: Selector<T, S>, option?: UseStoreOptions<S>): S;
-export declare function useStore<T, const P>(store: Store<T>, selector: Constrain<P, Path<T>>, option?: UseStoreOptions<Value<T, P>>): Value<T, P>;
-export declare function useStore<T>(store: Store<T>, option?: UseStoreOptions<T>): T;

package/dist/types/react/useUrlParamScope.d.ts

@@ -1,4 +0,0 @@
-export declare function useUrlParamScope({ key, type, }: {
-    key: string | string[];
-    type?: 'search' | 'hash';
-}): void;