@finema/core 1.4.219 → 2.1.0

package/dist/runtime/composables/loaderPage.js

@@ -0,0 +1,243 @@
+import { reactive } from "vue";
+import { ObjectHelper } from "../utils/ObjectHelper.js";
+import {
+  apiAddHelper,
+  apiDeleteHelper,
+  apiFetchHelper,
+  apiFindHelper,
+  updateHelper
+} from "../helpers/apiPageHelper.js";
+import { useCoreConfig } from "./useConfig.js";
+export const initPageOptions = (options) => ({
+  currentPageCount: 0,
+  currentPage: 1,
+  totalPage: 0,
+  totalCount: 0,
+  limit: options.limit,
+  search: "",
+  primary: options.primary
+});
+export const usePageLoader = (loaderOptions) => {
+  const config = useCoreConfig();
+  const fetch = reactive({
+    status: ObjectHelper.createStatus(),
+    items: [],
+    options: initPageOptions({
+      limit: config.limit_per_page,
+      primary: config.default_primary_key
+    })
+  });
+  const find = reactive({
+    status: ObjectHelper.createStatus(),
+    item: null,
+    options: {}
+  });
+  const add = reactive({
+    status: ObjectHelper.createStatus(),
+    item: null,
+    options: {}
+  });
+  const update = reactive({
+    status: ObjectHelper.createStatus(),
+    item: null,
+    options: {}
+  });
+  const del = reactive({
+    // Using 'del' as a variable name since 'delete' is a reserved keyword
+    status: ObjectHelper.createStatus(),
+    item: null,
+    options: {}
+  });
+  const clearAll = () => {
+    find.status = ObjectHelper.createStatus();
+    del.status = ObjectHelper.createStatus();
+    add.status = ObjectHelper.createStatus();
+    update.status = ObjectHelper.createStatus();
+    fetch.status = ObjectHelper.createStatus();
+    find.item = null;
+    del.item = null;
+    update.item = null;
+    add.item = null;
+    fetch.items = [];
+    fetch.options = initPageOptions({
+      limit: config.limit_per_page,
+      primary: config.default_primary_key
+    });
+    find.options = {};
+    add.options = {};
+    update.options = {};
+    del.options = {};
+  };
+  const fetchSetLoading = () => {
+    fetch.items = [];
+    fetch.status = ObjectHelper.toLoadingStatus(fetch.status);
+  };
+  const findSetLoading = () => {
+    find.status = ObjectHelper.toLoadingStatus(find.status);
+  };
+  const fetchPage = async (page = 1, query = "", opts) => {
+    return await apiFetchHelper(
+      () => ({
+        status: fetch.status,
+        items: fetch.items,
+        options: fetch.options
+      }),
+      (data) => {
+        fetch.status = data;
+      },
+      (data) => {
+        fetch.options = data;
+      },
+      (data) => {
+        fetch.items = data;
+      },
+      page,
+      query,
+      {
+        ...loaderOptions,
+        ...opts
+      }
+    );
+  };
+  const findRun = async (id, opts) => {
+    return await apiFindHelper(
+      () => ({
+        status: find.status,
+        data: find.item,
+        options: find.options
+      }),
+      (data) => {
+        find.status = data;
+      },
+      (data) => {
+        find.options = data;
+      },
+      (data) => {
+        find.item = data;
+      },
+      id,
+      {
+        ...loaderOptions,
+        ...opts
+      }
+    );
+  };
+  const addRun = async (payload) => {
+    return await apiAddHelper(
+      () => ({
+        items: fetch.items,
+        status: add.status,
+        data: add.item,
+        options: add.options
+      }),
+      (data) => {
+        add.status = data;
+      },
+      (data) => {
+        add.options = data;
+      },
+      (data) => {
+        add.item = data;
+      },
+      (data) => {
+        fetch.items = data;
+      },
+      payload.data,
+      {
+        ...loaderOptions,
+        ...payload
+      }
+    );
+  };
+  const updateRun = async (id, payload) => {
+    return await updateHelper(
+      () => ({
+        items: fetch.items,
+        status: update.status,
+        data: update.item,
+        oldData: find.item,
+        options: update.options
+      }),
+      (data) => {
+        update.status = data;
+      },
+      (data) => {
+        update.options = data;
+      },
+      (data) => {
+        update.item = data;
+      },
+      (data) => {
+        fetch.items = data;
+      },
+      (data) => {
+        find.item = data;
+      },
+      id,
+      payload.data,
+      {
+        ...loaderOptions,
+        ...payload
+      }
+    );
+  };
+  const fetchSearch = async (query = "", opts) => {
+    return fetchPage(1, query, opts);
+  };
+  const fetchPageChange = async (page, opts) => {
+    const {
+      page: _page,
+      ...params
+    } = fetch.options?.request?.params || {};
+    return fetchPage(page, "", {
+      params,
+      ...opts
+    });
+  };
+  const deleteRun = async (id, opts) => {
+    return await apiDeleteHelper(
+      () => ({
+        status: del.status,
+        data: del.item,
+        items: fetch.items,
+        options: del.options
+      }),
+      (data) => {
+        del.status = data;
+      },
+      (data) => {
+        del.options = data;
+      },
+      (data) => {
+        del.item = data;
+      },
+      (data) => {
+        fetch.items = data;
+      },
+      id,
+      {
+        ...loaderOptions,
+        ...opts
+      }
+    );
+  };
+  return {
+    // State and methods
+    fetch,
+    find,
+    add,
+    update,
+    delete: del,
+    // Rename del to delete in the return object
+    fetchPage,
+    fetchSearch,
+    fetchPageChange,
+    fetchSetLoading,
+    findSetLoading,
+    findRun,
+    addRun,
+    updateRun,
+    deleteRun,
+    clearAll
+  };
+};

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

@@ -1,19 +1,14 @@
-import { type BreadcrumbLink } from '#ui/types';
+import type { BreadcrumbItem } from '@nuxt/ui';
 export interface IDefinePageItem {
     title?: string;
     sub_title?: string;
     isHideBreadcrumbs?: boolean;
-    breadcrumbs?: BreadcrumbLink[];
+    breadcrumbs?: BreadcrumbItem[];
 }
 export declare const useApp: import("pinia").StoreDefinition<"_app", {
     pageMeta: IDefinePageItem;
-    sidebar: BreadcrumbLink[];
+    sidebar: BreadcrumbItem[];
 }, {}, {
     definePage(payload: IDefinePageItem): void;
-    defineSidebar(items: BreadcrumbLink[]): void;
-    defineSEO(payload: {
-        title?: string;
-        description?: string;
-        image?: string;
-    }): void;
+    defineSidebar(items: BreadcrumbItem[]): void;
 }>;

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

@@ -1,4 +1,3 @@
-import { useCoreConfig, useSeoMeta } from "#imports";
 import { defineStore } from "pinia";
 export const useApp = defineStore("_app", {
   state: () => ({
@@ -14,17 +13,6 @@ export const useApp = defineStore("_app", {
     },
     defineSidebar(items) {
       this.sidebar = items;
-    },
-    defineSEO(payload) {
-      const coreConfig = useCoreConfig();
-      useSeoMeta({
-        title: payload.title,
-        titleTemplate: (title) => title ? `${title} | ${coreConfig.site_name}` : coreConfig.site_name,
-        ogTitle: payload.title,
-        description: payload.description,
-        ogDescription: payload.description,
-        ogImage: payload.image
-      });
     }
   }
 });

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

@@ -1,3 +1,3 @@
-import { type UIComponentList } from '../types/config';
-export declare const useCoreConfig: () => any;
-export declare const useUiConfig: <T>(config: object, name: UIComponentList) => any;
+import type { core as Core } from '../../core.config.js';
+export declare const useCoreConfig: () => typeof Core;
+export declare const useUiConfig: (config: object, name: string) => any;

package/dist/runtime/composables/useConfig.js

@@ -0,0 +1,12 @@
+import { tv } from "tailwind-variants";
+import _appConfig from "#build/app.config";
+export const useCoreConfig = () => {
+  return _appConfig.core;
+};
+export const useUiConfig = (config, name) => {
+  const appConfig = _appConfig;
+  return tv({
+    extend: tv(config),
+    ...appConfig.ui[name] || {}
+  });
+};

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

@@ -7,20 +7,14 @@ export declare const enum DialogType {
 export interface IDialogMetaItem {
     title: string;
     description?: string;
+    icon?: string;
     type?: DialogType;
     confirmText?: string;
     cancelText?: string;
     isShowCancelBtn?: boolean;
     isHideIcon?: boolean;
-    confirmButtonClassName?: string;
-    cancelButtonClassName?: string;
 }
 export interface IDialog {
-    isShow: boolean;
-    meta: IDialogMetaItem | undefined;
-    openDialog: (meta: IDialogMetaItem) => void;
-    closeDialogCancel: () => void;
-    closeDialogProceed: () => void;
     error: (payload: IDialogMetaItem) => Promise<boolean>;
     info: (payload: IDialogMetaItem) => Promise<boolean>;
     success: (payload: IDialogMetaItem) => Promise<boolean>;

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