@ramathibodi/nuxt-commons 0.1.74 → 4.0.0

package/dist/runtime/components/device/IdCardButton.vue

@@ -1,69 +1,32 @@
-<script setup lang="ts">
-/**
- * DeviceIdCardButton bridges UI actions with host-agent hardware/device operations and emits runtime scan/read results.
- * This doc block is consumed by vue-docgen for generated API documentation.
- */
-import { computed, ref, useAttrs } from 'vue'
-import { VBtn } from 'vuetify/components/VBtn'
-import { useAlert } from '../../composables/alert'
-import { useHostAgent, type PatientRegisterPayload } from '../../composables/hostAgent'
-
-interface Props extends /* @vue-ignore */ InstanceType<typeof VBtn['$props']> {
-  /** If true -> call /idcard/infoAndPhoto, else /idcard/info */
-  withPhoto?: boolean // Includes portrait/photo data in ID card read results.
-  /** Optional reader name/query string */
-  reader?: string | null // Preferred hardware reader identifier to connect or switch to.
-  /** Auto-disable button while reading */
-  disableWhileLoading?: boolean // Disables the trigger button while a read operation is in progress.
-}
-
-/**
- * Public props accepted by DeviceIdCardButton.
- * Document each prop field with intent, defaults, and side effects for clear generated docs.
- */
-const props = withDefaults(defineProps<Props>(), {
-  withPhoto: false,
-  reader: null,
-  disableWhileLoading: true,
-})
-
-/**
- * Custom events emitted by DeviceIdCardButton.
- * Parents can listen to these events to react to user actions and internal state changes.
- */
-const emit = defineEmits<{
-  (e: 'read', payload: PatientRegisterPayload): void
-  (e: 'error', err: unknown): void
-  (e: 'loading', loading: boolean): void
-}>()
-
-const attrs = useAttrs()
-const host = useHostAgent()
-
-const loading = ref(false)
-const disabled = computed(() => (props.disableWhileLoading ? loading.value : false))
-
-async function onClick(ev: MouseEvent) {
-  // allow parent to prevent if they attach their own click handler and call preventDefault
-  if (ev.defaultPrevented) return
-
+<script setup>
+import { computed, ref, useAttrs } from "vue";
+import { VBtn } from "vuetify/components/VBtn";
+import { useAlert } from "../../composables/alert";
+import { useHostAgent } from "../../composables/hostAgent";
+const props = defineProps({
+  withPhoto: { type: Boolean, required: false, default: false },
+  reader: { type: [String, null], required: false, default: null },
+  disableWhileLoading: { type: Boolean, required: false, default: true }
+});
+const emit = defineEmits(["read", "error", "loading"]);
+const attrs = useAttrs();
+const host = useHostAgent();
+const loading = ref(false);
+const disabled = computed(() => props.disableWhileLoading ? loading.value : false);
+async function onClick(ev) {
+  if (ev.defaultPrevented) return;
   try {
-    loading.value = true
-    emit('loading', true)
-
-    const payload = props.withPhoto
-        ? await host.getIdCardInfoAndPhoto(props.reader ?? undefined)
-        : await host.getIdCardInfo(props.reader ?? undefined)
-
-    emit('read', payload)
-  } catch (e: any) {
-    emit('error', e)
-
-    const msg = e?.data?.detail || e?.data?.title || e?.message || 'ID card read failed'
-    useAlert()?.addAlert({ message: msg, alertType: 'error' })
+    loading.value = true;
+    emit("loading", true);
+    const payload = props.withPhoto ? await host.getIdCardInfoAndPhoto(props.reader ?? void 0) : await host.getIdCardInfo(props.reader ?? void 0);
+    emit("read", payload);
+  } catch (e) {
+    emit("error", e);
+    const msg = e?.data?.detail || e?.data?.title || e?.message || "ID card read failed";
+    useAlert()?.addAlert({ message: msg, alertType: "error" });
   } finally {
-    loading.value = false
-    emit('loading', false)
+    loading.value = false;
+    emit("loading", false);
   }
 }
 </script>
@@ -78,17 +41,17 @@ async function onClick(ev: MouseEvent) {
       v-bind="attrs"
       class="idcard-btn"
       :loading="loading"
-      :disabled="disabled || (attrs as any).disabled"
+      :disabled="disabled || attrs.disabled"
       @click="onClick"
   >
     <template
-        v-for="(_, name, index) in ($slots as {})"
+        v-for="(_, name, index) in $slots"
         :key="index"
         #[name]="slotData"
     >
       <slot
           :name="name"
-          v-bind="((slotData || {}) as object)"
+          v-bind="slotData || {}"
       />
     </template>
   </v-btn>

package/dist/runtime/components/device/IdCardButton.vue.d.ts

@@ -0,0 +1,57 @@
+import { VBtn } from 'vuetify/components/VBtn';
+import { type PatientRegisterPayload } from '../../composables/hostAgent.js';
+interface Props extends /* @vue-ignore */ InstanceType<typeof VBtn['$props']> {
+    /** If true -> call /idcard/infoAndPhoto, else /idcard/info */
+    withPhoto?: boolean;
+    /** Optional reader name/query string */
+    reader?: string | null;
+    /** Auto-disable button while reading */
+    disableWhileLoading?: boolean;
+}
+declare var __VLS_12: never, __VLS_13: {};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_12>]?: (props: typeof __VLS_13) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    withPhoto: boolean;
+    reader: null;
+    disableWhileLoading: boolean;
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    error: (err: unknown) => any;
+    loading: (loading: boolean) => any;
+    read: (payload: PatientRegisterPayload) => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<Props>, {
+    withPhoto: boolean;
+    reader: null;
+    disableWhileLoading: boolean;
+}>>> & Readonly<{
+    onError?: ((err: unknown) => any) | undefined;
+    onLoading?: ((loading: boolean) => any) | undefined;
+    onRead?: ((payload: PatientRegisterPayload) => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/runtime/components/device/IdCardWebSocket.d.vue.ts

@@ -0,0 +1,55 @@
+import { type IdCardWsServerMessage, type PatientRegisterPayload } from '../../composables/hostAgent.js';
+interface Props {
+    /** Subscribe withPhoto=true => server will push payload that includes photo when available */
+    withPhoto?: boolean;
+    /** Optional reader name; null/undefined means "any/default" */
+    reader?: string | null;
+    /** Auto-connect on mount (default true) */
+    autoConnect?: boolean;
+    /** Auto-subscribe after connect (default true) */
+    autoSubscribe?: boolean;
+    /** If true, try to reconnect when socket closes unexpectedly */
+    autoReconnect?: boolean;
+    /** Reconnect delay in ms */
+    reconnectDelayMs?: number;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    message: (msg: IdCardWsServerMessage) => any;
+    error: (err: unknown) => any;
+    connected: () => any;
+    disconnected: (info?: {
+        code?: number;
+        reason?: string;
+    } | undefined) => any;
+    subscribed: (info?: {
+        reader?: string | null;
+        withPhoto?: boolean;
+    } | undefined) => any;
+    unsubscribed: () => any;
+    inserted: (payload: PatientRegisterPayload) => any;
+    removed: () => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onMessage?: ((msg: IdCardWsServerMessage) => any) | undefined;
+    onError?: ((err: unknown) => any) | undefined;
+    onConnected?: (() => any) | undefined;
+    onDisconnected?: ((info?: {
+        code?: number;
+        reason?: string;
+    } | undefined) => any) | undefined;
+    onSubscribed?: ((info?: {
+        reader?: string | null;
+        withPhoto?: boolean;
+    } | undefined) => any) | undefined;
+    onUnsubscribed?: (() => any) | undefined;
+    onInserted?: ((payload: PatientRegisterPayload) => any) | undefined;
+    onRemoved?: (() => any) | undefined;
+}>, {
+    reader: string | null;
+    withPhoto: boolean;
+    autoConnect: boolean;
+    autoSubscribe: boolean;
+    autoReconnect: boolean;
+    reconnectDelayMs: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/device/IdCardWebSocket.vue

@@ -1,205 +1,144 @@
-<script setup lang="ts">
-/**
- * DeviceIdCardWebSocket bridges UI actions with host-agent hardware/device operations and emits runtime scan/read results.
- * This doc block is consumed by vue-docgen for generated API documentation.
- */
-import { onBeforeUnmount, onMounted, ref, watch } from 'vue'
-import { type IdCardWsServerMessage, type PatientRegisterPayload } from '../../composables/hostAgent'
+<script setup>
+import { onBeforeUnmount, onMounted, ref, watch } from "vue";
+import {} from "../../composables/hostAgent";
 import { useHostAgentWs } from "../../composables/hostAgentWs";
-
-interface Props {
-  /** Subscribe withPhoto=true => server will push payload that includes photo when available */
-  withPhoto?: boolean // Includes portrait/photo data in ID card read results.
-  /** Optional reader name; null/undefined means "any/default" */
-  reader?: string | null // Preferred hardware reader identifier to connect or switch to.
-  /** Auto-connect on mount (default true) */
-  autoConnect?: boolean // Connects to the device WebSocket automatically on mount.
-  /** Auto-subscribe after connect (default true) */
-  autoSubscribe?: boolean // Subscribes to live reader events automatically after connect.
-  /** If true, try to reconnect when socket closes unexpectedly */
-  autoReconnect?: boolean // Retries connection automatically when the socket closes unexpectedly.
-  /** Reconnect delay in ms */
-  reconnectDelayMs?: number // Delay in milliseconds before each reconnect attempt.
-}
-
-/**
- * Public props accepted by DeviceIdCardWebSocket.
- * Document each prop field with intent, defaults, and side effects for clear generated docs.
- */
-const props = withDefaults(defineProps<Props>(), {
-  withPhoto: false,
-  reader: null,
-  autoConnect: true,
-  autoSubscribe: true,
-  autoReconnect: false,
-  reconnectDelayMs: 1000,
-})
-
-/**
- * Custom events emitted by DeviceIdCardWebSocket.
- * Parents can listen to these events to react to user actions and internal state changes.
- */
-const emit = defineEmits<{
-  (e: 'connected'): void
-  (e: 'disconnected', info?: { code?: number; reason?: string }): void
-  (e: 'subscribed', info?: { reader?: string | null; withPhoto?: boolean }): void
-  (e: 'unsubscribed'): void
-  (e: 'inserted', payload: PatientRegisterPayload): void
-  (e: 'removed'): void
-  (e: 'error', err: unknown): void
-  (e: 'message', msg: IdCardWsServerMessage): void
-}>()
-
-const host = useHostAgentWs()
-
-const reconnectTimer = ref<ReturnType<typeof setTimeout> | null>(null)
-const mounted = ref(false)
-const manuallyDisconnected = ref(false)
-
+const props = defineProps({
+  withPhoto: { type: Boolean, required: false, default: false },
+  reader: { type: [String, null], required: false, default: null },
+  autoConnect: { type: Boolean, required: false, default: true },
+  autoSubscribe: { type: Boolean, required: false, default: true },
+  autoReconnect: { type: Boolean, required: false, default: false },
+  reconnectDelayMs: { type: Number, required: false, default: 1e3 }
+});
+const emit = defineEmits(["connected", "disconnected", "subscribed", "unsubscribed", "inserted", "removed", "error", "message"]);
+const host = useHostAgentWs();
+const reconnectTimer = ref(null);
+const mounted = ref(false);
+const manuallyDisconnected = ref(false);
 function clearReconnect() {
   if (reconnectTimer.value) {
-    clearTimeout(reconnectTimer.value)
-    reconnectTimer.value = null
+    clearTimeout(reconnectTimer.value);
+    reconnectTimer.value = null;
   }
 }
-
 function connectAndSubscribe() {
-  manuallyDisconnected.value = false
-  host.connectIdCardWs()
-
-  // subscribe immediately; safe because connectIdCardWs sets handlers then WS opens soon
-  // but we must wait until OPEN to send; so we subscribe on "open" event in handler below.
+  manuallyDisconnected.value = false;
+  host.connectIdCardWs();
 }
-
 function safeDisconnect() {
-  manuallyDisconnected.value = true
-  clearReconnect()
+  manuallyDisconnected.value = true;
+  clearReconnect();
   try {
-    // best-effort unsubscribe (only if connected)
     if (host.wsConnected.value) {
-      try { host.unsubscribeIdCardWs() } catch { /* ignore */ }
+      try {
+        host.unsubscribeIdCardWs();
+      } catch {
+      }
     }
-  } catch { /* ignore */ }
-  host.disconnectIdCardWs()
+  } catch {
+  }
+  host.disconnectIdCardWs();
 }
-
 const off = host.onIdCardWsEvent((ev) => {
-  if (ev.type === 'open') {
-    emit('connected')
-
+  if (ev.type === "open") {
+    emit("connected");
     if (props.autoSubscribe) {
       try {
-        host.subscribeIdCardWs({ reader: props.reader ?? null, withPhoto: props.withPhoto })
+        host.subscribeIdCardWs({ reader: props.reader ?? null, withPhoto: props.withPhoto });
       } catch (e) {
-        emit('error', e)
+        emit("error", e);
       }
     }
-    return
+    return;
   }
-
-  if (ev.type === 'close') {
-    emit('disconnected', { code: ev.code, reason: ev.reason })
-
+  if (ev.type === "close") {
+    emit("disconnected", { code: ev.code, reason: ev.reason });
     if (props.autoReconnect && mounted.value && !manuallyDisconnected.value) {
-      clearReconnect()
+      clearReconnect();
       reconnectTimer.value = setTimeout(() => {
         try {
-          connectAndSubscribe()
+          connectAndSubscribe();
         } catch (e) {
-          emit('error', e)
+          emit("error", e);
         }
-      }, props.reconnectDelayMs)
+      }, props.reconnectDelayMs);
     }
-    return
+    return;
   }
-
-  if (ev.type === 'error') {
-    emit('error', ev.error)
-    return
+  if (ev.type === "error") {
+    emit("error", ev.error);
+    return;
   }
-
-  if (ev.type === 'message') {
-    const msg = ev.data
-    emit('message', msg)
-
+  if (ev.type === "message") {
+    const msg = ev.data;
+    emit("message", msg);
     switch (msg.type) {
-      case 'monitor.subscribed':
-        if (msg.ok) emit('subscribed', { reader: msg.reader ?? null, withPhoto: !!msg.withPhoto })
-        break
-      case 'monitor.unsubscribed':
-        emit('unsubscribed')
-        break
-      case 'card.inserted':
-        emit('inserted', msg.payload)
-        break
-      case 'card.removed':
-        emit('removed')
-        break
-      case 'card.error':
-      case 'error':
-        emit('error', msg)
-        break
+      case "monitor.subscribed":
+        if (msg.ok) emit("subscribed", { reader: msg.reader ?? null, withPhoto: !!msg.withPhoto });
+        break;
+      case "monitor.unsubscribed":
+        emit("unsubscribed");
+        break;
+      case "card.inserted":
+        emit("inserted", msg.payload);
+        break;
+      case "card.removed":
+        emit("removed");
+        break;
+      case "card.error":
+      case "error":
+        emit("error", msg);
+        break;
     }
   }
-})
-
+});
 onMounted(() => {
-  mounted.value = true
-  if (props.autoConnect) connectAndSubscribe()
-})
-
+  mounted.value = true;
+  if (props.autoConnect) connectAndSubscribe();
+});
 onBeforeUnmount(() => {
-  mounted.value = false
-  try { off?.() } catch { /* ignore */ }
-  safeDisconnect()
-})
-
-/**
- * If props change while connected, switch subscription behavior.
- * - withPhoto changes => re-subscribe (server treats subscribe twice as error), so do unsubscribe -> subscribe
- * - reader changes => use switchReader action when possible; if not connected, just store for next subscribe
- */
+  mounted.value = false;
+  try {
+    off?.();
+  } catch {
+  }
+  safeDisconnect();
+});
 watch(
-    () => props.reader,
-    (r) => {
-      if (!mounted.value) return
-      if (!host.wsConnected.value) return
-      if (!host.wsSubscribed.value) return
-
-      try {
-        host.switchReaderIdCardWs(r ?? null)
-      } catch (e) {
-        emit('error', e)
-      }
+  () => props.reader,
+  (r) => {
+    if (!mounted.value) return;
+    if (!host.wsConnected.value) return;
+    if (!host.wsSubscribed.value) return;
+    try {
+      host.switchReaderIdCardWs(r ?? null);
+    } catch (e) {
+      emit("error", e);
     }
-)
-
+  }
+);
 watch(
-    () => props.withPhoto,
-    (withPhoto) => {
-      if (!mounted.value) return
-      if (!host.wsConnected.value) return
-
-      // Server disallows re-subscribe without unsubscribe first.
-      // We do a clean unsubscribe -> resubscribe sequence.
+  () => props.withPhoto,
+  (withPhoto) => {
+    if (!mounted.value) return;
+    if (!host.wsConnected.value) return;
+    try {
+      if (host.wsSubscribed.value) {
+        host.unsubscribeIdCardWs();
+      }
+    } catch {
+    }
+    setTimeout(() => {
       try {
-        if (host.wsSubscribed.value) {
-          host.unsubscribeIdCardWs()
-        }
-      } catch { /* ignore */ }
-
-      // resubscribe after a tick; give server a moment to process unsubscribe
-      setTimeout(() => {
-        try {
-          if (host.wsConnected.value) {
-            host.subscribeIdCardWs({ reader: props.reader ?? null, withPhoto })
-          }
-        } catch (e) {
-          emit('error', e)
+        if (host.wsConnected.value) {
+          host.subscribeIdCardWs({ reader: props.reader ?? null, withPhoto });
         }
-      }, 0)
-    }
-)
+      } catch (e) {
+        emit("error", e);
+      }
+    }, 0);
+  }
+);
 </script>
 
 <template>

package/dist/runtime/components/device/IdCardWebSocket.vue.d.ts

@@ -0,0 +1,55 @@
+import { type IdCardWsServerMessage, type PatientRegisterPayload } from '../../composables/hostAgent.js';
+interface Props {
+    /** Subscribe withPhoto=true => server will push payload that includes photo when available */
+    withPhoto?: boolean;
+    /** Optional reader name; null/undefined means "any/default" */
+    reader?: string | null;
+    /** Auto-connect on mount (default true) */
+    autoConnect?: boolean;
+    /** Auto-subscribe after connect (default true) */
+    autoSubscribe?: boolean;
+    /** If true, try to reconnect when socket closes unexpectedly */
+    autoReconnect?: boolean;
+    /** Reconnect delay in ms */
+    reconnectDelayMs?: number;
+}
+declare const __VLS_export: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    message: (msg: IdCardWsServerMessage) => any;
+    error: (err: unknown) => any;
+    connected: () => any;
+    disconnected: (info?: {
+        code?: number;
+        reason?: string;
+    } | undefined) => any;
+    subscribed: (info?: {
+        reader?: string | null;
+        withPhoto?: boolean;
+    } | undefined) => any;
+    unsubscribed: () => any;
+    inserted: (payload: PatientRegisterPayload) => any;
+    removed: () => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onMessage?: ((msg: IdCardWsServerMessage) => any) | undefined;
+    onError?: ((err: unknown) => any) | undefined;
+    onConnected?: (() => any) | undefined;
+    onDisconnected?: ((info?: {
+        code?: number;
+        reason?: string;
+    } | undefined) => any) | undefined;
+    onSubscribed?: ((info?: {
+        reader?: string | null;
+        withPhoto?: boolean;
+    } | undefined) => any) | undefined;
+    onUnsubscribed?: (() => any) | undefined;
+    onInserted?: ((payload: PatientRegisterPayload) => any) | undefined;
+    onRemoved?: (() => any) | undefined;
+}>, {
+    reader: string | null;
+    withPhoto: boolean;
+    autoConnect: boolean;
+    autoSubscribe: boolean;
+    autoReconnect: boolean;
+    reconnectDelayMs: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/device/Scanner.d.vue.ts

@@ -0,0 +1,66 @@
+import type { Base64File } from '../../composables/assetFile.js';
+interface Props {
+    feeder?: boolean;
+    duplex?: boolean;
+    dpi?: number;
+    quality?: number;
+    /** UI string: 'color' | 'grey' | 'bw' */
+    color?: string;
+    maxSize?: number;
+}
+declare function performScan(): Promise<void>;
+/**
+ * ✅ Upload helpers (restored)
+ */
+declare function fileToBase64(file: File): Promise<Base64File>;
+declare function performFileUpload(files: File | File[] | undefined): void;
+declare var __VLS_1: {
+    scannerOptions: {
+        deviceName?: string | null | undefined;
+        driver?: (import("../../composables/hostAgent.js").Driver | null) | undefined;
+        paperSource?: import("../../composables/hostAgent.js").PaperSource | undefined;
+        pageSize?: string | null | undefined;
+        dpi: number;
+        bitDepth?: import("../../composables/hostAgent.js").BitDepth | undefined;
+        quality?: number | undefined;
+        maxQuality?: boolean | undefined;
+        autoDeskew?: boolean | undefined;
+        excludeBlankPages?: boolean | undefined;
+        brightness?: number | undefined;
+        contrast?: number | undefined;
+    };
+    configHelper: {
+        feeder: boolean;
+        duplex: boolean;
+        color: string;
+    };
+    operation: {
+        performScan: typeof performScan;
+        performFileUpload: typeof performFileUpload;
+        fileToBase64: typeof fileToBase64;
+    };
+    isScanning: boolean;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    scan: (files: Base64File[]) => any;
+}, string, import("vue").PublicProps, Readonly<Props> & Readonly<{
+    onScan?: ((files: Base64File[]) => any) | undefined;
+}>, {
+    color: string;
+    duplex: boolean;
+    feeder: boolean;
+    dpi: number;
+    quality: number;
+    maxSize: number;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};