@ramathibodi/nuxt-commons 0.1.45 → 0.1.47

package/dist/module.d.mts

@@ -4,4 +4,5 @@ interface ModuleOptions {
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
-export { type ModuleOptions, _default as default };
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.d.ts

@@ -4,4 +4,5 @@ interface ModuleOptions {
 }
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions, ModuleOptions, false>;
 
-export { type ModuleOptions, _default as default };
+export { _default as default };
+export type { ModuleOptions };

package/dist/module.json

@@ -4,9 +4,9 @@
   "compatibility": {
     "nuxt": "^3.0.0"
   },
-  "version": "0.1.45",
+  "version": "0.1.47",
   "builder": {
-    "@nuxt/module-builder": "0.8.3",
+    "@nuxt/module-builder": "0.8.4",
     "unbuild": "2.0.0"
   }
 }

package/dist/runtime/components/ExportCSV.vue

@@ -8,11 +8,15 @@ interface ExportButtonProps extends /* @vue-ignore */ InstanceType<typeof VBtn['
   fileName?: string
   sheetName?: string
   modelValue?: object[]
+  stringFields?: Array<string>
+  tooltip?: string | Record<string,any> | undefined
 }
 
 const props = withDefaults(defineProps<ExportButtonProps>(), {
   fileName: 'download',
   sheetName: 'Sheet1',
+  stringFields: ()=>[],
+  tooltip: ()=>({text: 'Export', location: 'bottom'}),
 })
 
 const alert = useAlert()
@@ -63,7 +67,7 @@ function flattenObject(obj: any, parentKey = '', separator = '.') {
     const newKey = parentKey ? `${parentKey}${separator}${key}` : key
     const value = obj[key]
 
-    if (value && typeof value === 'object' && !Array.isArray(value)) {
+    if (value && typeof value === 'object' && !Array.isArray(value) && !props.stringFields.includes(newKey)) {
       Object.assign(acc, flattenObject(value, newKey, separator))
     } else {
       acc[newKey] = typeof value === 'object' ? JSON.stringify(value) : value
@@ -82,6 +86,7 @@ function flattenObject(obj: any, parentKey = '', separator = '.') {
       :disabled="loading"
       text="Export CSV"
       @click="exportFile"
+      v-tooltip="props.tooltip"
   >
     <template
         v-for="(_, name, index) in ($slots as {})"

package/dist/runtime/components/FileBtn.vue

@@ -1,5 +1,5 @@
 <script lang="ts" setup>
-import {ref, watch} from 'vue'
+import {ref} from 'vue'
 import {VBtn} from 'vuetify/components/VBtn'
 
 interface Props extends /* @vue-ignore */ InstanceType<typeof VBtn['$props']> {
@@ -7,11 +7,13 @@ interface Props extends /* @vue-ignore */ InstanceType<typeof VBtn['$props']> {
   multiple?: boolean
   iconOnly?: boolean
   modelValue?: File | File[] | undefined
+  tooltip?: string | Record<string,any> | undefined
 }
 
 const props = withDefaults(defineProps<Props>(), {
   multiple: false,
   accept: '*',
+  tooltip: 'Upload File',
 })
 
 const emit = defineEmits<{
@@ -41,6 +43,7 @@ defineExpose({ reset })
   <v-btn
     v-bind="$attrs"
     @click="openFileInput"
+    v-tooltip="tooltip"
   >
     <template
       v-for="(_, name, index) in ($slots as {})"

package/dist/runtime/components/ImportCSV.vue

@@ -2,6 +2,17 @@
 import * as XLSX from 'xlsx'
 import { ref } from 'vue'
 import { useAlert } from '../composables/alert'
+import { VBtn } from 'vuetify/components/VBtn'
+
+interface ImportButtonProps extends /* @vue-ignore */ InstanceType<typeof VBtn['$props']> {
+  stringFields?: Array<string>
+  tooltip?: string | Record<string,any> | undefined
+}
+
+const props = withDefaults(defineProps<ImportButtonProps>(), {
+  stringFields: ()=>[],
+  tooltip: ()=>({text: 'Import', location: 'bottom'}),
+})
 
 const alert = useAlert()
 const emit = defineEmits<{
@@ -59,7 +70,8 @@ const parseAndAggregateColumns = (items: any[]) => {
         assignNestedValue(aggregatedItem[rootKey], subKeys, parseIfJson(item[key]))
       } else {
         // Directly assign root-level properties
-        aggregatedItem[key] = parseIfJson(item[key])
+        if (props.stringFields.includes(key)) aggregatedItem[key] = item[key]
+        else aggregatedItem[key] = parseIfJson(item[key])
       }
     }
 
@@ -110,6 +122,7 @@ const parseIfJson = (value: any) => {
       accept=".csv, .xlsx"
       :multiple="false"
       @update:model-value="uploadedFile"
+      :tooltip="props.tooltip"
   >
     <template
         v-for="(_, name, index) in ($slots as {})"

package/dist/runtime/components/form/Dialog.vue

@@ -11,24 +11,30 @@ interface Props {
   formData?: object
   saveCaption?: string
   cancelCaption?: string
+  closeCaption?: string
+  saveAndStay?: boolean
 }
 
 const props = withDefaults(defineProps<Props>(), {
   saveCaption: 'บันทึก',
   cancelCaption: 'ยกเลิก',
+  closeCaption: 'ปิด',
+  saveAndStay: false,
 })
 
 const isShowing = defineModel<boolean>({ default: false })
 const isSaving = ref<boolean>(false)
+const isSavedAndStay = ref<boolean>(false)
 const formPadRef = ref()
 const formData = ref<object>({})
+const formDataOriginalValue = ref<object>()
 
 const emit = defineEmits(['create', 'update'])
 
 function save() {
   if (formPadRef.value.isValid) {
     isSaving.value = true
-    emit((isCreating.value) ? 'create' : 'update', cloneDeep(formData.value), callback)
+    emit((isCreating.value) ? 'create' : 'update', cloneDeep(formData.value), (props.saveAndStay) ? stayCallback : callback)
   }
 }
 
@@ -46,12 +52,26 @@ const callback: FormDialogCallback = {
   },
 }
 
+const stayCallback: FormDialogCallback = {
+  done: function () {
+    isSaving.value = false
+    isSavedAndStay.value = true
+  },
+  error: function () {
+    isSaving.value = false
+  },
+  setData: function (item: object) {
+    formData.value = cloneDeep(item)
+    formDataOriginalValue.value = cloneDeep(item)
+  }
+}
+
 const isDataChange = computed(() => {
-  return !((isCreating.value) ? isEqual(formData.value, createOriginalValue.value) : isEqual(formData.value, props.formData))
+  return !((isCreating.value) ? isEqual(formData.value, createOriginalValue.value) : isEqual(formData.value, formDataOriginalValue.value))
 })
 
 const isCreating = computed(() => {
-  return !props.formData
+  return !props.formData && !isSavedAndStay.value
 })
 
 const createOriginalValue = computed(() => {
@@ -61,12 +81,16 @@ const createOriginalValue = computed(() => {
 const loadFormData = () => {
   if (props.formData) {
     formData.value = cloneDeep(props.formData)
+    formDataOriginalValue.value = cloneDeep(props.formData)
   }
   else {
     formData.value = Object.assign({}, props.initialData)
   }
+  isSavedAndStay.value = false
 }
 
+const operation = ref({ isDataChange, isCreating, isSaving, save, cancel })
+
 watchEffect(loadFormData)
 
 watch(() => isShowing.value, (newValue) => {
@@ -85,7 +109,7 @@ watch(() => isShowing.value, (newValue) => {
     <VCard>
       <VToolbar>
         <VToolbarTitle>
-          <slot name="title">
+          <slot name="title" :operation="operation">
             {{ (isCreating) ? "New" : "Edit" }} {{ title }}
           </slot>
         </VToolbarTitle>
@@ -113,24 +137,26 @@ watch(() => isShowing.value, (newValue) => {
         </form-pad>
       </VCardText>
       <VCardActions>
-        <VSpacer />
-        <VBtn
-          color="primary"
-          variant="flat"
-          :loading="isSaving"
-          :disabled="!isDataChange"
-          @click="save"
-        >
-          {{ saveCaption }}
-        </VBtn>
-        <VBtn
-          color="error"
-          variant="flat"
-          :disabled="isSaving"
-          @click="cancel"
-        >
-          {{ cancelCaption }}
-        </VBtn>
+        <slot name="action" :operation="operation">
+          <VSpacer />
+          <VBtn
+              color="primary"
+              variant="flat"
+              :loading="isSaving"
+              :disabled="!isDataChange"
+              @click="save"
+          >
+            {{ saveCaption }}
+          </VBtn>
+          <VBtn
+              color="error"
+              variant="flat"
+              :disabled="isSaving"
+              @click="cancel"
+          >
+            {{ (!isDataChange) ? closeCaption : cancelCaption }}
+          </VBtn>
+        </slot>
       </VCardActions>
     </VCard>
   </v-dialog>

package/dist/runtime/components/form/Table.vue

@@ -23,6 +23,8 @@ interface Props extends /* @vue-ignore */ InstanceType<typeof VDataTable['$props
   searchable?: boolean
   inputPad?: boolean
   inputPadOnly?: boolean
+  saveAndStay?: boolean
+  stringFields?: Array<string>
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -36,6 +38,8 @@ const props = withDefaults(defineProps<Props>(), {
   searchable: true,
   inputPad: false,
   inputPadOnly: false,
+  saveAndStay: false,
+  stringFields: ()=>[],
 })
 
 const emit = defineEmits(['update:modelValue'])
@@ -85,6 +89,7 @@ function createItem(item: Record<string, any>, callback?: FormDialogCallback) {
 
   items.value.push(item)
 
+  if (callback && callback.setData) callback.setData(item)
   if (callback) callback.done()
 }
 
@@ -102,6 +107,7 @@ function updateItem(newItem: Record<string, any>, callback?: FormDialogCallback)
     items.value[index] = newItem
   }
 
+  if (callback && callback.setData) callback.setData(newItem)
   if (callback) callback.done()
 }
 
@@ -238,6 +244,7 @@ defineExpose({
                     variant="flat"
                     @import="importItems"
                     :color="toolbarColor"
+                    :stringFields="props.stringFields"
                 />
                 <ExportCSV
                     v-if="props.exportable && items.length && !(isReadonly.value || isDisabled.value)"
@@ -246,6 +253,7 @@ defineExpose({
                     :file-name="title"
                     :model-value="items"
                     :color="toolbarColor"
+                    :stringFields="props.stringFields"
                 />
                 <VBtn
                     v-if="props.insertable && !props.inputPadOnly && !(isReadonly.value || isDisabled.value)"
@@ -313,6 +321,7 @@ defineExpose({
               :form-data="currentItem"
               @create="createItem"
               @update="updateItem"
+              :saveAndStay="saveAndStay"
               v-if="!props.inputPadOnly"
           >
             <template #default="slotData">
@@ -321,6 +330,18 @@ defineExpose({
                   v-bind="slotData"
               />
             </template>
+            <template #title="slotData">
+              <slot
+                  name="formTitle"
+                  v-bind="slotData"
+              />
+            </template>
+            <template #action="slotData">
+              <slot
+                  name="formAction"
+                  v-bind="slotData"
+              />
+            </template>
           </FormDialog>
         </v-card>
         <slot name="inputPad" :operation="operation" :isReadonly="isReadonly" :isDisabled="isDisabled">

package/dist/runtime/components/master/Autocomplete.vue

@@ -15,6 +15,8 @@ interface Props extends /* @vue-ignore */ InstanceType<typeof VAutocomplete['$pr
   filterText?: string
   waitForFilter?: boolean
   waitForFilterText?: string
+
+  cache?: boolean | number
 }
 
 const props = withDefaults(defineProps<Props>(), {
@@ -24,6 +26,8 @@ const props = withDefaults(defineProps<Props>(), {
   lang: 'TH',
   noDataText: 'ไม่พบข้อมูล',
   waitForFilter: false,
+
+  cache: false,
 })
 
 const computedModelName = computed(()=>{
@@ -78,6 +82,7 @@ const computedSortBy = computed(()=>{
       item-value="itemCode"
       :no-data-text="computedNoDataText"
       :show-code="props.showCode"
+      :cache="props.cache"
   >
     <template
         v-for="(_, name, index) in ($slots as {})"

package/dist/runtime/components/master/label.vue

@@ -5,12 +5,15 @@ interface Props {
   groupKey?: string | null
   itemCode?: string | null
   locale?: string
+  cache?: boolean | number
+
   notFoundText?: string
   placeholder?: string
 }
 
 const props = withDefaults(defineProps<Props>(), {
   locale: 'TH',
+  cache: false,
 })
 
 const computedNotFoundText =  computed(()=>{
@@ -35,5 +38,6 @@ const computedItemTitle = computed(()=>{
       :item-title="computedItemTitle"
       :not-found-text="computedNotFoundText"
       :placeholder="computedPlaceholder"
+      :cache="props.cache"
   ></model-label>
 </template>

package/dist/runtime/components/model/Autocomplete.vue

@@ -16,7 +16,7 @@ interface Props extends /* @vue-ignore */ InstanceType<typeof VAutocomplete['$pr
   itemTitle: string
   itemValue: string
   fields?: Array<string | object>
-  cache?: boolean
+  cache?: boolean | number
 
   serverSearch?: boolean
   serverSearchKey?: string

package/dist/runtime/components/model/Table.vue

@@ -20,6 +20,8 @@ interface Props extends /* @vue-ignore */ InstanceType<typeof VDataTable['$props
   insertable?: boolean
   searchable?: boolean
   search?: string
+  saveAndStay?: boolean
+  stringFields?: Array<string>
 }
 
 const props = withDefaults(defineProps<Props & GraphqlModelProps>(), {
@@ -30,9 +32,11 @@ const props = withDefaults(defineProps<Props & GraphqlModelProps>(), {
   exportable: true,
   insertable: true,
   searchable: true,
+  saveAndStay: false,
   modelKey: 'id',
   modelBy: undefined,
   fields: () => [],
+  stringFields: ()=>[],
 })
 
 const attrs = useAttrs()
@@ -124,6 +128,7 @@ defineExpose({ reload,operation })
             icon="mdi mdi-file-upload"
             variant="flat"
             :color="toolbarColor"
+            :stringFields="props.stringFields"
             @import="importItems"
           />
           <ExportCSV
@@ -133,6 +138,7 @@ defineExpose({ reload,operation })
             :file-name="title"
             :model-value="items"
             :color="toolbarColor"
+            :stringFields="props.stringFields"
           />
           <VBtn
             v-if="canCreate && props.insertable"
@@ -238,6 +244,7 @@ defineExpose({ reload,operation })
       :form-data="currentItem"
       @create="createItem"
       @update="updateItem"
+      :saveAndStay="saveAndStay"
     >
       <template #default="slotData">
         <slot
@@ -245,6 +252,18 @@ defineExpose({ reload,operation })
           v-bind="slotData"
         />
       </template>
+      <template #title="slotData">
+        <slot
+            name="formTitle"
+            v-bind="slotData"
+        />
+      </template>
+      <template #action="slotData">
+        <slot
+            name="formAction"
+            v-bind="slotData"
+        />
+      </template>
     </FormDialog>
   </v-card>
 </template>

package/dist/runtime/components/model/label.vue

@@ -1,14 +1,14 @@
 <script lang="ts" setup>
 import { computedAsync } from '@vueuse/core'
 import { useGraphQlOperation } from '../../composables/graphqlOperation'
-import {concat} from "lodash-es";
+import { concat } from "lodash-es";
 
 interface Props {
   modelName: string
   modelBy?: object
   itemTitle: string | ((result:Record<string,any>)=>void)
   fields?: Array<string | object>
-  cache?: boolean
+  cache?: boolean | number
 
   notFoundText?: string
   placeholder?: string
@@ -40,5 +40,5 @@ const modelItemValue = computedAsync<string>(async () => {
 </script>
 
 <template>
-  {{ modelItemValue }}
+  <span>{{ modelItemValue }}</span>
 </template>

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

@@ -2,8 +2,9 @@ import type { UseFetchOptions } from 'nuxt/app';
 import type { SearchParameters } from 'ofetch';
 export declare function useApi(): {
     urlBuilder: (url: string | string[]) => string;
-    get: (url: string | string[], body?: Record<string, any> | [], params?: SearchParameters, options?: UseFetchOptions<unknown>) => Promise<any>;
-    getPromise: (url: string | string[], body?: Record<string, any> | [], params?: SearchParameters, options?: UseFetchOptions<unknown>) => Promise<any>;
-    post: (url: string | string[], body?: Record<string, any> | [], params?: SearchParameters, options?: UseFetchOptions<unknown>) => Promise<any>;
-    postPromise: (url: string | string[], body?: Record<string, any> | [], params?: SearchParameters, options?: UseFetchOptions<unknown>) => Promise<any>;
+    get: (url: string | string[], body?: Record<string, any> | [], params?: SearchParameters, options?: UseFetchOptions<unknown>, cache?: boolean | number) => Promise<unknown>;
+    getPromise: (url: string | string[], body?: Record<string, any> | [], params?: SearchParameters, options?: UseFetchOptions<unknown>, cache?: boolean | number) => Promise<unknown>;
+    post: (url: string | string[], body?: Record<string, any> | [], params?: SearchParameters, options?: UseFetchOptions<unknown>, cache?: boolean | number) => Promise<unknown>;
+    postPromise: (url: string | string[], body?: Record<string, any> | [], params?: SearchParameters, options?: UseFetchOptions<unknown>, cache?: boolean | number) => Promise<unknown>;
+    hashKey: (data: any) => Promise<string>;
 };

package/dist/runtime/composables/api.js

@@ -1,5 +1,8 @@
 import { ofetch } from "ofetch";
 import { trimEnd, trimStart } from "lodash-es";
+import ls from "localstorage-ttl";
+import { stableStringify } from "../utils/object.js";
+import { sha256 } from "../utils/hash.js";
 import { useAuthentication, useRuntimeConfig } from "#imports";
 export function useApi() {
   const config = useRuntimeConfig();
@@ -39,17 +42,43 @@ export function useApi() {
       headers: finalHeaders
     };
   }
-  function get(url, body, params, options) {
-    return ofetch(urlBuilder(url), optionBuilder("GET", body, params, options));
+  function get(url, body, params, options, cache = false) {
+    return getPromise(url, body, params, options, cache);
   }
-  function getPromise(url, body, params, options) {
-    return ofetch(urlBuilder(url), optionBuilder("GET", body, params, options));
+  function getPromise(url, body, params, options, cache = false) {
+    return ofetchWithCache(url, "GET", body, params, options, cache);
   }
-  function post(url, body, params, options) {
-    return ofetch(urlBuilder(url), optionBuilder("POST", body, params, options));
+  function post(url, body, params, options, cache = false) {
+    return postPromise(url, body, params, options, cache);
   }
-  function postPromise(url, body, params, options) {
-    return ofetch(urlBuilder(url), optionBuilder("POST", body, params, options));
+  function postPromise(url, body, params, options, cache = false) {
+    return ofetchWithCache(url, "POST", body, params, options, cache);
   }
-  return { urlBuilder, get, getPromise, post, postPromise };
+  async function hashKey(data) {
+    const jsonString = stableStringify(data);
+    return sha256(jsonString);
+  }
+  async function ofetchWithCache(url, method, body, params, options, cache) {
+    const keyData = { url: urlBuilder(url), method, body, params, options };
+    let ttl = 0;
+    if (cache) {
+      if (typeof cache === "boolean") ttl = 5 * 60 * 1e3;
+      else {
+        ttl = +cache * 60 * 1e3;
+      }
+    }
+    if (ttl === 0) {
+      return ofetch(urlBuilder(url), optionBuilder(method, body, params, options));
+    }
+    const key = "api-cache-" + await hashKey(keyData);
+    const cached = ls.get(key);
+    if (cached) {
+      return Promise.resolve(cached);
+    }
+    return ofetch(urlBuilder(url), optionBuilder(method, body, params, options)).then((result) => {
+      ls.set(key, result, ttl);
+      return result;
+    });
+  }
+  return { urlBuilder, get, getPromise, post, postPromise, hashKey };
 }

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

@@ -11,7 +11,7 @@ declare type VariableOptions = {
 };
 export declare function useGraphQl(): {
     query: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions, cache?: boolean) => import("#app").AsyncData<(T extends any[] ? T : T extends Record<string, any> ? keyof T extends (T extends T ? keyof T extends string ? string & keyof T : never : never) ? T : (T extends T ? keyof T extends string ? string & keyof T : never : never) extends never ? T : Pick<T, T extends T ? keyof T extends string ? string & keyof T : never : never> : T) | null, import("#app").NuxtError<unknown> | null>;
-    queryPromise: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions, cache?: boolean) => Promise<T>;
+    queryPromise: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions, cache?: boolean | number) => Promise<T>;
     mutation: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions) => UseMutationReturn<any, any>;
     mutationPromise: <T>(operation: string, fields: Array<string | Object> | ClassConstructor<any>, variables?: VariableOptions) => Promise<T>;
 };

package/dist/runtime/composables/graphql.js

@@ -3,12 +3,12 @@ import { classAttributes, isClassConstructor } from "../utils/object.js";
 import { gql, useAsyncQuery, useMutation, useRuntimeConfig } from "#imports";
 import { useApi } from "./api.js";
 export function useGraphQl() {
-  function simplePromiseCall(operation, query2, variables) {
+  function simplePromiseCall(operation, query2, variables, cache = false) {
     return new Promise((resolve, reject) => {
       useApi().postPromise(useRuntimeConfig().public.WS_GRAPHQL, {
         query: query2,
         variables
-      }).then((result) => {
+      }, void 0, void 0, cache).then((result) => {
         if (result.errors) reject(result.errors.map((error) => {
           return error.message;
         }).join("\n"));
@@ -38,7 +38,7 @@ export function useGraphQl() {
   function queryPromise(operation, fields, variables, cache = false) {
     if (isClassConstructor(fields)) fields = classAttributes(fields);
     const builder = gqlQuery({ operation, fields, variables });
-    return simplePromiseCall(operation, builder.query, builder.variables);
+    return simplePromiseCall(operation, builder.query, builder.variables, cache);
   }
   function mutation(operation, fields, variables) {
     if (isClassConstructor(fields)) fields = classAttributes(fields);

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

@@ -13,12 +13,12 @@ export declare function useGraphqlModel<T extends GraphqlModelProps>(props: T):
     search: import("vue").Ref<string | undefined, string | undefined>;
     setSearch: (keyword: string) => void;
     currentOptions: import("vue").Ref<any, any>;
-    operationCreate: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
-    operationUpdate: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
-    operationDelete: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
-    operationRead: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
-    operationReadPageable: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
-    operationSearch: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
+    operationCreate: import("vue").ComputedRef<import("../types/graphqlOperation").graphqlOperationObject<any, any>>;
+    operationUpdate: import("vue").ComputedRef<import("../types/graphqlOperation").graphqlOperationObject<any, any>>;
+    operationDelete: import("vue").ComputedRef<import("../types/graphqlOperation").graphqlOperationObject<any, any>>;
+    operationRead: import("vue").ComputedRef<import("../types/graphqlOperation").graphqlOperationObject<any, any>>;
+    operationReadPageable: import("vue").ComputedRef<import("../types/graphqlOperation").graphqlOperationObject<any, any>>;
+    operationSearch: import("vue").ComputedRef<import("../types/graphqlOperation").graphqlOperationObject<any, any>>;
     fields: import("vue").ComputedRef<(string | object)[]>;
     canServerPageable: import("vue").ComputedRef<boolean>;
     canServerSearch: import("vue").ComputedRef<boolean>;

package/dist/runtime/composables/graphqlModel.js

@@ -61,6 +61,7 @@ export function useGraphqlModel(props) {
       if (canServerPageable.value) {
         if (!importing) loadItems(currentOptions.value);
       } else items.value.push(result);
+      if (callback && callback.setData) callback.setData(result);
     }).catch((error) => {
       alert?.addAlert({ alertType: "error", message: error });
     }).finally(() => {
@@ -98,6 +99,7 @@ export function useGraphqlModel(props) {
           items.value[index] = result;
         }
       }
+      if (callback && callback.setData) callback.setData(result);
     }).catch((error) => {
       alert?.addAlert({ alertType: "error", message: error });
     }).finally(() => {

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

@@ -4,10 +4,10 @@ export type GraphqlModelItemProps = Omit<GraphqlModelConfigProps, 'operationSear
 export declare function useGraphqlModelItem<T extends GraphqlModelItemProps>(props: T): {
     modelBy: import("vue").Ref<object | undefined, object | undefined>;
     item: import("vue").Ref<Record<string, any> | undefined, Record<string, any> | undefined>;
-    operationCreate: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
-    operationUpdate: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
-    operationDelete: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
-    operationRead: import("vue").ComputedRef<import("../../../playground/composables/graphqlObject").graphqlOperationObject<any, any>>;
+    operationCreate: import("vue").ComputedRef<import("../types/graphqlOperation").graphqlOperationObject<any, any>>;
+    operationUpdate: import("vue").ComputedRef<import("../types/graphqlOperation").graphqlOperationObject<any, any>>;
+    operationDelete: import("vue").ComputedRef<import("../types/graphqlOperation").graphqlOperationObject<any, any>>;
+    operationRead: import("vue").ComputedRef<import("../types/graphqlOperation").graphqlOperationObject<any, any>>;
     fields: import("vue").ComputedRef<(string | object)[]>;
     canCreate: import("vue").ComputedRef<boolean>;
     canUpdate: import("vue").ComputedRef<boolean>;

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

@@ -12,10 +12,10 @@ export interface GraphqlModelConfigProps {
     fields?: Array<string | object>;
 }
 export declare function useGraphqlModelOperation<T extends GraphqlModelConfigProps>(props: T): {
-    operationCreate: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
-    operationUpdate: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
-    operationDelete: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
-    operationRead: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
-    operationReadPageable: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
-    operationSearch: import("vue").ComputedRef<import("#imports").graphqlOperationObject<any, any>>;
+    operationCreate: import("vue").ComputedRef<graphqlOperationObject<any, any>>;
+    operationUpdate: import("vue").ComputedRef<graphqlOperationObject<any, any>>;
+    operationDelete: import("vue").ComputedRef<graphqlOperationObject<any, any>>;
+    operationRead: import("vue").ComputedRef<graphqlOperationObject<any, any>>;
+    operationReadPageable: import("vue").ComputedRef<graphqlOperationObject<any, any>>;
+    operationSearch: import("vue").ComputedRef<graphqlOperationObject<any, any>>;
 };

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

@@ -7,4 +7,4 @@ export declare function buildVariables(outputVariables?: graphqlVariable[], inpu
 export declare function buildRequiredInputFields(variables: graphqlVariable[] | undefined, inputField?: string): string[];
 export declare function useGraphQlOperation<T>(operationType: string, operation: string, fields?: Array<string | Object> | ClassConstructor<any>, variables?: {
     [p: string]: any;
-}, cache?: boolean): Promise<T>;
+}, cache?: boolean | number): Promise<T>;

package/dist/runtime/composables/graphqlOperation.js

@@ -1,3 +1,4 @@
+import { cloneDeep } from "lodash-es";
 import { classAttributes, isClassConstructor } from "../utils/object.js";
 import { useGraphQl } from "./graphql.js";
 import { graphqlInputType, graphqlOperation, graphqlType, scalarType } from "#imports";
@@ -36,8 +37,9 @@ export function buildFields(operationFields, fields, depth = 0) {
 }
 export function buildVariables(outputVariables, inputVariables, reject, isRoot = true) {
   if (!outputVariables) return void 0;
+  let localOutputVariables = cloneDeep(outputVariables);
   if (inputVariables) {
-    outputVariables.map((variable) => {
+    localOutputVariables.map((variable) => {
       if (variable.type && !scalarType.includes(variable.type)) {
         if (variable.list) {
           if (inputVariables[variable.name] && Array.isArray(inputVariables[variable.name])) {
@@ -58,7 +60,7 @@ export function buildVariables(outputVariables, inputVariables, reject, isRoot =
       return variable;
     });
   }
-  outputVariables.forEach((variable) => {
+  localOutputVariables.forEach((variable) => {
     if (variable.required && variable.value === void 0) {
       console.warn("Required variable " + variable.name + " is not found, operation abort");
       if (reject) {
@@ -67,10 +69,10 @@ export function buildVariables(outputVariables, inputVariables, reject, isRoot =
       }
     }
   });
-  const usedVariables = outputVariables.map((variable) => variable.name);
+  const usedVariables = localOutputVariables.map((variable) => variable.name);
   const droppedVariable = Object.keys(inputVariables || {}).filter((key) => !usedVariables.includes(key));
   if (droppedVariable.length > 0) console.debug("There is data not appeared in schema and dropped before operation.", droppedVariable);
-  return outputVariables.reduce((acc, item) => {
+  return localOutputVariables.reduce((acc, item) => {
     acc[item.name] = isRoot ? item : item.value;
     return acc;
   }, {});

package/dist/runtime/composables/menu.js

@@ -20,7 +20,7 @@ export function routeToMenuItem(route) {
     };
     if (route.children) {
       const menuItems = new Array();
-      for (const children of route.children.sort((a, b) => (a.path?.toString() ?? "").localeCompare(b.path?.toString() ?? ""))) {
+      for (const children of route.children.sort((a, b) => (a.name?.toString() ?? "").localeCompare(b.name?.toString() ?? ""))) {
         const childMenuItem = routeToMenuItem(children);
         if (childMenuItem) menuItems.push(childMenuItem);
         menuItem.menuItems = menuItems;
@@ -31,7 +31,7 @@ export function routeToMenuItem(route) {
 }
 export function createMenu() {
   const menuAll = ref([]);
-  const routes = useRouter().getRoutes().sort((a, b) => (a.path?.toString() ?? "").localeCompare(b.path?.toString() ?? ""));
+  const routes = useRouter().getRoutes().sort((a, b) => (a.name?.toString() ?? "").localeCompare(b.name?.toString() ?? ""));
   for (const route of routes) {
     const paths = route.path.split("/");
     if (paths.length == 2) {

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

@@ -1,4 +1,5 @@
 export interface FormDialogCallback {
   done: Function
   error: Function
+  setData?: Function
 }

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

@@ -10,7 +10,7 @@ export interface graphqlOperationObject<T, U> {
   fields?: graphqlTypeObject
   operationType: 'Query' | 'Mutation'
   name: string
-  call: (fields?: Array<string | Object>, variables?: U) => Promise<T>
+  call: (fields?: Array<string | Object>, variables?: U, cache?: boolean | number) => Promise<T>
 }
 
 export interface graphqlTypeObject {

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

@@ -6,11 +6,11 @@ export declare const Datetime: () => {
     luxonDateTime: DateTimeMaybeValid;
     fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => {
         luxonDateTime: DateTimeMaybeValid;
-        fromString: any;
-        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
-        fromISO: (dateTime: string, locale?: supportedLocale) => any;
-        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
-        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        fromString: /*elided*/ any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => /*elided*/ any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => /*elided*/ any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => /*elided*/ any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => /*elided*/ any;
         toFormat: (format: string, locale?: supportedLocale) => string;
         toISO: () => string | null;
         toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
@@ -28,15 +28,15 @@ export declare const Datetime: () => {
         isFutureDate: () => boolean;
         isHappen: () => boolean;
         isHappenDate: () => boolean;
-        now: () => any;
+        now: () => /*elided*/ any;
     };
     fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => {
         luxonDateTime: DateTimeMaybeValid;
-        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
-        fromStringTime: any;
-        fromISO: (dateTime: string, locale?: supportedLocale) => any;
-        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
-        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => /*elided*/ any;
+        fromStringTime: /*elided*/ any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => /*elided*/ any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => /*elided*/ any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => /*elided*/ any;
         toFormat: (format: string, locale?: supportedLocale) => string;
         toISO: () => string | null;
         toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
@@ -54,15 +54,15 @@ export declare const Datetime: () => {
         isFutureDate: () => boolean;
         isHappen: () => boolean;
         isHappenDate: () => boolean;
-        now: () => any;
+        now: () => /*elided*/ any;
     };
     fromISO: (dateTime: string, locale?: supportedLocale) => {
         luxonDateTime: DateTimeMaybeValid;
-        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
-        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
-        fromISO: any;
-        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
-        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => /*elided*/ any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => /*elided*/ any;
+        fromISO: /*elided*/ any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => /*elided*/ any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => /*elided*/ any;
         toFormat: (format: string, locale?: supportedLocale) => string;
         toISO: () => string | null;
         toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
@@ -80,15 +80,15 @@ export declare const Datetime: () => {
         isFutureDate: () => boolean;
         isHappen: () => boolean;
         isHappenDate: () => boolean;
-        now: () => any;
+        now: () => /*elided*/ any;
     };
     fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => {
         luxonDateTime: DateTimeMaybeValid;
-        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
-        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
-        fromISO: (dateTime: string, locale?: supportedLocale) => any;
-        fromObject: any;
-        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => /*elided*/ any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => /*elided*/ any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => /*elided*/ any;
+        fromObject: /*elided*/ any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => /*elided*/ any;
         toFormat: (format: string, locale?: supportedLocale) => string;
         toISO: () => string | null;
         toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
@@ -106,15 +106,15 @@ export declare const Datetime: () => {
         isFutureDate: () => boolean;
         isHappen: () => boolean;
         isHappenDate: () => boolean;
-        now: () => any;
+        now: () => /*elided*/ any;
     };
     setDateTime: (inputDate: DateTime, locale?: supportedLocale) => {
         luxonDateTime: DateTimeMaybeValid;
-        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
-        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
-        fromISO: (dateTime: string, locale?: supportedLocale) => any;
-        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
-        setDateTime: any;
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => /*elided*/ any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => /*elided*/ any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => /*elided*/ any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => /*elided*/ any;
+        setDateTime: /*elided*/ any;
         toFormat: (format: string, locale?: supportedLocale) => string;
         toISO: () => string | null;
         toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
@@ -132,7 +132,7 @@ export declare const Datetime: () => {
         isFutureDate: () => boolean;
         isHappen: () => boolean;
         isHappenDate: () => boolean;
-        now: () => any;
+        now: () => /*elided*/ any;
     };
     toFormat: (format: string, locale?: supportedLocale) => string;
     toISO: () => string | null;
@@ -153,136 +153,11 @@ export declare const Datetime: () => {
     isHappenDate: () => boolean;
     now: () => {
         luxonDateTime: DateTimeMaybeValid;
-        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => {
-            luxonDateTime: DateTimeMaybeValid;
-            fromString: any;
-            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
-            fromISO: (dateTime: string, locale?: supportedLocale) => any;
-            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
-            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
-            toFormat: (format: string, locale?: supportedLocale) => string;
-            toISO: () => string | null;
-            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
-            toTinyDate: (locale?: supportedLocale) => string;
-            toMonthShortDate: (locale?: supportedLocale) => string;
-            toShortDate: (locale?: supportedLocale) => string;
-            toLongDate: (locale?: supportedLocale) => string;
-            toTinyDateTime: (locale?: supportedLocale) => string;
-            toShortDateTime: (locale?: supportedLocale) => string;
-            toLongDateTime: (locale?: supportedLocale) => string;
-            isAfter: (compareDate: string) => boolean;
-            isBefore: (compareDate: string) => boolean;
-            isEqual: (compareDate: string) => boolean;
-            isFuture: () => boolean;
-            isFutureDate: () => boolean;
-            isHappen: () => boolean;
-            isHappenDate: () => boolean;
-            now: () => any;
-        };
-        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => {
-            luxonDateTime: DateTimeMaybeValid;
-            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
-            fromStringTime: any;
-            fromISO: (dateTime: string, locale?: supportedLocale) => any;
-            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
-            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
-            toFormat: (format: string, locale?: supportedLocale) => string;
-            toISO: () => string | null;
-            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
-            toTinyDate: (locale?: supportedLocale) => string;
-            toMonthShortDate: (locale?: supportedLocale) => string;
-            toShortDate: (locale?: supportedLocale) => string;
-            toLongDate: (locale?: supportedLocale) => string;
-            toTinyDateTime: (locale?: supportedLocale) => string;
-            toShortDateTime: (locale?: supportedLocale) => string;
-            toLongDateTime: (locale?: supportedLocale) => string;
-            isAfter: (compareDate: string) => boolean;
-            isBefore: (compareDate: string) => boolean;
-            isEqual: (compareDate: string) => boolean;
-            isFuture: () => boolean;
-            isFutureDate: () => boolean;
-            isHappen: () => boolean;
-            isHappenDate: () => boolean;
-            now: () => any;
-        };
-        fromISO: (dateTime: string, locale?: supportedLocale) => {
-            luxonDateTime: DateTimeMaybeValid;
-            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
-            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
-            fromISO: any;
-            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
-            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
-            toFormat: (format: string, locale?: supportedLocale) => string;
-            toISO: () => string | null;
-            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
-            toTinyDate: (locale?: supportedLocale) => string;
-            toMonthShortDate: (locale?: supportedLocale) => string;
-            toShortDate: (locale?: supportedLocale) => string;
-            toLongDate: (locale?: supportedLocale) => string;
-            toTinyDateTime: (locale?: supportedLocale) => string;
-            toShortDateTime: (locale?: supportedLocale) => string;
-            toLongDateTime: (locale?: supportedLocale) => string;
-            isAfter: (compareDate: string) => boolean;
-            isBefore: (compareDate: string) => boolean;
-            isEqual: (compareDate: string) => boolean;
-            isFuture: () => boolean;
-            isFutureDate: () => boolean;
-            isHappen: () => boolean;
-            isHappenDate: () => boolean;
-            now: () => any;
-        };
-        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => {
-            luxonDateTime: DateTimeMaybeValid;
-            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
-            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
-            fromISO: (dateTime: string, locale?: supportedLocale) => any;
-            fromObject: any;
-            setDateTime: (inputDate: DateTime, locale?: supportedLocale) => any;
-            toFormat: (format: string, locale?: supportedLocale) => string;
-            toISO: () => string | null;
-            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
-            toTinyDate: (locale?: supportedLocale) => string;
-            toMonthShortDate: (locale?: supportedLocale) => string;
-            toShortDate: (locale?: supportedLocale) => string;
-            toLongDate: (locale?: supportedLocale) => string;
-            toTinyDateTime: (locale?: supportedLocale) => string;
-            toShortDateTime: (locale?: supportedLocale) => string;
-            toLongDateTime: (locale?: supportedLocale) => string;
-            isAfter: (compareDate: string) => boolean;
-            isBefore: (compareDate: string) => boolean;
-            isEqual: (compareDate: string) => boolean;
-            isFuture: () => boolean;
-            isFutureDate: () => boolean;
-            isHappen: () => boolean;
-            isHappenDate: () => boolean;
-            now: () => any;
-        };
-        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => {
-            luxonDateTime: DateTimeMaybeValid;
-            fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => any;
-            fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => any;
-            fromISO: (dateTime: string, locale?: supportedLocale) => any;
-            fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => any;
-            setDateTime: any;
-            toFormat: (format: string, locale?: supportedLocale) => string;
-            toISO: () => string | null;
-            toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
-            toTinyDate: (locale?: supportedLocale) => string;
-            toMonthShortDate: (locale?: supportedLocale) => string;
-            toShortDate: (locale?: supportedLocale) => string;
-            toLongDate: (locale?: supportedLocale) => string;
-            toTinyDateTime: (locale?: supportedLocale) => string;
-            toShortDateTime: (locale?: supportedLocale) => string;
-            toLongDateTime: (locale?: supportedLocale) => string;
-            isAfter: (compareDate: string) => boolean;
-            isBefore: (compareDate: string) => boolean;
-            isEqual: (compareDate: string) => boolean;
-            isFuture: () => boolean;
-            isFutureDate: () => boolean;
-            isHappen: () => boolean;
-            isHappenDate: () => boolean;
-            now: () => any;
-        };
+        fromString: (dateTime: string | null, formatDate?: string, locale?: supportedLocale) => /*elided*/ any;
+        fromStringTime: (time: string | null, formatTime?: string, locale?: supportedLocale) => /*elided*/ any;
+        fromISO: (dateTime: string, locale?: supportedLocale) => /*elided*/ any;
+        fromObject: (dateTime: DateObjectUnits, locale?: supportedLocale) => /*elided*/ any;
+        setDateTime: (inputDate: DateTime, locale?: supportedLocale) => /*elided*/ any;
         toFormat: (format: string, locale?: supportedLocale) => string;
         toISO: () => string | null;
         toLocaleFormat: (locale: supportedLocale, format: DateTimeFormatOptions) => string;
@@ -300,7 +175,7 @@ export declare const Datetime: () => {
         isFutureDate: () => boolean;
         isHappen: () => boolean;
         isHappenDate: () => boolean;
-        now: any;
+        now: /*elided*/ any;
     };
 };
 export declare function verifyDateFormat(date: string): string | null;

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

@@ -0,0 +1 @@
+export declare function sha256(input: string): Promise<string>;

package/dist/runtime/utils/hash.js

@@ -0,0 +1,7 @@
+export async function sha256(input) {
+  const encoder = new TextEncoder();
+  const dataBuffer = encoder.encode(input);
+  const hashBuffer = await crypto.subtle.digest("SHA-256", dataBuffer);
+  const hashArray = Array.from(new Uint8Array(hashBuffer));
+  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}

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

@@ -6,3 +6,4 @@ export declare function onlyClassAttributes<T extends Record<string, any>>(cls:
 export declare function classAttributes<T extends Record<string, any>>(cls: ClassConstructor<T>): string[];
 export declare function onlyAttributes(keys: string[], object: Record<string, any>): Record<string, any>;
 export declare function renameAttributes(object: Record<string, any>, mapper: Record<string, string>): Record<string, any>;
+export declare function stableStringify(obj: any): string;

package/dist/runtime/utils/object.js

@@ -25,3 +25,28 @@ export function renameAttributes(object, mapper) {
   });
   return returnObject;
 }
+export function stableStringify(obj) {
+  const seen = /* @__PURE__ */ new WeakSet();
+  const inner = (value) => {
+    if (value === null) return "null";
+    if (typeof value === "number") return isFinite(value) ? String(value) : "null";
+    if (typeof value === "boolean") return String(value);
+    if (typeof value === "string") return JSON.stringify(value);
+    if (typeof value === "function" || typeof value === "undefined") return "null";
+    if (Array.isArray(value)) {
+      return `[${value.map((v) => inner(v)).join(",")}]`;
+    }
+    if (typeof value === "object") {
+      if (seen.has(value)) throw new TypeError("Converting circular structure to JSON");
+      seen.add(value);
+      const keys = Object.keys(value).sort();
+      const props = keys.map((key) => {
+        const val = inner(value[key]);
+        return `"${key}":${val}`;
+      });
+      return `{${props.join(",")}}`;
+    }
+    return "null";
+  };
+  return inner(obj);
+}

package/dist/types.d.mts

@@ -1 +1,7 @@
-export { type ModuleOptions, default } from './module.js'
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module.js'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module.js'

package/dist/types.d.ts

@@ -1 +1,7 @@
-export { type ModuleOptions, default } from './module'
+import type { NuxtModule } from '@nuxt/schema'
+
+import type { default as Module } from './module'
+
+export type ModuleOptions = typeof Module extends NuxtModule<infer O> ? Partial<O> : Record<string, any>
+
+export { default } from './module'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ramathibodi/nuxt-commons",
-  "version": "0.1.45",
+  "version": "0.1.47",
   "description": "Ramathibodi Nuxt modules for common components",
   "repository": {
     "type": "git",
@@ -52,68 +52,70 @@
   },
   "dependencies": {
     "@codemirror/lang-html": "^6.4.9",
-    "@codemirror/lang-javascript": "^6.2.2",
+    "@codemirror/lang-javascript": "^6.2.3",
     "@codemirror/lang-vue": "^0.1.3",
     "@codemirror/theme-one-dark": "^6.1.2",
-    "@fortawesome/fontawesome-free": "^6.6.0",
-    "@fullcalendar/core": "^6.1.15",
-    "@fullcalendar/daygrid": "^6.1.15",
-    "@fullcalendar/interaction": "^6.1.15",
-    "@fullcalendar/list": "^6.1.15",
-    "@fullcalendar/multimonth": "^6.1.15",
-    "@fullcalendar/timegrid": "^6.1.15",
-    "@fullcalendar/vue3": "^6.1.15",
+    "@fortawesome/fontawesome-free": "^6.7.2",
+    "@fullcalendar/core": "^6.1.17",
+    "@fullcalendar/daygrid": "^6.1.17",
+    "@fullcalendar/interaction": "^6.1.17",
+    "@fullcalendar/list": "^6.1.17",
+    "@fullcalendar/multimonth": "^6.1.17",
+    "@fullcalendar/timegrid": "^6.1.17",
+    "@fullcalendar/vue3": "^6.1.17",
     "@graphql-codegen/add": "^5.0.3",
-    "@graphql-codegen/cli": "^5.0.2",
-    "@graphql-codegen/plugin-helpers": "^5.0.4",
-    "@graphql-codegen/typescript": "^4.0.9",
+    "@graphql-codegen/cli": "^5.0.5",
+    "@graphql-codegen/plugin-helpers": "^5.1.0",
+    "@graphql-codegen/typescript": "^4.1.6",
     "@mdi/font": "^7.4.47",
-    "@nuxt/kit": "^3.13.1",
+    "@nuxt/kit": "^3.16.2",
     "@nuxtjs/apollo": "5.0.0-alpha.14",
-    "@vue/apollo-composable": "^4.2.1",
+    "@vue/apollo-composable": "^4.2.2",
     "@vuepic/vue-datepicker": "^7.4.1",
-    "@vueuse/integrations": "^11.0.3",
+    "@vueuse/integrations": "^11.3.0",
     "@zxing/browser": "^0.1.5",
     "cropperjs": "^1.6.2",
     "currency.js": "^2.0.4",
     "exif-rotate-js": "^1.5.0",
-    "fuse.js": "^7.0.0",
+    "fuse.js": "^7.1.0",
     "gql-query-builder": "^3.8.0",
-    "graphql": "^16.9.0",
+    "graphql": "^16.10.0",
+    "localstorage-ttl": "^2.0.10",
     "lodash": "^4.17.21",
-    "luxon": "^3.5.0",
+    "luxon": "^3.6.1",
     "maska": "^2.1.11",
-    "p-limit": "^6.1.0",
+    "p-limit": "^6.2.0",
     "painterro": "^1.2.87",
     "pdf-vue3": "^1.0.12",
     "prettier": "3.3.2",
     "print-js": "^1.6.0",
     "uid": "^2.0.2",
-    "vue": "^3.5.3",
+    "vue": "^3.5.13",
     "vue-codemirror": "^6.1.1",
     "vue-signature-pad": "^3.0.2",
-    "vuetify": "^3.7.1",
-    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.0/xlsx-0.20.0.tgz"
+    "vuetify": "^3.8.0",
+    "xlsx": "https://cdn.sheetjs.com/xlsx-0.20.3/xlsx-0.20.3.tgz"
   },
   "devDependencies": {
-    "@nuxt/devtools": "^1.4.1",
-    "@nuxt/eslint-config": "^0.5.6",
-    "@nuxt/module-builder": "^0.8.3",
-    "@nuxt/schema": "^3.13.1",
-    "@nuxt/test-utils": "^3.14.1",
-    "@types/lodash": "^4.17.7",
-    "@types/luxon": "^3.4.2",
-    "@types/node": "^18.19.50",
+    "@nuxt/devtools": "^1.7.0",
+    "@nuxt/eslint-config": "^0.5.7",
+    "@nuxt/module-builder": "^0.8.4",
+    "@nuxt/schema": "^3.16.2",
+    "@nuxt/test-utils": "^3.17.2",
+    "@types/crypto-js": "^4.2.2",
+    "@types/lodash": "^4.17.16",
+    "@types/luxon": "^3.6.2",
+    "@types/node": "^18.19.86",
     "@vueuse/core": "^10.11.1",
     "@vueuse/nuxt": "^10.11.1",
-    "changelogen": "^0.5.5",
-    "eslint": "^9.10.0",
-    "nuxt": "^3.13.1",
+    "changelogen": "^0.5.7",
+    "eslint": "^9.23.0",
+    "nuxt": "^3.16.2",
     "nuxt-lodash": "^2.5.3",
-    "sass": "^1.78.0",
-    "typescript": "^5.5.4",
-    "vitest": "^1.6.0",
-    "vue-tsc": "2.0.29"
+    "sass": "^1.86.3",
+    "typescript": "^5.8.2",
+    "vitest": "^1.6.1",
+    "vue-tsc": "^2.2.10"
   },
   "packageManager": "pnpm@9.15.9+sha512.68046141893c66fad01c079231128e9afb89ef87e2691d69e4d40eee228988295fd4682181bae55b58418c3a253bde65a505ec7c5f9403ece5cc3cd37dcf2531"
 }

package/templates/.codegen/plugin-schema-object.js

@@ -105,7 +105,7 @@ module.exports = {
         
         export const scalarType = ${JSON.stringify(scalarType)}
         
-        function operationCall${'<' + 'T,U>'}(operationType:string, operation: string,fields?: ${'Array' + '<string | Object>'},variables?: U,cache: boolean = false) {
+        function operationCall${'<' + 'T,U>'}(operationType:string, operation: string,fields?: ${'Array' + '<string | Object>'},variables?: U,cache: boolean | number = false) {
             return useGraphQlOperation${'<' + 'T>'}(operationType,operation,fields,variables as {[p: string] : any} | undefined,cache)
         }
         
@@ -121,7 +121,7 @@ module.exports = {
                   return operationCall(operationType,name, fields, variables);
               }
             } else {
-              returnGraphqlOperation['call'] = async function(fields?: ${'Array' + '<string | Object>'}, variables?: U,cache: boolean = false): Promise${'<' + 'T>'} {
+              returnGraphqlOperation['call'] = async function(fields?: ${'Array' + '<string | Object>'}, variables?: U,cache: boolean | number = false): Promise${'<' + 'T>'} {
                   return operationCall(operationType,name, fields, variables,cache);
               }
             }