tantee-nuxt-commons 0.0.167 → 0.0.169

package/dist/runtime/components/pdf/View.vue

@@ -15,12 +15,12 @@ interface Props extends /* @vue-ignore */ InstanceType<typeof PDF['$props']> {
 }
 
 const props = withDefaults(defineProps<Props>(), {
-  base64String: "",
-  title: "",
-  fileName: "",
+  base64String: '',
+  title: '',
+  fileName: '',
   disabled: false,
   isPrint: false,
-  showBackToTopBtn: false
+  showBackToTopBtn: false,
 })
 
 const emit = defineEmits(['closeDialog'])
@@ -33,25 +33,34 @@ const generateUniqueId = (): string => {
 }
 
 const downloadPdf = (): void => {
-  const byteString = atob(props.base64String || '')
-  const byteArray = new Uint8Array(byteString.length)
+  try {
+    if (!props.base64String) alert?.addAlert({ message: 'No Base64 provided', alertType: 'error' })
 
-  for (let i = 0; i < byteString.length; i++) {
-    byteArray[i] = byteString.charCodeAt(i)
-  }
+    const byteString = atob(props.base64String || '')
+    const byteArray = new Uint8Array(byteString.length)
 
-  const blob = new Blob([byteArray], { type: 'application/pdf' })
-  const link = URL.createObjectURL(blob)
-  const anchorElement = document.createElement('a')
-  anchorElement.style.display = 'none'
-  anchorElement.href = link
-  anchorElement.download = `${generateUniqueId()}.pdf`
-
-  document.body.appendChild(anchorElement)
-  anchorElement.click()
-  URL.revokeObjectURL(link)
-  document.body.removeChild(anchorElement)
-  base64.value = ''
+    for (let i = 0; i < byteString.length; i++) {
+      byteArray[i] = byteString.charCodeAt(i)
+    }
+
+    const blob = new Blob([byteArray], { type: 'application/pdf' })
+    const link = URL.createObjectURL(blob)
+    const anchorElement = document.createElement('a')
+    anchorElement.style.display = 'none'
+    anchorElement.href = link
+    anchorElement.download = `${generateUniqueId()}.pdf`
+
+    document.body.appendChild(anchorElement)
+    anchorElement.click()
+    URL.revokeObjectURL(link)
+    document.body.removeChild(anchorElement)
+    base64.value = ''
+
+    alert?.addAlert({ message: 'Download success', alertType: 'success' })
+  }
+  catch (error) {
+    alert?.addAlert({ message: `Download unsuccess : ${error}`, alertType: 'error' })
+  }
 }
 
 const printPdf = () => {
@@ -60,7 +69,7 @@ const printPdf = () => {
     type: 'pdf',
     base64: true,
     onPrintDialogClose: endLoadPdf,
-    onError: (error: any) => {
+    onError: (error) => {
       alert?.addAlert({ message: error, alertType: 'error' })
     },
   })
@@ -73,18 +82,19 @@ const endLoadPdf = () => {
 }
 
 const isMobile = () => {
-  return /Android|Mobi|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini|Macintosh/i.test(navigator.userAgent);
+  return /Android|Mobi|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini|Macintosh/i.test(navigator.userAgent)
 }
 
 const checkMobileAndPrint = computed(() => {
-  return !isMobile() && props.isPrint;
-});
+  return !isMobile() && props.isPrint
+})
 
 const setWidthPdf = computed(() => {
   if (isMobile()) {
-    return "100%"
-  } else {
-    return "100dvh"
+    return '100%'
+  }
+  else {
+    return '100dvh'
   }
 })
 </script>
@@ -114,10 +124,10 @@ const setWidthPdf = computed(() => {
     </v-toolbar>
     <v-card-text class="justify-center h-screen">
       <PDF
-          v-bind="$attrs"
-          :pdf-width="setWidthPdf"
-          :src="base64"
-          :show-back-to-top-btn="props.showBackToTopBtn"
+        v-bind="$attrs"
+        :pdf-width="setWidthPdf"
+        :src="base64"
+        :show-back-to-top-btn="props.showBackToTopBtn"
       />
     </v-card-text>
   </v-card>

package/dist/runtime/composables/document/templateFormTable.js

@@ -34,13 +34,16 @@ function guessWidth(width) {
 export function processTemplateFormTable(item, parentTemplates, dataVariable) {
   let tableOptions = Object.assign({ title: item.inputLabel || "", formTemplate: "" }, item.inputOptions);
   let tableHeader = tableOptions.headers || [];
-  if (!tableHeader.some((h) => h.key === "action")) tableHeader.push({ title: "Action", key: "action", width: "100px" });
   let tableItemTemplate = "";
   tableHeader.forEach((h) => {
     if (h.template) {
       tableItemTemplate += `\r
 <template #item.${h.key}="props">${h.template}</template>`;
+    } else {
+      tableItemTemplate += `\r
+<template #item.${h.key}="props">{{autoSanitizedDisplay(props.item.${h.key})}}</template>`;
     }
   });
+  if (!tableHeader.some((h) => h.key === "action")) tableHeader.push({ title: "Action", key: "action", width: "100px" });
   return processDefaultTemplate(item, `<template #form="{data,rules}">${useDocumentTemplate(tableOptions.formTemplate)}</template>${tableItemTemplate}`, `title="${tableOptions.title}" :headers='${escapeObjectForInlineBinding(tableHeader)}'`, void 0, dataVariable);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tantee-nuxt-commons",
-  "version": "0.0.167",
+  "version": "0.0.169",
   "description": "Ramathibodi Nuxt modules for common components",
   "repository": {
     "type": "git",

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

@@ -1,31 +0,0 @@
-/** Core format you wanted to standardize around */
-export interface Base64String {
-    base64String?: string;
-}
-export interface Base64Asset extends Base64String {
-    id?: number;
-}
-export interface Base64File extends Base64Asset {
-    /** Display or server filename; when converting from a File, we use File.name */
-    fileName: string;
-    originalFileName?: string;
-    /** Parsed or inferred MIME type */
-    fileType?: string;
-}
-export interface Base64Image {
-    imageData: Base64Asset;
-    imageTitle?: string;
-    imageProps?: Record<string, unknown>;
-}
-/** Ensure we have a well-formed data URL; if raw base64 is provided, wrap it */
-declare function ensureDataUrl(base64Data: string, contentType?: string): string;
-export declare const useAssetFile: () => {
-    hydrateAssetFile: <T extends Base64Asset>(assetFile: T) => Promise<T>;
-    base64ToFile: (base64Data: string, filename: string, defaultContentType?: string) => File | undefined;
-    fileToBase64: (file: File, maxFileSizeMB?: number) => Promise<Base64File>;
-    fileToBase64String: (file: File, maxFileSizeMB?: number) => Promise<Base64String>;
-    downloadBase64File: (base64Data: string, filename: string) => void;
-    downloadAsset: (input: string | Base64File | Base64Asset, filename?: string, defaultContentType?: string) => void;
-    ensureDataUrl: typeof ensureDataUrl;
-};
-export {};

package/dist/runtime/composables/assetFile.js

@@ -1,134 +0,0 @@
-import { useGraphQlOperation } from "./graphqlOperation.js";
-const DATA_URL_RE = /^data:([^;]+);base64,(.+)$/i;
-function parseDataUrl(input) {
-  const match = input.match(DATA_URL_RE);
-  if (!match) return null;
-  const [, contentType, payload] = match;
-  return { contentType, payload };
-}
-function base64ToBytes(base64Payload) {
-  const normalized = base64Payload.replace(/-/g, "+").replace(/_/g, "/");
-  const binaryStr = atob(normalized);
-  const len = binaryStr.length;
-  const bytes = new Uint8Array(len);
-  const CHUNK = 32768;
-  for (let i = 0; i < len; i += CHUNK) {
-    const end = Math.min(i + CHUNK, len);
-    for (let j = i; j < end; j++) {
-      bytes[j] = binaryStr.charCodeAt(j);
-    }
-  }
-  return bytes;
-}
-function bytesToFile(bytes, filename, contentType) {
-  try {
-    return new File([bytes], filename, { type: contentType });
-  } catch {
-    return new Blob([bytes], { type: contentType });
-  }
-}
-function ensureDataUrl(base64Data, contentType = "application/octet-stream") {
-  if (DATA_URL_RE.test(base64Data)) return base64Data;
-  return `data:${contentType};base64,${base64Data}`;
-}
-function extensionFromMime(mime) {
-  const map = {
-    "image/png": "png",
-    "image/jpeg": "jpg",
-    "image/jpg": "jpg",
-    "image/gif": "gif",
-    "image/webp": "webp",
-    "application/pdf": "pdf",
-    "text/plain": "txt"
-  };
-  return map[mime];
-}
-export const useAssetFile = () => {
-  async function hydrateAssetFile(assetFile) {
-    if (!assetFile?.base64String && assetFile?.id != null) {
-      const result = await useGraphQlOperation(
-        "Query",
-        "assetFileById",
-        ["id", "base64String"],
-        { id: assetFile.id },
-        false
-      );
-      if (result?.base64String) assetFile.base64String = result.base64String;
-    }
-    return assetFile;
-  }
-  function base64ToFile(base64Data, filename, defaultContentType = "application/octet-stream") {
-    try {
-      const parsed = parseDataUrl(base64Data);
-      const contentType = parsed?.contentType ?? defaultContentType;
-      const payload = parsed?.payload ?? base64Data;
-      const bytes = base64ToBytes(payload);
-      return bytesToFile(bytes, filename, contentType);
-    } catch (error) {
-      console.error("Invalid base64 data", error);
-      return void 0;
-    }
-  }
-  function fileToBase64(file, maxFileSizeMB = 5) {
-    const maxSize = maxFileSizeMB * 1048576;
-    return new Promise((resolve, reject) => {
-      if (file.size > maxSize) {
-        reject(`File (${file.name}) size exceeds the ${maxFileSizeMB} MB limit.`);
-        return;
-      }
-      const reader = new FileReader();
-      reader.onload = (event) => {
-        const dataUrl = event.target?.result;
-        resolve({
-          fileName: file.name,
-          originalFileName: file.name,
-          base64String: dataUrl,
-          fileType: file.type || parseDataUrl(dataUrl)?.contentType
-        });
-      };
-      reader.onerror = reject;
-      reader.readAsDataURL(file);
-    });
-  }
-  async function fileToBase64String(file, maxFileSizeMB = 5) {
-    const res = await fileToBase64(file, maxFileSizeMB);
-    return { base64String: res.base64String };
-  }
-  function downloadBase64File(base64Data, filename) {
-    const file = base64ToFile(base64Data, filename);
-    if (!file) return;
-    const url = URL.createObjectURL(file);
-    const link = document.createElement("a");
-    link.href = url;
-    link.download = filename;
-    document.body.appendChild(link);
-    link.click();
-    document.body.removeChild(link);
-    setTimeout(() => URL.revokeObjectURL(url), 0);
-  }
-  function downloadAsset(input, filename, defaultContentType = "application/octet-stream") {
-    let base64 = typeof input === "string" ? input : input.base64String;
-    if (!base64) return;
-    if (!filename) {
-      const parsed2 = parseDataUrl(base64);
-      const ext = parsed2 ? extensionFromMime(parsed2.contentType) : void 0;
-      filename = typeof input !== "string" && input.fileName || `download${ext ? "." + ext : ""}`;
-    }
-    const parsed = parseDataUrl(base64);
-    if (!parsed) {
-      base64 = ensureDataUrl(base64, defaultContentType);
-    }
-    downloadBase64File(base64, filename);
-  }
-  return {
-    // core
-    hydrateAssetFile,
-    base64ToFile,
-    fileToBase64,
-    fileToBase64String,
-    downloadBase64File,
-    downloadAsset,
-    // helpers (exported in case you want them elsewhere)
-    ensureDataUrl
-  };
-};