@unicom-cloud/ui 0.8.41

package/types/form/interface.d.ts

@@ -0,0 +1,228 @@
+import { Options as ScrollIntoViewOptions } from '@unicom-cloud/scroll-into-view-if-needed';
+import { ValidateMessagesTemplateType } from '@unicom-cloud/utils/validate';
+import React, { CSSProperties, FormHTMLAttributes, HTMLAttributes, ReactElement, ReactNode } from 'react';
+import { JSX } from 'react/jsx-runtime';
+import { ColProps } from '../grid/Col';
+import type { TooltipProps } from '../tooltip/interface';
+import Store from './store';
+export type IndexedObject = {
+    [key: string]: any;
+};
+export type KeyType = string | number | symbol;
+export type ComponentType = keyof JSX.IntrinsicElements | React.ComponentType<any>;
+export type FieldError<FieldValue = any> = {
+    value?: FieldValue;
+    message?: ReactNode;
+    type?: string;
+    requiredError?: boolean;
+};
+export type ValidateFieldsErrors<FieldValue = any, FieldKey extends KeyType = string> = Record<FieldKey, FieldValue> | undefined | null;
+export interface FormProps<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> extends Omit<FormHTMLAttributes<any>, 'className' | 'onChange' | 'onSubmit' | 'onReset'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    prefixCls?: string;
+    form?: FormInstance<FormData, FieldValue, FieldKey>;
+    id?: string;
+    layout?: 'horizontal' | 'vertical' | 'inline';
+    size?: 'mini' | 'small' | 'default' | 'large';
+    labelCol?: ColProps;
+    wrapperCol?: ColProps;
+    requiredSymbol?: boolean | {
+        position: 'start' | 'end';
+    };
+    labelAlign?: 'left' | 'right';
+    initialValues?: Partial<FormData>;
+    validateTrigger?: string | string[];
+    onValuesChange?: (value: Partial<FormData>, values: Partial<FormData>) => void;
+    onChange?: (value: Partial<FormData>, values: Partial<FormData>) => void;
+    wrapper?: ComponentType;
+    wrapperProps?: IndexedObject;
+    disabled?: boolean;
+    colon?: boolean | ReactNode;
+    scrollToFirstError?: boolean | ScrollIntoViewOptions;
+    validateMessages?: Partial<{
+        [key in keyof ValidateMessagesTemplateType]: ValidateMessagesTemplateType[key] extends string ? ValidateMessagesTemplateType[key] | ((data: any, { label }: {
+            label: any;
+        }) => any) : Partial<Record<keyof ValidateMessagesTemplateType[key], string | ((data: any, { label }: {
+            label: any;
+        }) => any)>>;
+    }>;
+    onSubmit?: (values: FormData) => void;
+    onReset?: (values: FormData) => void;
+    onSubmitFailed?: (errors: {
+        [key: string]: FieldError;
+    }) => void;
+}
+export interface RulesProps<FieldValue = any> {
+    validateTrigger?: string | string[];
+    validateLevel?: 'error' | 'warning';
+    required?: boolean;
+    type?: string;
+    length?: number;
+    maxLength?: number;
+    minLength?: number;
+    includes?: boolean;
+    deepEqual?: any;
+    empty?: boolean;
+    min?: number;
+    max?: number;
+    equal?: number;
+    positive?: boolean;
+    negative?: boolean;
+    hasKeys?: string[];
+    match?: RegExp;
+    uppercase?: boolean;
+    lowercase?: boolean;
+    true?: boolean;
+    false?: boolean;
+    validator?: (value: FieldValue | undefined, callback: (error?: ReactNode) => void) => void;
+    message?: ReactNode;
+}
+export type FormItemChildrenFn<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = (formData: any, form: FormInstance<FormData, FieldValue, FieldKey>) => React.ReactNode;
+export interface FormItemProps<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> extends Omit<HTMLAttributes<any>, 'className' | 'children'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    prefixCls?: string;
+    store?: FormInstance<FormData, FieldValue, FieldKey>;
+    initialValue?: FieldValue;
+    field?: FieldKey;
+    label?: ReactNode;
+    tooltip?: ReactNode | (TooltipProps & {
+        icon?: ReactElement;
+    });
+    labelCol?: ColProps;
+    wrapperCol?: ColProps;
+    colon?: boolean | ReactNode;
+    disabled?: boolean;
+    rules?: RulesProps<FieldValue>[];
+    trigger?: string;
+    triggerPropName?: string;
+    getValueFromEvent?: (...args: any[]) => FieldValue;
+    validateTrigger?: string | string[];
+    noStyle?: boolean | {
+        showErrorTip: boolean;
+    };
+    required?: boolean;
+    hidden?: boolean;
+    extra?: ReactNode;
+    validateStatus?: 'success' | 'warning' | 'error' | 'validating';
+    hasFeedback?: boolean;
+    help?: ReactNode;
+    normalize?: (value: FieldValue | undefined, prevValue: FieldValue | undefined, allValues: Partial<FormData>) => any;
+    formatter?: (value: FieldValue | undefined) => any;
+    dependencies?: string[];
+    shouldUpdate?: boolean | ((prevValues: Partial<FormData>, currentValues: Partial<FormData>, info: {
+        isFormList?: boolean;
+        field?: FieldKey | FieldKey[];
+        isInner?: boolean;
+    }) => boolean);
+    labelAlign?: 'left' | 'right';
+    layout?: 'horizontal' | 'vertical' | 'inline';
+    requiredSymbol?: boolean | {
+        position: 'start' | 'end';
+    };
+    isFormList?: boolean;
+    children?: React.ReactNode | FormItemChildrenFn<FormData, FieldValue, FieldKey>;
+}
+export interface FormControlProps<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> {
+    field?: FieldKey;
+    _key?: FieldKey;
+    initialValue?: FieldValue;
+    dependencies?: FormItemProps['dependencies'];
+    getValueFromEvent?: FormItemProps['getValueFromEvent'];
+    rules?: RulesProps<FieldValue>[];
+    trigger?: string;
+    triggerPropName?: string;
+    validateTrigger?: string | string[];
+    normalize?: (value: FieldValue | undefined, prevValue: FieldValue | undefined, allValues: Partial<FormData>) => any;
+    formatter?: FormItemProps['formatter'];
+    onValuesChange?: (value: Partial<FormData>, values: Partial<FormData>) => void;
+    noStyle?: boolean;
+    shouldUpdate?: FormItemProps['shouldUpdate'];
+    disabled?: boolean;
+    validateStatus?: 'success' | 'warning' | 'error' | 'validating';
+    help?: ReactNode;
+    isFormList?: boolean;
+    hasFeedback?: boolean;
+    children?: ReactNode;
+}
+export interface FormListProps<SubFieldValue = any, SubFieldKey extends KeyType = string, FieldKey extends KeyType = string> {
+    field: FieldKey;
+    initialValue?: SubFieldValue[];
+    noStyle?: FormItemProps['noStyle'];
+    rules?: RulesProps<SubFieldValue[]>[];
+    children?: (fields: {
+        key: number;
+        field: SubFieldKey;
+    }[], operation: {
+        add: (defaultValue?: SubFieldValue, index?: number) => void;
+        remove: (index: number) => void;
+        move: (fromIndex: number, toIndex: number) => void;
+    }) => React.ReactNode;
+}
+export type FormContextProps<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = Pick<FormProps<FormData, FieldValue, FieldKey>, 'prefixCls' | 'labelCol' | 'wrapperCol' | 'requiredSymbol' | 'labelAlign' | 'disabled' | 'colon' | 'layout' | 'validateTrigger'> & {
+    validateMessages?: FormProps['validateMessages'];
+    getFormElementId?: (field: FieldKey) => string;
+    store?: FormInstance<FormData, FieldValue, FieldKey>;
+};
+export type FormItemContextProps<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = FormContextProps<FormData, FieldValue, FieldKey> & {
+    validateMessages?: FormProps['validateMessages'];
+    updateFormItem?: (field: string, params: {
+        errors?: FieldError<FieldValue>;
+        warnings?: ReactNode[];
+    }) => void;
+};
+export type FormInstance<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = Pick<Store<FormData, FieldValue, FieldKey>, 'getFieldsValue' | 'getFieldValue' | 'getFieldError' | 'getFieldsError' | 'getTouchedFields' | 'getFields' | 'getInitialValues' | 'setInitialValues' | 'setInitialValue' | 'setFieldValue' | 'setFieldsValue' | 'setFields' | 'resetFields' | 'clearFields' | 'submit' | 'validate' | 'getFieldsState'> & {
+    scrollToField: (field: FieldKey, options?: ScrollIntoViewOptions) => void;
+    getInnerMethods: (inner?: boolean) => InnerMethodsReturnType<FormData, FieldValue, FieldKey>;
+};
+export type InnerMethodsReturnType<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> = Pick<Store<FormData, FieldValue, FieldKey>, 'registerField' | 'registerStateWatcher' | 'registerFormWatcher' | 'registerWatcher' | 'innerSetInitialValues' | 'innerSetInitialValue' | 'innerSetCallbacks' | 'innerSetFieldValue' | 'innerGetStore' | 'innerGetStoreStatus' | 'innerCollectFormState' | 'innerGetFieldValue'>;
+export interface ValidateOptions {
+    validateOnly?: boolean;
+}
+export interface FormValidateFn<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> {
+    (): Promise<FormData>;
+    (fields: FieldKey[]): Promise<Partial<FormData>>;
+    (options: ValidateOptions): Promise<Partial<FormData>>;
+    (callback: (errors?: ValidateFieldsErrors<FieldValue, FieldKey>, values?: FormData) => void): void;
+    (fields: FieldKey[], callback: (errors?: ValidateFieldsErrors<FieldValue, FieldKey>, values?: Partial<FormData>) => void): void;
+    (fields: FieldKey[], options: ValidateOptions): Promise<Partial<FormData>>;
+    (options: ValidateOptions, callback: (errors?: ValidateFieldsErrors<FieldValue, FieldKey>, values?: Partial<FormData>) => void): void;
+    (fields: FieldKey[], options: ValidateOptions, callback: (errors?: ValidateFieldsErrors<FieldValue, FieldKey>, values?: Partial<FormData>) => void): void;
+}
+export declare const VALIDATE_STATUS: {
+    error: string;
+    success: string;
+    warning: string;
+    validating: string;
+};
+export interface FormProviderProps {
+    onFormValuesChange?: (id: string | undefined, changedValues: any, { forms, }: {
+        forms: {
+            [key: string]: FormInstance;
+        };
+    }) => void;
+    onFormSubmit?: (id: string | undefined, values: any, { forms, }: {
+        forms: {
+            [key: string]: FormInstance;
+        };
+    }) => void;
+    onFormReset?: (id: string | undefined, values: any, { forms, }: {
+        forms: {
+            [key: string]: FormInstance;
+        };
+    }) => void;
+}
+export type FieldState<FieldValue = any> = {
+    errors: FieldError<FieldValue>[];
+    warnings: ReactNode[];
+    validateStatus: FormItemProps['validateStatus'] | undefined;
+    isSubmitting: boolean;
+    isTouched: boolean;
+};
+export declare enum SubmitStatus {
+    init = "init",
+    error = "error",
+    success = "success",
+    submitting = "submitting"
+}

package/types/form/promisify.d.ts

@@ -0,0 +1,2 @@
+declare function promisify<T = any>(fn: (...args: any[]) => any): () => Promise<T>;
+export default promisify;

package/types/form/store.d.ts

@@ -0,0 +1,89 @@
+import React from 'react';
+import Control from './Control';
+import type { FieldError, FieldState, FormProps, FormValidateFn, KeyType } from './interface';
+import { SubmitStatus } from './interface';
+export type DeepPartial<T> = T extends object ? {
+    [P in keyof T]?: DeepPartial<T[P]>;
+} : T;
+export type NotifyType = 'setFieldValue' | 'reset' | 'innerSetValue';
+export type innerCallbackType = 'onValuesChange' | 'onSubmit' | 'onReset' | 'onChange' | 'onSubmitFailed';
+export type StoreChangeInfo<T> = {
+    prev: any;
+    field?: T | T[];
+    isFormList?: boolean;
+    ignore?: boolean;
+    changeValues?: {
+        [key in KeyType]: unknown;
+    };
+    data?: {
+        errors?: FieldError;
+        warnings?: React.ReactNode;
+        touched?: boolean;
+    };
+};
+declare class Store<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData> {
+    private submitStatus;
+    private registerFields;
+    private registerWatchers;
+    private registerStateWatchers;
+    private registerFormWatchers;
+    private touchedFields;
+    private store;
+    private initialValues;
+    private callbacks;
+    private notifyWatchers;
+    private notifyFormWatcher;
+    private notifyStateWatchers;
+    private triggerValuesChange;
+    private triggerTouchChange;
+    innerCollectFormState: () => void;
+    innerSetCallbacks: (values: Pick<FormProps<FormData, FieldValue, FieldKey>, innerCallbackType> & {
+        onValidateFail?: ((errors: { [key in FieldKey]: FieldError<FieldValue>; }) => void) | undefined;
+    }) => void;
+    registerFormWatcher: (item: any) => () => void;
+    registerStateWatcher: (item: any) => () => void;
+    registerWatcher: (item: any) => () => void;
+    registerField: (item: Control<FormData, FieldValue, FieldKey>) => () => void;
+    private getRegisteredFields;
+    getRegisteredField: (field?: FieldKey) => Control<FormData, FieldValue, FieldKey>;
+    private notify;
+    innerSetInitialValues: (values: Partial<FormData>) => void;
+    innerSetInitialValue: (field: FieldKey, value: FieldValue) => void;
+    private _getIterativelyKeysByField;
+    private _inTouchFields;
+    private _popTouchField;
+    private _pushTouchField;
+    innerSetFieldValue: (field: FieldKey, value: FieldValue, options?: {
+        isFormList?: boolean;
+        ignore?: boolean;
+    }) => void;
+    innerGetStore: () => Partial<FormData>;
+    innerGetStoreStatus: () => {
+        submitStatus: SubmitStatus;
+    };
+    innerGetFieldValue: (field: FieldKey) => any;
+    getTouchedFields: () => FieldKey[];
+    setFieldValue: (field: FieldKey, value: FieldValue) => void;
+    setFieldsValue: (values: DeepPartial<FormData>) => void;
+    setFields: (obj: { [field in FieldKey]?: {
+        value?: FieldValue | undefined;
+        error?: FieldError<FieldValue> | undefined;
+        touched?: boolean | undefined;
+        warning?: React.ReactNode;
+    } | undefined; }) => void;
+    getFieldValue: (field: FieldKey) => FieldValue;
+    getFieldError: (field: FieldKey) => FieldError<FieldValue> | null;
+    getFieldsError: (fields?: FieldKey[]) => { [key in FieldKey]?: FieldError<FieldValue> | undefined; };
+    getFields: () => Partial<FormData>;
+    getFieldsValue: (fields?: FieldKey[]) => Partial<FormData>;
+    getInitialValues: () => Partial<FormData>;
+    setInitialValues: (values: Partial<FormData>) => void;
+    setInitialValue: (field: FieldKey, value: FieldValue) => void;
+    resetFields: (fieldKeys?: FieldKey | FieldKey[]) => void;
+    validate: FormValidateFn<FormData, FieldValue, FieldKey>;
+    private toggleSubmitStatus;
+    submit: () => void;
+    getFieldsState: (fields?: FieldKey[]) => { [key in FieldKey]?: FieldState<FieldValue> | undefined; };
+    clearFields: (fieldKeys?: FieldKey | FieldKey[]) => void;
+}
+export default Store;

package/types/form/style/index.d.ts

@@ -0,0 +1,3 @@
+import '../../grid/style';
+import '../../style/index.less';
+import './index.less';

package/types/form/useForm.d.ts

@@ -0,0 +1,3 @@
+import type { FormInstance, KeyType } from './interface';
+export declare function getFormInstance<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData>(): FormInstance<FormData, FieldValue, FieldKey>;
+export default function useForm<FormData = any, FieldValue = FormData[keyof FormData], FieldKey extends KeyType = keyof FormData>(form?: FormInstance<FormData, FieldValue, FieldKey>): [FormInstance<FormData, FieldValue, FieldKey>];

package/types/form/util.d.ts

@@ -0,0 +1,14 @@
+import type { PropertyPath } from 'lodash';
+import { ReactNode } from 'react';
+import type { RulesProps } from '../form/interface';
+import type { FormProps, IndexedObject } from './interface';
+export declare function cloneDeep(value: any): any;
+export declare const formatValidateMsg: (validateMessages: FormProps['validateMessages'], info: {
+    label: ReactNode;
+}) => any;
+export declare function set<T extends IndexedObject>(target: T, field: PropertyPath, value: any): T;
+export declare function iterativelyGetKeys(_obj: any, _prefix?: string): any;
+export declare function isSyntheticEvent(e: any): boolean;
+export declare function schemaValidate(field: any, value: any, _rules: RulesProps[], validateMessages: any): Promise<unknown>;
+export declare function isFieldMatch(field: any, fields: any): any;
+export declare const ID_SUFFIX = "_input";

package/types/grid/Col.d.ts

@@ -0,0 +1,4 @@
+import type { ColProps } from './interface';
+declare const ColComponent: import("react").ForwardRefExoticComponent<ColProps & import("react").RefAttributes<unknown>>;
+export default ColComponent;
+export type { ColProps };

package/types/grid/Row.d.ts

@@ -0,0 +1,4 @@
+import type { RowProps } from './interface';
+declare const RowComponent: import("react").ForwardRefExoticComponent<RowProps & import("react").RefAttributes<unknown>>;
+export default RowComponent;
+export type { RowProps };

package/types/grid/context.d.ts

@@ -0,0 +1,19 @@
+import { GridItemData } from './interface';
+type RowContextType = {
+    gutter?: [number, number];
+    div?: boolean;
+};
+export declare const RowContext: import("react").Context<RowContextType>;
+type GridContextType = {
+    overflow?: boolean;
+    collapsed?: boolean;
+    displayIndexList?: number[];
+    cols?: number;
+    colGap?: number;
+};
+export declare const GridContext: import("react").Context<GridContextType>;
+export declare const GridDataCollectorContext: import("react").Context<Readonly<{
+    collectItemData?: ((index: number, itemData: GridItemData) => void) | undefined;
+    removeItemData?: ((index: number) => void) | undefined;
+}>>;
+export {};

package/types/grid/grid-item.d.ts

@@ -0,0 +1,7 @@
+import React from 'react';
+import type { GridItemProps } from './interface';
+declare const GridItemComponent: React.ForwardRefExoticComponent<GridItemProps & React.RefAttributes<unknown>> & {
+    __PQB_GRID_ITEM__: boolean;
+};
+export default GridItemComponent;
+export type { GridItemProps };

package/types/grid/grid.d.ts

@@ -0,0 +1,5 @@
+import React from 'react';
+import type { GridProps } from './interface';
+declare const GridComponent: React.ForwardRefExoticComponent<GridProps & React.RefAttributes<unknown>>;
+export default GridComponent;
+export type { GridProps };

package/types/grid/hook/useResponsiveState.d.ts

@@ -0,0 +1,2 @@
+import { ResponsiveValue } from '../interface';
+export declare const useResponsiveState: (val: number | ResponsiveValue, defaultValue: number, fallbackToXs?: boolean) => number;

package/types/grid/index.d.ts

@@ -0,0 +1,11 @@
+import './style';
+import Col from './Col';
+import Row from './Row';
+import GridItem from './grid-item';
+declare const Grid: import("react").ForwardRefExoticComponent<import("./interface").GridProps & import("react").RefAttributes<unknown>> & {
+    Col: typeof Col;
+    Row: typeof Row;
+    GridItem: typeof GridItem;
+};
+export default Grid;
+export type { ColProps, GridProps, ResponsiveValue, RowProps, } from './interface';

package/types/grid/interface.d.ts

@@ -0,0 +1,76 @@
+import { CSSProperties, HTMLAttributes, ReactNode } from 'react';
+export type GridResponsiveBreakpoint = 'xxxl' | 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+export type GridRowGutter = number | Partial<Record<GridResponsiveBreakpoint, number>>;
+export interface RowProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    gutter?: GridRowGutter | Array<GridRowGutter>;
+    div?: boolean;
+    align?: 'start' | 'center' | 'end' | 'stretch';
+    justify?: 'start' | 'center' | 'end' | 'space-around' | 'space-between';
+}
+export interface ColProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className' | 'ref'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    span?: number;
+    offset?: number;
+    order?: number;
+    push?: number;
+    pull?: number;
+    xs?: number | {
+        [key: string]: any;
+    };
+    sm?: number | {
+        [key: string]: any;
+    };
+    md?: number | {
+        [key: string]: any;
+    };
+    lg?: number | {
+        [key: string]: any;
+    };
+    xl?: number | {
+        [key: string]: any;
+    };
+    xxl?: number | {
+        [key: string]: any;
+    };
+    xxxl?: number | {
+        [key: string]: any;
+    };
+    flex?: FlexType;
+}
+export interface GridProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    cols?: number | ResponsiveValue;
+    rowGap?: number | ResponsiveValue;
+    colGap?: number | ResponsiveValue;
+    collapsed?: boolean;
+    collapsedRows?: number;
+}
+export interface GridItemProps extends Omit<HTMLAttributes<HTMLDivElement>, 'className'> {
+    style?: CSSProperties;
+    className?: string | string[];
+    span?: number | ResponsiveValue;
+    offset?: number | ResponsiveValue;
+    suffix?: boolean;
+    __index__?: number;
+    children?: ReactNode | ((info: {
+        overflow: boolean;
+    }) => ReactNode);
+}
+export interface GridItemData extends GridItemProps {
+    span: number;
+    offset: number;
+}
+export interface ResponsiveValue {
+    xxxl?: number;
+    xxl?: number;
+    xl?: number;
+    lg?: number;
+    md?: number;
+    sm?: number;
+    xs?: number;
+}
+export type FlexType = string | number | 'auto' | 'none';

package/types/grid/style/index.d.ts

@@ -0,0 +1,2 @@
+import '../../style/index.less';
+import './index.less';

package/types/grid/util.d.ts

@@ -0,0 +1,11 @@
+import { GridItemData } from './interface';
+export declare function resolveItemData(cols: number, { span, offset, suffix }: GridItemData): GridItemData;
+export declare function setItemVisible({ cols, collapsed, collapsedRows, itemDataList, }: {
+    cols: number;
+    collapsed: boolean;
+    collapsedRows: number;
+    itemDataList: GridItemData[];
+}): {
+    overflow: boolean;
+    displayIndexList: number[];
+};

package/types/hooks/component/UseKey.d.ts

@@ -0,0 +1,2 @@
+declare const UseKey: (props: any) => any;
+export default UseKey;

package/types/hooks/factory/createBreakpoint.d.ts

@@ -0,0 +1,4 @@
+declare const createBreakpoint: (breakpoints?: {
+    [name: string]: number;
+}) => () => string;
+export default createBreakpoint;

package/types/hooks/factory/createGlobalState.d.ts

@@ -0,0 +1,7 @@
+import { IHookStateInitAction, IHookStateSetAction } from '../misc/hookState';
+export declare function createGlobalState<S = any>(initialState: IHookStateInitAction<S>): () => [S, (state: IHookStateSetAction<S>) => void];
+export declare function createGlobalState<S = undefined>(): () => [
+    S,
+    (state: IHookStateSetAction<S>) => void
+];
+export default createGlobalState;

package/types/hooks/factory/createHTMLMediaHook.d.ts

@@ -0,0 +1,33 @@
+import React from 'react';
+export interface HTMLMediaProps extends React.AudioHTMLAttributes<any>, React.VideoHTMLAttributes<any> {
+    src: string;
+}
+export interface HTMLMediaState {
+    buffered: any[];
+    duration: number;
+    paused: boolean;
+    muted: boolean;
+    time: number;
+    volume: number;
+    playing: boolean;
+}
+export interface HTMLMediaControls {
+    play: () => Promise<void> | void;
+    pause: () => void;
+    mute: () => void;
+    unmute: () => void;
+    volume: (volume: number) => void;
+    seek: (time: number) => void;
+}
+type MediaPropsWithRef<T> = HTMLMediaProps & {
+    ref?: React.MutableRefObject<T | null>;
+};
+export default function createHTMLMediaHook<T extends HTMLAudioElement | HTMLVideoElement>(tag: 'audio' | 'video'): (elOrProps: HTMLMediaProps | React.ReactElement<HTMLMediaProps>) => readonly [React.ReactElement<MediaPropsWithRef<T>, string | React.JSXElementConstructor<any>>, HTMLMediaState, {
+    play: () => Promise<void> | undefined;
+    pause: () => void;
+    seek: (time: number) => void;
+    volume: (volume: number) => void;
+    mute: () => void;
+    unmute: () => void;
+}, React.MutableRefObject<T | null>];
+export {};

package/types/hooks/factory/createMemo.d.ts

@@ -0,0 +1,2 @@
+declare const createMemo: <T extends (...args: any) => any>(fn: T) => (...args: Parameters<T>) => ReturnType<T>;
+export default createMemo;

package/types/hooks/factory/createReducer.d.ts

@@ -0,0 +1,8 @@
+type Dispatch<Action> = (action: Action) => void;
+interface Store<Action, State> {
+    getState: () => State;
+    dispatch: Dispatch<Action>;
+}
+type Middleware<Action, State> = (store: Store<Action, State>) => (next: Dispatch<Action>) => (action: Action) => void;
+declare const createReducer: <Action, State>(...middlewares: Middleware<Action, State>[]) => (reducer: (state: State, action: Action) => State, initialState: State, initializer?: (value: State) => State) => [State, Dispatch<Action>];
+export default createReducer;

package/types/hooks/factory/createReducerContext.d.ts

@@ -0,0 +1,5 @@
+declare const createReducerContext: <R extends import("react").Reducer<any, any>>(reducer: R, defaultInitialState: React.ReducerState<R>) => readonly [() => [import("react").ReducerState<R>, import("react").Dispatch<import("react").ReducerAction<R>>], ({ children, initialState, }: {
+    children?: React.ReactNode;
+    initialState?: React.ReducerState<R>;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<[import("react").ReducerState<R>, import("react").Dispatch<import("react").ReducerAction<R>>] | undefined>>, import("react").Context<[import("react").ReducerState<R>, import("react").Dispatch<import("react").ReducerAction<R>>] | undefined>];
+export default createReducerContext;

package/types/hooks/factory/createRenderProp.d.ts

@@ -0,0 +1 @@
+export default function createRenderProp(hook: any, mapPropsToArgs?: (props: any) => any[]): (props: any) => any;

package/types/hooks/factory/createRouter.d.ts

@@ -0,0 +1,7 @@
+export interface RouterProviderProps {
+    route: string;
+    fullRoute?: string;
+    parent?: any;
+}
+declare const createRouter: () => void;
+export default createRouter;

package/types/hooks/factory/createStateContext.d.ts

@@ -0,0 +1,5 @@
+declare const createStateContext: <T>(defaultInitialValue: T) => readonly [() => [T, import("react").Dispatch<import("react").SetStateAction<T>>], ({ children, initialValue, }: {
+    children?: React.ReactNode;
+    initialValue?: T;
+}) => import("react").FunctionComponentElement<import("react").ProviderProps<[T, import("react").Dispatch<import("react").SetStateAction<T>>] | undefined>>, import("react").Context<[T, import("react").Dispatch<import("react").SetStateAction<T>>] | undefined>];
+export default createStateContext;

package/types/hooks/index.d.ts

@@ -0,0 +1,2 @@
+export { default as useVerificationCode } from "./use-verification-code";
+export { default as useWatermark } from "./use-watermark";

package/types/hooks/misc/hookState.d.ts

@@ -0,0 +1,8 @@
+export type IHookStateInitialSetter<S> = () => S;
+export type IHookStateInitAction<S> = S | IHookStateInitialSetter<S>;
+export type IHookStateSetter<S> = ((prevState: S) => S) | (() => S);
+export type IHookStateSetAction<S> = S | IHookStateSetter<S>;
+export type IHookStateResolvable<S> = S | IHookStateInitialSetter<S> | IHookStateSetter<S>;
+export declare function resolveHookState<S>(nextState: IHookStateInitAction<S>): S;
+export declare function resolveHookState<S, C extends S>(nextState: IHookStateSetAction<S>, currentState?: C): S;
+export declare function resolveHookState<S, C extends S>(nextState: IHookStateResolvable<S>, currentState?: C): S;

package/types/hooks/misc/parseTimeRanges.d.ts

@@ -0,0 +1,4 @@
+export default function parseTimeRanges(ranges: any): {
+    start: number;
+    end: number;
+}[];

package/types/hooks/misc/types.d.ts

@@ -0,0 +1,2 @@
+export type PromiseType<P extends Promise<any>> = P extends Promise<infer T> ? T : never;
+export type FunctionReturningPromise = (...args: any[]) => Promise<any>;

package/types/hooks/misc/util.d.ts

@@ -0,0 +1,5 @@
+export declare const noop: () => void;
+export declare function on<T extends Window | Document | HTMLElement | EventTarget>(obj: T | null, ...args: Parameters<T['addEventListener']> | [string, Function | null, ...any]): void;
+export declare function off<T extends Window | Document | HTMLElement | EventTarget>(obj: T | null, ...args: Parameters<T['removeEventListener']> | [string, Function | null, ...any]): void;
+export declare const isBrowser: boolean;
+export declare const isNavigator: boolean;

package/types/hooks/use-verification-code/index.d.ts

@@ -0,0 +1,2 @@
+import { VerificationCodeOptions, VerificationCodeReturnType } from './interface';
+export default function useVerificationCode(props: VerificationCodeOptions): VerificationCodeReturnType;