@xyo-network/react-form-group 2.81.10 → 2.83.0

package/dist/browser/index.d.ts

@@ -1,6 +1,228 @@
-export * from './context/index.js';
-export * from './control/index.js';
-export * from './FormGroup.js';
-export * from './InputError.js';
-export * from './storage/index.js';
-//# sourceMappingURL=index.d.ts.map
+import * as react from 'react';
+import { PropsWithChildren } from 'react';
+import * as _xyo_network_react_shared from '@xyo-network/react-shared';
+import { ContextExState } from '@xyo-network/react-shared';
+import * as _xyo_network_payload_model from '@xyo-network/payload-model';
+import { Payload } from '@xyo-network/payload-model';
+import { BaseParams, EmptyObject } from '@xylabs/object';
+import { BaseEmitter } from '@xyo-network/module-abstract';
+import { Promisable } from '@xylabs/promise';
+import * as react_jsx_runtime from 'react/jsx-runtime';
+import { ArchivistInstance } from '@xyo-network/archivist-model';
+
+type ValidControlValue = string | undefined;
+
+interface SetOptions {
+    disableEmit?: boolean;
+}
+interface ControlSerializeSettings {
+    sensitive?: boolean;
+    serializable?: boolean;
+}
+interface ControlValueAccessor<T = ValidControlValue> {
+    readonly error: string;
+    readonly previousValue: T;
+    readonly serializeSettings: ControlSerializeSettings;
+    readonly touched: boolean;
+    readonly value: T;
+    registerOnChange(fn: (value: T) => void): void;
+    registerOnErrorChange(fn: (error: string) => void): void;
+    registerOnTouched(fn: (isTouched: boolean) => void): void;
+    setTouched(isTouched: boolean): void;
+    setValue(fieldValue: T, options?: SetOptions): void;
+}
+
+type ControlValueAccessorBaseConfig = {
+    disableEvents?: boolean;
+};
+declare const DefaultSetOptions: SetOptions;
+type ControlValueAccessorBaseEvents<TValue = ValidControlValue> = {
+    errorChanged: {
+        error: string;
+    };
+    touchChanged: {
+        touched: boolean;
+    };
+    valueChanged: {
+        value: TValue;
+    };
+};
+declare class ControlValueAccessorBase<TValue = ValidControlValue, TEventData extends ControlValueAccessorBaseEvents<TValue> = ControlValueAccessorBaseEvents<TValue>> extends BaseEmitter<BaseParams, TEventData> implements ControlValueAccessor<TValue> {
+    private config;
+    private _error;
+    private _previousValue;
+    private _serializeSettings;
+    private _touched;
+    private _value;
+    constructor(config: ControlValueAccessorBaseConfig);
+    get error(): string;
+    get previousValue(): TValue;
+    get serializeSettings(): ControlSerializeSettings;
+    get touched(): boolean;
+    get value(): TValue;
+    onChange: (_: TValue) => void;
+    onErrorChange: (error: string) => void;
+    onTouched: (_isTouched: boolean) => void;
+    registerOnChange(fn: (_value: TValue) => void): void;
+    registerOnErrorChange(fn: (error: string) => void): void;
+    registerOnTouched(fn: (isTouched: boolean) => void): void;
+    setTouched(isTouched: boolean): void;
+    setValue(value: TValue, options?: SetOptions): void;
+    protected setError(error: string): void;
+    protected setPreviousValue(value: TValue): void;
+    protected setSerializeSettings(settings: ControlSerializeSettings): void;
+}
+
+declare const VALID: "VALID";
+declare const INVALID: "INVALID";
+declare const PENDING: "PENDING";
+declare const DISABLED: "DISABLED";
+type FormControlStatus = typeof VALID | typeof INVALID | typeof PENDING | typeof DISABLED;
+
+type AbstractControlEvents<TValue> = ControlValueAccessorBaseEvents<TValue> & {
+    statusChanged: {
+        status: FormControlStatus;
+    };
+};
+declare class AbstractControl<TValue extends ValidControlValue = ValidControlValue> extends ControlValueAccessorBase<TValue, AbstractControlEvents<TValue>> {
+    private _status;
+    constructor();
+    get disabled(): boolean;
+    get enabled(): boolean;
+    get invalid(): boolean;
+    get pending(): boolean;
+    get rawValue(): TValue;
+    get status(): FormControlStatus | undefined;
+    get valid(): boolean;
+    setErrorAndValidity(error: string, status: FormControlStatus): void;
+    setStatus(status: FormControlStatus): void;
+    validate(): boolean;
+}
+
+type CursorPosition = {
+    current: number | undefined;
+    previous: number | undefined;
+};
+interface FormControlValidator {
+    blurError?: (value: string) => void;
+    changeError?: (value: string) => void;
+    pattern?: RegExp;
+    patternStrict?: RegExp;
+    required?: boolean;
+}
+interface FormControlMask {
+    cursorPosition: CursorPosition;
+    getCursorPosition?: () => number | undefined;
+    mask?: (value: string) => string;
+    onCursorChange?: (cursor: number | undefined) => void;
+    unmask?: (value: string) => string;
+}
+interface FormControl<TProps extends EmptyObject = EmptyObject> extends FormControlValidator, FormControlMask, AbstractControl {
+    readonly name?: string;
+    props: TProps;
+}
+
+declare abstract class FormControlBase<TProps extends EmptyObject = EmptyObject> extends AbstractControl implements FormControl {
+    cursorPosition: CursorPosition;
+    invalidMessage: string;
+    pattern: RegExp;
+    patternStrict: RegExp;
+    props: TProps;
+    required: boolean;
+    private _name;
+    constructor();
+    get name(): string | undefined;
+    get rawValue(): ValidControlValue;
+    blurError?(value: string): void | undefined;
+    changeError?(value: string): void;
+    getCursorPosition?(): number | undefined;
+    mask?(value: string): string;
+    onCursorChange: (cursor: number | undefined) => void;
+    setValue(value: string | undefined, setOptions: SetOptions): void;
+    unmask?(value: string): string;
+    validate(): boolean;
+    protected setName(name: string | undefined): void;
+}
+
+type ErrorSummary = {
+    errorMessage: string;
+    invalidFields: string[];
+};
+
+interface FormGroupStorage<TValue extends Payload = Payload> {
+    clear: () => Promisable<void>;
+    get: () => Promisable<TValue | undefined>;
+    insert: (state: TValue) => Promisable<void>;
+}
+
+declare class ArchivistFormGroupStorage implements FormGroupStorage {
+    private archivist;
+    constructor(archivist: ArchivistInstance);
+    clear(): Promise<void>;
+    get(): Promise<_xyo_network_payload_model.WithMeta<{
+        schema: string;
+    } & _xyo_network_payload_model.PayloadFields> | undefined>;
+    insert(value: Payload): Promise<void>;
+}
+
+type PayloadWithTimestamp = Payload<{
+    timestamp?: number;
+}>;
+type KeyOfString<T> = keyof T extends string ? keyof T : never;
+type FormGroupErrors<TValue> = Record<KeyOfString<TValue>, string>;
+type FormGroupParams<TStorageValue extends Payload = Payload> = {
+    serialize?: boolean;
+    storage?: {
+        sensitive?: FormGroupStorage<TStorageValue>;
+        storage?: FormGroupStorage<TStorageValue>;
+    };
+    ttlStorage?: number;
+};
+declare class FormGroup<TValue extends PayloadWithTimestamp = PayloadWithTimestamp, TStorageValue extends PayloadWithTimestamp = PayloadWithTimestamp> extends AbstractControl {
+    private fgParams?;
+    private _controls;
+    private serializeListeners;
+    private serializedSensitiveState;
+    private serializedState;
+    constructor(fgParams?: FormGroupParams<TStorageValue> | undefined);
+    get errorSummary(): ErrorSummary;
+    get errors(): FormGroupErrors<TValue>;
+    get nonSensitiveStorage(): FormGroupStorage<TStorageValue> | undefined;
+    get sensitiveStorage(): FormGroupStorage<TStorageValue> | undefined;
+    get touched(): boolean;
+    get valid(): boolean;
+    get values(): TValue;
+    getControl(name: string): Record<KeyOfString<TValue>, AbstractControl<ValidControlValue>>[KeyOfString<TValue>];
+    getSerializedValue(name: string, sensitive?: boolean): Promise<string | undefined>;
+    registerControl(name: string, control: AbstractControl): void;
+    resetControls(): void;
+    resetValues(): void;
+    unregisterControl(name: string): void;
+    validateFields(requiredFields?: string[] | undefined): void;
+    private serializeControlValue;
+    private serializeValues;
+    private setStateValueFromStorage;
+}
+
+interface FormGroupContextWithPayloadState<TValue extends Payload = Payload, TStorageValue extends Payload = Payload> extends ContextExState {
+    formGroup?: FormGroup<TValue, TStorageValue>;
+}
+
+declare const FormGroupBaseContext: react.Context<FormGroupContextWithPayloadState<{
+    schema: string;
+} & _xyo_network_payload_model.PayloadFields, {
+    schema: string;
+} & _xyo_network_payload_model.PayloadFields> & _xyo_network_react_shared.ContextExState>;
+
+interface FormGroupPayloadProviderProps<TStorage extends Payload = Payload> extends PropsWithChildren {
+    params?: FormGroupParams<TStorage>;
+}
+declare const FormGroupPayloadProvider: ({ children, params, ...props }: FormGroupPayloadProviderProps) => react_jsx_runtime.JSX.Element;
+
+declare const useFormGroup: (required?: boolean) => Omit<FormGroupContextWithPayloadState<{
+    schema: string;
+} & _xyo_network_payload_model.PayloadFields, {
+    schema: string;
+} & _xyo_network_payload_model.PayloadFields> & _xyo_network_react_shared.ContextExState, "provided">;
+
+export { AbstractControl, type AbstractControlEvents, ArchivistFormGroupStorage, type ControlSerializeSettings, type ControlValueAccessor, ControlValueAccessorBase, type ControlValueAccessorBaseConfig, type ControlValueAccessorBaseEvents, type CursorPosition, DISABLED, DefaultSetOptions, type ErrorSummary, type FormControl, FormControlBase, type FormControlMask, type FormControlStatus, type FormControlValidator, FormGroup, FormGroupBaseContext, type FormGroupContextWithPayloadState, type FormGroupParams, FormGroupPayloadProvider, type FormGroupPayloadProviderProps, type FormGroupStorage, INVALID, type KeyOfString, PENDING, type PayloadWithTimestamp, type SetOptions, VALID, type ValidControlValue, useFormGroup };