@websolutespa/bom-mixer-hooks 0.0.1

package/CHANGELOG.md

@@ -0,0 +1,7 @@
+# @websolutespa/bom-mixer-hooks
+
+## 0.0.1
+
+### Patch Changes
+
+- Added: first release.

package/dist/index.d.ts

@@ -0,0 +1,551 @@
+import * as React$1 from 'react';
+import React__default, { RefObject, Dispatch, SetStateAction, MutableRefObject, ComponentProps, useEffect } from 'react';
+import { FetchRequestOptions, ISchema, IEquatable } from '@websolutespa/bom-mixer-core';
+import * as zustand_middleware from 'zustand/middleware';
+import { StateStorage } from 'zustand/middleware';
+import * as zustand from 'zustand';
+import { ICartItem, ICartAddItem, IAddressOptions, ICheckoutPartial, IFeatureType, ILayout, IPage, IUser } from '@websolutespa/bom-mixer-models';
+import { NextRouter } from 'next/router';
+
+declare function useApiFetch<T = any>(pathname: string, options?: FetchRequestOptions): [T | undefined, boolean, any, React$1.Dispatch<any>];
+declare function useApiGet<T = any>(pathname: string, options?: FetchRequestOptions): [T | undefined, boolean, any, React$1.Dispatch<any>];
+declare function useApiPost<T = any>(pathname: string, payload: unknown, options?: FetchRequestOptions): [T | undefined, boolean, any, React$1.Dispatch<any>];
+declare function useApiPut<T = any>(pathname: string, payload: unknown, options?: FetchRequestOptions): [T | undefined, boolean, any, React$1.Dispatch<any>];
+declare function useApiPatch<T = any>(pathname: string, payload: unknown, options?: FetchRequestOptions): [T | undefined, boolean, any, React$1.Dispatch<any>];
+declare function useApiDelete<T = any>(pathname: string, options?: FetchRequestOptions): [T | undefined, boolean, any, React$1.Dispatch<any>];
+type Api = {
+    get: <T = any>(pathname: string, options?: FetchRequestOptions) => Promise<T>;
+    post: <T = any>(pathname: string, payload?: unknown, options?: FetchRequestOptions) => Promise<T>;
+    put: <T = any>(pathname: string, payload?: unknown, options?: FetchRequestOptions) => Promise<T>;
+    patch: <T = any>(pathname: string, payload?: unknown, options?: FetchRequestOptions) => Promise<T>;
+    delete: <T = any>(pathname: string, options?: FetchRequestOptions) => Promise<T>;
+};
+declare function useApi(): Api;
+
+declare function useBodyScroll(elementRef?: RefObject<HTMLElement> | null, options?: BodyScrollOptions): [boolean, Dispatch<SetStateAction<boolean>>];
+declare function getOwnerPaddingRight(element: Element): number;
+declare function getOwnerScrollbarWidth(element: Element): number;
+type ElementStackItem = {
+    overflow: string;
+    paddingRight: string;
+};
+type BodyScrollOptions = {
+    scrollLayer?: boolean;
+    delayReset?: number;
+};
+
+type BreakpointType = 'xs' | 'sm' | 'md' | 'lg' | 'xl';
+type Breakpoint = {
+    key: BreakpointType;
+    min: number;
+    max: number;
+};
+declare function useBreakpoint(): Breakpoint;
+
+type CartProps = {
+    hydrated: boolean;
+    items: ICartItem[];
+};
+type CartActions = {
+    count(): number;
+    has(item: ISchema): boolean;
+    find(item: ISchema): ICartItem | undefined;
+    add(item: ICartAddItem, qty?: number): void;
+    remove(item: ISchema): number;
+    update(item: ICartItem): void;
+    clear(): void;
+};
+type CartState = CartProps & {
+    actions: CartActions;
+};
+declare const CartContext: React$1.Context<(Omit<zustand.StoreApi<CartState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<CartState, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => void | Promise<void>;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: CartState) => void) => () => void;
+        onFinishHydration: (fn: (state: CartState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<CartState, unknown>>;
+    };
+}) | null>;
+type CartProviderProps = React.PropsWithChildren<{
+    items?: ICartItem[];
+    storage?: StateStorage;
+}>;
+declare function CartProvider({ children, ...props }: CartProviderProps): JSX.Element;
+declare function useCart<T>(selector: (state: CartState) => T, equalityFn?: (left: T, right: T) => boolean): T;
+
+type CheckoutProps = {
+    hydrated: boolean;
+    data: IAddressOptions;
+    checkout: ICheckoutPartial;
+};
+type CheckoutActions = {
+    setCheckout(checkout: ICheckoutPartial): void;
+};
+type CheckoutState = CheckoutProps & {
+    actions: CheckoutActions;
+};
+declare const CheckoutContext: React$1.Context<(Omit<zustand.StoreApi<CheckoutState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<zustand_middleware.PersistOptions<CheckoutState, unknown>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => void | Promise<void>;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: CheckoutState) => void) => () => void;
+        onFinishHydration: (fn: (state: CheckoutState) => void) => () => void;
+        getOptions: () => Partial<zustand_middleware.PersistOptions<CheckoutState, unknown>>;
+    };
+}) | null>;
+type CheckoutProviderProps = React.PropsWithChildren<{
+    data: IAddressOptions;
+    checkout?: ICheckoutPartial;
+    storage?: StateStorage;
+}>;
+declare function CheckoutProvider({ children, ...props }: CheckoutProviderProps): JSX.Element;
+declare function useCheckout<T>(selector: (state: CheckoutState) => T, equalityFn?: (left: T, right: T) => boolean): T;
+
+declare function useClickAnyWhere(handler: (event: MouseEvent) => void): void;
+
+type ClickOutGetContainer = () => HTMLElement | null;
+declare function useClickOut(ref: MutableRefObject<HTMLElement | null>, handler: (event: MouseEvent) => void): void;
+
+declare function useCurrency(currency?: string, locale?: string): (value: number) => string;
+
+declare function useCurrentState<S>(initialState: S | (() => S)): CurrentStateType<S>;
+type CurrentStateType<S> = [S, Dispatch<SetStateAction<S>>, MutableRefObject<S>];
+
+declare function useDateTimeFormat(options?: Intl.DateTimeFormatOptions, locale?: string): (value: Date | string) => string;
+
+declare function useDebounce<T>(value: T, msec?: number): T;
+
+/**
+ * Returns a memoized function that will only call the passed function when it hasn't been called for the msec period
+ * @param func The function to be called
+ * @param msec Wait period after function hasn't been called for
+ * @returns A memoized function that is debounced
+ */
+declare function useDebounceCallback<T extends (...args: any[]) => any>(callback: T, msec?: number): (...args: unknown[]) => void;
+
+declare function useDebugChangedProps(props: ComponentProps<any>): void;
+
+declare function useDomObserver(ref: MutableRefObject<HTMLElement | null> | undefined, callback?: MutationCallback): void;
+
+type UIValue = string | number | boolean | undefined;
+type UIViews = {
+    [key: string]: UIValue;
+};
+type UIReducer = (state: UIViews) => UIValue;
+type UIActions = {
+    reduce(key: string, reducer: UIReducer): void;
+};
+type UIStore = {
+    views: UIViews;
+    actions: UIActions;
+};
+declare const useUI: zustand.UseBoundStore<zustand.StoreApi<UIStore>>;
+
+declare function useDrawer(): [drawer: UIValue, open: (value?: string) => void, close: () => void];
+
+type Size = {
+    width: number;
+    height: number;
+};
+declare function useElementSize<T extends HTMLElement = HTMLDivElement>(): [(node: T | null) => void, Size];
+
+declare function useEventListener_<K extends keyof WindowEventMap>(eventName: K, handler: (event: WindowEventMap[K]) => void, element?: undefined, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener_<K extends keyof HTMLElementEventMap, T extends HTMLElement = HTMLDivElement>(eventName: K, handler: (event: HTMLElementEventMap[K]) => void, element: RefObject<T>, options?: boolean | AddEventListenerOptions): void;
+declare function useEventListener_<K extends keyof DocumentEventMap>(eventName: K, handler: (event: DocumentEventMap[K]) => void, element: RefObject<Document>, options?: boolean | AddEventListenerOptions): void;
+declare const useEventListener: typeof useEventListener_;
+
+type FilterParams = {
+    [key: string]: IEquatable[] | null;
+};
+type FilterValues = IEquatable[][];
+declare enum FilterMode {
+    SELECT = "select",
+    AND = "and",
+    OR = "or",
+    QUERY = "query"
+}
+type IFilterOption = {
+    id: IEquatable;
+    title: string;
+    count?: number;
+    disabled?: boolean;
+};
+type IFilter = {
+    id?: string;
+    title?: string;
+    mode?: FilterMode;
+    options?: IFilterOption[];
+    values?: IEquatable[];
+};
+declare class Filter<T> implements IFilter {
+    id: string;
+    title: string;
+    mode: FilterMode;
+    options: IFilterOption[];
+    values: IEquatable[];
+    constructor(options?: IFilter);
+    static fromFeatureType<T>(featureType: IFeatureType, mode?: FilterMode): Filter<T>;
+    filter(item: T, value: IEquatable): boolean;
+    match(item: T): boolean;
+    removeInvalidOptions(items: T[]): void;
+    getLabel(): string | null;
+    hasAny(): boolean;
+    getCount(): number;
+    hasResults(): boolean;
+    has(option: IFilterOption): boolean;
+    set(option: IFilterOption): void;
+    remove(option: IFilterOption): void;
+    toggle(option: IFilterOption): void;
+    clear(): void;
+}
+
+declare function getFilters<T>(items: T[], featureTypes: IFeatureType[], filterMap: (key: string, item: T, value: IEquatable) => boolean, params?: FilterParams | null): Filter<T>[];
+declare function getFilteredItems<T>(items: T[], selectedFilters: Filter<T>[]): T[];
+declare function setFilters<T>(items: T[], filters: Filter<T>[], filter?: Filter<T>, values?: IEquatable[]): T[];
+declare function filtersToParams<T>(filters: Filter<T>[]): FilterParams | null;
+
+declare function useFilters<T>(items: T[], featureTypes: IFeatureType[], filterItem: (key: string, item: T, value: IEquatable) => boolean, initialValues?: FilterParams | null): UseFiltersResultType<T>;
+type UseFiltersResultType<T> = {
+    filteredItems: T[];
+    filters: Filter<T>[];
+    setFilter: (filter?: Filter<T>, values?: IEquatable[]) => void;
+    itemsWithOmittedKeys: (...keys: string[]) => T[];
+};
+
+declare const createGenericContext: <T>() => readonly [() => NonNullable<T>, React$1.Provider<T | undefined>];
+
+/**
+ * @desc Made compatible with {GeolocationPositionError} and {PositionError} cause
+ * PositionError been renamed to GeolocationPositionError in typescript 4.1.x and making
+ * own compatible interface is most easiest way to avoid errors.
+ */
+type IGeolocationPositionError = {
+    readonly code: number;
+    readonly message: string;
+    readonly PERMISSION_DENIED: number;
+    readonly POSITION_UNAVAILABLE: number;
+    readonly TIMEOUT: number;
+};
+type GeoLocationSensorState = {
+    loading: boolean;
+    accuracy: number | null;
+    altitude: number | null;
+    altitudeAccuracy: number | null;
+    heading: number | null;
+    latitude: number | null;
+    longitude: number | null;
+    speed: number | null;
+    timestamp: number | null;
+    error?: Error | IGeolocationPositionError;
+};
+declare function getCurrentPosition(options?: PositionOptions): Promise<GeoLocationSensorState>;
+declare function hasGeolocation(): boolean;
+
+declare function useGeolocation(options?: PositionOptions): GeoLocationSensorState;
+
+declare function useIdle(delay?: number, immediate?: boolean): boolean;
+
+declare function useInfiniteLoader(items: any[], perPage?: number, delayInMs?: number): [any[], () => void, boolean];
+
+declare const useIsomorphicLayoutEffect: typeof useEffect;
+
+/**
+ * KeyBinding Codes
+ * The content of this file is based on the design of the open source project "microsoft/vscode",
+ *   Copyright (c) Microsoft Corporation. All rights reserved.
+ *
+ * We inherit the KeyMod values from "microsoft/vscode",
+ * but use the Browser's KeyboardEvent event implementation, and all values are used only as identification.
+ */
+declare enum KeyCode {
+    Unknown = 0,
+    Backspace = 8,
+    Tab = 9,
+    Enter = 13,
+    Shift = 16,
+    Ctrl = 17,
+    Alt = 18,
+    PauseBreak = 19,
+    CapsLock = 20,
+    Escape = 27,
+    Space = 32,
+    PageUp = 33,
+    PageDown = 34,
+    End = 35,
+    Home = 36,
+    LeftArrow = 37,
+    UpArrow = 38,
+    RightArrow = 39,
+    DownArrow = 40,
+    Insert = 45,
+    Delete = 46,
+    KEY_0 = 48,
+    KEY_1 = 49,
+    KEY_2 = 50,
+    KEY_3 = 51,
+    KEY_4 = 52,
+    KEY_5 = 53,
+    KEY_6 = 54,
+    KEY_7 = 55,
+    KEY_8 = 56,
+    KEY_9 = 57,
+    KEY_A = 65,
+    KEY_B = 66,
+    KEY_C = 67,
+    KEY_D = 68,
+    KEY_E = 69,
+    KEY_F = 70,
+    KEY_G = 71,
+    KEY_H = 72,
+    KEY_I = 73,
+    KEY_J = 74,
+    KEY_K = 75,
+    KEY_L = 76,
+    KEY_M = 77,
+    KEY_N = 78,
+    KEY_O = 79,
+    KEY_P = 80,
+    KEY_Q = 81,
+    KEY_R = 82,
+    KEY_S = 83,
+    KEY_T = 84,
+    KEY_U = 85,
+    KEY_V = 86,
+    KEY_W = 87,
+    KEY_X = 88,
+    KEY_Y = 89,
+    KEY_Z = 90,
+    Meta = 91,
+    F1 = 112,
+    F2 = 113,
+    F3 = 114,
+    F4 = 115,
+    F5 = 116,
+    F6 = 117,
+    F7 = 118,
+    F8 = 119,
+    F9 = 120,
+    F10 = 121,
+    F11 = 122,
+    F12 = 123,
+    NumLock = 144,
+    ScrollLock = 145,
+    Equal = 187,
+    Minus = 189,
+    Backquote = 192,
+    Backslash = 220
+}
+declare enum KeyMod {
+    CtrlCmd = 2048,
+    Shift = 1024,
+    Alt = 512,
+    WinCtrl = 256
+}
+
+declare const useKeyboard: UseKeyboard;
+
+type KeyboardOptions = {
+    disableGlobalEvent?: boolean;
+    stopPropagation?: boolean;
+    preventDefault?: boolean;
+    capture?: boolean;
+    event?: 'keydown' | 'keypress' | 'keyup';
+};
+type KeyboardResult = {
+    bindings: {
+        onKeyDown: React__default.KeyboardEventHandler;
+        onKeyDownCapture: React__default.KeyboardEventHandler;
+        onKeyPress: React__default.KeyboardEventHandler;
+        onKeyPressCapture: React__default.KeyboardEventHandler;
+        onKeyUp: React__default.KeyboardEventHandler;
+        onKeyUpCapture: React__default.KeyboardEventHandler;
+    };
+};
+type UseKeyboardHandler = (event: React__default.KeyboardEvent | KeyboardEvent) => void;
+type UseKeyboard = (handler: UseKeyboardHandler, keyBindings: Array<number> | number, options?: KeyboardOptions) => KeyboardResult;
+
+type ILabelContext = (key: string, params?: {
+    [key: string]: any;
+}) => string;
+declare const useLabel: () => ILabelContext;
+declare function LabelProvider({ children }: {
+    children?: React__default.ReactNode;
+}): JSX.Element;
+declare function parseParams(label: string, params: {
+    [key: string]: any;
+}): string;
+
+type ILayoutContext = ILayout;
+declare const useLayout: () => ILayout;
+declare function LayoutProvider({ children, layout }: {
+    children?: React__default.ReactNode;
+    layout: ILayout;
+}): JSX.Element;
+
+declare function useModal(): [modal: UIValue, open: (value?: string) => void, close: () => void];
+
+declare function useMounted(): boolean;
+
+declare function useNumber(options?: Intl.NumberFormatOptions, locale?: string): (value: number) => string;
+
+type IPageContext = IPage;
+declare const usePage: () => NonNullable<IPage>;
+declare function PageProvider({ children, page }: {
+    children?: React__default.ReactNode;
+    page: IPage;
+}): JSX.Element;
+
+type IPaginationInfo<T> = {
+    items: T[];
+    total: number;
+    pages: number;
+    page: number;
+    perPage: number;
+};
+declare function getPagedItems<T>(items: T[], page: number, perPage: number): T[];
+
+declare function usePagination<T>($items: T[], $page?: number, $perPage?: number): {
+    items: T[];
+    page: number;
+    pages: number;
+    total: number;
+    nextPage: () => void;
+    previousPage: () => void;
+    goToPage: (page: number) => void;
+    setPerPage: (perPage: number) => void;
+};
+
+declare function usePortal(name?: string, getContainer?: () => HTMLElement | null): HTMLElement | null;
+declare function createElementWithId(id: string): HTMLElement;
+declare function getUID(): string;
+
+declare function usePrevious<T>(state: T): T | undefined | null;
+
+type SizeType = {
+    width: number;
+    height: number;
+};
+type SizeResult = [SizeType, () => void];
+declare function useRealSize<T extends HTMLElement>(ref: MutableRefObject<T | null>): SizeResult;
+declare function getRealSize(element: HTMLElement | null): SizeType;
+
+declare function useResize(callback: () => unknown, immediate?: boolean): void;
+
+type Scroll = {
+    left: number;
+    top: number;
+};
+declare function useScroll(): Scroll;
+
+declare function useScrollTo(): (event: React.MouseEvent<HTMLElement>) => void;
+declare function scrollToSelector(selector?: string, offset?: number): void;
+declare function scrollToRelativeY(y?: number, offset?: number): void;
+declare function scrollToY(y?: number): void;
+
+declare const isBrowser: boolean;
+declare function getSearchParams(url: string, key?: string): IParams | string | null;
+declare function updateSearchParams(currentPath: string, params: IParams): {
+    pathname: string;
+    query: {
+        [key: string]: string;
+    };
+};
+declare function replaceSearchParams(router: NextRouter, params: IParams): void;
+declare function pushSearchParams(router: NextRouter, params: IParams): void;
+declare function replaceSearchParamsSilently(params: IParams): void;
+declare function useSearchParams(): IUseSearchParamsResult;
+declare function useSearchParamsValue(key: string): IUseSearchParamsValueResult;
+type IUseSearchParamsResult = {
+    params: IParams;
+    replaceParamsSilently: (params: IParams) => void;
+    replaceParams: (params: IParams) => void;
+};
+type IUseSearchParamsValueResult = {
+    params: string | null;
+    replaceParamsSilently: (params: IParams) => void;
+};
+type IParams = {
+    [key: string]: string;
+};
+
+declare function decode(encoded: string | null | undefined, key?: string): IParamsEncoded;
+declare function getSearchParamsEncoded(url: string, key?: string): {} | null;
+declare function updateSearchParamsEncoded(currentPath: string, value: IParamsEncoded, key?: string): {
+    pathname: string;
+    query: {
+        [key: string]: string;
+    };
+};
+declare function replaceSearchParamsEncoded(router: NextRouter, value: IParamsEncoded, key?: string): void;
+declare function pushSearchParamsEncoded(router: NextRouter, value: IParamsEncoded, key?: string): void;
+declare function replaceSearchParamsEncodedSilently(value: IParamsEncoded, key?: string): void;
+declare function useSearchParamsEncoded(key?: string): IUseSearchParamsEncodedResult;
+type IUseSearchParamsEncodedResult = {
+    params: IParamsEncoded;
+    replaceParamsSilently: (params: IParamsEncoded) => void;
+    replaceParams: (params: IParamsEncoded) => void;
+};
+type IParamsEncoded = {
+    [key: string]: any;
+} | null;
+
+type Sorting<T> = {
+    items: T[];
+    sort?: IEquatable;
+};
+declare function useSorting<T>(items_: T[], callback_: (items: T[], sort?: IEquatable) => T[], sort_?: IEquatable): {
+    items: T[];
+    sort: string | number | undefined;
+    setSort: (sort?: IEquatable) => void;
+};
+
+type SSRState = {
+    isBrowser: boolean;
+    isServer: boolean;
+};
+declare function useSSR(): SSRState;
+declare const detectIsBrowser: () => boolean;
+
+declare function useSwiperIndex(): [number, (index: number) => void];
+
+/**
+ * Like `useRef`, but it returns immutable ref that contains actual value.
+ *
+ * @param value
+ */
+declare function useSyncedRef<T>(value: T): {
+    readonly current: T;
+};
+
+declare function useUnit(unit?: string, locale?: string): (value: number) => string;
+
+/**
+ * Run effect only when component is unmounted.
+ *
+ * @param effect Effector to run on unmount
+ */
+declare function useUnmountEffect(effect: CallableFunction): void;
+
+type UserState = {
+    user?: IUser;
+};
+type UserActions = {
+    setUser: (user?: IUser) => void;
+};
+type UserStore = UserState & {
+    actions: UserActions;
+};
+declare const useUser: zustand.UseBoundStore<zustand.StoreApi<UserStore>>;
+
+type WindowSize = {
+    width: number;
+    height: number;
+};
+declare function useWindowSize(): WindowSize;
+
+export { BodyScrollOptions, CartContext, CartProvider, CheckoutContext, CheckoutProvider, ClickOutGetContainer, CurrentStateType, ElementStackItem, Filter, FilterMode, FilterParams, FilterValues, GeoLocationSensorState, IFilter, IFilterOption, IGeolocationPositionError, ILabelContext, ILayoutContext, IPageContext, IPaginationInfo, IParams, IParamsEncoded, IUseSearchParamsEncodedResult, IUseSearchParamsResult, IUseSearchParamsValueResult, KeyCode, KeyMod, KeyboardOptions, KeyboardResult, LabelProvider, LayoutProvider, PageProvider, SSRState, SizeResult, SizeType, Sorting, UIReducer, UIValue, UseFiltersResultType, UseKeyboard, UseKeyboardHandler, createElementWithId, createGenericContext, decode, detectIsBrowser, filtersToParams, getCurrentPosition, getFilteredItems, getFilters, getOwnerPaddingRight, getOwnerScrollbarWidth, getPagedItems, getRealSize, getSearchParams, getSearchParamsEncoded, getUID, hasGeolocation, isBrowser, parseParams, pushSearchParams, pushSearchParamsEncoded, replaceSearchParams, replaceSearchParamsEncoded, replaceSearchParamsEncodedSilently, replaceSearchParamsSilently, scrollToRelativeY, scrollToSelector, scrollToY, setFilters, updateSearchParams, updateSearchParamsEncoded, useApi, useApiDelete, useApiFetch, useApiGet, useApiPatch, useApiPost, useApiPut, useBodyScroll, useBreakpoint, useCart, useCheckout, useClickAnyWhere, useClickOut, useCurrency, useCurrentState, useDateTimeFormat, useDebounce, useDebounceCallback, useDebugChangedProps, useDomObserver, useDrawer, useElementSize, useEventListener, useFilters, useGeolocation, useIdle, useInfiniteLoader, useIsomorphicLayoutEffect, useKeyboard, useLabel, useLayout, useModal, useMounted, useNumber, usePage, usePagination, usePortal, usePrevious, useRealSize, useResize, useSSR, useScroll, useScrollTo, useSearchParams, useSearchParamsEncoded, useSearchParamsValue, useSorting, useSwiperIndex, useSyncedRef, useUI, useUnit, useUnmountEffect, useUser, useWindowSize };