@appello/common/dist/index.d.ts

Common package with many useful features for web and mobile development

import * as react from 'react';
import { Ref, RefCallback, EffectCallback, DependencyList, Dispatch, SetStateAction } from 'react';
import { UseFormProps } from 'react-hook-form';
import { Path, PathValue } from 'dot-path-value';

declare function useCodeTimer(): {
    seconds: number;
    inProgress: boolean;
    sendCode: (cb?: VoidFunction, passSeconds?: number) => void;
};

declare function useCombinedRef<T>(...refs: Ref<T>[]): RefCallback<T>;

type ElementType = HTMLElement | Element | Window | Document;
type Nullable<T> = T | null;
type NotNullable<T> = T extends null ? never : T;
type Nillable<T> = T | null | undefined;
type NotNillable<T> = T extends null | undefined ? never : T;
type Unidentifiable<T> = T | undefined;
type Negative<T> = T | undefined | null | false;
type ValueOf<T> = T[keyof T];
type AnyObject = Record<any, any>;
type AnyPromise = Promise<any>;
type PartialRecord<T extends keyof any, K> = {
    [P in T]?: K;
};
type PartialDeep<T> = {
    [P in keyof T]?: T[P] extends object ? PartialDeep<T[P]> : T[P];
};
type ResponseErrors = Record<string, string>;
type UnknownFunction = (...args: unknown[]) => unknown;
type AnyFunction = (...args: any[]) => any;
type PromiseType<T> = T extends Promise<infer U> ? U : T;
type RequiredKeys<T> = {
    [K in keyof T]-?: object extends {
        [P in K]: T[K];
    } ? never : K;
}[keyof T];
type OptionalKeys<T> = {
    [K in keyof T]-?: object extends {
        [P in K]: T[K];
    } ? K : never;
}[keyof T];
type Merge<T, K> = Omit<T, keyof K> & K;
type AsyncReturnType<T extends (...args: any) => Promise<any>> = T extends (...args: any) => Promise<infer R> ? R : any;
type FirstArgument<T extends (...args: any) => any> = T extends (arg: infer A, ...args: any) => any ? A : never;

declare const capitalize: (str: string) => string;

declare const checkIsServer: () => boolean;

declare const checkNavigator: () => boolean;

declare const compact: <T>(array: T[]) => T[];

type DebounceOptions$1 = {
    leading?: boolean;
    trailing?: boolean;
    maxWait?: number;
};
declare function debounce<T extends AnyFunction>(func: T, wait?: number, options?: DebounceOptions$1): {
    (...args: Parameters<T>): ReturnType<T> | undefined;
    cancel: () => void;
    flush: () => any;
    pending: () => boolean;
};

declare const deepEqual: <T>(obj1: T, obj2: T) => boolean;

declare const deepKeys: <TValue extends object>(value: TValue) => string[];

declare const deepMergeObjects: <T extends object>(target: T, source: unknown) => T;

declare const difference: <T>(array: T[], values: T[]) => T[];

declare const entries: <T>(o: T) => [Extract<keyof T, string | number>, T[keyof T]][];

declare const enumKeyToReadable: (enumKey: string, options?: {
    capitalizeAll?: boolean;
    lowercase?: boolean;
}) => string;

type OptionKeys$1 = {
    label: string;
    value: string;
};
declare function enumToSelectOptions<TEnumValue extends string>(enumList: Record<string, TEnumValue>, customFnLabel?: (value: TEnumValue) => string): OptionKeys$1[];

declare const formatCurrency: (value: number, options?: {
    currency?: string;
    separator?: string;
    decimals?: number;
    symbolAfter?: boolean;
}) => string;

declare const formatNumber: (value: number, options?: {
    separator?: string;
    decimals?: number;
    prefix?: string;
    suffix?: string;
}) => string;

declare function getDirtyValues<DirtyFields extends Record<string, unknown>, Values extends Record<keyof DirtyFields, unknown>>(dirtyFields: DirtyFields, values: Values): Partial<typeof values>;

declare const getFileExtension: (fileName: string) => Unidentifiable<string>;

declare const getFileName: (path: string, withExtension?: boolean) => string;

type Prototype = '[object Undefined]' | '[object Null]' | '[object Boolean]' | '[object Number]' | '[object String]' | '[object Symbol]' | '[object BigInt]' | '[object Object]' | '[object Function]' | '[object Array]' | '[object Date]' | '[object RegExp]' | '[object Error]' | '[object Arguments]' | '[object Set]' | '[object Map]' | '[object WeakSet]' | '[object WeakMap]' | '[object ArrayBuffer]' | '[object DataView]' | '[object Promise]' | '[object Generator]' | '[object GeneratorFunction]' | '[object AsyncFunction]' | '[object Reflect]' | '[object Proxy]';
declare function getProto(value: any): Prototype;

declare function getWeekdaysNames(options?: {
    longFormat?: boolean;
}): string[];

declare const intersection: <T>(array: T[], values: T[]) => T[];

declare const isArray: (arg: any) => arg is any[];

declare const isBlob: (value: any) => value is Blob;

declare const isDate: (value: any) => value is Date;

declare const isEmpty: (value: any) => boolean;

declare const isFile: (value: any) => value is File;

declare const isFloat: (value: any) => value is number;

declare const isFunction: (value: any) => value is Function;

declare const isInt: (value: any) => value is number;

declare function isNil<T>(value: T | null | undefined): value is null | undefined;

declare const isNumber: (value: any) => value is number;

declare const isObject: (value: any) => value is object;

declare const isPrimitive: (value: any) => boolean;

declare const isPromise: (value: any) => value is AnyPromise;

declare const isString: (value: any) => value is string;

declare const isSymbol: (value: any) => value is symbol;

declare const keys: <T>(o: T) => (keyof T)[];

declare function makeFormData(object: any, formData?: FormData, prefix?: string): FormData;

interface MakeQueryStringOptions {
    withPrefix?: boolean;
}
declare function makeQueryString<T extends string | number>(params: Record<string, T | undefined>, options?: MakeQueryStringOptions): string;

type FormDataEntry = [key: string, value: any];
declare function mapFormData(formData: FormData, callback: (item: FormDataEntry) => FormDataEntry): FormData;

declare const mergeCollectionByKey: <T extends AnyObject = AnyObject>(oldCollect: T[], newCollect: T[], type?: "push" | "unshift", key?: keyof T | ((item: T) => string | number)) => T[];

declare function noop(): void;

declare function omit<T extends Record<any, any>, K extends keyof T>(obj: T, keys: K[]): Omit<T, K>;

declare function pick<T extends Record<any, any>, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;

declare const pluralize: (count: number, singular: string, plural?: string) => string;

declare function sleep(ms: number): Promise<void>;

type ThrottleOptions = {
    leading?: boolean;
    trailing?: boolean;
    maxWait?: number;
};
declare function throttle<T extends AnyFunction>(func: T, wait?: number, options?: ThrottleOptions): {
    (...args: Parameters<T>): ReturnType<T> | undefined;
    cancel: () => void;
    flush: () => any;
    pending: () => boolean;
};

declare const toBase64: (file: File) => Promise<Nullable<string | ArrayBuffer>>;

declare function toFinite(value: any): number;

declare const truncate: (str: string, length?: number, omission?: string) => string;

declare const uniq: <T>(array: T[]) => T[];

interface DebounceOptions extends DebounceOptions$1 {
    wait?: number;
}

declare function useDebounceCallback<T extends AnyFunction>(fn: T, options?: DebounceOptions): {
    debounce: {
        (...args: Parameters<T>): any;
        cancel: () => void;
        flush: () => any;
        pending: () => boolean;
    };
    cancel: () => void;
    flush: () => any;
};

declare function useDebounceEffect(effect: EffectCallback, deps?: DependencyList, options?: DebounceOptions): void;

declare function useDefault<T>(defaultValue: T, initialValue: T): [T, Dispatch<SetStateAction<T>>];

declare function useFirstMountState(): boolean;

type SyncPolicyLiteral = 'default-values-first' | 'storage-first';
interface WebStorage {
    getItem(key: string, ...args: any[]): any;
    setItem(key: string, value: any, ...args: any[]): any;
    removeItem(key: string, ...args: any[]): any;
}
interface FormPersistProps<T extends AnyObject = AnyObject> {
    key: string;
    storage?: WebStorage;
    excludeFields?: (keyof T)[];
    includeFields?: (keyof T)[];
}
declare const useHookFormPersist: <T extends AnyObject = AnyObject>({ key: keyStorage, storage, excludeFields, includeFields, }: FormPersistProps<T>) => {
    syncFromStorage: ({ defaultValues, syncPolicy, }: {
        defaultValues?: UseFormProps<T>["defaultValues"];
        syncPolicy?: SyncPolicyLiteral;
    }) => Promise<T>;
    syncToStorage: (watchedValues: T) => void;
    clear: () => Promise<void>;
};

type UseIntervalProps = {
    fn: () => void;
    delay?: number;
    immediateStart?: boolean;
    immediateCallFn?: boolean;
    onStop?: () => void;
};
declare function useInterval({ fn, delay, onStop, immediateStart, immediateCallFn, }: UseIntervalProps): {
    start: () => void;
    stop: () => void;
    setState: react.Dispatch<react.SetStateAction<boolean>>;
};

declare function useIsClient(): boolean;

declare function useIsMounted(): () => boolean;

declare function useLatest<T>(value: T): react.RefObject<T>;

declare function useManualUpdate(): VoidFunction;

type Func = (this: any, ...args: any[]) => any;
declare function useMemoCallback<T extends Func>(fn: T): T;

declare const useMountEffect: (fn: () => void) => void;

type ShouldUpdateFunc<T> = (prev: Unidentifiable<T>, next: T) => boolean;
declare function usePrevious<T>(state: T, shouldUpdate?: ShouldUpdateFunc<T>): T | undefined;

interface UseQueryParamsBuilderProps<T extends AnyObject = AnyObject> {
    requestCb: (params: T) => Promise<any>;
    defaultParams: T;
    options?: Pick<DebounceOptions, 'wait'>;
}
declare const useQueryParamsBuilder: <T extends AnyObject = AnyObject>({ requestCb, defaultParams, options, }: UseQueryParamsBuilderProps<T>) => {
    loading: boolean;
    queryParams: T;
    updateQueryParams: (params: Partial<T>, withDebounce?: boolean) => void;
    reset: () => void;
};

type OptionKeys<T> = {
    label: Path<T>;
    value: Path<T>;
};
declare function useSelectOptions<T extends object, TKeys extends OptionKeys<T>, P extends AnyObject>(data: T[] | undefined, keys: TKeys, additionalProps?: (item: T) => P): ({
    value: PathValue<T, TKeys["value"]>;
    label: PathValue<T, TKeys["label"]>;
} & P)[];

declare function useStateObject<T extends AnyObject>(initialValue: T): {
    state: T;
    handleUpdate: (arg: ((obj: T) => Partial<T>) | Partial<T>) => void;
};

interface UseStepReturn {
    step: number;
    increment: () => void;
    decrement: () => void;
    reset: () => void;
    setStep: Dispatch<SetStateAction<number>>;
}
declare function useStep(initialValue?: number): UseStepReturn;

interface UseSwitchValueReturn {
    value: boolean;
    on(): void;
    off(): void;
    toggle(): void;
    set: Dispatch<SetStateAction<boolean>>;
}
declare function useSwitchValue(initial: boolean): UseSwitchValueReturn;

declare const useUnmountEffect: (fn: () => void) => void;

declare function useUpdateEffect(effect: EffectCallback, deps: DependencyList): void;

interface AwsImageServiceResizeOptions {
    width?: number;
    height?: number;
    fit?: 'cover' | 'contain' | 'fill' | 'inside' | 'outside';
    background?: {
        r: number;
        g: number;
        b: number;
        alpha: number;
    };
}
interface AwsImageServiceSmartCropOptions {
    faceIndex?: number;
    padding?: number;
}
interface AwsImageServiceProps {
    resize?: AwsImageServiceResizeOptions;
    flatten?: boolean;
    grayscale?: boolean;
    flip?: boolean;
    flop?: boolean;
    negate?: boolean;
    normalise?: boolean;
    tint?: {
        r: number;
        g: number;
        b: number;
    };
    smartCrop?: AwsImageServiceSmartCropOptions;
}
declare class AwsImageService {
    private static instance;
    private readonly awsUrl;
    private readonly awsBucket;
    private constructor();
    static initialize(awsUrl: string, awsBucket: string): AwsImageService;
    private static getInstance;
    static genAwsImgUrl(key: string, options?: AwsImageServiceProps): string;
}

export { AwsImageService, capitalize, checkIsServer, checkNavigator, compact, debounce, deepEqual, deepKeys, deepMergeObjects, difference, entries, enumKeyToReadable, enumToSelectOptions, formatCurrency, formatNumber, getDirtyValues, getFileExtension, getFileName, getProto, getWeekdaysNames, intersection, isArray, isBlob, isDate, isEmpty, isFile, isFloat, isFunction, isInt, isNil, isNumber, isObject, isPrimitive, isPromise, isString, isSymbol, keys, makeFormData, makeQueryString, mapFormData, mergeCollectionByKey, noop, omit, pick, pluralize, sleep, throttle, toBase64, toFinite, truncate, uniq, useCodeTimer, useCombinedRef, useDebounceCallback, useDebounceEffect, useDefault, useFirstMountState, useHookFormPersist, useInterval, useIsClient, useIsMounted, useLatest, useManualUpdate, useMemoCallback, useMountEffect, usePrevious, useQueryParamsBuilder, useSelectOptions, useStateObject, useStep, useSwitchValue, useUnmountEffect, useUpdateEffect };
export type { AnyFunction, AnyObject, AnyPromise, AsyncReturnType, AwsImageServiceProps, AwsImageServiceResizeOptions, AwsImageServiceSmartCropOptions, DebounceOptions$1 as DebounceOptions, ElementType, FirstArgument, FormPersistProps, Merge, Negative, Nillable, NotNillable, NotNullable, Nullable, OptionalKeys, PartialDeep, PartialRecord, PromiseType, RequiredKeys, ResponseErrors, ThrottleOptions, Unidentifiable, UnknownFunction, ValueOf };