cross-state 0.53.3 → 0.54.1

package/dist/react/index.d.ts

@@ -0,0 +1,306 @@
+import "../scope-DI1OFHcr.js";
+import { Constrain, Duration, GetKeys, Join, MaybePromise, Object_, Path as Path$1, PathAsString, Selector, Store, Update, UpdateFunction, Value, WildcardPathAsString, WildcardValue } from "../store-DKaeE840.js";
+import { ScopeProps, ScopeProvider, UseCacheArray, UseCacheValue, UseStoreOptions, cacheMethods, scopeMethods, storeMethods, useCache, useScope, useStore } from "../storeMethods-C4luym7C.js";
+import React$1, { Component, ComponentPropsWithoutRef, Context, FormEvent, FunctionComponent, HTMLProps, ReactNode } from "react";
+
+//#region src/react/form/customInput.d.ts
+interface CustomInputProps extends React.HTMLAttributes<HTMLDivElement> {
+  name: string;
+  children?: ReactNode;
+}
+declare function CustomInput({
+  name,
+  children,
+  ...props
+}: CustomInputProps): React.JSX.Element;
+//#endregion
+//#region src/react/form/formField.d.ts
+interface FormFieldComponentProps<TValue, TPath> {
+  name: TPath;
+  value: TValue;
+  onChange: (event: {
+    target: {
+      value: TValue;
+    };
+  } | TValue | undefined, ...args: any[]) => void;
+  onBlur: (...args: any[]) => void;
+}
+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);
+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>>;
+type FormFieldProps<TPath, TDraft> = {
+  name: TPath & PathAsString<TDraft>;
+  commitOnBlur?: boolean;
+  commitDebounce?: number;
+};
+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>;
+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>;
+})>;
+//#endregion
+//#region src/react/form/formForEach.d.ts
+type ElementName<TDraft, TPath extends string> = keyof { [Path in TPath as Join<Path, GetKeys<NonNullable<Value<TDraft, Path>>> & (string | number)>]: 1 };
+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;
+}
+//#endregion
+//#region src/react/form/useFormAutosave.d.ts
+interface FormAutosaveOptions<TDraft, TOriginal> {
+  save: (draft: TDraft, form: FormContext<TDraft, TOriginal>) => MaybePromise<void>;
+  debounce?: Duration;
+  resetAfterSave?: boolean;
+}
+//#endregion
+//#region src/react/form/form.d.ts
+type Transform<TDraft> = Path$1<TDraft> | "" extends infer TPath ? TPath extends TPath ? {
+  update: (value: Value<TDraft, TPath>, store: Store<TDraft>) => void | TDraft;
+} & (TPath extends "" ? {
+  trigger?: "";
+} : {
+  trigger: TPath;
+}) : never : never;
+interface FormOptions<TDraft, TOriginal> {
+  defaultValue: TDraft;
+  validations?: Validations<TDraft, TOriginal>;
+  localizeError?: (error: string, field: string) => string | undefined;
+  autoSave?: FormAutosaveOptions<TDraft, TOriginal>;
+  transform?: Transform<TDraft>[];
+  validatedClass?: string;
+}
+type Validations<TDraft, TOriginal> = { [TPath in WildcardPathAsString<TDraft>]?: Record<string, Validation<TDraft, TOriginal, TPath>> } & Record<string, Record<string, Validation<TDraft, TOriginal, any>>>;
+type Validation<TDraft, TOriginal, TPath> = (value: WildcardValue<TDraft, TPath>, context: {
+  draft: TDraft;
+  original: TOriginal;
+  field: PathAsString<TDraft> | "";
+}) => boolean;
+type Field<TDraft, TOriginal, TPath extends string> = {
+  originalValue: Value<TOriginal, TPath> | undefined;
+  value: Value<TDraft, TPath>;
+  setValue: (value: Update<Value<TDraft, TPath>>) => void;
+  hasChange: boolean;
+  errors: string[];
+} & (Value<TDraft, TPath> extends Object_ ? FieldHelperMethods<TDraft, TPath> : {});
+type FieldHelperMethods<TDraft, TPath extends string> = {
+  names: ElementName<TDraft, TPath>[];
+  add: NonNullable<Value<TDraft, TPath>> extends readonly (infer T)[] ? (element: T) => void : NonNullable<Value<TDraft, TPath>> extends Record<infer K, infer V> ? (key: K, value: V) => void : never;
+  remove: Value<TDraft, TPath> extends readonly any[] ? (index: number) => void : (key: string) => void;
+};
+interface FormState<TDraft> {
+  draft: TDraft | undefined;
+  hasTriggeredValidations: boolean;
+  saveScheduled: boolean;
+  saveInProgress: boolean;
+}
+interface FormDerivedState<TDraft> {
+  draft: TDraft;
+  hasTriggeredValidations: boolean;
+  saveScheduled: boolean;
+  saveInProgress: boolean;
+  hasChanges: boolean;
+  errors: Map<string, string[]>;
+  isValid: boolean;
+}
+interface FormContext<TDraft, TOriginal> {
+  formState: Store<FormState<TDraft>>;
+  options: FormOptions<TDraft, TOriginal>;
+  original: TOriginal | undefined;
+  getField: <TPath extends string>(path: TPath) => Field<TDraft, TOriginal, TPath>;
+  getDraft: () => TDraft;
+  hasTriggeredValidations: () => boolean;
+  saveScheduled: () => boolean;
+  saveInProgress: () => boolean;
+  hasChanges: () => boolean;
+  getErrors: () => Map<string, string[]>;
+  isValid: () => boolean;
+  validate: () => boolean;
+  reset: () => void;
+}
+interface FormInstance<TDraft, TOriginal> extends FormDerivedState<TDraft>, Pick<FormContext<TDraft, TOriginal>, "options" | "original" | "getField" | "validate" | "reset"> {}
+declare class Form<TDraft, TOriginal extends TDraft = TDraft> {
+  readonly options: FormOptions<TDraft, TOriginal>;
+  context: Context<FormContext<TDraft, TOriginal> | null>;
+  constructor(options: FormOptions<TDraft, TOriginal>);
+  useForm(): FormContext<TDraft, TOriginal>;
+  useFormState<S>(selector: (state: FormInstance<TDraft, TOriginal>) => S, useStoreOptions?: UseStoreOptions<S>): S;
+  useField<TPath extends string>(path: TPath, useStoreOptions?: UseStoreOptions<any>): Field<TDraft, TOriginal, TPath>;
+  Form({
+    original,
+    defaultValue,
+    validations,
+    localizeError,
+    autoSave,
+    transform,
+    validatedClass,
+    ...formProps
+  }: {
+    original?: TOriginal;
+    onSubmit?: (event: FormEvent<HTMLFormElement>, form: FormInstance<TDraft, TOriginal>) => void;
+  } & Partial<FormOptions<TDraft, TOriginal>> & Omit<HTMLProps<HTMLFormElement>, "defaultValue" | "autoSave" | "onSubmit">): React.JSX.Element;
+  FormState<S>({
+    selector,
+    children
+  }: {
+    selector: (form: FormInstance<TDraft, TOriginal>) => S;
+    children: (selectedState: S) => ReactNode;
+  }): React.JSX.Element;
+  Field<const TPath extends string>(props: FormFieldPropsWithRender<TDraft, TOriginal, TPath>): React.JSX.Element;
+  Field<const TPath extends string, const TComponent extends FormFieldComponent = "input">(props: FormFieldPropsWithComponent<TDraft, TOriginal, TPath, TComponent>): React.JSX.Element;
+  ForEach<const TPath extends string>(props: FormForEachProps<TDraft, TPath>): React.JSX.Element;
+  withForm<TProps extends Record<string, unknown>>(Component: React.ComponentType<TProps>, formProps?: Parameters<this["Form"]>[0]): FunctionComponent<TProps>;
+}
+declare function createForm<TDraft, TOriginal extends TDraft = TDraft>(options: FormOptions<TDraft, TOriginal>): Form<TDraft, TOriginal>;
+//#endregion
+//#region src/react/loadingBoundary.d.ts
+interface LoadingBoundaryEntry {
+  label?: ReactNode;
+}
+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;
+}
+declare function LoadingBoundary({
+  fallback,
+  children,
+  isLoading: isLoadingExternal
+}: LoadingBoundaryProps): React.JSX.Element;
+declare function useLoadingBoundary(isLoading: boolean | undefined, label?: ReactNode): void;
+//#endregion
+//#region src/react/url/urlContext.d.ts
+type Location = string | {
+  pathname: string;
+  search: string;
+  hash: string;
+};
+interface UrlContextType {
+  location: Location;
+  navigate: (navigate: (from: Location) => string) => void;
+}
+type UrlContextProviderProps = {
+  children?: ReactNode;
+} & ({
+  location: UrlContextType["location"];
+} | {
+  locationHook: () => UrlContextType["location"];
+}) & ({
+  navigate: UrlContextType["navigate"];
+} | {
+  navigateHook: () => UrlContextType["navigate"];
+});
+declare const UrlContext: Context<UrlContextType | undefined>;
+declare function UrlProvider({
+  children,
+  ...props
+}: UrlContextProviderProps): React$1.JSX.Element;
+declare function useUrlContext(): UrlContextType;
+//#endregion
+//#region src/react/url/urlOptions.d.ts
+interface UrlOptions<T> {
+  key: string;
+  type?: "search" | "hash";
+  serialize?: (value: T) => string;
+  deserialize?: (value: string) => T;
+  defaultValue: T;
+  writeDefaultValue?: boolean;
+  onCommit?: (value: T) => void;
+  persist?: {
+    id: string;
+  } | null;
+}
+interface UrlOptionsWithoutDefaults<T> extends Omit<UrlOptions<T | undefined>, "defaultValue"> {
+  defaultValue?: T | undefined;
+}
+declare function createUrlOptions<T>(options: UrlOptions<T>): Required<UrlOptions<T>>;
+declare function createUrlOptions<T>(options: UrlOptionsWithoutDefaults<T>): Required<UrlOptions<T | undefined>>;
+//#endregion
+//#region src/react/url/urlStore.d.ts
+declare class UrlStore<T> {
+  readonly options: Required<UrlOptions<T>>;
+  constructor(options: Required<UrlOptions<T>>);
+  useStore(): T;
+  useProp(): [T, update: (value: T) => void];
+  parse(location: Location): T | undefined;
+}
+declare function createUrlStore<T>(options: UrlOptions<T>): UrlStore<T>;
+declare function createUrlStore<T>(options: UrlOptionsWithoutDefaults<T>): UrlStore<T | undefined>;
+//#endregion
+//#region src/react/url/useUrlParam.d.ts
+declare function useUrlParam<T>(store: UrlStore<T>): [T, update: UpdateFunction<T>];
+declare function useUrlParam<T>(options: UrlOptions<T>): [T, update: UpdateFunction<T>];
+declare function useUrlParam<T>(options: UrlOptionsWithoutDefaults<T>): [T | undefined, update: UpdateFunction<T | undefined>];
+//#endregion
+//#region src/react/useDecoupledState.d.ts
+interface UseDecoupledStateOptions<T> {
+  debounce?: Duration;
+  throttle?: Duration;
+  onCommit?: (value: T) => void;
+}
+declare function useDecoupledState<T>(value: T, onChange: (value: T) => void, options?: UseDecoupledStateOptions<T>): [state: T, setState: (value: T) => void];
+//#endregion
+//#region src/react/useProp.d.ts
+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"]];
+declare function useProp<T, const P>(store: Store<T>, selector: Constrain<P, Path$1<T>>, options?: UseStoreOptions<Value<T, P>>): [value: Value<T, P>, setValue: Store<Value<T, P>>["set"]];
+declare function useProp<T>(store: Store<T>, options?: UseStoreOptions<T>): [value: T, setValue: Store<T>["set"]];
+//#endregion
+export { CustomInput, CustomInputProps, Field, Form, FormContext, FormDerivedState, FormFieldComponent, FormFieldProps, FormInstance, FormOptions, FormState, LoadingBoundary, type LoadingBoundaryEntry, type LoadingBoundaryProps, type ScopeProps, ScopeProvider, Transform, UrlContext, type UrlContextProviderProps, type UrlContextType, type UrlOptions, type UrlOptionsWithoutDefaults, UrlProvider, type UrlStore, type UseCacheArray, type UseCacheValue, type UseDecoupledStateOptions, type UseStoreOptions, Validation, Validations, cacheMethods, createForm, createUrlOptions, createUrlStore, scopeMethods, storeMethods, useCache, useDecoupledState, useLoadingBoundary, useProp, useScope, useStore, useUrlContext, useUrlParam };
+//# sourceMappingURL=index.d.ts.map