tantee-nuxt-commons 0.0.174 → 0.0.175

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

@@ -0,0 +1,272 @@
+import type { IdCardWsClientMessage, IdCardWsEvent } from './hostAgent.js';
+export declare function useHostAgentWs(): {
+    ws: import("vue").ShallowRef<WebSocket | null, WebSocket | null>;
+    wsConnected: import("vue").ComputedRef<boolean>;
+    wsSubscribed: import("vue").ComputedRef<boolean>;
+    wsReader: import("vue").ComputedRef<string | null>;
+    wsWithPhoto: import("vue").ComputedRef<boolean>;
+    wsLastMessage: import("vue").ComputedRef<{
+        type: "monitor.subscribed";
+        ok: boolean;
+        reader?: string | null | undefined;
+        withPhoto?: boolean | undefined;
+    } | {
+        type: "monitor.started";
+        reader?: string | null | undefined;
+    } | {
+        type: "monitor.switchAck";
+        ok: boolean;
+        reader?: string | null | undefined;
+    } | {
+        type: "monitor.switched";
+        reader?: string | null | undefined;
+    } | {
+        type: "monitor.unsubscribed";
+        ok: boolean;
+    } | {
+        type: "pong";
+        ts?: string | undefined;
+    } | {
+        type: "card.inserted";
+        payload: {
+            patient: {
+                citizenId?: string | null | undefined;
+                citizenIdVerified: boolean;
+                dob?: string | null | undefined;
+                dobPrecision?: "yearMonthDay" | "yearMonth" | "year" | string | undefined;
+                gender?: string | null | undefined;
+                meta?: import("~/.nuxt/imports").JsonMeta | null;
+            };
+            patientNames?: {
+                nameType: string;
+                prefix?: string | null | undefined;
+                firstName: string;
+                middleName?: string | null | undefined;
+                lastName?: string | null | undefined;
+                suffix?: string | null | undefined;
+            }[] | null | undefined;
+            patientAddresses?: {
+                mrn?: string | null | undefined;
+                addressType: string;
+                text: string;
+                place?: string | null | undefined;
+                villageNo?: string | null | undefined;
+                alleyWay?: string | null | undefined;
+                alley?: string | null | undefined;
+                street?: string | null | undefined;
+                subDistrictCode?: string | null | undefined;
+                districtCode?: string | null | undefined;
+                provinceCode?: string | null | undefined;
+            }[] | null | undefined;
+            patientPhotos?: {
+                photoSource?: string | null | undefined;
+                base64String: string;
+            }[] | null | undefined;
+        };
+    } | {
+        type: "card.removed";
+    } | {
+        type: "card.error";
+        message?: string | undefined;
+    } | {
+        type: "error";
+        code?: string | undefined;
+        message?: string | undefined;
+    } | {
+        [x: string]: any;
+        type: string;
+    } | null>;
+    wsLastRaw: import("vue").ComputedRef<{
+        readonly data: any;
+        readonly lastEventId: string;
+        readonly origin: string;
+        readonly ports: readonly {
+            close: {
+                (): void;
+                (): void;
+            };
+            postMessage: {
+                (message: any, transfer: Transferable[]): void;
+                (message: any, options?: StructuredSerializeOptions): void;
+                (message: any, transfer: Transferable[]): void;
+                (message: any, options?: StructuredSerializeOptions): void;
+            };
+            start: {
+                (): void;
+                (): void;
+            };
+            addEventListener: {
+                <K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                <K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                <K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: {
+                (event: Event): boolean;
+                (event: Event): boolean;
+            };
+            onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
+            onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
+        }[];
+        readonly source: Window | {
+            close: {
+                (): void;
+                (): void;
+            };
+            postMessage: {
+                (message: any, transfer: Transferable[]): void;
+                (message: any, options?: StructuredSerializeOptions): void;
+                (message: any, transfer: Transferable[]): void;
+                (message: any, options?: StructuredSerializeOptions): void;
+            };
+            start: {
+                (): void;
+                (): void;
+            };
+            addEventListener: {
+                <K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                <K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                <K extends keyof MessagePortEventMap>(type: K, listener: (this: MessagePort, ev: MessagePortEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: {
+                (event: Event): boolean;
+                (event: Event): boolean;
+            };
+            onmessage: ((this: MessagePort, ev: MessageEvent) => any) | null;
+            onmessageerror: ((this: MessagePort, ev: MessageEvent) => any) | null;
+        } | {
+            onstatechange: ((this: ServiceWorker, ev: Event) => any) | null;
+            readonly scriptURL: string;
+            readonly state: ServiceWorkerState;
+            postMessage: {
+                (message: any, transfer: Transferable[]): void;
+                (message: any, options?: StructuredSerializeOptions): void;
+                (message: any, transfer: Transferable[]): void;
+                (message: any, options?: StructuredSerializeOptions): void;
+            };
+            addEventListener: {
+                <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+                <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+            };
+            removeEventListener: {
+                <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+                <K extends keyof ServiceWorkerEventMap>(type: K, listener: (this: ServiceWorker, ev: ServiceWorkerEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+                (type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+            };
+            dispatchEvent: {
+                (event: Event): boolean;
+                (event: Event): boolean;
+            };
+            onerror: ((this: AbstractWorker, ev: ErrorEvent) => any) | null;
+        } | null;
+        initMessageEvent: {
+            (type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: MessagePort[]): void;
+            (type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: Iterable<MessagePort>): void;
+            (type: string, bubbles?: boolean, cancelable?: boolean, data?: any, origin?: string, lastEventId?: string, source?: MessageEventSource | null, ports?: MessagePort[]): void;
+        };
+        readonly bubbles: boolean;
+        cancelBubble: boolean;
+        readonly cancelable: boolean;
+        readonly composed: boolean;
+        readonly currentTarget: {
+            addEventListener: {
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+            };
+            dispatchEvent: {
+                (event: Event): boolean;
+                (event: Event): boolean;
+            };
+            removeEventListener: {
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+            };
+        } | null;
+        readonly defaultPrevented: boolean;
+        readonly eventPhase: number;
+        readonly isTrusted: boolean;
+        returnValue: boolean;
+        readonly srcElement: {
+            addEventListener: {
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+            };
+            dispatchEvent: {
+                (event: Event): boolean;
+                (event: Event): boolean;
+            };
+            removeEventListener: {
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+            };
+        } | null;
+        readonly target: {
+            addEventListener: {
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: AddEventListenerOptions | boolean): void;
+            };
+            dispatchEvent: {
+                (event: Event): boolean;
+                (event: Event): boolean;
+            };
+            removeEventListener: {
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+                (type: string, callback: EventListenerOrEventListenerObject | null, options?: EventListenerOptions | boolean): void;
+            };
+        } | null;
+        readonly timeStamp: DOMHighResTimeStamp;
+        readonly type: string;
+        composedPath: {
+            (): EventTarget[];
+            (): EventTarget[];
+        };
+        initEvent: {
+            (type: string, bubbles?: boolean, cancelable?: boolean): void;
+            (type: string, bubbles?: boolean, cancelable?: boolean): void;
+        };
+        preventDefault: {
+            (): void;
+            (): void;
+        };
+        stopImmediatePropagation: {
+            (): void;
+            (): void;
+        };
+        stopPropagation: {
+            (): void;
+            (): void;
+        };
+        readonly NONE: 0;
+        readonly CAPTURING_PHASE: 1;
+        readonly AT_TARGET: 2;
+        readonly BUBBLING_PHASE: 3;
+    } | null>;
+    wsLastError: import("vue").ComputedRef<any>;
+    connectIdCardWs: () => WebSocket;
+    disconnectIdCardWs: (code?: number, reason?: string) => void;
+    sendIdCardWs: (message: IdCardWsClientMessage) => void;
+    subscribeIdCardWs: (params?: {
+        reader?: string | null;
+        withPhoto?: boolean;
+    }) => void;
+    pingIdCardWs: () => void;
+    switchReaderIdCardWs: (reader?: string | null) => void;
+    unsubscribeIdCardWs: () => void;
+    onIdCardWsEvent: (cb: (ev: IdCardWsEvent) => void) => () => boolean;
+};

package/dist/runtime/composables/hostAgentWs.js

@@ -0,0 +1,145 @@
+import { computed, ref, shallowRef, onScopeDispose, getCurrentScope } from "vue";
+import { useApi } from "./api.js";
+function toWsUrl(httpUrl) {
+  if (httpUrl.startsWith("https://")) return "wss://" + httpUrl.slice("https://".length);
+  if (httpUrl.startsWith("http://")) return "ws://" + httpUrl.slice("http://".length);
+  return httpUrl;
+}
+export function useHostAgentWs() {
+  const api = useApi();
+  const base = ["agent"];
+  const ws = shallowRef(null);
+  const wsConnected = ref(false);
+  const wsSubscribed = ref(false);
+  const wsReader = ref(null);
+  const wsWithPhoto = ref(false);
+  const wsLastMessage = ref(null);
+  const wsLastRaw = ref(null);
+  const wsLastError = ref(null);
+  const subscribers = /* @__PURE__ */ new Set();
+  const emit = (ev) => {
+    for (const cb of subscribers) cb(ev);
+  };
+  function disconnectIdCardWs(code, reason) {
+    if (ws.value) {
+      try {
+        ws.value.close(code, reason);
+      } catch {
+      }
+    }
+    ws.value = null;
+    wsConnected.value = false;
+    wsSubscribed.value = false;
+  }
+  function connectIdCardWs() {
+    disconnectIdCardWs();
+    const httpUrl = api.urlBuilder([...base, "idcard/ws"]);
+    const socket = new WebSocket(toWsUrl(httpUrl));
+    ws.value = socket;
+    wsConnected.value = false;
+    wsSubscribed.value = false;
+    wsLastMessage.value = null;
+    wsLastRaw.value = null;
+    wsLastError.value = null;
+    socket.onopen = () => {
+      wsConnected.value = true;
+      emit({ type: "open" });
+    };
+    socket.onclose = (e) => {
+      wsConnected.value = false;
+      wsSubscribed.value = false;
+      emit({ type: "close", code: e.code, reason: e.reason });
+    };
+    socket.onerror = (e) => {
+      wsLastError.value = e;
+      emit({ type: "error", error: e });
+    };
+    socket.onmessage = (e) => {
+      wsLastRaw.value = e;
+      let msg;
+      if (typeof e.data === "string") {
+        try {
+          msg = JSON.parse(e.data);
+        } catch {
+          msg = { type: "error", message: "invalid json from server", raw: e.data };
+        }
+      } else {
+        msg = { type: "error", message: "non-text ws message", raw: e.data };
+      }
+      wsLastMessage.value = msg;
+      switch (msg.type) {
+        case "monitor.subscribed":
+          wsSubscribed.value = !!msg.ok;
+          wsReader.value = msg.reader ?? null;
+          wsWithPhoto.value = !!msg.withPhoto;
+          break;
+        case "monitor.started":
+          wsReader.value = msg.reader ?? null;
+          break;
+        case "monitor.switchAck":
+          if (msg.ok) wsReader.value = msg.reader ?? null;
+          break;
+        case "monitor.switched":
+          wsReader.value = msg.reader ?? null;
+          break;
+        case "monitor.unsubscribed":
+          wsSubscribed.value = false;
+          break;
+      }
+      emit({ type: "message", data: msg, raw: e });
+    };
+    return socket;
+  }
+  function sendIdCardWs(message) {
+    if (!ws.value || ws.value.readyState !== WebSocket.OPEN) {
+      throw new Error("IDCard WS is not connected");
+    }
+    ws.value.send(JSON.stringify(message));
+  }
+  function subscribeIdCardWs(params) {
+    const reader = params?.reader ?? null;
+    const withPhoto = !!params?.withPhoto;
+    wsReader.value = reader;
+    wsWithPhoto.value = withPhoto;
+    sendIdCardWs({ action: "subscribe", reader, withPhoto });
+  }
+  function pingIdCardWs() {
+    sendIdCardWs({ action: "ping" });
+  }
+  function switchReaderIdCardWs(reader) {
+    sendIdCardWs({ action: "switchReader", reader: reader ?? null });
+  }
+  function unsubscribeIdCardWs() {
+    sendIdCardWs({ action: "unsubscribe" });
+  }
+  function onIdCardWsEvent(cb) {
+    subscribers.add(cb);
+    return () => subscribers.delete(cb);
+  }
+  if (getCurrentScope()) {
+    onScopeDispose(() => {
+      disconnectIdCardWs();
+      subscribers.clear();
+    });
+  }
+  return {
+    // WS state
+    ws,
+    wsConnected: computed(() => wsConnected.value),
+    wsSubscribed: computed(() => wsSubscribed.value),
+    wsReader: computed(() => wsReader.value),
+    wsWithPhoto: computed(() => wsWithPhoto.value),
+    wsLastMessage: computed(() => wsLastMessage.value),
+    wsLastRaw: computed(() => wsLastRaw.value),
+    wsLastError: computed(() => wsLastError.value),
+    // WS controls
+    connectIdCardWs,
+    disconnectIdCardWs,
+    sendIdCardWs,
+    subscribeIdCardWs,
+    pingIdCardWs,
+    switchReaderIdCardWs,
+    unsubscribeIdCardWs,
+    onIdCardWsEvent
+  };
+}

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

@@ -0,0 +1,38 @@
+import { type Ref } from 'vue';
+export interface PersistSlimProps {
+    /** enable persistence */
+    persist?: boolean;
+    /** key name in localStorage (required when persist=true) */
+    persistKey?: string;
+    /** optional prefix namespace */
+    persistPrefix?: string;
+    /** write debounce in ms */
+    persistDebounce?: number;
+    /** remove key when model is empty */
+    persistClearOnEmpty?: boolean;
+    /** TTL in seconds (optional) */
+    persistTtl?: number;
+    /** slim encryption (optional) */
+    persistEncrypt?: boolean;
+    /**
+     * slim secret (required if persistEncrypt=true)
+     * (you can also set it globally via ls.config)
+     */
+    persistSecret?: string;
+    /** if true, hydrate even when model already has value */
+    persistAlwaysHydrate?: boolean;
+}
+export declare function useLocalStorageModel<T>(model: Ref<T>, props: PersistSlimProps, options?: {
+    /** map model -> stored payload */
+    serializer?: (v: T) => any;
+    /** map stored payload -> model */
+    deserializer?: (raw: any) => T;
+    /** custom empty checker */
+    isEmpty?: (v: T) => boolean;
+}): {
+    isHydrated: Ref<boolean, boolean>;
+    storageKey: import("vue").ComputedRef<string>;
+    remove: () => void;
+    read: () => unknown;
+    write: (val: T) => void;
+};

package/dist/runtime/composables/localStorageModel.js

@@ -0,0 +1,88 @@
+import { computed, onMounted, ref, watch } from "vue";
+import { useDebounceFn } from "@vueuse/core";
+import ls from "localstorage-slim";
+function isEmptyValue(v) {
+  if (v == null) return true;
+  if (Array.isArray(v)) return v.length === 0;
+  return false;
+}
+export function useLocalStorageModel(model, props, options) {
+  const isHydrated = ref(false);
+  const storageKey = computed(() => {
+    if (!props.persist) return "";
+    const key = props.persistKey?.trim();
+    if (!key) return "";
+    const prefix = (props.persistPrefix ?? "").trim();
+    return prefix ? `${prefix}:${key}` : key;
+  });
+  const isEmpty = options?.isEmpty ?? isEmptyValue;
+  const serializer = options?.serializer ?? ((v) => v);
+  const deserializer = options?.deserializer ?? ((raw) => raw);
+  function read() {
+    if (!storageKey.value) return void 0;
+    try {
+      return ls.get(storageKey.value, {
+        decrypt: !!props.persistEncrypt,
+        secret: props.persistSecret
+      });
+    } catch {
+      return void 0;
+    }
+  }
+  function write(val) {
+    if (!storageKey.value) return;
+    try {
+      ls.set(storageKey.value, serializer(val), {
+        ttl: props.persistTtl,
+        // seconds
+        encrypt: !!props.persistEncrypt,
+        secret: props.persistSecret
+      });
+    } catch {
+    }
+  }
+  function remove() {
+    if (!storageKey.value) return;
+    try {
+      ls.remove(storageKey.value);
+    } catch {
+    }
+  }
+  onMounted(() => {
+    if (!props.persist) {
+      isHydrated.value = true;
+      return;
+    }
+    const stored = read();
+    const shouldHydrate = props.persistAlwaysHydrate || isEmpty(model.value);
+    if (stored !== void 0 && shouldHydrate) {
+      try {
+        model.value = deserializer(stored);
+      } catch {
+      }
+    }
+    isHydrated.value = true;
+  });
+  const persistNow = () => {
+    if (!props.persist || !storageKey.value) return;
+    const clearOnEmpty = props.persistClearOnEmpty ?? true;
+    const val = model.value;
+    if (clearOnEmpty && isEmpty(val)) remove();
+    else write(val);
+  };
+  const persistDebounced = useDebounceFn(persistNow, () => props.persistDebounce ?? 200);
+  watch(
+    model,
+    () => {
+      persistDebounced();
+    },
+    { deep: true }
+  );
+  return {
+    isHydrated,
+    storageKey,
+    remove,
+    read,
+    write
+  };
+}

package/dist/runtime/plugins/clientConfig.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/clientConfig.js

@@ -0,0 +1,22 @@
+import { createClientConfigService } from "../composables/clientConfig.js";
+import { defineNuxtPlugin } from "nuxt/app";
+import { ref } from "vue";
+export default defineNuxtPlugin(async (nuxtApp) => {
+  const clientConfigService = createClientConfigService({
+    storageKey: "client_config"
+  });
+  const clientConfig = ref(clientConfigService.get() ?? {});
+  nuxtApp.provide("clientConfig", clientConfig);
+  nuxtApp.provide("clientConfigRefresh", async () => {
+    const loaded = await clientConfigService.load();
+    clientConfig.value = loaded ?? {};
+    return clientConfig.value;
+  });
+  try {
+    const loaded = await clientConfigService.load();
+    clientConfig.value = loaded ?? {};
+  } catch (e) {
+    console.warn("[client-config] init load failed:", e?.message || e);
+    clientConfig.value = clientConfigService.get() ?? {};
+  }
+});

package/dist/runtime/plugins/default.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("#app").Plugin<Record<string, unknown>> & import("#app").ObjectPlugin<Record<string, unknown>>;
+export default _default;

package/dist/runtime/plugins/default.js

@@ -0,0 +1,50 @@
+import { defineNuxtPlugin } from "nuxt/app";
+export default defineNuxtPlugin((nuxtApp) => {
+  nuxtApp.vueApp.directive("default", {
+    beforeMount(el, binding) {
+      const def = binding.value;
+      if (def === void 0 || def === null || def === "") return;
+      const apply = (value) => {
+        if ("value" in el) {
+          ;
+          el.value = value;
+        }
+        el.dispatchEvent(new Event("input", { bubbles: true }));
+        el.dispatchEvent(new Event("change", { bubbles: true }));
+      };
+      apply(def);
+      const inner = el.querySelector?.("input, textarea, select");
+      if (inner) {
+        const onMountedSync = () => {
+          const cur = inner.value;
+          if (cur === "" || cur == null) {
+            inner.value = String(def);
+            inner.dispatchEvent(new Event("input", { bubbles: true }));
+            inner.dispatchEvent(new Event("change", { bubbles: true }));
+          }
+        };
+        queueMicrotask(onMountedSync);
+        el.__vDefaultCleanup = () => {
+        };
+      }
+    },
+    // If the default value changes later, you can decide whether to re-apply.
+    // This version only applies when the current DOM value is empty.
+    updated(el, binding) {
+      const def = binding.value;
+      if (def === void 0 || def === null || def === "") return;
+      const target = "value" in el ? el : el.querySelector?.("input, textarea, select");
+      if (!target) return;
+      const cur = target.value;
+      if (cur === "" || cur === void 0 || cur === null) {
+        target.value = def;
+        target.dispatchEvent(new Event("input", { bubbles: true }));
+        target.dispatchEvent(new Event("change", { bubbles: true }));
+      }
+    },
+    unmounted(el) {
+      el.__vDefaultCleanup?.();
+      delete el.__vDefaultCleanup;
+    }
+  });
+});

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

@@ -0,0 +1,13 @@
+import type { ClientConfig,ClientConfigService } from "../composables/clientConfig";
+
+declare module "#app" {
+    interface NuxtApp {
+        $clientConfig: ClientConfig;
+        $clientConfigService: ClientConfigService;
+    }
+
+    interface RuntimeNuxtApp {
+        $clientConfig: ClientConfig;
+        $clientConfigService: ClientConfigService;
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tantee-nuxt-commons",
-  "version": "0.0.174",
+  "version": "0.0.175",
   "description": "Ramathibodi Nuxt modules for common components",
   "repository": {
     "type": "git",
@@ -70,6 +70,7 @@
     "@mdi/font": "^7.4.47",
     "@nuxt/kit": "^3.16.2",
     "@nuxtjs/apollo": "5.0.0-alpha.14",
+    "@thumbmarkjs/thumbmarkjs": "^1.6.1",
     "@vue/apollo-composable": "^4.2.2",
     "@vuepic/vue-datepicker": "^7.4.1",
     "@vueuse/integrations": "^11.3.0",
@@ -80,7 +81,7 @@
     "fuse.js": "^7.1.0",
     "gql-query-builder": "^3.8.0",
     "graphql": "^16.10.0",
-    "localstorage-ttl": "^2.0.10",
+    "localstorage-slim": "^2.7.1",
     "lodash": "^4.17.21",
     "luxon": "^3.6.1",
     "maska": "^2.1.11",