aq-fe-framework 0.1.865 → 0.1.867

package/dist/{MyDataTable-C36iuGQn.d.mts → MyDataTable-BZc8ObyA.d.mts}

@@ -22,4 +22,4 @@ interface MyDataTableProps<TData extends MRT_RowData> extends MRT_TableOptions<T
 }
 declare function MyDataTable<TData extends MRT_RowData>({ rowActionSize, columns, data, setSelectedRow, isError, isLoading, pagination, idSelectionOne, setIdSelectionOne, renderTopToolbarCustomActions, visibleFields, ...rest }: MyDataTableProps<TData>): react_jsx_runtime.JSX.Element;
 
-export { type MyDataTableInternalProps as M, type PaginationState as P, type MyDataTableProps as a, MyDataTable as b };
+export { type MyDataTableProps as M, type PaginationState as P, type MyDataTableInternalProps as a, MyDataTable as b };

package/dist/chunk-E4JVWPXS.mjs

@@ -0,0 +1,473 @@
+import {
+  __spreadProps,
+  __spreadValues
+} from "./chunk-JD6AELXS.mjs";
+
+// src/utils/utils_aq.ts
+function utils_aq_mapBaseEntityToDomain(entity) {
+  var _a, _b;
+  return {
+    id: (_b = (_a = entity.id) == null ? void 0 : _a.toString()) != null ? _b : "",
+    // đảm bảo string
+    code: entity.code,
+    name: entity.name,
+    editDate: entity.modifiedWhen,
+    editByUserName: entity.modifiedFullName,
+    concurrencyStamp: entity.concurrencyStamp,
+    isEnabled: entity.isEnabled
+    // Các field khác nếu có trong IBaseDomain mà không có trong IBaseEntity thì sẽ undefined
+  };
+}
+function utils_aq_mapDomainToEntity(domain) {
+  return {
+    id: domain.id ? parseInt(domain.id) : void 0,
+    code: domain.code,
+    name: domain.name,
+    concurrencyStamp: domain.concurrencyStamp,
+    modifiedWhen: domain.editDate,
+    modifiedFullName: domain.editByUserName,
+    isEnabled: domain.isEnabled
+  };
+}
+
+// src/utils/utils_converter.ts
+function utils_converter_mapEnumToSelectData(enumObj, labelMap) {
+  return Object.entries(enumObj).filter(([key, value]) => isNaN(Number(key))).map(([_, value]) => {
+    var _a;
+    const stringValue = value.toString();
+    return {
+      value: stringValue,
+      label: (_a = labelMap[stringValue]) != null ? _a : `Kh\xF4ng r\xF5 (${stringValue})`
+    };
+  });
+}
+var utils_converter_getLabelByValue = (data, value) => {
+  const numericValue = Number(value);
+  return data[numericValue] || "Kh\xF4ng x\xE1c \u0111\u1ECBnh";
+};
+var utils_converter_getKeyByValue = (obj, value) => {
+  var _a;
+  return (_a = Object.entries(obj).find(([_, v]) => v === value)) == null ? void 0 : _a[0];
+};
+function utils_converter_enumToSelectOptions(enumObject) {
+  const result = [];
+  const numericEnumKeys = Object.keys(enumObject).filter((key) => isNaN(Number(key)));
+  for (const key of numericEnumKeys) {
+    const enumValue = enumObject[key];
+    if (typeof enumValue === "number") {
+      result.push({
+        value: String(enumValue),
+        label: key
+      });
+    }
+  }
+  return result;
+}
+function utils_converter_youTubeUrlToEmbed(url) {
+  try {
+    const urlObj = new URL(url);
+    const videoId = urlObj.searchParams.get("v");
+    if (videoId) {
+      return `https://www.youtube.com/embed/${videoId}`;
+    }
+    if (url.includes("/embed/")) {
+      return url;
+    }
+    return "";
+  } catch (e) {
+    return "";
+  }
+}
+
+// src/utils/utils_currency.ts
+function utils_currency_formatWithSuffix(amount, suffix = "") {
+  const formatter = new Intl.NumberFormat("vi-VN");
+  const formattedAmount = formatter.format(amount);
+  return `${formattedAmount}${suffix}`;
+}
+
+// src/utils/utils_excel.ts
+import saveAs from "file-saver";
+import * as XLSX from "xlsx";
+function isObjectPath(path) {
+  return /^[a-zA-Z_$][a-zA-Z0-9_$]*(\.[a-zA-Z_$][a-zA-Z0-9_$]*)+$/.test(path);
+}
+function getValueByPath(obj, path) {
+  if (isObjectPath(path)) {
+    return path.split(".").reduce((acc, key) => acc == null ? void 0 : acc[key], obj);
+  }
+  return obj == null ? void 0 : obj[path];
+}
+async function utils_excel_exportExcel({
+  workbook,
+  sheetName,
+  data,
+  config
+}) {
+  const sheet = workbook.addWorksheet(sheetName);
+  const fieldKeys = config.map((item) => String(item.fieldKey));
+  const headerMappings = {};
+  const markedColumns = [];
+  config.forEach((item) => {
+    const fieldKeyStr = String(item.fieldKey);
+    headerMappings[fieldKeyStr] = item.fieldName;
+    if (item.isRequired) markedColumns.push(fieldKeyStr);
+  });
+  sheet.columns = fieldKeys.map((fieldKey) => ({
+    key: fieldKey,
+    width: 20
+  }));
+  const displayRow = sheet.addRow(
+    fieldKeys.map(
+      (fieldKey) => markedColumns.includes(fieldKey) ? `${headerMappings[fieldKey]} *` : headerMappings[fieldKey] || fieldKey
+    )
+  );
+  const keyRow = sheet.addRow(fieldKeys);
+  data.forEach((row) => {
+    const rowData = {};
+    config.forEach(({ fieldKey, formatter }) => {
+      const fieldKeyStr = String(fieldKey);
+      const rawValue = getValueByPath(row, fieldKeyStr);
+      rowData[fieldKeyStr] = formatter ? formatter(rawValue, row) : rawValue;
+    });
+    sheet.addRow(rowData);
+  });
+  for (let i = 1; i <= fieldKeys.length; i++) {
+    const cell = displayRow.getCell(i);
+    cell.font = { bold: true };
+    cell.fill = {
+      type: "pattern",
+      pattern: "solid",
+      fgColor: { argb: "FFE0E0E0" }
+    };
+  }
+  for (let i = 1; i <= fieldKeys.length; i++) {
+    const cell = keyRow.getCell(i);
+    cell.font = { italic: true };
+    cell.fill = {
+      type: "pattern",
+      pattern: "solid",
+      fgColor: { argb: "FFF0F0F0" }
+    };
+  }
+  if (markedColumns.length > 0) {
+    for (let i = 1; i <= fieldKeys.length; i++) {
+      const cell = displayRow.getCell(i);
+      const text = cell.value;
+      if (typeof text === "string" && text.endsWith(" *")) {
+        cell.value = {
+          richText: [
+            {
+              text: text.slice(0, -2),
+              font: { bold: true }
+            },
+            {
+              text: " *",
+              font: { bold: true, color: { argb: "FFFF0000" } }
+            }
+          ]
+        };
+      }
+    }
+  }
+  return workbook;
+}
+async function utils_excel_download({
+  workbook,
+  name
+}) {
+  const buffer = await workbook.xlsx.writeBuffer();
+  const blob = new Blob([buffer], {
+    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+  });
+  saveAs(blob, name);
+}
+async function utils_excel_parseToJson(file, titleIndex, dataStartIndex) {
+  const buffer = await file.arrayBuffer();
+  const workbook = XLSX.read(buffer);
+  const sheet = workbook.Sheets[workbook.SheetNames[0]];
+  const raw = XLSX.utils.sheet_to_json(sheet, { header: 1 });
+  const headers = raw[titleIndex - 1];
+  const rows = raw.slice(dataStartIndex - 1);
+  const data = rows.map((row) => {
+    const obj = {};
+    headers.forEach((header, i) => {
+      obj[header] = row[i];
+    });
+    return obj;
+  });
+  return {
+    data,
+    // 👈 ép kiểu an toàn vì bạn biết nó đúng
+    headers
+  };
+}
+function utils_excel_handleExport(data, exportConfig, fileName) {
+  const processedData = data.map((row) => {
+    const newRow = {};
+    exportConfig.fields.forEach(({ fieldName, formatFunction }) => {
+      const value = row[fieldName];
+      newRow[fieldName] = formatFunction ? formatFunction(value, row) : value;
+    });
+    return newRow;
+  });
+  const headers = {};
+  exportConfig.fields.forEach(({ fieldName, header }) => {
+    headers[fieldName] = header;
+  });
+  const worksheet = XLSX.utils.json_to_sheet(processedData);
+  const headerRow = exportConfig.fields.map(({ fieldName }) => headers[fieldName]);
+  XLSX.utils.sheet_add_aoa(worksheet, [headerRow], { origin: "A1" });
+  const workbook = XLSX.utils.book_new();
+  XLSX.utils.book_append_sheet(workbook, worksheet, "Exported Data");
+  XLSX.writeFile(workbook, `${fileName}.xlsx`);
+}
+
+// src/utils/utils_field.ts
+function utils_field_extractAQBaseField(values) {
+  const { id, name, code, concurrencyStamp } = values || {};
+  return { id, name, code, concurrencyStamp };
+}
+
+// src/utils/utils_file.ts
+import Docxtemplater from "docxtemplater";
+import { saveAs as saveAs2 } from "file-saver";
+import PizZip from "pizzip";
+function utils_file_fileToAQDocumentType(file) {
+  return new Promise((resolve, reject) => {
+    const fileReader = new FileReader();
+    fileReader.onloadend = () => {
+      const fileName = file.name;
+      const fileExtension = file.name.split(".").pop();
+      const fileBase64String = fileReader.result;
+      resolve({
+        fileName,
+        fileExtension,
+        fileBase64String: fileBase64String.split(",")[1]
+        // Chỉ lấy phần base64 sau dấu phẩy
+      });
+    };
+    fileReader.onerror = reject;
+    fileReader.readAsDataURL(file);
+  });
+}
+async function utils_file_AQDocumentTypeToFile({
+  data,
+  filePath,
+  fileName = "output.docx"
+}) {
+  const response = await fetch(filePath);
+  const arrayBuffer = await response.arrayBuffer();
+  const zip = new PizZip(arrayBuffer);
+  const doc = new Docxtemplater(zip);
+  doc.render(data);
+  const blob = doc.getZip().generate({ type: "blob" });
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onloadend = () => {
+      var _a;
+      const base64String = (_a = reader.result) == null ? void 0 : _a.split(",")[1];
+      resolve({
+        fileName,
+        fileExtension: "docx",
+        fileBase64String: base64String
+      });
+    };
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
+async function utils_file_docxtemplaterDownload({
+  data,
+  filePath,
+  fileName
+}) {
+  const response = await fetch(filePath);
+  const arrayBuffer = await response.arrayBuffer();
+  const zip = new PizZip(arrayBuffer);
+  const doc = new Docxtemplater(zip);
+  doc.render(data);
+  const buffer = doc.getZip().generate({ type: "blob" });
+  saveAs2(buffer, fileName || "output.docx");
+}
+function utils_file_base64ToFile(base64, filename) {
+  const [meta, content] = base64.split(",");
+  const mimeMatch = meta.match(/data:(.*);base64/);
+  const mime = mimeMatch ? mimeMatch[1] : "application/octet-stream";
+  const binary = atob(content);
+  const len = binary.length;
+  const bytes = new Uint8Array(len);
+  for (let i = 0; i < len; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new File([bytes], filename, { type: mime });
+}
+
+// src/utils/utils_format.ts
+function utils_format_fixDecimal(number, digits = 2) {
+  if (typeof number !== "number" || isNaN(number)) return void 0;
+  return parseFloat(number.toFixed(digits));
+}
+
+// src/utils/utils_input_updateEnableList.ts
+function updateEnableList(oldList, selectedIds, getId, createNew) {
+  const result = [];
+  selectedIds.forEach((id) => {
+    const existing = oldList.find((item) => getId(item) === id);
+    if (existing) {
+      result.push(__spreadProps(__spreadValues({}, existing), { isEnabled: true }));
+    } else {
+      result.push(createNew(id));
+    }
+  });
+  oldList.forEach((item) => {
+    const id = getId(item);
+    if (id !== void 0 && !selectedIds.includes(id) && item.isEnabled !== 0) {
+      result.push(__spreadProps(__spreadValues({}, item), { isEnabled: 0 }));
+    }
+  });
+  return result;
+}
+
+// src/utils/utils_list.ts
+function utils_list_isTotalEqual(list, field, total) {
+  const totalValue = list.reduce((sum, item) => sum + Number(item[field]), 0);
+  return totalValue === total;
+}
+function utils_list_isFieldUnique(list, field) {
+  const seen = /* @__PURE__ */ new Set();
+  for (const item of list) {
+    const value = item[field];
+    if (seen.has(value)) {
+      return false;
+    }
+    seen.add(value);
+  }
+  return true;
+}
+function utils_list_hasEmptyField(list, field) {
+  return list.some((item) => {
+    const value = item[field];
+    return value === null || value === void 0 || value === "";
+  });
+}
+function utils_list_sumField(list, field) {
+  return list.reduce((sum, item) => sum + Number(item[field]), 0);
+}
+
+// src/utils/utils_pdf.ts
+import axios from "axios";
+async function utils_pdf_download(url) {
+  try {
+    const response = await axios.get(url, {
+      responseType: "blob"
+      // Đảm bảo nhận dữ liệu dạng blob để tải file
+    });
+    const blob = new Blob([response.data], { type: "application/pdf" });
+    const link = document.createElement("a");
+    link.href = window.URL.createObjectURL(blob);
+    link.download = "file.pdf";
+    link.click();
+    window.URL.revokeObjectURL(link.href);
+  } catch (error) {
+    console.error("Error downloading PDF:", error);
+  }
+}
+
+// src/utils/utils_reactQuery.ts
+function utils_reactQuery_updateListItemInQuery({
+  queryClient,
+  queryKey,
+  listKey,
+  itemId,
+  updatedFields,
+  matchBy = "id"
+}) {
+  const oldData = queryClient.getQueryData(queryKey);
+  if (!oldData) return;
+  const updatedList = oldData[listKey].map(
+    (item) => item[matchBy] === itemId ? __spreadValues(__spreadValues({}, item), updatedFields) : item
+  );
+  queryClient.setQueryData(queryKey, __spreadProps(__spreadValues({}, oldData), {
+    [listKey]: updatedList
+  }));
+}
+
+// src/utils/utils_text.ts
+function utils_text_getNormalizedTextFromHtml(html) {
+  const noHtml = (html != null ? html : "").replace(/<[^>]+>/g, "");
+  return noHtml.trim().toLowerCase();
+}
+
+// src/utils/utils_time.ts
+function utils_time_convertTimeStringToSeconds(time) {
+  const [hours, minutes, seconds] = time.split(":").map(Number);
+  return hours * 3600 + minutes * 60 + seconds;
+}
+function utils_time_getHourMinuteFromString(input) {
+  if (!input) return "";
+  if (typeof input === "string") {
+    const [hour2, minute2] = input.split(":");
+    return `${hour2}:${minute2}`;
+  }
+  const hour = String(input.getHours()).padStart(2, "0");
+  const minute = String(input.getMinutes()).padStart(2, "0");
+  return `${hour}:${minute}`;
+}
+function utils_time_getCurrentTimeString() {
+  const formatTime = (number) => {
+    return number < 10 ? "0" + number : number;
+  };
+  const now = /* @__PURE__ */ new Date();
+  const hours = formatTime(now.getHours());
+  const minutes = formatTime(now.getMinutes());
+  const seconds = formatTime(now.getSeconds());
+  return `${hours}:${minutes}:${seconds}`;
+}
+function utils_time_extractHourMinute(isoString) {
+  if (!isoString) return "";
+  const date = new Date(isoString);
+  const hours = String(date.getHours()).padStart(2, "0");
+  const minutes = String(date.getMinutes()).padStart(2, "0");
+  return `${hours}:${minutes}`;
+}
+
+// src/utils/utils_validator.ts
+var utils_validator_validateCode = (value) => {
+  if (!value) return "Kh\xF4ng \u0111\u01B0\u1EE3c \u0111\u1EC3 tr\u1ED1ng";
+  return null;
+};
+
+export {
+  utils_pdf_download,
+  utils_excel_exportExcel,
+  utils_excel_download,
+  utils_excel_parseToJson,
+  utils_excel_handleExport,
+  utils_aq_mapBaseEntityToDomain,
+  utils_aq_mapDomainToEntity,
+  utils_converter_mapEnumToSelectData,
+  utils_converter_getLabelByValue,
+  utils_converter_getKeyByValue,
+  utils_converter_enumToSelectOptions,
+  utils_converter_youTubeUrlToEmbed,
+  utils_currency_formatWithSuffix,
+  utils_field_extractAQBaseField,
+  utils_file_fileToAQDocumentType,
+  utils_file_AQDocumentTypeToFile,
+  utils_file_docxtemplaterDownload,
+  utils_file_base64ToFile,
+  utils_format_fixDecimal,
+  updateEnableList,
+  utils_list_isTotalEqual,
+  utils_list_isFieldUnique,
+  utils_list_hasEmptyField,
+  utils_list_sumField,
+  utils_reactQuery_updateListItemInQuery,
+  utils_text_getNormalizedTextFromHtml,
+  utils_time_convertTimeStringToSeconds,
+  utils_time_getHourMinuteFromString,
+  utils_time_getCurrentTimeString,
+  utils_time_extractHourMinute,
+  utils_validator_validateCode
+};