@finema/core 1.4.219 → 2.1.0

package/dist/runtime/helpers/apiBaseHelper.js

@@ -0,0 +1,63 @@
+import { ObjectHelper } from "../utils/ObjectHelper.js";
+import { ParamHelper } from "../utils/ParamHelper.js";
+import { NewRequester } from "../lib/Requester.js";
+export const checkExpiration = (timestamp, expire) => {
+  if (!expire || !timestamp) return false;
+  return timestamp + expire > Date.now();
+};
+export const bindParamsToUrl = (urlTemplate, urlParams = {}) => {
+  let resultUrl = urlTemplate;
+  Object.entries(urlParams).forEach(([key, value]) => {
+    resultUrl = resultUrl.replace(`:${key}`, String(value));
+  });
+  return resultUrl;
+};
+export const prepareRequestOptions = (baseOptions, requestOptions, params) => {
+  const options = {
+    ...baseOptions || {},
+    ...requestOptions || {}
+  };
+  options.params = ParamHelper.getParams({ params }, options);
+  return options;
+};
+export const handleApiRequest = async (requestContext, mockData, callbacks) => {
+  const {
+    url,
+    method,
+    data,
+    options
+  } = requestContext;
+  try {
+    if (mockData) {
+      await new Promise((resolve) => setTimeout(resolve, 300));
+      callbacks.onSuccess(mockData);
+    } else {
+      const response = await NewRequester.create(method, url, data, options);
+      callbacks.onSuccess(response.data, response.status);
+    }
+  } catch (error) {
+    callbacks.onError(error);
+  } finally {
+    callbacks.onComplete?.();
+  }
+};
+export const updateLoaderState = {
+  setLoading: (status) => ObjectHelper.toLoadingStatus(
+    status
+  ),
+  setSuccess: (status) => ObjectHelper.toSuccessStatus(
+    status
+  ),
+  setError: (status, error) => ObjectHelper.toErrorStatus(
+    status,
+    error
+  ),
+  setComplete: (status) => ObjectHelper.toCompleteStatus(
+    status
+  ),
+  setOptions: (options, updates) => ({
+    ...options,
+    ...updates,
+    _timestamp: Date.now()
+  })
+};

package/dist/runtime/helpers/apiListHelper.d.ts

@@ -1,13 +1,11 @@
-import { type IAPIListState, type IAPIOptions, type IStatus } from '#core/types/lib';
 import type { AxiosRequestConfig } from 'axios';
-export interface IListRunLoaderOptions<T, D = Record<string, any>> {
+import type { IAPIListState, IAPIOptions, IStatus } from '../types/lib.js';
+import { type IBaseLoaderOptions } from './apiBaseHelper.js';
+export interface IListRunLoaderOptions<T = any, D = Record<string, any>> extends IBaseLoaderOptions {
     mockItems?: T[];
-    isMock?: boolean;
-    params?: Record<string, any>;
-    expire?: number;
     data?: D;
 }
-export interface IListLoaderOptions<T, O> {
+export interface IListLoaderOptions<T = any, O = any> {
     url: string;
     primary?: string;
     mockItems?: T[];

package/dist/runtime/helpers/apiListHelper.js

@@ -0,0 +1,50 @@
+import { bindParamsToUrl } from "./apiBaseHelper.js";
+import {
+  checkExpiration,
+  prepareRequestOptions,
+  handleApiRequest,
+  updateLoaderState
+} from "./apiBaseHelper.js";
+export const apiListHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateItems, opts) => {
+  if (checkExpiration(state().options._timestamp, opts.expire)) {
+    onUpdateStatus(updateLoaderState.setComplete(state().status));
+    return;
+  }
+  onUpdateStatus(updateLoaderState.setLoading(state().status));
+  onUpdateOptions({});
+  const requestOptions = prepareRequestOptions(
+    {},
+    opts.getRequestOptions?.(opts),
+    opts.params
+  );
+  const url = bindParamsToUrl(opts.getURL ? opts.getURL(opts) : opts.url, opts.urlBind || {});
+  await handleApiRequest(
+    {
+      url,
+      method: "GET",
+      options: requestOptions
+    },
+    opts.isMock ? opts.mockItems || [] : null,
+    {
+      onSuccess: (items, status) => {
+        onUpdateItems(items);
+        onUpdateStatus(updateLoaderState.setSuccess(state().status));
+        onUpdateOptions({
+          _timestamp: Date.now(),
+          _status: status,
+          request: requestOptions
+        });
+      },
+      onError: (error) => {
+        onUpdateStatus(updateLoaderState.setError(state().status, error));
+        onUpdateOptions({
+          _status: error.response?.status,
+          request: requestOptions
+        });
+      },
+      onComplete: () => {
+        onUpdateStatus(updateLoaderState.setComplete(state().status));
+      }
+    }
+  );
+};

package/dist/runtime/helpers/apiObjectHelper.d.ts

@@ -1,38 +1,37 @@
-import { type IAPIObjectState, type IAPIOptions, type IStatus } from '#core/types/lib';
 import type { AxiosRequestConfig, Method } from 'axios';
-import type { Ref, UnwrapRef } from 'vue';
-import { type IListRunLoaderOptions } from '#core/helpers/apiListHelper';
-export interface IObjectRunLoaderOptions<T, D = Record<string, any>> {
+import type { ComputedRef } from 'vue';
+import type { IAPIObjectState, IAPIOptions, IStatus } from '../types/lib.js';
+import { type IBaseLoaderOptions } from './apiBaseHelper.js';
+import type { IListRunLoaderOptions } from './apiListHelper.js';
+export interface IObjectRunLoaderOptions<T = any, B = any> extends IBaseLoaderOptions {
     mockItem?: T;
-    isMock?: boolean;
-    params?: Record<string, any>;
-    expire?: number;
-    data?: D;
+    data?: B;
+    urlBind?: Record<string, any>;
 }
-export interface IObjectLoaderOptions<T, B, O> {
+export interface IObjectLoaderOptions<T = any, B = any, _O = any> {
     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;
+    getURL?: (data: B | undefined, opts: IObjectRunLoaderOptions<T, B>) => string;
+    getRequestOptions?: (data: B | undefined, opts: IObjectRunLoaderOptions<T, B>) => AxiosRequestConfig;
 }
-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>;
+export interface IUseObjectLoader<T, B, _O> {
+    status: ComputedRef<IStatus>;
+    data: ComputedRef<T | null>;
+    options: ComputedRef<IAPIOptions>;
+    run: (payload?: IObjectRunLoaderOptions<T, B>) => 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>>;
+    status: ComputedRef<IStatus>;
+    items: ComputedRef<T[]>;
+    options: ComputedRef<Record<string, any>>;
     run: (opts?: IListRunLoaderOptions<T, O>) => void;
     setItems: (items: T[]) => void;
     clear: () => void;
     setLoading: () => void;
 }
-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>;
+export declare const apiObjectHelper: <T, B, _O>(state: () => IAPIObjectState<T>, onUpdateStatus: (status: IStatus) => void, onUpdateOptions: (options: IAPIOptions) => void, onUpdateData: (data?: T) => void, payload: B | undefined, opts: IObjectLoaderOptions<T, B, _O> & IObjectRunLoaderOptions<T, B>) => Promise<void>;

package/dist/runtime/helpers/apiObjectHelper.js

@@ -0,0 +1,51 @@
+import { bindParamsToUrl } from "./apiBaseHelper.js";
+import {
+  checkExpiration,
+  handleApiRequest,
+  prepareRequestOptions,
+  updateLoaderState
+} from "./apiBaseHelper.js";
+export const apiObjectHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateData, payload, opts) => {
+  if (checkExpiration(state().options._timestamp, opts.expire)) {
+    onUpdateStatus(updateLoaderState.setComplete(state().status));
+    return;
+  }
+  onUpdateStatus(updateLoaderState.setLoading(state().status));
+  onUpdateOptions({});
+  const requestOptions = prepareRequestOptions(
+    {},
+    opts.getRequestOptions?.(payload, opts),
+    opts.params
+  );
+  const url = bindParamsToUrl(opts.getURL ? opts.getURL(payload, opts) : opts.url, opts.urlBind || {});
+  await handleApiRequest(
+    {
+      url,
+      method: opts.method,
+      data: payload,
+      options: requestOptions
+    },
+    opts.isMock ? opts.mockItem || null : null,
+    {
+      onSuccess: (item, status) => {
+        onUpdateData(item);
+        onUpdateStatus(updateLoaderState.setSuccess(state().status));
+        onUpdateOptions({
+          request: requestOptions,
+          _timestamp: Date.now(),
+          _status: status
+        });
+      },
+      onError: (error) => {
+        onUpdateStatus(updateLoaderState.setError(state().status, error));
+        onUpdateOptions({
+          request: requestOptions,
+          _status: error.response?.status
+        });
+      },
+      onComplete: () => {
+        onUpdateStatus(updateLoaderState.setComplete(state().status));
+      }
+    }
+  );
+};

package/dist/runtime/helpers/apiPageHelper.d.ts

@@ -1,31 +1,19 @@
-import { type IAPIAddState, type IAPIDeleteState, type IAPIFetchState, type IAPIFindState, type IAPIOptions, type IAPIUpdateState, type IPageOptions, type IStatus } from '../types/lib';
 import type { AxiosRequestConfig } from 'axios';
-import type { Ref, UnwrapRef } from 'vue';
-export interface IPageFetchLoaderOptions<D = Record<string, any>> {
-    isMock?: boolean;
-    params?: Record<string, any>;
-    expire?: number;
+import type { IAPIAddState, IAPIDeleteState, IAPIFetchState, IAPIFindState, IAPIOptions, IAPIUpdateState, IPageOptions, IStatus } from '../types/lib.js';
+import { type IBaseLoaderOptions } from './apiBaseHelper.js';
+export interface IPageFetchLoaderOptions<D = Record<string, any>> extends IBaseLoaderOptions {
     data?: D;
 }
-export interface IPageFindLoaderOptions<D = Record<string, any>> {
-    isMock?: boolean;
-    params?: Record<string, any>;
-    expire?: number;
+export interface IPageFindLoaderOptions<D = Record<string, any>> extends IBaseLoaderOptions {
     data?: D;
 }
-export interface IPageUpdateLoaderOptions<D = Record<string, any>> {
-    isMock?: boolean;
-    params?: Record<string, any>;
+export interface IPageUpdateLoaderOptions<D = Record<string, any>> extends IBaseLoaderOptions {
     data?: D;
 }
-export interface IPageDeleteLoaderOptions<D = Record<string, any>> {
-    isMock?: boolean;
-    params?: Record<string, any>;
+export interface IPageDeleteLoaderOptions<D = Record<string, any>> extends IBaseLoaderOptions {
     data?: D;
 }
-export interface IPageAddLoaderOptions<D = Record<string, any>> {
-    isMock?: boolean;
-    params?: Record<string, any>;
+export interface IPageAddLoaderOptions<D = Record<string, any>> extends IBaseLoaderOptions {
     data?: D;
 }
 export interface IPageLoaderOptions<T> {
@@ -56,33 +44,45 @@ export interface IPageLoaderOptions<T> {
     };
 }
 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>>;
+    fetch: {
+        status: IStatus;
+        items: T[];
+        options: IPageOptions;
+    };
+    find: {
+        status: IStatus;
+        item: T | null;
+        options: IAPIOptions;
+        value: (id: string, opts?: any) => Promise<void>;
+    };
+    add: {
+        status: IStatus;
+        item: T | null;
+        options: IAPIOptions;
+    };
+    update: {
+        status: IStatus;
+        item: T | null;
+        options: IAPIOptions;
+    };
+    delete: {
+        status: IStatus;
+        item: T | null;
+        options: IAPIOptions;
+    };
+    fetchPage: (page?: number, query?: string, opts?: IPageFetchLoaderOptions) => Promise<void>;
+    fetchPageChange: (page: number, opts?: IPageFetchLoaderOptions) => Promise<void>;
+    fetchSearch: (query: string, opts?: IPageFetchLoaderOptions) => Promise<void>;
+    fetchSetLoading: () => void;
+    findSetLoading: () => void;
+    findRun: (id: string, opts?: any) => Promise<void>;
+    addRun: (data: any, opts?: IPageAddLoaderOptions) => Promise<void>;
+    updateRun: (id: string, data: any, opts?: any) => Promise<void>;
+    deleteRun: (id: string, opts?: IPageDeleteLoaderOptions) => Promise<void>;
+    clearAll: () => void;
 }
 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) => 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>;
+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/runtime/helpers/apiPageHelper.js

@@ -0,0 +1,287 @@
+import { useCoreConfig } from "../composables/useConfig.js";
+import { bindParamsToUrl } from "./apiBaseHelper.js";
+import {
+  checkExpiration,
+  handleApiRequest,
+  prepareRequestOptions,
+  updateLoaderState
+} from "./apiBaseHelper.js";
+import { _findIndex, _get, _shuffle } from "#imports";
+export const apiAddHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateData, onUpdateItems, data, opts) => {
+  onUpdateStatus(updateLoaderState.setLoading(state().status));
+  onUpdateOptions({});
+  const requestOptions = prepareRequestOptions(
+    opts.getBaseRequestOptions?.() || {},
+    opts.add?.getRequestOptions?.(data, opts),
+    opts.params
+  );
+  const url = bindParamsToUrl(opts.add?.getURL ? opts.add.getURL(data, opts) : opts.baseURL, opts.pathBind);
+  await handleApiRequest(
+    {
+      url,
+      method: "POST",
+      data,
+      options: requestOptions
+    },
+    opts.isMock ? opts.mockItems?.[0] || null : null,
+    {
+      onSuccess: (item, status) => {
+        onUpdateData(item);
+        if (state().items) {
+          onUpdateItems([item, ...state().items]);
+        }
+        onUpdateStatus(updateLoaderState.setSuccess(state().status));
+        onUpdateOptions({
+          _timestamp: Date.now(),
+          _status: status,
+          request: requestOptions
+        });
+      },
+      onError: (error) => {
+        onUpdateStatus(updateLoaderState.setError(state().status, error));
+        onUpdateOptions({
+          _status: error.response?.status,
+          request: requestOptions
+        });
+      },
+      onComplete: () => {
+        onUpdateStatus(updateLoaderState.setComplete(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(updateLoaderState.setLoading(state().status));
+  onUpdateOptions({});
+  const requestOptions = prepareRequestOptions(
+    opts.getBaseRequestOptions?.() || {},
+    opts.delete?.getRequestOptions?.(id, opts),
+    opts.params
+  );
+  const url = bindParamsToUrl(opts.delete?.getURL ? opts.delete.getURL(id, opts) : `${opts.baseURL}/${id}`, opts.pathBind);
+  await handleApiRequest(
+    {
+      url,
+      method: "DELETE",
+      options: requestOptions
+    },
+    opts.isMock ? null : null,
+    // No mock data needed for delete
+    {
+      onSuccess: (_, status) => {
+        if (state().items) {
+          onUpdateItems(
+            state().items.filter((item) => getPrimaryKey(item) !== id)
+          );
+        }
+        onUpdateStatus(updateLoaderState.setSuccess(state().status));
+        onUpdateOptions({
+          _timestamp: Date.now(),
+          _status: status,
+          request: requestOptions
+        });
+      },
+      onError: (error) => {
+        onUpdateStatus(updateLoaderState.setError(state().status, error));
+        onUpdateOptions({
+          _status: error.response?.status,
+          request: requestOptions
+        });
+      },
+      onComplete: () => {
+        onUpdateStatus(updateLoaderState.setComplete(state().status));
+      }
+    }
+  );
+};
+export const apiFetchHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateItems, page, query, opts) => {
+  const config = useCoreConfig();
+  if (checkExpiration(state().options._timestamp, opts.expire)) {
+    onUpdateStatus(updateLoaderState.setComplete(state().status));
+    return;
+  }
+  onUpdateStatus(updateLoaderState.setLoading(state().status));
+  onUpdateOptions({
+    ...state().options,
+    ...opts,
+    currentPage: page,
+    search: query,
+    primary: opts.primary ?? "id",
+    _status: void 0
+  });
+  const getOptions = (data) => {
+    const {
+      total,
+      limit: limit2,
+      ...more
+    } = data;
+    return {
+      ...state().options,
+      ...more,
+      currentPageCount: state().items?.length || 0,
+      currentPage: page,
+      totalCount: total,
+      limit: limit2,
+      search: query,
+      totalPage: Math.ceil(total / data.limit)
+    };
+  };
+  const baseRequestOptions = {
+    ...opts.getBaseRequestOptions?.() || {},
+    ...opts.fetch?.getRequestOptions?.(page, query, opts) || {}
+  };
+  const limit = baseRequestOptions.params?.limit || config.limit_per_page;
+  const requestOptions = prepareRequestOptions(
+    baseRequestOptions,
+    {
+      params: {
+        limit,
+        q: (query || "").trim(),
+        page
+      }
+    },
+    opts.params
+  );
+  const url = bindParamsToUrl(opts.fetch?.getURL ? opts.fetch.getURL(page, query, opts) : opts.baseURL, opts.pathBind);
+  await handleApiRequest(
+    {
+      url,
+      method: "GET",
+      options: requestOptions
+    },
+    opts.isMock ? {
+      items: _shuffle(opts.mockItems || []),
+      totalCount: (opts.mockItems || []).length,
+      limit
+    } : null,
+    {
+      onSuccess: (response, status) => {
+        const {
+          items,
+          ...moreOptions
+        } = response;
+        onUpdateItems(items);
+        onUpdateOptions({
+          ...getOptions(moreOptions),
+          _timestamp: Date.now(),
+          _status: status,
+          request: requestOptions
+        });
+        onUpdateStatus(updateLoaderState.setSuccess(state().status));
+      },
+      onError: (error) => {
+        onUpdateStatus(updateLoaderState.setError(state().status, error));
+        onUpdateOptions({
+          ...state().options,
+          _status: error.response?.status,
+          request: requestOptions
+        });
+      },
+      onComplete: () => {
+        onUpdateStatus(updateLoaderState.setComplete(state().status));
+      }
+    }
+  );
+};
+export const apiFindHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateData, id, opts) => {
+  if (checkExpiration(state().options._timestamp, opts.expire)) {
+    onUpdateStatus(updateLoaderState.setComplete(state().status));
+    return;
+  }
+  onUpdateStatus(updateLoaderState.setLoading(state().status));
+  onUpdateOptions({});
+  const requestOptions = prepareRequestOptions(
+    opts.getBaseRequestOptions?.() || {},
+    opts.find?.getRequestOptions?.(id, opts),
+    opts.params
+  );
+  const url = bindParamsToUrl(opts.find?.getURL ? opts.find.getURL(id, opts) : `${opts.baseURL}/${id}`, opts.pathBind);
+  await handleApiRequest(
+    {
+      url,
+      method: "GET",
+      options: requestOptions
+    },
+    opts.isMock ? opts.mockItems?.[0] || null : null,
+    {
+      onSuccess: (item, status) => {
+        onUpdateData(item);
+        onUpdateStatus(updateLoaderState.setSuccess(state().status));
+        onUpdateOptions({
+          _timestamp: Date.now(),
+          _status: status,
+          request: requestOptions
+        });
+      },
+      onError: (error) => {
+        onUpdateStatus(updateLoaderState.setError(state().status, error));
+        onUpdateOptions({
+          _status: error.response?.status,
+          request: requestOptions
+        });
+      },
+      onComplete: () => {
+        onUpdateStatus(updateLoaderState.setComplete(state().status));
+      }
+    }
+  );
+};
+export const updateHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateData, onUpdateItems, onUpdateOldData, id, data, opts) => {
+  if (checkExpiration(state().options._timestamp, opts.expire)) {
+    onUpdateStatus(updateLoaderState.setComplete(state().status));
+    return;
+  }
+  onUpdateStatus(updateLoaderState.setLoading(state().status));
+  onUpdateOptions({});
+  const requestOptions = prepareRequestOptions(
+    opts.getBaseRequestOptions?.() || {},
+    opts.update?.getRequestOptions?.(id, data, opts),
+    opts.params
+  );
+  const url = bindParamsToUrl(opts.update?.getURL ? opts.update.getURL(id, data, opts) : `${opts.baseURL}/${id}`, opts.pathBind);
+  await handleApiRequest(
+    {
+      url,
+      method: "PUT",
+      data,
+      options: requestOptions
+    },
+    opts.isMock ? opts.mockItems?.[0] || null : null,
+    {
+      onSuccess: (item, status) => {
+        onUpdateData(item);
+        const finalItem = item;
+        if (state().oldData) {
+          onUpdateOldData(finalItem);
+        }
+        const currentItems = state().items;
+        if (currentItems) {
+          const index = _findIndex(currentItems, (existingItem) => existingItem.id === id);
+          if (index !== -1) {
+            const itemsTemp = [...currentItems];
+            itemsTemp[index] = finalItem;
+            onUpdateItems(itemsTemp);
+          }
+        }
+        onUpdateStatus(updateLoaderState.setSuccess(state().status));
+        onUpdateOptions({
+          _timestamp: Date.now(),
+          _status: status,
+          request: requestOptions
+        });
+      },
+      onError: (error) => {
+        onUpdateStatus(updateLoaderState.setError(state().status, error));
+        onUpdateOptions({
+          _status: error.response?.status,
+          request: requestOptions
+        });
+      },
+      onComplete: () => {
+        onUpdateStatus(updateLoaderState.setComplete(state().status));
+      }
+    }
+  );
+};

package/dist/runtime/helpers/componentHelper.d.ts

@@ -4,27 +4,26 @@ export declare const checkFileType: (file: File, acceptFileType: string | string
 export declare const generateURL: (file: File) => string;
 export declare const isImage: (file: File) => boolean;
 export declare const isImageFromPath: (path?: string) => boolean;
-export declare const isVideoFromPath: (path?: string) => boolean;
 export declare const isPDFFromPath: (path?: string) => boolean;
 export declare const useFileAllocate: (selectedFile: Ref<File | undefined | null>, props: {
     accept?: string | string[];
     maxSize?: number;
 }) => {
-    selectedFileSizeKb: any;
-    selectedFileSizeMb: any;
-    isSelectedFileUseMb: any;
-    acceptFileSizeKb: any;
-    acceptFileSizeMb: any;
-    isAcceptFileUseMb: any;
-    acceptFile: any;
+    selectedFileSizeKb: import("vue").ComputedRef<string>;
+    selectedFileSizeMb: import("vue").ComputedRef<string>;
+    isSelectedFileUseMb: import("vue").ComputedRef<boolean>;
+    acceptFileSizeKb: import("vue").ComputedRef<number>;
+    acceptFileSizeMb: import("vue").ComputedRef<string>;
+    isAcceptFileUseMb: import("vue").ComputedRef<boolean | 0>;
+    acceptFile: import("vue").ComputedRef<string | undefined>;
 };
 export declare const useFileSize: (size?: number) => {
-    isSelectedFileUseMb: any;
-    selectedFileSizeKb: any;
-    selectedFileSizeMb: any;
+    isSelectedFileUseMb: import("vue").ComputedRef<boolean>;
+    selectedFileSizeKb: import("vue").ComputedRef<string>;
+    selectedFileSizeMb: import("vue").ComputedRef<string>;
 };
 export declare const useFileProgress: () => {
-    percent: any;
+    percent: Ref<number, number>;
     onUploadProgress: (progressEvent: ProgressEvent) => void;
     onDownloadProgress: (progressEvent: ProgressEvent) => void;
 };