@finema/core 1.1.5 → 1.2.2

package/README.md

@@ -1,18 +1,94 @@
-# Vue 3 + TypeScript + Vite
+<!--
+Get your module up and running quickly.
 
-This template should help get you started developing with Vue 3 and TypeScript in Vite. The template uses Vue 3 `<script setup>` SFCs, check out the [script setup docs](https://v3.vuejs.org/api/sfc-script-setup.html#sfc-script-setup) to learn more.
+Find and replace all on all files (CMD+SHIFT+F):
+- Name: My Module
+- Package name: my-module
+- Description: My new Nuxt module
+-->
 
-## Recommended IDE Setup
+# @finema/core Nuxt Module
 
-- [VS Code](https://code.visualstudio.com/) + [Volar](https://marketplace.visualstudio.com/items?itemName=Vue.volar) (and disable Vetur) + [TypeScript Vue Plugin (Volar)](https://marketplace.visualstudio.com/items?itemName=Vue.vscode-typescript-vue-plugin).
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
 
-## Type Support For `.vue` Imports in TS
+@finema/core for doing amazing things.
 
-TypeScript cannot handle type information for `.vue` imports by default, so we replace the `tsc` CLI with `vue-tsc` for type checking. In editors, we need [TypeScript Vue Plugin (Volar)](https://marketplace.visualstudio.com/items?itemName=Vue.vscode-typescript-vue-plugin) to make the TypeScript language service aware of `.vue` types.
+- [✨ &nbsp;Release Notes](/CHANGELOG.md)
+<!-- - [🏀 Online playground](https://stackblitz.com/github/your-org/my-module?file=playground%2Fapp.vue) -->
+<!-- - [📖 &nbsp;Documentation](https://example.com) -->
 
-If the standalone TypeScript plugin doesn't feel fast enough to you, Volar has also implemented a [Take Over Mode](https://github.com/johnsoncodehk/volar/discussions/471#discussioncomment-1361669) that is more performant. You can enable it by the following steps:
+## Features
 
-1. Disable the built-in TypeScript Extension
-   1. Run `Extensions: Show Built-in Extensions` from VSCode's command palette
-   2. Find `TypeScript and JavaScript Language Features`, right click and select `Disable (Workspace)`
-2. Reload the VSCode window by running `Developer: Reload Window` from the command palette.
+<!-- Highlight some of the features your module provide here -->
+- ⛰ &nbsp;Foo
+- 🚠 &nbsp;Bar
+- 🌲 &nbsp;Baz
+
+## Quick Setup
+
+1. Add `@finema/core` dependency to your project
+
+```bash
+# Using pnpm
+pnpm add -D @finema/core
+
+# Using yarn
+yarn add --dev @finema/core
+
+# Using npm
+npm install --save-dev @finema/core
+```
+
+1. Add `@finema/core` to the `modules` section of `nuxt.config.ts`
+
+```js
+export default defineNuxtConfig({
+  modules: [
+    '@finema/core'
+  ]
+})
+```
+
+That's it! You can now use @finema/core in your Nuxt app ✨
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Generate type stubs
+npm run dev:prepare
+
+# Develop with the playground
+npm run dev
+
+# Build the playground
+npm run dev:build
+
+# Run ESLint
+npm run lint
+
+# Run Vitest
+npm run test
+npm run test:watch
+
+# Release new version
+npm run release
+```
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/my-module/latest.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-version-href]: https://npmjs.com/package/my-module
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/my-module.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-downloads-href]: https://npmjs.com/package/my-module
+
+[license-src]: https://img.shields.io/npm/l/my-module.svg?style=flat&colorA=18181B&colorB=28CF8D
+[license-href]: https://npmjs.com/package/my-module
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-18181B?logo=nuxt.js
+[nuxt-href]: https://nuxt.com

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.mts

@@ -0,0 +1,15 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+    /**
+     * @default ''
+     */
+    prefix?: string;
+    /**
+     * @default false
+     */
+    global?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { type ModuleOptions, _default as default };

package/dist/module.d.ts

@@ -0,0 +1,15 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface ModuleOptions {
+    /**
+     * @default ''
+     */
+    prefix?: string;
+    /**
+     * @default false
+     */
+    global?: boolean;
+}
+declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
+
+export { type ModuleOptions, _default as default };

package/dist/module.json

@@ -0,0 +1,8 @@
+{
+  "name": "@finema/core",
+  "version": "1.2.2",
+  "configKey": "core",
+  "compatibility": {
+    "nuxt": "^3.4.0"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,28 @@
+import { defineNuxtModule, createResolver, addPlugin, addImportsDir } from '@nuxt/kit';
+
+const name = "@finema/core";
+const version = "1.2.2";
+
+const module = defineNuxtModule({
+  meta: {
+    name,
+    version,
+    configKey: "core",
+    compatibility: {
+      nuxt: "^3.4.0"
+    }
+  },
+  // Default configuration options of the Nuxt module
+  defaults: {},
+  setup(options, nuxt) {
+    const { resolve } = createResolver(import.meta.url);
+    const runtimeDir = resolve("./runtime");
+    nuxt.options.build.transpile.push(runtimeDir);
+    addPlugin({
+      src: resolve(runtimeDir, "plugin")
+    });
+    addImportsDir(resolve(runtimeDir, "composables"));
+  }
+});
+
+export { module as default };

package/dist/runtime/composables/useLibs.d.ts

@@ -0,0 +1,24 @@
+import * as CoreLibs from '../lib';
+export declare const useLibs: () => {
+    Requester: typeof CoreLibs.Requester;
+    NewRequester: CoreLibs.IRequester;
+    apiListHelper: <T, O>(state: () => import("../types/lib").IAPIListState<T>, onUpdateStatus: (status: import("../types/lib").IStatus) => void, onUpdateOptions: (options: import("../types/lib").IAPIOptions) => void, onUpdateItems: (data: T[]) => void, opts: CoreLibs.IListLoaderOptions<T, O> & CoreLibs.IListRunLoaderOptions<T, O>) => Promise<void>;
+    apiObjectHelper: <T_1, B, O_1>(state: () => import("../types/lib").IAPIObjectState<T_1>, onUpdateStatus: (status: import("../types/lib").IStatus) => void, onUpdateOptions: (options: import("../types/lib").IAPIOptions) => void, onUpdateData: (data: any) => void, data: B | undefined, opts: CoreLibs.IObjectLoaderOptions<T_1, B, O_1> & CoreLibs.IObjectRunLoaderOptions<T_1, O_1>) => Promise<void>;
+    apiAddHelper: <T_2>(state: () => import("../types/lib").IAPIAddState<T_2>, onUpdateStatus: (status: import("../types/lib").IStatus) => void, onUpdateOptions: (options: import("../types/lib").IAPIOptions) => void, onUpdateData: (data: any) => void, onUpdateItems: (data: any[]) => void, data: any, opts: CoreLibs.IPageLoaderOptions<any> & CoreLibs.IPageFetchLoaderOptions<Record<string, any>>) => Promise<void>;
+    apiDeleteHelper: <T_3>(state: () => import("../types/lib").IAPIDeleteState<T_3>, onUpdateStatus: (status: import("../types/lib").IStatus) => void, onUpdateOptions: (options: import("../types/lib").IAPIOptions) => void, _onUpdateData: (data: T_3) => void, onUpdateItems: (data: T_3[]) => void, id: string | number, opts: CoreLibs.IPageLoaderOptions<any> & CoreLibs.IPageDeleteLoaderOptions<Record<string, any>>) => Promise<void>;
+    apiFetchHelper: <T_4>(state: () => import("../types/lib").IAPIFetchState<T_4>, onUpdateStatus: (status: import("../types/lib").IStatus) => void, onUpdateOptions: (options: import("../types/lib").IPageOptions) => void, onUpdateItems: (items: T_4[]) => void, page: number, query: string, opts: CoreLibs.IPageLoaderOptions<T_4> & CoreLibs.IPageFetchLoaderOptions<any>) => Promise<void>;
+    apiFindHelper: <T_5>(state: () => import("../types/lib").IAPIFindState<T_5>, onUpdateStatus: (status: import("../types/lib").IStatus) => void, onUpdateOptions: (options: import("../types/lib").IAPIOptions) => void, onUpdateData: (data: any) => void, id: string | number, opts: CoreLibs.IPageLoaderOptions<T_5> & CoreLibs.IPageFindLoaderOptions<Record<string, any>>) => Promise<void>;
+    updateHelper: <T_6>(state: () => import("../types/lib").IAPIUpdateState<T_6>, onUpdateStatus: (status: import("../types/lib").IStatus) => void, onUpdateOptions: (options: import("../types/lib").IAPIOptions) => void, onUpdateData: (data: T_6) => void, _onUpdateItems: (data: T_6[]) => void, onUpdateOldData: (data: T_6) => void, id: string | number, data: any, opts: CoreLibs.IPageLoaderOptions<any> & CoreLibs.IPageUpdateLoaderOptions<Record<string, any>>) => Promise<void>;
+    useListLoader: <T_7 = any, O_2 = Record<string, any>>(loaderOptions: CoreLibs.IListLoaderOptions<T_7, O_2>) => CoreLibs.IUseListLoader<T_7, O_2>;
+    useObjectLoader: <T_8 = any, B_1 = any, O_3 = Record<string, any>>(loaderOptions: CoreLibs.IObjectLoaderOptions<T_8, B_1, O_3>) => CoreLibs.IUseObjectLoader<T_8, B_1, O_3>;
+    initPageOptions: () => {
+        currentPageCount: number;
+        currentPage: number;
+        totalPage: number;
+        totalCount: number;
+        limit: number;
+        search: string;
+        primary: string;
+    };
+    usePageLoader: <T_9 = any>(loaderOptions: CoreLibs.IPageLoaderOptions<T_9>) => CoreLibs.IUsePageLoader<T_9>;
+};

package/dist/runtime/composables/useLibs.mjs

@@ -0,0 +1,4 @@
+import * as CoreLibs from "../lib/index.mjs";
+export const useLibs = () => {
+  return { ...CoreLibs };
+};

package/dist/runtime/composables/useUtils.d.ts

@@ -0,0 +1,10 @@
+import { StringHelper } from '../utils/StringHelper';
+import { TimeHelper } from '../utils/TimeHelper';
+import { ParamHelper } from '../utils/ParamHelper';
+import { FileHelper } from '../utils/FileHelper';
+export declare const useUtils: () => {
+    StringHelper: typeof StringHelper;
+    TimeHelper: typeof TimeHelper;
+    ParamHelper: typeof ParamHelper;
+    FileHelper: typeof FileHelper;
+};

package/dist/runtime/composables/useUtils.mjs

@@ -0,0 +1,12 @@
+import { StringHelper } from "../utils/StringHelper.mjs";
+import { TimeHelper } from "../utils/TimeHelper.mjs";
+import { ParamHelper } from "../utils/ParamHelper.mjs";
+import { FileHelper } from "../utils/FileHelper.mjs";
+export const useUtils = () => {
+  return {
+    StringHelper,
+    TimeHelper,
+    ParamHelper,
+    FileHelper
+  };
+};

package/dist/{lib → runtime/lib}/Requester.d.ts

@@ -1,4 +1,4 @@
-import { AxiosInstance, AxiosRequestConfig, CancelTokenSource, CancelTokenStatic, Method } from 'axios';
+import { type AxiosInstance, type AxiosRequestConfig, type CancelTokenSource, type CancelTokenStatic, type Method } from 'axios';
 export interface IResponse<T = any> {
     data: T;
     status: number;

package/dist/runtime/lib/Requester.mjs

@@ -0,0 +1,37 @@
+import axios from "axios";
+export class Requester {
+  cancelToken;
+  source;
+  isCancel;
+  service;
+  options;
+  constructor(options = {}) {
+    this.options = options;
+    this.service = axios.create(options);
+    this.cancelToken = axios.CancelToken;
+    this.source = this.cancelToken.source();
+    this.isCancel = axios.isCancel;
+  }
+  async get(path, options = {}) {
+    return this.service.get(path, options);
+  }
+  async put(path, payload, options = {}) {
+    return this.service.put(path, payload, options);
+  }
+  async delete(path, options = {}) {
+    return this.service.delete(path, options);
+  }
+  async post(path, payload, options = {}) {
+    return this.service.post(path, payload, options);
+  }
+  async create(method, path, payload, options = {}) {
+    return this.service({
+      method,
+      url: path,
+      data: payload,
+      ...this.options,
+      ...options
+    });
+  }
+}
+export const NewRequester = new Requester({});

package/dist/{lib → runtime/lib}/api/apiListHelper.d.ts

@@ -1,3 +1,3 @@
-import { IAPIListState, IAPIOptions, IStatus } from './types';
-import { IListLoaderOptions, IListRunLoaderOptions } from './loaderTypes';
+import { type IAPIListState, type IAPIOptions, type IStatus } from '../../types/lib';
+import { type IListLoaderOptions, type 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/runtime/lib/api/apiListHelper.mjs

@@ -0,0 +1,44 @@
+import { NewRequester } from "../Requester.mjs";
+import { ObjectHelper } from "../../utils/ObjectHelper.mjs";
+import { ParamHelper } from "../../utils/ParamHelper.mjs";
+export const apiListHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateItems, opts) => {
+  const timestamp = state().options._timestamp;
+  if (opts.expire && timestamp) {
+    if (timestamp + opts.expire > Date.now()) {
+      onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+      return;
+    }
+  }
+  onUpdateStatus(ObjectHelper.toLoadingStatus(state().status));
+  onUpdateOptions({});
+  const reqOptions = opts.getRequestOptions?.(opts) ?? {};
+  reqOptions.params = ParamHelper.getParams(opts, reqOptions);
+  try {
+    if (opts.isMock) {
+      const res = {
+        data: opts.mockItems
+      };
+      onUpdateItems(res.data);
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+    } else {
+      const { data: items, status } = await NewRequester.get(
+        opts.getURL ? opts.getURL(opts) : opts.url,
+        reqOptions
+      );
+      onUpdateItems(items);
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+      onUpdateOptions({
+        _timestamp: Date.now(),
+        _status: status,
+        request: reqOptions
+      });
+    }
+  } catch (e) {
+    onUpdateStatus(ObjectHelper.toErrorStatus(state().status, e));
+    onUpdateOptions({
+      _status: e.response?.status,
+      request: reqOptions
+    });
+  }
+  onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+};

package/dist/{lib → runtime/lib}/api/apiObjectHelper.d.ts

@@ -1,3 +1,3 @@
-import { IAPIObjectState, IAPIOptions, IStatus } from './types';
-import { IObjectLoaderOptions, IObjectRunLoaderOptions } from './loaderTypes';
+import { type IAPIObjectState, type IAPIOptions, type IStatus } from '../../types/lib';
+import { type IObjectLoaderOptions, type 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/runtime/lib/api/apiObjectHelper.mjs

@@ -0,0 +1,46 @@
+import { NewRequester } from "../Requester.mjs";
+import { ObjectHelper } from "../../utils/ObjectHelper.mjs";
+import { ParamHelper } from "../../utils/ParamHelper.mjs";
+export const apiObjectHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateData, data, opts) => {
+  const timestamp = state().options._timestamp;
+  if (opts.expire && timestamp) {
+    if (timestamp + opts.expire > Date.now()) {
+      onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+      return;
+    }
+  }
+  onUpdateStatus(ObjectHelper.toLoadingStatus(state().status));
+  onUpdateOptions({});
+  const reqOptions = opts.getRequestOptions?.(data, opts) ?? {};
+  reqOptions.params = ParamHelper.getParams(opts, reqOptions);
+  try {
+    if (opts.isMock) {
+      const res = {
+        data: opts.mockItem
+      };
+      onUpdateData(res.data);
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+    } else {
+      const { data: item, status } = await NewRequester.create(
+        opts.method,
+        opts.getURL ? opts.getURL(data, opts) : opts.url,
+        data,
+        reqOptions
+      );
+      onUpdateData(item);
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+      onUpdateOptions({
+        request: reqOptions,
+        _timestamp: Date.now(),
+        _status: status
+      });
+    }
+  } catch (e) {
+    onUpdateStatus(ObjectHelper.toErrorStatus(state().status, e));
+    onUpdateOptions({
+      request: reqOptions,
+      _status: e.response?.status
+    });
+  }
+  onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+};

package/dist/{lib → runtime/lib}/api/apiPageHelper.d.ts

@@ -1,5 +1,5 @@
-import { IAPIAddState, IAPIDeleteState, IAPIFetchState, IAPIFindState, IAPIOptions, IAPIUpdateState, IPageOptions, IStatus } from './types';
-import { IPageDeleteLoaderOptions, IPageFetchLoaderOptions, IPageFindLoaderOptions, IPageLoaderOptions, IPageUpdateLoaderOptions } from './loaderTypes';
+import { type IAPIAddState, type IAPIDeleteState, type IAPIFetchState, type IAPIFindState, type IAPIOptions, type IAPIUpdateState, type IPageOptions, type IStatus } from '../../types/lib';
+import { type IPageDeleteLoaderOptions, type IPageFetchLoaderOptions, type IPageFindLoaderOptions, type IPageLoaderOptions, type 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>;

package/dist/runtime/lib/api/apiPageHelper.mjs

@@ -0,0 +1,265 @@
+import { NewRequester } from "../Requester.mjs";
+import { ObjectHelper } from "../../utils/ObjectHelper.mjs";
+import { _findIndex, _get, _shuffle } from "../../utils/lodash.mjs";
+import { ParamHelper } from "../../utils/ParamHelper.mjs";
+import { CONFIG } from "./config.mjs";
+export const apiAddHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateData, onUpdateItems, data, opts) => {
+  onUpdateStatus(ObjectHelper.toLoadingStatus(state().status));
+  onUpdateOptions({});
+  const reqOptions = {
+    ...opts.getBaseRequestOptions?.() || {},
+    ...opts.add?.getRequestOptions?.(data, opts) ?? {}
+  };
+  reqOptions.params = ParamHelper.getParams(opts, reqOptions);
+  try {
+    let item = null;
+    if (opts.isMock) {
+      const res = {
+        data: opts.mockItems?.[0]
+      };
+      onUpdateData(res.data);
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+    } else {
+      const { data: itemm, status } = await NewRequester.post(
+        opts.add?.getURL ? opts.add.getURL(data, opts) : opts.baseURL,
+        data,
+        reqOptions
+      );
+      onUpdateData(itemm);
+      item = itemm;
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+      onUpdateOptions({
+        _timestamp: Date.now(),
+        _status: status,
+        request: reqOptions
+      });
+    }
+    if (state().items) {
+      onUpdateItems([item, ...state().items]);
+    }
+  } catch (e) {
+    onUpdateStatus(ObjectHelper.toErrorStatus(state().status, e));
+    onUpdateOptions({
+      _status: e.response?.status,
+      request: reqOptions
+    });
+  }
+  onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+};
+export const apiDeleteHelper = async (state, onUpdateStatus, onUpdateOptions, _onUpdateData, onUpdateItems, id, opts) => {
+  const primaryKey = opts.primary ?? "id";
+  const getPrimaryKey = (item) => _get(item, primaryKey, "");
+  onUpdateStatus(ObjectHelper.toLoadingStatus(state().status));
+  onUpdateOptions({});
+  const reqOptions = {
+    ...opts.getBaseRequestOptions?.() || {},
+    ...opts.delete?.getRequestOptions?.(id, opts) ?? {}
+  };
+  reqOptions.params = ParamHelper.getParams(opts, reqOptions);
+  try {
+    if (opts.isMock) {
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+    } else {
+      const { status } = await NewRequester.delete(
+        opts.delete?.getURL ? opts.delete.getURL(id, opts) : `${opts.baseURL}/${id}`,
+        reqOptions
+      );
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+      onUpdateOptions({
+        _timestamp: Date.now(),
+        _status: status,
+        request: reqOptions
+      });
+    }
+    if (state().items) {
+      onUpdateItems(
+        state().items.filter((item) => {
+          return getPrimaryKey(item) !== id;
+        })
+      );
+    }
+  } catch (e) {
+    onUpdateStatus(ObjectHelper.toErrorStatus(state().status, e));
+    onUpdateOptions({
+      _status: e.response?.status,
+      request: reqOptions
+    });
+  }
+  onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+};
+export const apiFetchHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateItems, page, query, opts) => {
+  const timestamp = state().options._timestamp;
+  if (opts.expire && timestamp) {
+    if (timestamp + opts.expire > Date.now()) {
+      onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+      return;
+    }
+  }
+  onUpdateStatus(ObjectHelper.toLoadingStatus(state().status));
+  onUpdateOptions({
+    ...state().options,
+    ...opts,
+    currentPage: page,
+    search: query,
+    primary: opts.primary ?? "id",
+    _status: void 0
+  });
+  const getOptions = (data) => ({
+    ...state().options,
+    currentPageCount: state().items?.length || 0,
+    currentPage: page,
+    totalCount: data.total,
+    limit: data.limit,
+    search: query,
+    totalPage: Math.ceil(data.total / data.limit)
+  });
+  const reqOptions = {
+    ...opts.getBaseRequestOptions?.() || {},
+    ...opts.fetch?.getRequestOptions?.(page, query, opts) ?? {}
+  };
+  const limit = reqOptions.params?.limit || CONFIG.LIMIT_PER_PAGE;
+  reqOptions.params = {
+    limit,
+    page,
+    q: (query || "").trim()
+  };
+  reqOptions.params = ParamHelper.getParams(opts, reqOptions);
+  try {
+    if (opts.isMock) {
+      await new Promise((resolve) => {
+        setTimeout(resolve, 500);
+      });
+      const res = {
+        data: {
+          items: opts.mockItems || [],
+          totalCount: (opts.mockItems || []).length
+        }
+      };
+      onUpdateItems(_shuffle(res.data.items));
+      onUpdateOptions(getOptions(res.data));
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+    } else {
+      const {
+        data: { items: itemss, ...moreOptions },
+        status
+      } = await NewRequester.get(
+        opts.fetch?.getURL ? opts.fetch.getURL(page, query, opts) : opts.baseURL,
+        reqOptions
+      );
+      onUpdateItems(itemss);
+      onUpdateOptions({
+        ...getOptions(moreOptions),
+        _timestamp: Date.now(),
+        _status: status,
+        request: reqOptions
+      });
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+    }
+  } catch (e) {
+    onUpdateStatus(ObjectHelper.toErrorStatus(state().status, e));
+    onUpdateOptions({
+      ...state().options,
+      _status: e.response?.status,
+      request: reqOptions
+    });
+  }
+  onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+};
+export const apiFindHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateData, id, opts) => {
+  const timestamp = state().options._timestamp;
+  if (opts.expire && timestamp) {
+    if (timestamp + opts.expire > Date.now()) {
+      onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+      return;
+    }
+  }
+  onUpdateStatus(ObjectHelper.toLoadingStatus(state().status));
+  onUpdateOptions({});
+  const reqOptions = {
+    ...opts.getBaseRequestOptions?.() || {},
+    ...opts.find?.getRequestOptions?.(id, opts) ?? {}
+  };
+  reqOptions.params = ParamHelper.getParams(opts, reqOptions);
+  try {
+    if (opts.isMock) {
+      const res = {
+        data: opts.mockItems?.[0]
+      };
+      onUpdateData(res.data);
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+    } else {
+      const { data, status } = await NewRequester.get(
+        opts.find?.getURL ? opts.find.getURL(id, opts) : `${opts.baseURL}/${id}`,
+        reqOptions
+      );
+      onUpdateData(data);
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+      onUpdateOptions({
+        _timestamp: Date.now(),
+        _status: status,
+        request: reqOptions
+      });
+    }
+  } catch (e) {
+    onUpdateStatus(ObjectHelper.toErrorStatus(state().status, e));
+    onUpdateOptions({
+      _status: e.response?.status,
+      request: reqOptions
+    });
+  }
+  onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+};
+export const updateHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateData, _onUpdateItems, onUpdateOldData, id, data, opts) => {
+  onUpdateStatus(ObjectHelper.toLoadingStatus(state().status));
+  onUpdateOptions({});
+  const reqOptions = {
+    ...opts.getBaseRequestOptions?.() || {},
+    ...opts.update?.getRequestOptions?.(id, data, opts) ?? {}
+  };
+  reqOptions.params = ParamHelper.getParams(opts, reqOptions);
+  try {
+    let finalItem;
+    if (opts.isMock) {
+      const res = {
+        data: opts.mockItems?.[0]
+      };
+      onUpdateData(res.data);
+      finalItem = res.data;
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+    } else {
+      const { data: item, status } = await NewRequester.put(
+        opts.update?.getURL ? opts.update.getURL(id, data, opts) : `${opts.baseURL}/${id}`,
+        data,
+        reqOptions
+      );
+      onUpdateData(item);
+      finalItem = item;
+      onUpdateStatus(ObjectHelper.toSuccessStatus(state().status));
+      onUpdateOptions({
+        _timestamp: Date.now(),
+        _status: status,
+        request: reqOptions
+      });
+    }
+    if (state().oldData) {
+      onUpdateOldData(finalItem);
+    }
+    if (state().items) {
+      const index = _findIndex(state().items, (item) => item.id === id);
+      if (index !== -1) {
+        const itemsTemp = state().items;
+        if (itemsTemp?.[index]) {
+          itemsTemp[index] = finalItem;
+          state().items = itemsTemp;
+        }
+      }
+    }
+  } catch (e) {
+    onUpdateStatus(ObjectHelper.toErrorStatus(state().status, e));
+    onUpdateOptions({
+      _status: e.response?.status,
+      request: reqOptions
+    });
+  }
+  onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
+};