@finema/core 1.4.220 → 2.1.1

package/dist/runtime/components/Table/types.d.ts

@@ -1,40 +1,36 @@
-import { type IPageOptions, type IStatus } from '#core/types/lib';
+import type { Component } from 'vue';
+import type { TableColumn as NuxtUiTableColumn } from '@nuxt/ui';
+import type { IPageOptions, IStatus } from '#core/types/lib';
 export declare const enum COLUMN_TYPES {
     COMPONENT = "COMPONENT",
     DATE = "DATE",
     DATE_TIME = "DATE_TIME",
     NUMBER = "NUMBER",
-    IMAGE = "IMAGE"
+    IMAGE = "IMAGE",
+    TEXT = "TEXT"
 }
-export interface IColumn<P extends Record<string, any> = Record<string, any>, O extends Record<string, any> = Record<string, any>> {
-    [key: string]: any;
-    key: string;
-    sortable?: boolean;
-    direction?: 'asc' | 'desc';
-    class?: string;
-    component?: any;
+export type TableColumn<T extends Record<string, any> = Record<string, any>> = NuxtUiTableColumn<T> & {
     type?: COLUMN_TYPES;
-    transform?: (value: any, item: any, column: IColumn) => any;
-    props?: P;
-    on?: O;
-}
-export interface IBaseTableOptions<T = object> {
+    component?: Component;
+    accessorKey: string;
+};
+export interface IBaseTableOptions<T extends Record<string, any> = Record<string, any>> {
     rawData: T[];
-    primary: string;
     status: IStatus;
-    columns: IColumn[];
+    columns: TableColumn<T>[];
     isHideBottomPagination?: boolean;
     isHideCaption?: boolean;
     isHideTopPagination?: boolean;
     isSimplePagination?: boolean;
 }
-export interface ITableOptions<T = object> extends IBaseTableOptions<T> {
+export interface ITableOptions<T extends Record<string, any> = Record<string, any>> extends IBaseTableOptions<T> {
     pageOptions: IPageOptions;
     isHideToolbar?: boolean;
     isEnabledSearch?: boolean;
     searchPlaceholder?: string;
     isPreventRouteChange: boolean;
 }
-export interface ISimpleTableOptions<T = object> extends IBaseTableOptions<T> {
+export interface ISimpleTableOptions<T extends Record<string, any> = Record<string, any>> extends IBaseTableOptions<T> {
     limit?: number;
+    primary?: number;
 }

package/dist/runtime/components/Table/{types.mjs → types.js}

@@ -4,5 +4,6 @@ export var COLUMN_TYPES = /* @__PURE__ */ ((COLUMN_TYPES2) => {
   COLUMN_TYPES2["DATE_TIME"] = "DATE_TIME";
   COLUMN_TYPES2["NUMBER"] = "NUMBER";
   COLUMN_TYPES2["IMAGE"] = "IMAGE";
+  COLUMN_TYPES2["TEXT"] = "TEXT";
   return COLUMN_TYPES2;
 })(COLUMN_TYPES || {});

package/dist/runtime/components/TeleportSafe.vue

@@ -1,40 +1,42 @@
-<template>
-  <Teleport v-if="isShow" :to="target" :disabled="!target || disabled">
-    <slot />
-  </Teleport>
-</template>
-
-<script setup lang="ts">
-import { onBeforeUnmount, onMounted, ref } from 'vue'
-
-const props = defineProps<{ to: string; disabled?: boolean }>()
-
-const target = ref<Element | null>(null)
-const isShow = ref(false)
-
-onBeforeUnmount(() => {
-  isShow.value = false
-})
-
-onMounted(() => {
-  isShow.value = true
-
-  const observer = new MutationObserver((mutationList, observer) => {
-    for (const mutation of mutationList) {
-      if (mutation.type !== 'childList') continue
-      const el = document.querySelector(props.to)
-      if (!el) continue
-      target.value = el
-      observer.disconnect()
-
-      break
-    }
-  })
-
-  observer.observe(document, { childList: true, subtree: true })
-
-  return () => {
-    observer.disconnect()
-  }
-})
-</script>
+<template>
+  <Teleport
+    v-if="isShow"
+    :to="target"
+    :disabled="!target || disabled"
+  >
+    <slot />
+  </Teleport>
+</template>
+
+<script setup>
+import { onBeforeUnmount, onMounted, ref } from "vue";
+const props = defineProps({
+  to: { type: String, required: true },
+  disabled: { type: Boolean, required: false }
+});
+const target = ref(null);
+const isShow = ref(false);
+onBeforeUnmount(() => {
+  isShow.value = false;
+});
+onMounted(() => {
+  isShow.value = true;
+  const observer = new MutationObserver((mutationList, observer2) => {
+    for (const mutation of mutationList) {
+      if (mutation.type !== "childList") continue;
+      const el = document.querySelector(props.to);
+      if (!el) continue;
+      target.value = el;
+      observer2.disconnect();
+      break;
+    }
+  });
+  observer.observe(document, {
+    childList: true,
+    subtree: true
+  });
+  return () => {
+    observer.disconnect();
+  };
+});
+</script>

package/dist/runtime/components/TeleportSafe.vue.d.ts

@@ -0,0 +1,16 @@
+type __VLS_Props = {
+    to: string;
+    disabled?: boolean;
+};
+declare var __VLS_5: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_5) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

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

@@ -1,3 +1,3 @@
-import { type IListLoaderOptions } from '../helpers/apiListHelper';
-import { type IUseListLoader } from '../helpers/apiObjectHelper';
+import { type IListLoaderOptions } from '../helpers/apiListHelper.js';
+import type { IUseListLoader } from '../helpers/apiObjectHelper.js';
 export declare const useListLoader: <T = any, O = Record<string, any>>(loaderOptions: IListLoaderOptions<T, O>) => IUseListLoader<T, O>;

package/dist/runtime/composables/loaderList.js

@@ -0,0 +1,51 @@
+import { reactive, computed } from "vue";
+import { ObjectHelper } from "../utils/ObjectHelper.js";
+import {
+  apiListHelper
+} from "../helpers/apiListHelper.js";
+export const useListLoader = (loaderOptions) => {
+  const result = reactive({
+    items: [],
+    status: ObjectHelper.createStatus(),
+    options: {}
+  });
+  const clear = () => {
+    result.status = ObjectHelper.createStatus();
+    result.items = [];
+    result.options = {};
+  };
+  const run = async (payload) => {
+    return apiListHelper(
+      () => result,
+      (_data) => {
+        result.status = _data;
+      },
+      (_data) => {
+        result.options = _data;
+      },
+      (_data) => {
+        result.items = _data;
+      },
+      {
+        ...loaderOptions,
+        ...payload
+      }
+    );
+  };
+  const setLoading = () => {
+    result.items = [];
+    result.status = ObjectHelper.toLoadingStatus(result.status);
+  };
+  const setItems = (_items) => {
+    result.items = _items;
+  };
+  return {
+    items: computed(() => result.items),
+    status: computed(() => result.status),
+    options: computed(() => result.options),
+    run,
+    clear,
+    setItems,
+    setLoading
+  };
+};

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

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

package/dist/runtime/composables/loaderObject.js

@@ -0,0 +1,50 @@
+import { reactive, computed } from "vue";
+import { ObjectHelper } from "../utils/ObjectHelper.js";
+import {
+  apiObjectHelper
+} from "../helpers/apiObjectHelper.js";
+export const useObjectLoader = (loaderOptions) => {
+  const result = reactive({
+    data: null,
+    status: ObjectHelper.createStatus(),
+    options: {}
+  });
+  const clear = () => {
+    result.status = ObjectHelper.createStatus();
+    result.data = null;
+  };
+  const run = async (payload = {}) => {
+    return await apiObjectHelper(
+      () => result,
+      (_data) => {
+        result.status = _data;
+      },
+      (_data) => {
+        result.options = _data;
+      },
+      (_data) => {
+        result.data = _data ?? null;
+      },
+      payload.data,
+      {
+        ...loaderOptions,
+        ...payload
+      }
+    );
+  };
+  const setLoading = () => {
+    result.status = ObjectHelper.toLoadingStatus(result.status);
+  };
+  const setData = (_data) => {
+    result.data = _data;
+  };
+  return {
+    data: computed(() => result.data),
+    status: computed(() => result.status),
+    options: computed(() => result.options),
+    run,
+    clear,
+    setLoading,
+    setData
+  };
+};

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

@@ -1,14 +1,13 @@
-import { type IPageLoaderOptions, type IUsePageLoader } from '../helpers/apiPageHelper';
+import type { IPageOptions } from '../types/lib.js';
+import { type IPageLoaderOptions, type IUsePageLoader } from '../helpers/apiPageHelper.js';
+/**
+ * Initialize page options with default values
+ */
 export declare const initPageOptions: (options: {
     limit: number;
     primary: string;
-}) => {
-    currentPageCount: number;
-    currentPage: number;
-    totalPage: number;
-    totalCount: number;
-    limit: number;
-    search: string;
-    primary: string;
-};
-export declare const usePageLoader: <T = any>(loaderOptions: IPageLoaderOptions<T>) => IUsePageLoader<T>;
+}) => IPageOptions;
+/**
+ * Create a page loader composable for handling paginated data with CRUD operations
+ */
+export declare const usePageLoader: <T extends Record<string, any>>(loaderOptions: IPageLoaderOptions<T>) => IUsePageLoader<T>;

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