@finema/core 1.4.220 → 2.1.0

package/dist/runtime/composables/useDialog.js

@@ -0,0 +1,53 @@
+import Dialog from "../components/Dialog/index.vue";
+import { useOverlay } from "#imports";
+export var DialogType = /* @__PURE__ */ ((DialogType2) => {
+  DialogType2["ERROR"] = "error";
+  DialogType2["INFO"] = "info";
+  DialogType2["SUCCESS"] = "success";
+  DialogType2["WARNING"] = "warning";
+  return DialogType2;
+})(DialogType || {});
+export const useDialog = () => {
+  const overlay = useOverlay();
+  const openDialog = async (payload) => {
+    const modal = overlay.create(Dialog, { props: payload });
+    const result = await modal.open();
+    const res = await result.result;
+    return new Promise((resolve, reject) => {
+      if (res) {
+        resolve(true);
+      }
+      reject(false);
+    });
+  };
+  const error = async (payload) => {
+    return openDialog({
+      ...payload,
+      type: "error" /* ERROR */
+    });
+  };
+  const success = async (payload) => {
+    return openDialog({
+      ...payload,
+      type: "success" /* SUCCESS */
+    });
+  };
+  const info = async (payload) => {
+    return openDialog({
+      ...payload,
+      type: "info" /* INFO */
+    });
+  };
+  const warning = async (payload) => {
+    return openDialog({
+      ...payload,
+      type: "warning" /* WARNING */
+    });
+  };
+  return {
+    error,
+    success,
+    info,
+    warning
+  };
+};

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

@@ -1,7 +1,7 @@
 import type { ComputedRef } from 'vue';
+import type { Store } from 'pinia';
 import type { IUsePageLoader } from '#core/helpers/apiPageHelper';
 import type { IFlexDeckOptions } from '#core/components/FlexDeck/types';
-import type { Store } from 'pinia';
 export interface IUseFlexDeck<T = object> {
     repo: IUsePageLoader<T> | Store<any, any>;
     options?: (() => Partial<IFlexDeckOptions<T>>) | Partial<IFlexDeckOptions<T>>;

package/dist/runtime/composables/{useFlexDeck.mjs → useFlexDeck.js}

@@ -1,12 +1,12 @@
-import { computed, useCoreConfig } from "#imports";
 import { get } from "@vueuse/core";
+import { computed, useCoreConfig } from "#imports";
 export const createFlexDeckOptions = (repo, options) => {
   const config = useCoreConfig();
   return {
-    rawData: get(repo.fetchItems),
-    pageOptions: get(repo.fetchOptions),
-    status: get(repo.fetchStatus),
-    primary: get(repo.fetchOptions).primary ?? config.default_primary_key,
+    rawData: get(repo.fetch.items),
+    pageOptions: get(repo.fetch.options),
+    status: get(repo.fetch.status),
+    primary: get(repo.fetch.options).primary || config.default_primary_key,
     isPreventRouteChange: false,
     ...options
   };

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

@@ -1,9 +1,12 @@
-import { type ComputedRef } from 'vue';
+import type { ComputedRef } from 'vue';
 import { type FieldContext, type FieldOptions } from 'vee-validate';
-import { type IFieldProps, type IFormField } from '../components/Form/types';
+import type { IFieldProps, IFormField } from '../components/Form/types.js';
 interface IFieldContext<TValue> extends FieldContext<TValue> {
     wrapperProps: ComputedRef<IFieldProps>;
 }
 export declare const useFieldHOC: <TValue = unknown>(newFormProps: IFieldProps, opts?: Partial<FieldOptions<TValue>>) => IFieldContext<TValue>;
 export declare const createFormFields: (fields: () => IFormField[]) => ComputedRef<IFormField[]>;
+export declare const moveToError: ({ errors }: {
+    errors: any;
+}) => void;
 export {};

package/dist/runtime/composables/useForm.js

@@ -0,0 +1,37 @@
+import { useField } from "vee-validate";
+import { toTypedSchema } from "@vee-validate/valibot";
+import { computed, toRef } from "#imports";
+export const useFieldHOC = (newFormProps, opts) => {
+  const field = useField(
+    toRef(newFormProps, "name"),
+    toTypedSchema(newFormProps.rules),
+    {
+      form: newFormProps.form,
+      ...opts
+    }
+  );
+  return {
+    ...field,
+    wrapperProps: computed(() => ({
+      ...newFormProps,
+      ui: newFormProps.containerUi || {},
+      placeholder: newFormProps.placeholder || newFormProps.label,
+      errorMessage: field.errorMessage.value
+    }))
+  };
+};
+export const createFormFields = (fields) => computed(fields);
+export const moveToError = ({ errors }) => {
+  const firstErrorFieldName = Object.keys(errors)[0];
+  const el = document.querySelector(`[name="${firstErrorFieldName}"]`);
+  if (el) {
+    el.focus({ preventScroll: true });
+    const elementRect = el.getBoundingClientRect();
+    const absoluteElementTop = elementRect.top + window.scrollY;
+    const paddingTop = 60;
+    window.scrollTo({
+      top: absoluteElementTop - paddingTop,
+      behavior: "smooth"
+    });
+  }
+};

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

@@ -1,24 +1,8 @@
-import type { NotificationAction, NotificationColor } from '#ui/types/notification';
-import type { Avatar } from '#ui/types/avatar';
-import type { Button } from '#ui/types/button';
-export interface INotification {
-    id: string;
-    title: string;
-    description?: string;
-    icon?: string;
-    avatar?: Avatar;
-    closeButton?: Button;
-    timeout: number;
-    actions?: NotificationAction[];
-    click?: (...args: any[]) => void;
-    callback?: (...args: any[]) => void;
-    color?: NotificationColor;
-    ui?: any;
-}
+import type { Toast } from '#ui/composables/useToast';
 export declare const useNotification: () => {
-    info: (notification: Partial<INotification>) => void;
-    success: (notification: Partial<INotification>) => void;
-    warning: (notification: Partial<INotification>) => void;
-    error: (notification: Partial<INotification>) => void;
-    remove: any;
+    info: (notification: Partial<Toast>) => void;
+    success: (notification: Partial<Toast>) => void;
+    warning: (notification: Partial<Toast>) => void;
+    error: (notification: Partial<Toast>) => void;
+    remove: (id: string | number) => void;
 };

package/dist/runtime/composables/{useNotification.mjs → useNotification.js}

@@ -1,48 +1,32 @@
 import { useToast } from "#imports";
-const safeList = [
-  "bg-success-200",
-  "bg-info-200",
-  "bg-danger-200",
-  "bg-warning-200",
-  "bg-primary-200"
-];
-const ui = (ui2 = {}, titleClass) => ({
-  background: "bg-{color}-200",
-  title: titleClass,
-  ...ui2
-});
 export const useNotification = () => {
   const toast = useToast();
   const info = (notification) => {
     toast.add({
       icon: "ph:info",
       color: "info",
-      ...notification,
-      ui: ui(notification.ui, "text-info")
+      ...notification
     });
   };
   const success = (notification) => {
     toast.add({
       icon: "ph:check-circle",
       color: "success",
-      ...notification,
-      ui: ui(notification.ui, "text-success")
+      ...notification
     });
   };
   const warning = (notification) => {
     toast.add({
       icon: "ph:warning",
       color: "warning",
-      ...notification,
-      ui: ui(notification.ui, "text-warning")
+      ...notification
     });
   };
   const error = (notification) => {
     toast.add({
       icon: "ph:x-circle",
-      color: "danger",
-      ...notification,
-      ui: ui(notification.ui, "text-danger")
+      color: "error",
+      ...notification
     });
   };
   return {

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

@@ -1,20 +1,21 @@
-import { type ComputedRef } from 'vue';
-import { type Store } from 'pinia';
+import type { ComputedRef } from 'vue';
+import type { Store } from 'pinia';
+import type { TableColumn, // Using local TableColumn
+ISimpleTableOptions, ITableOptions } from '../components/Table/types.js';
+import type { IUsePageLoader } from '../helpers/apiPageHelper.js';
 import { type IStatus } from '#imports';
-import { type IColumn, type ISimpleTableOptions, type ITableOptions } from '../components/Table/types';
-import { type IUsePageLoader } from '../helpers/apiPageHelper';
-export interface IUseTable<T = object> {
+export interface IUseTable<T extends Record<string, any> = object> {
     repo: IUsePageLoader<T> | Store<any, any>;
-    columns: () => IColumn[];
+    columns: () => TableColumn<T>[];
     options?: (() => Partial<ITableOptions<T>>) | Partial<ITableOptions<T>>;
     transformItems?: (items: T[]) => T[];
 }
-export interface IUseTableSimple<T = object> {
+export interface IUseTableSimple<T extends Record<string, any> = object> {
     items: () => T[];
     status?: () => IStatus;
-    columns: () => IColumn[];
+    columns: () => TableColumn<T>[];
     options?: (() => Partial<ISimpleTableOptions<T>>) | Partial<ISimpleTableOptions<T>>;
 }
-export declare const useTable: <T = object>(options: IUseTable<T>) => ComputedRef<ITableOptions<T>>;
-export declare const useTableSimple: <T = object>(options: IUseTableSimple<T>) => ComputedRef<ISimpleTableOptions<T>>;
-export declare const createTableOptions: <T = object>(repo: IUsePageLoader<T>, columns: IColumn[], options: Partial<ITableOptions<T>>, transformItems?: (items: T[]) => T[]) => ITableOptions<T>;
+export declare const useTable: <T extends Record<string, any>>(options: IUseTable<T>) => ComputedRef<ITableOptions<T>>;
+export declare const useTableSimple: <T extends Record<string, any>>(options: IUseTableSimple<T>) => ComputedRef<ISimpleTableOptions<T>>;
+export declare const createTableOptions: <T extends Record<string, any>>(repo: IUsePageLoader<T>, columns: TableColumn<T>[], options: Partial<ITableOptions<T>>, transformItems?: (items: T[]) => T[]) => ITableOptions<T>;

package/dist/runtime/composables/{useTable.mjs → useTable.js}

@@ -1,6 +1,5 @@
 import { get } from "@vueuse/core";
 import { computed, ObjectHelper } from "#imports";
-import { useCoreConfig } from "./useConfig.mjs";
 export const useTable = (options) => computed(() => {
   return createTableOptions(
     options.repo,
@@ -10,24 +9,20 @@ export const useTable = (options) => computed(() => {
   );
 });
 export const useTableSimple = (options) => computed(() => {
-  const config = useCoreConfig();
   return {
     items: options.items(),
     columns: options.columns(),
     rawData: options.items(),
     status: options.status ? options.status() : ObjectHelper.createStatus(),
-    primary: config.default_primary_key,
     ...typeof options.options === "function" ? options.options() : options.options ?? {}
   };
 });
 export const createTableOptions = (repo, columns, options, transformItems) => {
-  const config = useCoreConfig();
   return {
-    rawData: transformItems ? transformItems(get(repo.fetchItems)) : get(repo.fetchItems),
-    pageOptions: get(repo.fetchOptions),
+    rawData: transformItems ? transformItems(get(repo.fetch.items)) : get(repo.fetch.items),
+    pageOptions: get(repo.fetch.options),
     columns,
-    status: get(repo.fetchStatus),
-    primary: get(repo.fetchOptions).primary ?? config.default_primary_key,
+    status: get(repo.fetch.status),
     isPreventRouteChange: false,
     ...options
   };

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

@@ -1,8 +1,8 @@
-import { type AxiosRequestConfig } from 'axios';
+import type { AxiosRequestConfig } from 'axios';
 export interface IUploadRequest {
     requestOptions: Omit<AxiosRequestConfig, 'baseURL'> & {
         baseURL: string;
     };
     pathURL?: string;
 }
-export declare const useUploadLoader: (request: IUploadRequest) => import("../helpers/apiObjectHelper").IUseObjectLoader<any, any, Record<string, any>>;
+export declare const useUploadLoader: (request: IUploadRequest) => import("../helpers/apiObjectHelper.js").IUseObjectLoader<any, any, Record<string, any>>;

package/dist/runtime/composables/{useUpload.mjs → useUpload.js}

@@ -1,4 +1,4 @@
-import { useObjectLoader } from "./loaderObject.mjs";
+import { useObjectLoader } from "./loaderObject.js";
 export const useUploadLoader = (request) => {
   return useObjectLoader({
     method: "post",

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

@@ -0,0 +1,29 @@
+import type { AxiosRequestConfig } from 'axios';
+import type { IAPIOptions, IStatus } from '../types/lib.js';
+export interface IBaseLoaderOptions {
+    isMock?: boolean;
+    params?: Record<string, any>;
+    expire?: number;
+    [key: string]: any;
+}
+export interface IRequestContext {
+    url: string;
+    method: string;
+    data?: any;
+    options: AxiosRequestConfig;
+}
+export declare const checkExpiration: (timestamp: number | undefined, expire?: number) => boolean;
+export declare const bindParamsToUrl: (urlTemplate: string, urlParams?: Record<string, any>) => string;
+export declare const prepareRequestOptions: (baseOptions?: AxiosRequestConfig, requestOptions?: AxiosRequestConfig, params?: Record<string, any>) => AxiosRequestConfig;
+export declare const handleApiRequest: <T>(requestContext: IRequestContext, mockData: T | T[] | null, callbacks: {
+    onSuccess: (data: T, status?: number) => void;
+    onError: (error: any) => void;
+    onComplete?: () => void;
+}) => Promise<void>;
+export declare const updateLoaderState: {
+    setLoading: (status: IStatus) => IStatus;
+    setSuccess: (status: IStatus) => IStatus;
+    setError: (status: IStatus, error: any) => IStatus;
+    setComplete: (status: IStatus) => IStatus;
+    setOptions: (options: IAPIOptions, updates: Partial<IAPIOptions>) => IAPIOptions;
+};

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));
+      }
+    }
+  );
+};