@finema/core 1.2.2 → 1.3.0

package/dist/runtime/composables/useDialog.mjs

@@ -0,0 +1,81 @@
+import { defineStore } from "pinia";
+import { ref, useWatchFalse } 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 = defineStore("_dialog", () => {
+  const isShow = ref(false);
+  const meta = ref(void 0);
+  const isReject = ref(false);
+  const proceed = ref(void 0);
+  const cancel = ref(void 0);
+  const openDialog = async (payload) => {
+    return new Promise((resolve, reject) => {
+      isShow.value = true;
+      meta.value = payload;
+      proceed.value = resolve;
+      cancel.value = reject;
+    });
+  };
+  const closeDialogProceed = () => {
+    isShow.value = false;
+    meta.value = void 0;
+  };
+  const closeDialogCancel = () => {
+    isShow.value = false;
+    meta.value = void 0;
+    isReject.value = true;
+  };
+  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 */
+    });
+  };
+  useWatchFalse(
+    () => isShow.value,
+    (val) => {
+      if (isReject.value) {
+        cancel.value();
+      } else {
+        proceed.value();
+      }
+      proceed.value = void 0;
+      cancel.value = void 0;
+      isReject.value = false;
+    }
+  );
+  return {
+    isShow,
+    meta,
+    openDialog,
+    closeDialogCancel,
+    closeDialogProceed,
+    error,
+    success,
+    info,
+    warning
+  };
+});

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

@@ -0,0 +1,24 @@
+import { type DefineComponent, type ComputedRef } from 'vue';
+import { type FieldContext, type FieldOptions } from 'vee-validate';
+import { type IFormField } from '#core/components/Form/types';
+export interface IFieldWrapperProps {
+    errorMessage?: string;
+    label?: string | any;
+    className?: any;
+    classInner?: any;
+    classInputInner?: any;
+    isRequired?: boolean;
+    isHideLabel?: boolean;
+    customErrorMessage?: string | DefineComponent;
+    name: string;
+}
+interface IFieldContext<TValue> extends FieldContext<TValue> {
+    isRequired: ComputedRef<boolean>;
+    onChange: (e: InputEvent) => void;
+    fieldClassName: ComputedRef<any[]>;
+    disabled: ComputedRef<boolean>;
+    wrapperProps: ComputedRef<IFieldWrapperProps>;
+}
+export declare const useFieldHOC: <TValue = unknown>(newFormProps: IFieldProps, opts?: Partial<FieldOptions<TValue>> | undefined) => IFieldContext<TValue>;
+export declare const createFormFields: (fields: () => IFormField[]) => any;
+export {};

package/dist/runtime/composables/useForm.mjs

@@ -0,0 +1,44 @@
+import { useField } from "vee-validate";
+import { toTypedSchema } from "@vee-validate/zod";
+import { computed, toRef } from "#imports";
+export const useFieldHOC = (newFormProps, opts) => {
+  const field = useField(toRef(newFormProps, "name"), toTypedSchema(newFormProps.rules), {
+    form: newFormProps.form,
+    ...opts
+  });
+  const isRequired = computed(() => false);
+  const onChange = (e) => {
+    const target = e.target;
+    const newValue = newFormProps.transform ? newFormProps.transform(target.value, field.value, e) : target.value;
+    target.value = newValue;
+    field.handleChange(newValue);
+  };
+  const fieldClassName = computed(() => {
+    return [
+      "form-control peer",
+      {
+        "input-error": !field.meta.valid && field.meta.dirty,
+        "input-success": field.meta.valid && field.meta.dirty
+      }
+    ];
+  });
+  return {
+    ...field,
+    isRequired,
+    onChange,
+    fieldClassName,
+    disabled: computed(() => newFormProps.isDisabled ?? newFormProps.isReadOnly ?? false),
+    wrapperProps: computed(() => ({
+      label: newFormProps.label,
+      errorMessage: field.errorMessage.value,
+      className: newFormProps.class,
+      classInner: newFormProps.classInner,
+      classInputInner: newFormProps.classInputInner,
+      isRequired: isRequired.value,
+      isHideLabel: newFormProps.isHideLabel,
+      customErrorMessage: newFormProps.customErrorMessage,
+      name: newFormProps.name
+    }))
+  };
+};
+export const createFormFields = (fields) => computed(fields);

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

@@ -0,0 +1,18 @@
+import { type ComputedRef } from 'vue';
+import { type Store } from 'pinia';
+import { type IStatus, type IUsePageLoader } from '#imports';
+import { type IColumn, type IRow, type ISimpleTableOptions, type ITableOptions } from '#core/components/Table/types';
+export interface IUseTable<T = object> {
+    repo: IUsePageLoader<T> | Store<any, any>;
+    columns: () => IColumn[];
+    options?: (() => Partial<ITableOptions<T>>) | Partial<ITableOptions<T>>;
+}
+export interface IUseSimpleTable<T = object> {
+    items: () => T[];
+    status?: () => IStatus;
+    columns: () => IColumn[];
+    options?: (() => Partial<ISimpleTableOptions<T>>) | Partial<ISimpleTableOptions<T>>;
+}
+export declare const useTable: <T = object>(options: IUseTable<T>) => ComputedRef<ITableOptions<T>>;
+export declare const useSimpleTable: <T = object>(options: IUseSimpleTable<T>) => ComputedRef<ISimpleTableOptions<T>>;
+export declare const createTableOptions: <T = object>(repo: IUsePageLoader<T>, columns: IColumn[], rows: IRow[], options: ITableOptions<T>) => ITableOptions<T>;

package/dist/runtime/composables/useTable.mjs

@@ -0,0 +1,35 @@
+import { get } from "@vueuse/core";
+import { computed, ObjectHelper } from "#imports";
+import { useCoreConfig } from "./useConfig.mjs";
+export const useTable = (options) => computed(() => {
+  return createTableOptions(
+    options.repo,
+    options.columns(),
+    get(options.repo.fetchItems),
+    typeof options.options === "function" ? options.options() : options.options ?? {}
+  );
+});
+export const useSimpleTable = (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, rows, options) => {
+  const config = useCoreConfig();
+  return {
+    rawData: get(repo.fetchItems),
+    pageOptions: get(repo.fetchOptions),
+    columns,
+    status: get(repo.fetchStatus),
+    deleteStatus: get(repo.deleteStatus),
+    primary: get(repo.fetchOptions).primary ?? config.default_primary_key,
+    isNotChangeRoute: false,
+    ...options
+  };
+};

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

@@ -0,0 +1,3 @@
+export declare const useWatchTrue: (source: () => boolean, cb: (v: boolean, o: boolean) => any) => void;
+export declare const useWatchFalse: (source: () => boolean, cb: (v: boolean, o: boolean) => any) => void;
+export declare const useWatchChange: (source: () => any, cb: (v: any, o: any) => any) => void;

package/dist/runtime/composables/useWatch.mjs

@@ -0,0 +1,22 @@
+import { ParamHelper, watch } from "#imports";
+export const useWatchTrue = (source, cb) => {
+  watch(source, (value, oldVal) => {
+    if (ParamHelper.isChangeWithTrue(value, oldVal)) {
+      cb(value, oldVal);
+    }
+  });
+};
+export const useWatchFalse = (source, cb) => {
+  watch(source, (value, oldVal) => {
+    if (ParamHelper.isChangeWithFalse(value, oldVal)) {
+      cb(value, oldVal);
+    }
+  });
+};
+export const useWatchChange = (source, cb) => {
+  watch(source, (value, oldVal) => {
+    if (value !== oldVal) {
+      cb(value, oldVal);
+    }
+  });
+};

package/dist/runtime/core.config.d.ts

@@ -0,0 +1,4 @@
+export declare const core: {
+    limit_per_page: number;
+    default_primary_key: string;
+};

package/dist/runtime/core.config.mjs

@@ -0,0 +1,4 @@
+export const core = {
+  limit_per_page: 30,
+  default_primary_key: "id"
+};

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

@@ -1,3 +1,3 @@
-import { type IAPIListState, type IAPIOptions, type IStatus } from '../../types/lib';
-import { type IListLoaderOptions, type IListRunLoaderOptions } from './loaderTypes';
-export declare const apiListHelper: <T, O>(state: () => IAPIListState<T>, onUpdateStatus: (status: IStatus) => void, onUpdateOptions: (options: IAPIOptions) => void, onUpdateItems: (data: T[]) => void, opts: IListLoaderOptions<T, O> & IListRunLoaderOptions<T, O>) => Promise<void>;
+import { type IAPIListState, type IAPIOptions, type IStatus } from '#core/types/lib';
+import { type IListLoaderOptions, type IListRunLoaderOptions } from '#core/types/loaderTypes';
+export declare const apiListHelper: <T, O>(state: () => IAPIListState<T>, onUpdateStatus: (status: IStatus) => void, onUpdateOptions: (options: IAPIOptions) => void, onUpdateItems: (data: T[]) => void, opts: any) => Promise<void>;

package/dist/runtime/{lib/api → helpers}/apiListHelper.mjs

@@ -1,6 +1,6 @@
-import { NewRequester } from "../Requester.mjs";
-import { ObjectHelper } from "../../utils/ObjectHelper.mjs";
-import { ParamHelper } from "../../utils/ParamHelper.mjs";
+import { ObjectHelper } from "../utils/ObjectHelper.mjs";
+import { ParamHelper } from "#imports";
+import { NewRequester } from "#core/lib/Requester";
 export const apiListHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateItems, opts) => {
   const timestamp = state().options._timestamp;
   if (opts.expire && timestamp) {

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

@@ -1,3 +1,3 @@
-import { type IAPIObjectState, type IAPIOptions, type IStatus } from '../../types/lib';
-import { type IObjectLoaderOptions, type IObjectRunLoaderOptions } from './loaderTypes';
-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>;
+import { type IAPIObjectState, type IAPIOptions, type IStatus } from '#core/types/lib';
+import { type IObjectLoaderOptions, type IObjectRunLoaderOptions } from '#core/types/loaderTypes';
+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: any) => Promise<void>;

package/dist/runtime/{lib/api → helpers}/apiObjectHelper.mjs

@@ -1,6 +1,6 @@
-import { NewRequester } from "../Requester.mjs";
-import { ObjectHelper } from "../../utils/ObjectHelper.mjs";
-import { ParamHelper } from "../../utils/ParamHelper.mjs";
+import { ObjectHelper } from "../utils/ObjectHelper.mjs";
+import { ParamHelper } from "#core/utils/ParamHelper";
+import { NewRequester } from "#core/lib/Requester";
 export const apiObjectHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateData, data, opts) => {
   const timestamp = state().options._timestamp;
   if (opts.expire && timestamp) {

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

@@ -1,7 +1,7 @@
-import { type IAPIAddState, type IAPIDeleteState, type IAPIFetchState, type IAPIFindState, type IAPIOptions, type IAPIUpdateState, type IPageOptions, type IStatus } from '../../types/lib';
-import { type IPageDeleteLoaderOptions, type IPageFetchLoaderOptions, type IPageFindLoaderOptions, type IPageLoaderOptions, type IPageUpdateLoaderOptions } from './loaderTypes';
+import { type IPageDeleteLoaderOptions, type IPageFetchLoaderOptions, type IPageFindLoaderOptions, type IPageLoaderOptions, type IPageUpdateLoaderOptions } from '#core/types/loaderTypes';
+import { type IAPIAddState, type IAPIDeleteState, type IAPIFetchState, type IAPIFindState, type IAPIOptions, type IAPIUpdateState, type IPageOptions, type IStatus } from '#core/types/lib';
 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<Record<string, any>>) => 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: 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: any) => 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/{lib/api → helpers}/apiPageHelper.mjs

@@ -1,8 +1,8 @@
-import { NewRequester } from "../Requester.mjs";
-import { ObjectHelper } from "../../utils/ObjectHelper.mjs";
-import { _findIndex, _get, _shuffle } from "../../utils/lodash.mjs";
-import { ParamHelper } from "../../utils/ParamHelper.mjs";
-import { CONFIG } from "./config.mjs";
+import { ObjectHelper } from "../utils/ObjectHelper.mjs";
+import { ParamHelper } from "#core/utils/ParamHelper";
+import { NewRequester } from "#core/lib/Requester";
+import { _findIndex, _get, _shuffle } from "#core/utils/lodash";
+import { useCoreConfig } from "../composables/useConfig.mjs";
 export const apiAddHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateData, onUpdateItems, data, opts) => {
   onUpdateStatus(ObjectHelper.toLoadingStatus(state().status));
   onUpdateOptions({});
@@ -88,6 +88,7 @@ export const apiDeleteHelper = async (state, onUpdateStatus, onUpdateOptions, _o
   onUpdateStatus(ObjectHelper.toCompleteStatus(state().status));
 };
 export const apiFetchHelper = async (state, onUpdateStatus, onUpdateOptions, onUpdateItems, page, query, opts) => {
+  const config = useCoreConfig();
   const timestamp = state().options._timestamp;
   if (opts.expire && timestamp) {
     if (timestamp + opts.expire > Date.now()) {
@@ -117,7 +118,7 @@ export const apiFetchHelper = async (state, onUpdateStatus, onUpdateOptions, onU
     ...opts.getBaseRequestOptions?.() || {},
     ...opts.fetch?.getRequestOptions?.(page, query, opts) ?? {}
   };
-  const limit = reqOptions.params?.limit || CONFIG.LIMIT_PER_PAGE;
+  const limit = reqOptions.params?.limit || config.limit_per_page;
   reqOptions.params = {
     limit,
     page,

package/dist/runtime/plugin.mjs

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

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

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

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

@@ -0,0 +1 @@
+export type UIComponentList = 'modal' | 'slideover';

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

@@ -1,102 +1,89 @@
-import { type AxiosRequestConfig } from 'axios'
-
+import { type AxiosRequestConfig } from 'axios';
 export interface IAPIOptions {
-  _status?: number
-  _timestamp?: number
-  request?: Partial<AxiosRequestConfig>
-  [key: string]: any
+    _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
+    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
+    isError: boolean;
+    isSuccess: boolean;
+    isLoading: boolean;
+    isLoaded: boolean;
+    errorData: any | null;
 }
-
 export interface IAPIFetchState<T> {
-  items: T[]
-  status: IStatus
-  options: IPageOptions
+    items: T[];
+    status: IStatus;
+    options: IPageOptions;
 }
-
 export interface IAPIFindState<T> {
-  data: T
-  status: IStatus
-  options: IAPIOptions
+    data: T;
+    status: IStatus;
+    options: IAPIOptions;
 }
-
 export interface IAPIAddState<T> {
-  data: T
-  items: T[]
-  status: IStatus
-  options: IAPIOptions
+    data: T;
+    items: T[];
+    status: IStatus;
+    options: IAPIOptions;
 }
-
 export interface IAPIObjectState<T> {
-  data: T | null
-  status: IStatus
-  options: IAPIOptions
+    data: T | null;
+    status: IStatus;
+    options: IAPIOptions;
 }
-
 export interface IAPIListState<T> {
-  items: T[]
-  status: IStatus
-  options: IAPIOptions
+    items: T[];
+    status: IStatus;
+    options: IAPIOptions;
 }
-
 export interface IAPIDeleteState<T> {
-  data: T
-  items: T[]
-  status: IStatus
-  options: IAPIOptions
+    data: T;
+    items: T[];
+    status: IStatus;
+    options: IAPIOptions;
 }
-
 export interface IAPIUpdateState<T> {
-  data: T
-  oldData: T
-  items: T[] | undefined | null
-  status: IStatus
-  options: IAPIOptions
+    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
+    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
+    data: T | null;
+    status: IStatus;
+    options: IAPIOptions;
 }
-
 export interface IListState<T> {
-  items: T[]
-  status: IStatus
-  options: IAPIOptions
+    items: T[];
+    status: IStatus;
+    options: IAPIOptions;
 }

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

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

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

@@ -0,0 +1,9 @@
+export type Strategy = 'merge' | 'override'
+
+export type NestedKeyOf<ObjectType extends object> = {
+  [Key in keyof ObjectType]: ObjectType[Key] extends object ? NestedKeyOf<ObjectType[Key]> : Key
+}[keyof ObjectType]
+
+export type DeepPartial<T> = Partial<{
+  [P in keyof T]: DeepPartial<T[P]> | Record<string, string>
+}>

package/dist/runtime/ui.config.d.ts

@@ -0,0 +1,2 @@
+export declare const modal: any;
+export declare const slideover: any;

package/dist/runtime/ui.config.mjs

@@ -0,0 +1,44 @@
+import { modal as inheritModal, slideover as inheritSlideover } from "#ui/ui.config";
+export const modal = {
+  ...inheritModal,
+  header: "px-4 py-2 border-b",
+  innerWrapper: "p-4",
+  size: {
+    sm: "sm:max-w-sm",
+    md: "sm:max-w-lg",
+    lg: "sm:max-w-2xl",
+    xl: "sm:max-w-4xl"
+  },
+  position: {
+    top: "flex min-h-full items-end sm:items-start justify-center text-center",
+    center: "flex min-h-full items-end sm:items-center  justify-center text-center",
+    bottom: "flex min-h-full items-end sm:items-end justify-center text-center"
+  },
+  fixHeightSize: {
+    default: "max-h-[calc(100vh-4rem)]",
+    sm: "max-h-[256px]",
+    md: "max-h-[512px]",
+    lg: "max-h-[768px]",
+    xl: "max-h-[1024px]"
+  },
+  default: {
+    size: "md",
+    position: "center",
+    fixHeightSize: "default"
+  }
+};
+export const slideover = {
+  ...inheritSlideover,
+  bodyWrapper: "p-4",
+  size: {
+    sm: "w-screen max-w-xs",
+    md: "w-screen max-w-md",
+    lg: "w-screen max-w-xl",
+    xl: "w-screen max-w-2xl",
+    half: "w-screen max-w-[calc(100vw/2)]",
+    full: "w-screen max-w-full"
+  },
+  default: {
+    size: "md"
+  }
+};

package/dist/runtime/ui.css

@@ -0,0 +1,14 @@
+:root {
+  --color-primary-50: 248 248 255;
+  --color-primary-100: 232 239 253;
+  --color-primary-200: 190 227 248;
+  --color-primary-300: 144 205 244;
+  --color-primary-400: 99 179 237;
+  --color-primary-500: 54 117 251;
+  --color-primary-600: 0 104 254;
+  --color-primary-700: 43 108 176;
+  --color-primary-800: 44 82 130;
+  --color-primary-900: 32 36 62;
+  --color-primary-950: 32 36 62;
+  --color-primary-DEFAULT: 54 117 251;
+}

package/dist/runtime/utils/StringHelper.mjs

@@ -33,7 +33,7 @@ export class StringHelper {
     if (errorData.code !== "INVALID_PARAMS" && !errorData.fields) {
       return msg;
     }
-    for (const [_, value] of Object.entries(errorData.fields)) {
+    for (const [, value] of Object.entries(errorData.fields)) {
       msg = value.message;
     }
     return msg;

package/dist/runtime/utils/lodash.d.ts

@@ -43,6 +43,13 @@ export declare const _map: {
     <T_5>(collection: lodash.Dictionary<T_5> | lodash.NumericDictionary<T_5> | null | undefined, iteratee?: string | undefined): any[];
     <T_6>(collection: lodash.Dictionary<T_6> | lodash.NumericDictionary<T_6> | null | undefined, iteratee?: object | undefined): boolean[];
 };
+export declare const _merge: {
+    <TObject, TSource>(object: TObject, source: TSource): TObject & TSource;
+    <TObject_1, TSource1, TSource2>(object: TObject_1, source1: TSource1, source2: TSource2): TObject_1 & TSource1 & TSource2;
+    <TObject_2, TSource1_1, TSource2_1, TSource3>(object: TObject_2, source1: TSource1_1, source2: TSource2_1, source3: TSource3): TObject_2 & TSource1_1 & TSource2_1 & TSource3;
+    <TObject_3, TSource1_2, TSource2_2, TSource3_1, TSource4>(object: TObject_3, source1: TSource1_2, source2: TSource2_2, source3: TSource3_1, source4: TSource4): TObject_3 & TSource1_2 & TSource2_2 & TSource3_1 & TSource4;
+    (object: any, ...otherArgs: any[]): any;
+};
 export declare const _flatDeep: <T>(array: lodash.ListOfRecursiveArraysOrValues<T> | null | undefined) => lodash.Flat<T>[];
 export declare const _uniq: <T>(array: lodash.List<T> | null | undefined) => T[];
 export declare const _sortBy: {