@finema/core 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './utils';
+export * from './lib';

package/dist/lib/Requester.d.ts

@@ -0,0 +1,30 @@
+import { AxiosInstance, AxiosRequestConfig, CancelTokenSource, CancelTokenStatic, Method } from 'axios';
+export interface IResponse<T = any> {
+    data: T;
+    status: number;
+    statusText: string;
+    headers: any;
+    config: AxiosRequestConfig;
+    request?: any;
+}
+export interface IRequester {
+    get: <T>(path: string, options?: AxiosRequestConfig) => Promise<IResponse<T>>;
+    put: <T>(path: string, payload: any, options?: AxiosRequestConfig) => Promise<IResponse<T>>;
+    delete: <T>(path: string, options?: AxiosRequestConfig) => Promise<IResponse<T>>;
+    post: <T>(path: string, payload: any, options?: AxiosRequestConfig) => Promise<IResponse<T>>;
+    create: <T>(method: Method, path: string, payload: any, options?: AxiosRequestConfig) => Promise<IResponse<T>>;
+}
+export declare class Requester {
+    cancelToken: CancelTokenStatic;
+    source: CancelTokenSource;
+    isCancel: (value: any) => boolean;
+    service: AxiosInstance;
+    private readonly options;
+    constructor(options?: AxiosRequestConfig);
+    get<T>(path: string, options?: AxiosRequestConfig): Promise<IResponse<T>>;
+    put<T>(path: string, payload: any, options?: AxiosRequestConfig): Promise<IResponse<T>>;
+    delete<T>(path: string, options?: AxiosRequestConfig): Promise<IResponse<T>>;
+    post<T>(path: string, payload: any, options?: AxiosRequestConfig): Promise<IResponse<T>>;
+    create<T>(method: Method, path: string, payload: any, options?: AxiosRequestConfig): Promise<IResponse<T>>;
+}
+export declare const NewRequester: IRequester;

package/dist/lib/api/apiListHelper.d.ts

@@ -0,0 +1,3 @@
+import { IAPIListState, IAPIOptions, IStatus } from './types';
+import { IListLoaderOptions, IListRunLoaderOptions } from './loaderTypes';
+export declare const apiListHelper: <T, O>(state: () => IAPIListState<T>, onUpdateStatus: (status: IStatus) => void, onUpdateOptions: (options: IAPIOptions) => void, onUpdateItems: (data: T[]) => void, opts: IListLoaderOptions<T, O> & IListRunLoaderOptions<T, O>) => Promise<void>;

package/dist/lib/api/apiObjectHelper.d.ts

@@ -0,0 +1,3 @@
+import { IAPIObjectState, IAPIOptions, IStatus } from './types';
+import { IObjectLoaderOptions, IObjectRunLoaderOptions } from './loaderTypes';
+export declare const apiObjectHelper: <T, B, O>(state: () => IAPIObjectState<T>, onUpdateStatus: (status: IStatus) => void, onUpdateOptions: (options: IAPIOptions) => void, onUpdateData: (data: any) => void, data: B | undefined, opts: IObjectLoaderOptions<T, B, O> & IObjectRunLoaderOptions<T, O>) => Promise<void>;

package/dist/lib/api/apiPageHelper.d.ts

@@ -0,0 +1,7 @@
+import { IAPIAddState, IAPIDeleteState, IAPIFetchState, IAPIFindState, IAPIOptions, IAPIUpdateState, IPageOptions, IStatus } from './types';
+import { IPageDeleteLoaderOptions, IPageFetchLoaderOptions, IPageFindLoaderOptions, IPageLoaderOptions, IPageUpdateLoaderOptions } from './loaderTypes';
+export declare const apiAddHelper: <T>(state: () => IAPIAddState<T>, onUpdateStatus: (status: IStatus) => void, onUpdateOptions: (options: IAPIOptions) => void, onUpdateData: (data: any) => void, onUpdateItems: (data: any[]) => void, data: any, opts: IPageLoaderOptions<any> & IPageFetchLoaderOptions) => Promise<void>;
+export declare const apiDeleteHelper: <T>(state: () => IAPIDeleteState<T>, onUpdateStatus: (status: IStatus) => void, onUpdateOptions: (options: IAPIOptions) => void, _onUpdateData: (data: T) => void, onUpdateItems: (data: T[]) => void, id: string | number, opts: IPageLoaderOptions<any> & IPageDeleteLoaderOptions) => Promise<void>;
+export declare const apiFetchHelper: <T>(state: () => IAPIFetchState<T>, onUpdateStatus: (status: IStatus) => void, onUpdateOptions: (options: IPageOptions) => void, onUpdateItems: (items: T[]) => void, page: number, query: string, opts: IPageLoaderOptions<T> & IPageFetchLoaderOptions<any>) => Promise<void>;
+export declare const apiFindHelper: <T>(state: () => IAPIFindState<T>, onUpdateStatus: (status: IStatus) => void, onUpdateOptions: (options: IAPIOptions) => void, onUpdateData: (data: any) => void, id: string | number, opts: IPageLoaderOptions<T> & IPageFindLoaderOptions<Record<string, any>>) => Promise<void>;
+export declare const updateHelper: <T>(state: () => IAPIUpdateState<T>, onUpdateStatus: (status: IStatus) => void, onUpdateOptions: (options: IAPIOptions) => void, onUpdateData: (data: T) => void, _onUpdateItems: (data: T[]) => void, onUpdateOldData: (data: T) => void, id: string | number, data: any, opts: IPageLoaderOptions<any> & IPageUpdateLoaderOptions) => Promise<void>;

package/dist/lib/api/config.d.ts

@@ -0,0 +1,4 @@
+export declare const CONFIG: {
+    LIMIT_PER_PAGE: number;
+    DEFAULT_PRIMARY: string;
+};

package/dist/lib/api/loaderList.d.ts

@@ -0,0 +1,2 @@
+import { IListLoaderOptions, IUseListLoader } from './loaderTypes';
+export declare const useListLoader: <T = any, O = Record<string, any>>(loaderOptions: IListLoaderOptions<T, O>) => IUseListLoader<T, O>;

package/dist/lib/api/loaderObject.d.ts

@@ -0,0 +1,2 @@
+import { IObjectLoaderOptions, IUseObjectLoader } from './loaderTypes';
+export declare const useObjectLoader: <T = any, B = any, O = Record<string, any>>(loaderOptions: IObjectLoaderOptions<T, B, O>) => IUseObjectLoader<T, B, O>;

package/dist/lib/api/loaderPage.d.ts

@@ -0,0 +1,11 @@
+import { IPageLoaderOptions, IUsePageLoader } from './loaderTypes';
+export declare const initPageOptions: () => {
+    currentPageCount: number;
+    currentPage: number;
+    totalPage: number;
+    totalCount: number;
+    limit: number;
+    search: string;
+    primary: string;
+};
+export declare const usePageLoader: <T = any>(loaderOptions: IPageLoaderOptions<T>) => IUsePageLoader<T>;

package/dist/lib/api/loaderTypes.d.ts

@@ -0,0 +1,133 @@
+import { AxiosRequestConfig, Method } from 'axios';
+import { Ref, UnwrapRef } from 'vue';
+import { IAPIOptions, IPageOptions, IStatus } from './types';
+export interface IPageFetchLoaderOptions<D = Record<string, any>> {
+    isMock?: boolean;
+    params?: Record<string, any>;
+    expire?: number;
+    data?: D;
+}
+export interface IPageFindLoaderOptions<D = Record<string, any>> {
+    isMock?: boolean;
+    params?: Record<string, any>;
+    expire?: number;
+    data?: D;
+}
+export interface IPageUpdateLoaderOptions<D = Record<string, any>> {
+    isMock?: boolean;
+    params?: Record<string, any>;
+    data?: D;
+}
+export interface IPageDeleteLoaderOptions<D = Record<string, any>> {
+    isMock?: boolean;
+    params?: Record<string, any>;
+    data?: D;
+}
+export interface IPageAddLoaderOptions<D = Record<string, any>> {
+    isMock?: boolean;
+    params?: Record<string, any>;
+    data?: D;
+}
+export interface IObjectRunLoaderOptions<T, D = Record<string, any>> {
+    mockItem?: T;
+    isMock?: boolean;
+    params?: Record<string, any>;
+    expire?: number;
+    data?: D;
+}
+export interface IListRunLoaderOptions<T, D = Record<string, any>> {
+    mockItems?: T[];
+    isMock?: boolean;
+    params?: Record<string, any>;
+    expire?: number;
+    data?: D;
+}
+export interface IPageLoaderOptions<T> {
+    prefix?: string;
+    baseURL: string;
+    primary?: string;
+    isMock?: boolean;
+    mockItems?: T[];
+    getBaseRequestOptions?: () => AxiosRequestConfig;
+    fetch?: {
+        getURL?: (page: number, query: string, opts: IPageFetchLoaderOptions<any>) => string;
+        getRequestOptions?: (page: number, query: string, opts: IPageFetchLoaderOptions<any>) => AxiosRequestConfig;
+    };
+    find?: {
+        getURL?: (id: string | number, opts: IPageFindLoaderOptions<any>) => string;
+        getRequestOptions?: (id: string | number, opts: IPageFindLoaderOptions<any>) => AxiosRequestConfig;
+    };
+    update?: {
+        getURL?: (id: string | number, data: any, opts: IPageUpdateLoaderOptions<any>) => string;
+        getRequestOptions?: (id: string | number, data: any, opts: IPageUpdateLoaderOptions<any>) => AxiosRequestConfig;
+    };
+    delete?: {
+        getURL?: (id: string | number, opts: IPageDeleteLoaderOptions<any>) => string;
+        getRequestOptions?: (id: string | number, opts: IPageDeleteLoaderOptions<any>) => AxiosRequestConfig;
+    };
+    add?: {
+        getURL?: (data: any, opts: IPageAddLoaderOptions<any>) => string;
+        getRequestOptions?: (data: any, opts: IPageAddLoaderOptions<any>) => AxiosRequestConfig;
+    };
+}
+export interface IObjectLoaderOptions<T, B, O> {
+    prefix?: string;
+    url: string;
+    method: Method;
+    primary?: string;
+    mockItem?: T;
+    getURL?: (data: B | undefined, opts: IObjectRunLoaderOptions<T, O>) => string;
+    getRequestOptions?: (data: B | undefined, opts: IObjectRunLoaderOptions<T, O>) => AxiosRequestConfig;
+}
+export interface IListLoaderOptions<T, O> {
+    prefix?: string;
+    url: string;
+    primary?: string;
+    mockItems?: T[];
+    getURL?: (opts: IListRunLoaderOptions<T, O>) => string;
+    getRequestOptions?: (opts: IListRunLoaderOptions<T, O>) => AxiosRequestConfig;
+}
+export interface IUsePageLoader<T> {
+    fetchStatus: Ref<IStatus>;
+    findStatus: Ref<IStatus>;
+    addStatus: Ref<IStatus>;
+    updateStatus: Ref<IStatus>;
+    deleteStatus: Ref<IStatus>;
+    fetchOptions: Ref<IPageOptions>;
+    deleteOptions: Ref<IAPIOptions>;
+    addOptions: Ref<IAPIOptions>;
+    findOptions: Ref<IAPIOptions>;
+    updateOptions: Ref<IAPIOptions>;
+    clear: () => void;
+    fetch: (page?: number, query?: string, opts?: IPageFetchLoaderOptions) => Promise<void>;
+    search: (query: string, opts?: IPageFetchLoaderOptions) => Promise<void>;
+    find: (id: string, opts?: any) => Promise<void>;
+    update: (id: string, data: any, opts?: any) => Promise<void>;
+    add: (data: any, opts?: IPageAddLoaderOptions) => Promise<void>;
+    remove: (id: string, opts?: IPageDeleteLoaderOptions) => Promise<void>;
+    setFetchLoading: () => void;
+    setFindLoading: () => void;
+    fetchItems: Ref<UnwrapRef<T[]>>;
+    findItem: Ref<UnwrapRef<T | null>>;
+    deleteItem: Ref<UnwrapRef<T | null>>;
+    addItem: Ref<UnwrapRef<T | null>>;
+    updateItem: Ref<UnwrapRef<T | null>>;
+}
+export interface IUseObjectLoader<T, B, O> {
+    status: Ref<IStatus>;
+    data: Ref<UnwrapRef<T | null>>;
+    options: Ref<IAPIOptions>;
+    run: (data?: B, opts?: IObjectRunLoaderOptions<T, O>) => Promise<void>;
+    clear: () => void;
+    setLoading: () => void;
+    setData: (data: T | null) => void;
+}
+export interface IUseListLoader<T, O> {
+    status: Ref<IStatus>;
+    items: Ref<UnwrapRef<T[]>>;
+    options: Ref<Record<string, any>>;
+    run: (opts?: IListRunLoaderOptions<T, O>) => void;
+    setItems: (items: T[]) => void;
+    clear: () => void;
+    setLoading: () => void;
+}

package/dist/lib/api/test.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/lib/api/types.d.ts

@@ -0,0 +1,89 @@
+import { AxiosRequestConfig } from 'axios';
+export interface IAPIOptions {
+    _status?: number;
+    _timestamp?: number;
+    request?: Partial<AxiosRequestConfig>;
+    [key: string]: any;
+}
+export interface IPageOptions extends IAPIOptions {
+    currentPageCount: number;
+    currentPage: number;
+    totalPage: number;
+    totalCount: number;
+    limit: number;
+    search?: string;
+    primary?: string;
+}
+export interface IStatus {
+    isError: boolean;
+    isSuccess: boolean;
+    isLoading: boolean;
+    isLoaded: boolean;
+    errorData: any | null;
+}
+export interface IAPIFetchState<T> {
+    items: T[];
+    status: IStatus;
+    options: IPageOptions;
+}
+export interface IAPIFindState<T> {
+    data: T;
+    status: IStatus;
+    options: IAPIOptions;
+}
+export interface IAPIAddState<T> {
+    data: T;
+    items: T[];
+    status: IStatus;
+    options: IAPIOptions;
+}
+export interface IAPIObjectState<T> {
+    data: T | null;
+    status: IStatus;
+    options: IAPIOptions;
+}
+export interface IAPIListState<T> {
+    items: T[];
+    status: IStatus;
+    options: IAPIOptions;
+}
+export interface IAPIDeleteState<T> {
+    data: T;
+    items: T[];
+    status: IStatus;
+    options: IAPIOptions;
+}
+export interface IAPIUpdateState<T> {
+    data: T;
+    oldData: T;
+    items: T[] | undefined | null;
+    status: IStatus;
+    options: IAPIOptions;
+}
+export interface IPageState<T> {
+    deleteStatus: IStatus;
+    updateStatus: IStatus;
+    addStatus: IStatus;
+    findStatus: IStatus;
+    fetchStatus: IStatus;
+    fetchItems: T[];
+    findItem: null | T;
+    addItem: null | T;
+    updateItem: null | T;
+    deleteItem: null | T | any;
+    findOptions: object;
+    addOptions: object;
+    deleteOptions: object;
+    updateOptions: object;
+    fetchOptions: IPageOptions;
+}
+export interface IObjectState<T> {
+    data: T | null;
+    status: IStatus;
+    options: IAPIOptions;
+}
+export interface IListState<T> {
+    items: T[];
+    status: IStatus;
+    options: IAPIOptions;
+}

package/dist/lib/api/utils.d.ts

@@ -0,0 +1,9 @@
+interface IGetParams {
+    params?: {
+        [key: string]: any;
+    };
+}
+export declare const getParams: (opts: IGetParams, reqOptions: IGetParams) => {
+    [key: string]: any;
+} | undefined;
+export {};

package/dist/lib/index.d.ts

@@ -0,0 +1,10 @@
+export * from './Requester';
+export * from './api/apiListHelper';
+export * from './api/apiObjectHelper';
+export * from './api/apiPageHelper';
+export * from './api/loaderList';
+export * from './api/loaderObject';
+export * from './api/loaderPage';
+export * from './api/loaderTypes';
+export * from './api/types';
+export * from './api/utils';

package/dist/utils/ArrayHelper.d.ts

@@ -0,0 +1,7 @@
+import { IOption } from './types';
+export declare class ArrayHelper {
+    static toOptions(data: any[], valueAttr?: string, labelAttr?: string): IOption[];
+    static toArray<T>(value: any): Array<T | any>;
+    static isEmpty(value: any): boolean;
+    static create: (length: number) => any[];
+}

package/dist/utils/ArrayHelper.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/CookieHelper.d.ts

@@ -0,0 +1,9 @@
+import { CookieSerializeOptions } from 'cookie';
+export declare class CookieHelper {
+    static set(name: string, data: any, options?: CookieSerializeOptions): void;
+    static get(name: string, options?: {
+        fromRes?: boolean;
+        parseJSON?: boolean;
+    }): any;
+    static remove(name: string, opts?: CookieSerializeOptions): void;
+}

package/dist/utils/FileHelper.d.ts

@@ -0,0 +1,6 @@
+export declare class FileHelper {
+    static toBase64: (file: File) => Promise<string>;
+    static printByURL: (link: string) => void;
+    static readFileAsync: (file: File) => Promise<string>;
+    static dataURLtoFile: (dataUrl: string, filename: string) => Promise<File>;
+}

package/dist/utils/ObjectHelper.d.ts

@@ -0,0 +1,18 @@
+import { AxiosError } from 'axios';
+import { IStatus } from '../lib/api/types.ts';
+import { IOption } from './types';
+export declare class ObjectHelper {
+    static createOption(value: any, label?: string): IOption;
+    static toOption(data: any, valueAttr?: string, labelAttr?: string): IOption;
+    static toOptions(data: any, valueAttr?: string, labelAttr?: string): IOption[];
+    static toStatus(obj: any): IStatus;
+    static toLoadingStatus(obj: any): any;
+    static toItemsSuccessStatus(obj: any, items: any[]): any;
+    static toObjectSuccessStatus(obj: any, data?: any): any;
+    static toErrorStatus(obj: any, error: AxiosError | any): any;
+    static toSuccessStatus(obj: any): any;
+    static toCompleteStatus(obj: any): any;
+    static createStatus(): IStatus;
+    static isInvalidParams(errorData: any): boolean;
+    static isEmpty: (object: any) => boolean;
+}

package/dist/utils/ObjectHelper.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/ParamHelper.d.ts

@@ -0,0 +1,8 @@
+import { IError } from './types';
+export declare class ParamHelper {
+    static getBoolTrue: (bool: any) => boolean;
+    static getBoolFalse: (bool: any) => boolean;
+    static isNotFoundError: (error: IError | any) => boolean;
+    static isChangeWithFalse: (value: boolean, oldValue: boolean) => boolean;
+    static isChangeWithTrue: (value: boolean, oldValue: boolean) => boolean;
+}

package/dist/utils/ParamHelper.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/StringHelper.d.ts

@@ -0,0 +1,13 @@
+export declare class StringHelper {
+    static genString: (length?: number) => string;
+    static withComma: (value?: number | string) => string;
+    static copyToClipBoard: (value?: string) => Promise<void>;
+    static split: (str: string | null | undefined, separator: string | RegExp) => string[];
+    static joinURL: (value: any, value2: any) => string;
+    static truncate: (str: any, num?: number) => any;
+    static getError: (errorData: {
+        code: string;
+        message: any;
+        fields: object;
+    } | any, defaultErrorMessage?: string) => any;
+}

package/dist/utils/StringHelper.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/TimeHelper.d.ts

@@ -0,0 +1,11 @@
+export declare class TimeHelper {
+    static toUTC: (time: string) => string;
+    static toLocal: (time: string) => string;
+    static getCurrentDate: () => string;
+    static getDateFormTime: (time: string) => string;
+    static getDateFormTimeWithLocal: (time: string) => string;
+    static getISODateTimeFormTime: (time: string) => string;
+    static getDateTimeFormTime: (time: string) => string;
+    static getTimeFormTime: (time: string) => string;
+    static getCurrentDateTime: () => string;
+}

package/dist/utils/TimeHelper.spec.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/faker.d.ts

@@ -0,0 +1,2 @@
+import * as fake from '@faker-js/faker';
+export declare const faker: typeof fake;

package/dist/utils/index.d.ts

@@ -0,0 +1,9 @@
+export * from './ObjectHelper';
+export * from './ParamHelper';
+export * from './TimeHelper';
+export * from './ArrayHelper';
+export * from './FileHelper';
+export * from './StringHelper';
+export * from './CookieHelper';
+export * from './faker';
+export * from './lodash';

package/dist/utils/lodash.d.ts

@@ -0,0 +1,99 @@
+import * as lodash from 'lodash';
+export declare const _get: {
+    <TObject extends object, TKey extends keyof TObject>(object: TObject, path: TKey | [TKey]): TObject[TKey];
+    <TObject_1 extends object, TKey_1 extends keyof TObject_1>(object: TObject_1 | null | undefined, path: TKey_1 | [TKey_1]): TObject_1[TKey_1] | undefined;
+    <TObject_2 extends object, TKey_2 extends keyof TObject_2, TDefault>(object: TObject_2 | null | undefined, path: TKey_2 | [TKey_2], defaultValue: TDefault): TDefault | Exclude<TObject_2[TKey_2], undefined>;
+    <TObject_3 extends object, TKey1 extends keyof TObject_3, TKey2 extends keyof TObject_3[TKey1]>(object: TObject_3, path: [TKey1, TKey2]): TObject_3[TKey1][TKey2];
+    <TObject_4 extends object, TKey1_1 extends keyof TObject_4, TKey2_1 extends keyof TObject_4[TKey1_1]>(object: TObject_4 | null | undefined, path: [TKey1_1, TKey2_1]): TObject_4[TKey1_1][TKey2_1] | undefined;
+    <TObject_5 extends object, TKey1_2 extends keyof TObject_5, TKey2_2 extends keyof TObject_5[TKey1_2], TDefault_1>(object: TObject_5 | null | undefined, path: [TKey1_2, TKey2_2], defaultValue: TDefault_1): TDefault_1 | Exclude<TObject_5[TKey1_2][TKey2_2], undefined>;
+    <TObject_6 extends object, TKey1_3 extends keyof TObject_6, TKey2_3 extends keyof TObject_6[TKey1_3], TKey3 extends keyof TObject_6[TKey1_3][TKey2_3]>(object: TObject_6, path: [TKey1_3, TKey2_3, TKey3]): TObject_6[TKey1_3][TKey2_3][TKey3];
+    <TObject_7 extends object, TKey1_4 extends keyof TObject_7, TKey2_4 extends keyof TObject_7[TKey1_4], TKey3_1 extends keyof TObject_7[TKey1_4][TKey2_4]>(object: TObject_7 | null | undefined, path: [TKey1_4, TKey2_4, TKey3_1]): TObject_7[TKey1_4][TKey2_4][TKey3_1] | undefined;
+    <TObject_8 extends object, TKey1_5 extends keyof TObject_8, TKey2_5 extends keyof TObject_8[TKey1_5], TKey3_2 extends keyof TObject_8[TKey1_5][TKey2_5], TDefault_2>(object: TObject_8 | null | undefined, path: [TKey1_5, TKey2_5, TKey3_2], defaultValue: TDefault_2): TDefault_2 | Exclude<TObject_8[TKey1_5][TKey2_5][TKey3_2], undefined>;
+    <TObject_9 extends object, TKey1_6 extends keyof TObject_9, TKey2_6 extends keyof TObject_9[TKey1_6], TKey3_3 extends keyof TObject_9[TKey1_6][TKey2_6], TKey4 extends keyof TObject_9[TKey1_6][TKey2_6][TKey3_3]>(object: TObject_9, path: [TKey1_6, TKey2_6, TKey3_3, TKey4]): TObject_9[TKey1_6][TKey2_6][TKey3_3][TKey4];
+    <TObject_10 extends object, TKey1_7 extends keyof TObject_10, TKey2_7 extends keyof TObject_10[TKey1_7], TKey3_4 extends keyof TObject_10[TKey1_7][TKey2_7], TKey4_1 extends keyof TObject_10[TKey1_7][TKey2_7][TKey3_4]>(object: TObject_10 | null | undefined, path: [TKey1_7, TKey2_7, TKey3_4, TKey4_1]): TObject_10[TKey1_7][TKey2_7][TKey3_4][TKey4_1] | undefined;
+    <TObject_11 extends object, TKey1_8 extends keyof TObject_11, TKey2_8 extends keyof TObject_11[TKey1_8], TKey3_5 extends keyof TObject_11[TKey1_8][TKey2_8], TKey4_2 extends keyof TObject_11[TKey1_8][TKey2_8][TKey3_5], TDefault_3>(object: TObject_11 | null | undefined, path: [TKey1_8, TKey2_8, TKey3_5, TKey4_2], defaultValue: TDefault_3): TDefault_3 | Exclude<TObject_11[TKey1_8][TKey2_8][TKey3_5][TKey4_2], undefined>;
+    <T>(object: lodash.NumericDictionary<T>, path: number): T;
+    <T_1>(object: lodash.NumericDictionary<T_1> | null | undefined, path: number): T_1 | undefined;
+    <T_2, TDefault_4>(object: lodash.NumericDictionary<T_2> | null | undefined, path: number, defaultValue: TDefault_4): T_2 | TDefault_4;
+    <TDefault_5>(object: null | undefined, path: lodash.PropertyPath, defaultValue: TDefault_5): TDefault_5;
+    (object: null | undefined, path: lodash.PropertyPath): undefined;
+    <TObject_12, TPath extends string>(data: TObject_12, path: TPath): string extends TPath ? any : lodash.GetFieldType<TObject_12, TPath>;
+    <TObject_13, TPath_1 extends string, TDefault_6 = lodash.GetFieldType<TObject_13, TPath_1>>(data: TObject_13, path: TPath_1, defaultValue: TDefault_6): TDefault_6 | Exclude<lodash.GetFieldType<TObject_13, TPath_1>, null | undefined>;
+    (object: any, path: lodash.PropertyPath, defaultValue?: any): any;
+};
+export declare const _range: {
+    (start: number, end?: number | undefined, step?: number | undefined): number[];
+    (end: number, index: string | number, guard: object): number[];
+};
+export declare const _concat: <T>(...values: lodash.Many<T>[]) => T[];
+export declare const _toNumber: (value: any) => number;
+export declare const _isUndefined: (value: any) => value is undefined;
+export declare const _dropRight: <T>(array: lodash.List<T> | null | undefined, n?: number | undefined) => T[];
+export declare const _intersection: <T>(...arrays: (lodash.List<T> | null | undefined)[]) => T[];
+export declare const _set: {
+    <T extends object>(object: T, path: lodash.PropertyPath, value: any): T;
+    <TResult>(object: object, path: lodash.PropertyPath, value: any): TResult;
+};
+export declare const _map: {
+    <T, TResult>(collection: T[] | null | undefined, iteratee: lodash.ArrayIterator<T, TResult>): TResult[];
+    <T_1, TResult_1>(collection: lodash.List<T_1> | null | undefined, iteratee: lodash.ListIterator<T_1, TResult_1>): TResult_1[];
+    <T_2>(collection: lodash.Dictionary<T_2> | lodash.NumericDictionary<T_2> | null | undefined): T_2[];
+    <T_3 extends object, TResult_2>(collection: T_3 | null | undefined, iteratee: lodash.ObjectIterator<T_3, TResult_2>): TResult_2[];
+    <T_4, K extends keyof T_4>(collection: lodash.Dictionary<T_4> | lodash.NumericDictionary<T_4> | null | undefined, iteratee: K): T_4[K][];
+    <T_5>(collection: lodash.Dictionary<T_5> | lodash.NumericDictionary<T_5> | null | undefined, iteratee?: string | undefined): any[];
+    <T_6>(collection: lodash.Dictionary<T_6> | lodash.NumericDictionary<T_6> | null | undefined, iteratee?: object | undefined): boolean[];
+};
+export declare const _flatDeep: <T>(array: lodash.ListOfRecursiveArraysOrValues<T> | null | undefined) => lodash.Flat<T>[];
+export declare const _uniq: <T>(array: lodash.List<T> | null | undefined) => T[];
+export declare const _sortBy: {
+    <T>(collection: lodash.List<T> | null | undefined, ...iteratees: lodash.Many<lodash.ListIteratee<T>>[]): T[];
+    <T_1 extends object>(collection: T_1 | null | undefined, ...iteratees: lodash.Many<lodash.ObjectIteratee<T_1>>[]): T_1[keyof T_1][];
+};
+export declare const _uniqBy: <T>(array: lodash.List<T> | null | undefined, iteratee: lodash.ValueIteratee<T>) => T[];
+export declare const _random: {
+    (floating?: boolean | undefined): number;
+    (max: number, floating?: boolean | undefined): number;
+    (min: number, max: number, floating?: boolean | undefined): number;
+    (min: number, index: string | number, guard: object): number;
+};
+export declare const _cloneDeep: <T>(value: T) => T;
+export declare const _isEmpty: {
+    <T extends {
+        __trapAny: any;
+    }>(value?: T | undefined): boolean;
+    (value: string): value is "";
+    (value: Map<any, any> | Set<any> | lodash.List<any> | null | undefined): boolean;
+    (value: object): boolean;
+    <T_1 extends object>(value: T_1 | null | undefined): value is lodash.EmptyObjectOf<T_1> | null | undefined;
+    (value?: any): boolean;
+};
+export declare const _isObject: (value?: any) => value is object;
+export declare const _isArray: {
+    (value?: any): value is any[];
+    <T>(value?: any): value is any[];
+};
+export declare const _findIndex: <T>(array: lodash.List<T> | null | undefined, predicate?: lodash.ListIterateeCustom<T, boolean> | undefined, fromIndex?: number | undefined) => number;
+export declare const _isEqual: (value: any, other: any) => boolean;
+export declare const _difference: <T>(array: lodash.List<T> | null | undefined, ...values: lodash.List<T>[]) => T[];
+export declare const _shuffle: {
+    <T>(collection: lodash.List<T> | null | undefined): T[];
+    <T_1 extends object>(collection: T_1 | null | undefined): T_1[keyof T_1][];
+};
+export declare const _size: (collection: string | object | null | undefined) => number;
+export declare const _toPairs: {
+    <T>(object?: lodash.Dictionary<T> | lodash.NumericDictionary<T> | undefined): [string, T][];
+    (object?: object | undefined): [string, any][];
+};
+export declare const _orderBy: {
+    <T>(collection: lodash.List<T> | null | undefined, iteratees?: lodash.Many<lodash.ListIterator<T, unknown>> | undefined, orders?: lodash.Many<boolean | "asc" | "desc"> | undefined): T[];
+    <T_1>(collection: lodash.List<T_1> | null | undefined, iteratees?: lodash.Many<lodash.ListIteratee<T_1>> | undefined, orders?: lodash.Many<boolean | "asc" | "desc"> | undefined): T_1[];
+    <T_2 extends object>(collection: T_2 | null | undefined, iteratees?: lodash.Many<lodash.ObjectIterator<T_2, unknown>> | undefined, orders?: lodash.Many<boolean | "asc" | "desc"> | undefined): T_2[keyof T_2][];
+    <T_3 extends object>(collection: T_3 | null | undefined, iteratees?: lodash.Many<lodash.ObjectIteratee<T_3>> | undefined, orders?: lodash.Many<boolean | "asc" | "desc"> | undefined): T_3[keyof T_3][];
+};
+export declare const _fromPairs: {
+    <T>(pairs: lodash.List<[lodash.PropertyName, T]> | null | undefined): lodash.Dictionary<T>;
+    (pairs: lodash.List<any[]> | null | undefined): lodash.Dictionary<any>;
+};
+export declare const _xor: <T>(...arrays: (lodash.List<T> | null | undefined)[]) => T[];
+export declare const _clone: (object: any) => any;
+export declare const _debounce: <T extends (...args: any[]) => any>(func: T, wait?: number) => lodash.DebouncedFunc<T>;

package/dist/utils/types.d.ts

@@ -0,0 +1,8 @@
+export interface IOption {
+    value: any;
+    label: string;
+}
+export interface IError {
+    code: string;
+    message: string;
+}

package/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@finema/core",
+  "version": "1.0.0",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "main": "./dist/core.umd.cjs",
+  "module": "./dist/core.js",
+  "exports": {
+    ".": {
+      "import": "./dist/core.js",
+      "require": "./dist/core.umd.cjs"
+    }
+  },
+  "types": "./dist/index.d.ts",
+  "dependencies": {
+    "@faker-js/faker": "^7.6.0",
+    "axios": "^1.2.6",
+    "cookie": "^0.5.0",
+    "cookie-universal": "^2.2.2",
+    "dayjs": "^1.11.7",
+    "lodash": "^4.17.21",
+    "url-join": "^5.0.0",
+    "vue": "^3.3.4"
+  },
+  "devDependencies": {
+    "@types/lodash": "^4.14.195",
+    "@vitejs/plugin-vue": "^4.2.3",
+    "typescript": "^5.0.2",
+    "vite": "^4.4.0",
+    "vitest": "^0.33.0",
+    "vue-tsc": "^1.8.3"
+  },
+  "scripts": {
+    "test": "vitest run",
+    "dev": "vite",
+    "build": "vite build && vue-tsc --emitDeclarationOnly",
+    "preview": "vite preview"
+  }
+}