@finema/core 1.1.5 → 1.2.2

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

@@ -0,0 +1,4 @@
+export const CONFIG = {
+  LIMIT_PER_PAGE: 30,
+  DEFAULT_PRIMARY: "id"
+};

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

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

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

@@ -0,0 +1,49 @@
+import { ref } from "vue";
+import { ObjectHelper } from "../../utils/ObjectHelper.mjs";
+import { apiListHelper } from "./apiListHelper.mjs";
+export const useListLoader = (loaderOptions) => {
+  const status = ref(ObjectHelper.createStatus());
+  const items = ref([]);
+  const options = ref({});
+  const clear = () => {
+    status.value = ObjectHelper.createStatus();
+    items.value = [];
+  };
+  const run = async (opts) => {
+    return apiListHelper(
+      () => ({
+        status: status.value,
+        items: items.value,
+        options: options.value
+      }),
+      (_data) => {
+        status.value = _data;
+      },
+      (_data) => {
+        options.value = _data;
+      },
+      (_data) => {
+        items.value = _data;
+      },
+      {
+        ...loaderOptions,
+        ...opts
+      }
+    );
+  };
+  const setLoading = () => {
+    status.value = ObjectHelper.toLoadingStatus(status.value);
+  };
+  const setItems = (_items) => {
+    items.value = _items;
+  };
+  return {
+    items,
+    status,
+    options,
+    run,
+    clear,
+    setItems,
+    setLoading
+  };
+};

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

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

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

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

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

@@ -1,4 +1,4 @@
-import { IPageLoaderOptions, IUsePageLoader } from './loaderTypes';
+import { type IPageLoaderOptions, type IUsePageLoader } from './loaderTypes';
 export declare const initPageOptions: () => {
     currentPageCount: number;
     currentPage: number;

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

@@ -0,0 +1,219 @@
+import { ref } from "vue";
+import { ObjectHelper } from "../../utils/ObjectHelper.mjs";
+import {
+  apiAddHelper,
+  apiDeleteHelper,
+  apiFetchHelper,
+  apiFindHelper,
+  updateHelper
+} from "./apiPageHelper.mjs";
+import { CONFIG } from "./config.mjs";
+export const initPageOptions = () => ({
+  currentPageCount: 0,
+  currentPage: 1,
+  totalPage: 0,
+  totalCount: 0,
+  limit: CONFIG.LIMIT_PER_PAGE,
+  search: "",
+  primary: CONFIG.DEFAULT_PRIMARY
+});
+export const usePageLoader = (loaderOptions) => {
+  const fetchStatus = ref(ObjectHelper.createStatus());
+  const fetchItems = ref([]);
+  const findItem = ref(null);
+  const deleteItem = ref(null);
+  const addItem = ref(null);
+  const updateItem = ref(null);
+  const findStatus = ref(ObjectHelper.createStatus());
+  const addStatus = ref(ObjectHelper.createStatus());
+  const updateStatus = ref(ObjectHelper.createStatus());
+  const deleteStatus = ref(ObjectHelper.createStatus());
+  const fetchOptions = ref(initPageOptions());
+  const addOptions = ref({});
+  const findOptions = ref({});
+  const updateOptions = ref({});
+  const deleteOptions = ref({});
+  const clear = () => {
+    findStatus.value = ObjectHelper.createStatus();
+    deleteStatus.value = ObjectHelper.createStatus();
+    addStatus.value = ObjectHelper.createStatus();
+    updateStatus.value = ObjectHelper.createStatus();
+    findItem.value = null;
+    deleteItem.value = null;
+    updateItem.value = null;
+    fetchStatus.value = ObjectHelper.createStatus();
+    fetchOptions.value = initPageOptions();
+    findOptions.value = {};
+    addOptions.value = {};
+    deleteOptions.value = {};
+    fetchItems.value = [];
+  };
+  const setFetchLoading = () => {
+    fetchStatus.value = ObjectHelper.toLoadingStatus(fetchStatus.value);
+  };
+  const setFindLoading = () => {
+    findStatus.value = ObjectHelper.toLoadingStatus(findStatus.value);
+  };
+  const fetch = async (page = 1, query = "", opts) => {
+    await apiFetchHelper(
+      () => ({
+        status: fetchStatus.value,
+        items: fetchItems.value,
+        options: fetchOptions.value
+      }),
+      (data) => {
+        fetchStatus.value = data;
+      },
+      (data) => {
+        fetchOptions.value = data;
+      },
+      (data) => {
+        fetchItems.value = data;
+      },
+      page,
+      query,
+      {
+        ...loaderOptions,
+        ...opts
+      }
+    );
+  };
+  const find = async (id, opts) => {
+    await apiFindHelper(
+      () => ({
+        status: findStatus.value,
+        data: findItem.value,
+        options: findOptions.value
+      }),
+      (data) => {
+        findStatus.value = data;
+      },
+      (data) => {
+        findOptions.value = data;
+      },
+      (data) => {
+        findItem.value = data;
+      },
+      id,
+      {
+        ...loaderOptions,
+        ...opts
+      }
+    );
+  };
+  const add = async (data, opts) => {
+    await apiAddHelper(
+      () => ({
+        items: fetchItems.value,
+        status: addStatus.value,
+        data: addItem.value,
+        options: addOptions.value
+      }),
+      (data2) => {
+        addStatus.value = data2;
+      },
+      (data2) => {
+        addOptions.value = data2;
+      },
+      (data2) => {
+        addItem.value = data2;
+      },
+      (data2) => {
+        fetchItems.value = data2;
+      },
+      data,
+      {
+        ...loaderOptions,
+        ...opts
+      }
+    );
+  };
+  const update = async (id, data, opts) => {
+    await updateHelper(
+      () => ({
+        items: fetchItems.value,
+        status: updateStatus.value,
+        data: updateItem.value,
+        oldData: findItem.value,
+        options: updateOptions.value
+      }),
+      (data2) => {
+        updateStatus.value = data2;
+      },
+      (data2) => {
+        updateOptions.value = data2;
+      },
+      (data2) => {
+        updateItem.value = data2;
+      },
+      (data2) => {
+        fetchItems.value = data2;
+      },
+      (data2) => {
+        findItem.value = data2;
+      },
+      id,
+      data,
+      {
+        ...loaderOptions,
+        ...opts
+      }
+    );
+  };
+  const search = async (query = "", opts) => {
+    await fetch(1, query, opts);
+  };
+  const remove = async (id, opts) => {
+    await apiDeleteHelper(
+      () => ({
+        status: deleteStatus.value,
+        data: deleteItem.value,
+        items: fetchItems.value,
+        options: deleteOptions.value
+      }),
+      (data) => {
+        deleteStatus.value = data;
+      },
+      (data) => {
+        deleteOptions.value = data;
+      },
+      (data) => {
+        deleteItem.value = data;
+      },
+      (data) => {
+        fetchItems.value = data;
+      },
+      id,
+      {
+        ...loaderOptions,
+        ...opts
+      }
+    );
+  };
+  return {
+    fetchItems,
+    fetchOptions,
+    addOptions,
+    findOptions,
+    deleteOptions,
+    updateOptions,
+    fetchStatus,
+    deleteStatus,
+    deleteItem,
+    fetch,
+    search,
+    remove,
+    find,
+    findItem,
+    findStatus,
+    add,
+    addItem,
+    addStatus,
+    updateItem,
+    updateStatus,
+    update,
+    setFetchLoading,
+    setFindLoading,
+    clear
+  };
+};

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

@@ -1,6 +1,6 @@
-import { AxiosRequestConfig, Method } from 'axios';
-import { Ref, UnwrapRef } from 'vue';
-import { IAPIOptions, IPageOptions, IStatus } from './types';
+import { type AxiosRequestConfig, type Method } from 'axios';
+import { type Ref, type UnwrapRef } from 'vue';
+import { type IAPIOptions, type IPageOptions, type IStatus } from '../../types/lib';
 export interface IPageFetchLoaderOptions<D = Record<string, any>> {
     isMock?: boolean;
     params?: Record<string, any>;

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

@@ -6,5 +6,3 @@ export * from './api/loaderList';
 export * from './api/loaderObject';
 export * from './api/loaderPage';
 export * from './api/loaderTypes';
-export * from './api/types';
-export * from './api/utils';

package/dist/runtime/lib/index.mjs

@@ -0,0 +1,8 @@
+export * from "./Requester.mjs";
+export * from "./api/apiListHelper.mjs";
+export * from "./api/apiObjectHelper.mjs";
+export * from "./api/apiPageHelper.mjs";
+export * from "./api/loaderList.mjs";
+export * from "./api/loaderObject.mjs";
+export * from "./api/loaderPage.mjs";
+export * from "./api/loaderTypes.mjs";

package/dist/runtime/plugin.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/runtime/plugin.mjs

@@ -0,0 +1,4 @@
+import { defineNuxtPlugin } from "#app";
+export default defineNuxtPlugin((nuxtApp) => {
+  console.log("Plugin injected by finema ui module!");
+});

package/dist/runtime/types/common.d.ts

@@ -0,0 +1,13 @@
+export interface IError {
+  code: string
+  message: any
+}
+
+export interface IOption {
+  value: any
+  label: string
+}
+
+interface IGetParams {
+  params?: Record<string, any>
+}

package/dist/runtime/types/lib.d.ts

@@ -0,0 +1,102 @@
+import { type AxiosRequestConfig } from 'axios'
+
+export interface IAPIOptions {
+  _status?: number
+  _timestamp?: number
+  request?: Partial<AxiosRequestConfig>
+  [key: string]: any
+}
+
+export interface IPageOptions extends IAPIOptions {
+  currentPageCount: number
+  currentPage: number
+  totalPage: number
+  totalCount: number
+  limit: number
+  search?: string
+  primary?: string
+}
+
+export interface IStatus {
+  isError: boolean
+  isSuccess: boolean
+  isLoading: boolean
+  isLoaded: boolean
+  errorData: any | null
+}
+
+export interface IAPIFetchState<T> {
+  items: T[]
+  status: IStatus
+  options: IPageOptions
+}
+
+export interface IAPIFindState<T> {
+  data: T
+  status: IStatus
+  options: IAPIOptions
+}
+
+export interface IAPIAddState<T> {
+  data: T
+  items: T[]
+  status: IStatus
+  options: IAPIOptions
+}
+
+export interface IAPIObjectState<T> {
+  data: T | null
+  status: IStatus
+  options: IAPIOptions
+}
+
+export interface IAPIListState<T> {
+  items: T[]
+  status: IStatus
+  options: IAPIOptions
+}
+
+export interface IAPIDeleteState<T> {
+  data: T
+  items: T[]
+  status: IStatus
+  options: IAPIOptions
+}
+
+export interface IAPIUpdateState<T> {
+  data: T
+  oldData: T
+  items: T[] | undefined | null
+  status: IStatus
+  options: IAPIOptions
+}
+
+export interface IPageState<T> {
+  deleteStatus: IStatus
+  updateStatus: IStatus
+  addStatus: IStatus
+  findStatus: IStatus
+  fetchStatus: IStatus
+  fetchItems: T[]
+  findItem: null | T
+  addItem: null | T
+  updateItem: null | T
+  deleteItem: null | T | any
+  findOptions: object
+  addOptions: object
+  deleteOptions: object
+  updateOptions: object
+  fetchOptions: IPageOptions
+}
+
+export interface IObjectState<T> {
+  data: T | null
+  status: IStatus
+  options: IAPIOptions
+}
+
+export interface IListState<T> {
+  items: T[]
+  status: IStatus
+  options: IAPIOptions
+}

package/dist/runtime/utils/FileHelper.mjs

@@ -0,0 +1,29 @@
+export class FileHelper {
+  static toBase64 = async (file) => {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.readAsDataURL(file);
+      reader.onload = () => {
+        resolve(reader.result);
+      };
+      reader.onerror = (error) => {
+        reject(error);
+      };
+    });
+  };
+  static readFileAsync = async (file) => {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = (ev) => {
+        resolve(ev.target ? ev.target.result : "");
+      };
+      reader.onerror = reject;
+      reader.readAsText(file);
+    });
+  };
+  static dataURLtoFile = async (dataUrl, filename) => {
+    const res = await fetch(dataUrl);
+    const blob = await res.blob();
+    return new File([blob], filename, { type: "image/png" });
+  };
+}

package/dist/{utils → runtime/utils}/ObjectHelper.d.ts

@@ -1,6 +1,6 @@
-import { AxiosError } from 'axios';
-import { IStatus } from '../lib';
-import { IOption } from './types';
+import { type AxiosError } from 'axios';
+import { type IStatus } from '../types/lib';
+import { type IOption } from '../types/common';
 export declare class ObjectHelper {
     static createOption(value: any, label?: string): IOption;
     static toOption(data: any, valueAttr?: string, labelAttr?: string): IOption;

package/dist/runtime/utils/ObjectHelper.mjs

@@ -0,0 +1,108 @@
+import { _get, _isEmpty } from "./lodash.mjs";
+import { ParamHelper } from "./ParamHelper.mjs";
+export class ObjectHelper {
+  static createOption(value, label = "") {
+    return {
+      value,
+      label
+    };
+  }
+  static toOption(data, valueAttr = "id", labelAttr = "name") {
+    const newData = data || {};
+    const value = _get(newData, valueAttr, "");
+    return {
+      value,
+      label: _get(newData, labelAttr, value)
+    };
+  }
+  static toOptions(data, valueAttr = "id", labelAttr = "name") {
+    if (!data) {
+      return [];
+    }
+    const value = _get(data, valueAttr, "");
+    return [
+      {
+        value,
+        label: _get(data, labelAttr, value)
+      }
+    ];
+  }
+  static toStatus(obj) {
+    return {
+      isLoaded: ParamHelper.getBoolFalse(obj.isLoaded),
+      isLoading: ParamHelper.getBoolFalse(obj.isLoading),
+      isError: ParamHelper.getBoolFalse(obj.isError),
+      isSuccess: ParamHelper.getBoolFalse(obj.isSuccess),
+      errorData: obj.errorData || null
+    };
+  }
+  static toLoadingStatus(obj) {
+    return {
+      ...obj,
+      isLoaded: false,
+      isError: false,
+      isLoading: true,
+      isSuccess: false
+    };
+  }
+  static toItemsSuccessStatus(obj, items) {
+    return {
+      ...obj,
+      isSuccess: true,
+      errorData: null,
+      items
+    };
+  }
+  static toObjectSuccessStatus(obj, data = null) {
+    return {
+      ...obj,
+      isSuccess: true,
+      errorData: null,
+      data
+    };
+  }
+  static toErrorStatus(obj, error) {
+    let newError = JSON.parse(error.response?.request?.response || "{}");
+    if (!error.response?.status) {
+      newError = {
+        code: "NETWORK_ERROR",
+        message: "Network error"
+      };
+    }
+    return {
+      ...obj,
+      isError: true,
+      isSuccess: false,
+      errorData: newError
+    };
+  }
+  static toSuccessStatus(obj) {
+    return {
+      ...obj,
+      isSuccess: true,
+      errorData: null
+    };
+  }
+  static toCompleteStatus(obj) {
+    return {
+      ...obj,
+      isLoading: false,
+      isLoaded: true
+    };
+  }
+  static createStatus() {
+    return {
+      isLoaded: false,
+      isLoading: false,
+      isError: false,
+      isSuccess: false,
+      errorData: null
+    };
+  }
+  static isInvalidParams(errorData) {
+    return errorData.code === "INVALID_PARAMS";
+  }
+  static isEmpty = (object) => {
+    return _isEmpty(object);
+  };
+}

package/dist/{utils → runtime/utils}/ParamHelper.d.ts

@@ -1,5 +1,6 @@
-import { IError } from './types';
+import { type IError, type IGetParams } from '../types/common';
 export declare class ParamHelper {
+    static getParams: (opts: IGetParams, reqOptions: IGetParams) => Record<string, any> | undefined;
     static getBoolTrue: (bool: any) => boolean;
     static getBoolFalse: (bool: any) => boolean;
     static isNotFoundError: (error: IError | any) => boolean;

package/dist/runtime/utils/ParamHelper.mjs

@@ -0,0 +1,39 @@
+import { _get } from "./lodash.mjs";
+export class ParamHelper {
+  static getParams = (opts, reqOptions) => {
+    if (opts.params) {
+      return {
+        ...reqOptions.params,
+        ...opts.params
+      };
+    }
+    return reqOptions.params;
+  };
+  static getBoolTrue = (bool) => {
+    if (bool === "false") {
+      return false;
+    }
+    if (bool === "true") {
+      return true;
+    }
+    return bool === null ? true : !!bool;
+  };
+  static getBoolFalse = (bool) => {
+    if (bool === "false") {
+      return false;
+    }
+    if (bool === "true") {
+      return true;
+    }
+    return bool === null ? false : !!bool;
+  };
+  static isNotFoundError = (error) => {
+    return _get(error, "code", true) === "NOT_FOUND";
+  };
+  static isChangeWithFalse = (value, oldValue) => {
+    return oldValue !== value && !value;
+  };
+  static isChangeWithTrue = (value, oldValue) => {
+    return oldValue !== value && value;
+  };
+}