@voicenter-team/voicenter-ui-plus 2.0.10 → 3.0.0

package/library/utils/ZIndexUtils.mjs

@@ -0,0 +1,59 @@
+import { useZIndex } from "element-plus";
+import DomHandler from "./DomHandler.mjs";
+function handler() {
+  let modalStack = [];
+  let lastZIndex = useZIndex().currentZIndex.value;
+  const generateZIndex = () => {
+    lastZIndex = useZIndex().nextZIndex();
+    return lastZIndex;
+  };
+  const getCurrentZIndex = () => {
+    return lastZIndex;
+  };
+  const getZIndex = (el) => {
+    return el ? parseInt(el.style.zIndex, 10) || 0 : 0;
+  };
+  return {
+    get: getZIndex,
+    set: (el) => {
+      if (el) {
+        el.style.zIndex = String(generateZIndex());
+      }
+    },
+    clear: (el) => {
+      if (el) {
+        el.style.zIndex = "";
+      }
+    },
+    getCurrent: () => getCurrentZIndex(),
+    getModalByKey: (key) => {
+      return modalStack.find((i) => i === key);
+    },
+    setModal: (key) => {
+      modalStack = modalStack.filter((i) => i !== key);
+      modalStack.push(key);
+      if (modalStack.length && !DomHandler.hasClass(document.body, "overflow-hidden")) {
+        DomHandler.addClass(document.body, "overflow-hidden");
+      }
+    },
+    removeModal: (key) => {
+      modalStack = modalStack.filter((i) => i !== key);
+      if (!modalStack.length) {
+        DomHandler.removeClass(document.body, "overflow-hidden");
+      }
+    },
+    lastModal: () => {
+      return modalStack.length ? modalStack[modalStack.length - 1] : "";
+    },
+    countModals: () => {
+      return modalStack.length;
+    },
+    nextIndex: () => {
+      return generateZIndex();
+    }
+  };
+}
+const ZIndexUtils = handler();
+export {
+  ZIndexUtils as default
+};

package/library/utils/dateTime.mjs

@@ -0,0 +1,97 @@
+import dayjs from "dayjs";
+const formatDate = (date, format2 = "YYYY-MM-DD") => {
+  return dayjs(date).format(format2);
+};
+const parseDate = (dateString, format2) => {
+  return dayjs(dateString, format2).toDate();
+};
+const addDays = (date, days) => {
+  return dayjs(date).add(days, "day").toDate();
+};
+const subtractDays = (date, days) => {
+  return dayjs(date).subtract(days, "day").toDate();
+};
+const getHours = (date) => {
+  return dayjs(date).hour();
+};
+const getMinutes = (date) => {
+  return dayjs(date).minute();
+};
+const getSeconds = (date) => {
+  return dayjs(date).second();
+};
+const setTime = (date, options) => {
+  let d = dayjs(date);
+  if (options.hours !== void 0) {
+    d = d.hour(options.hours);
+  }
+  if (options.minutes !== void 0) {
+    d = d.minute(options.minutes);
+  }
+  if (options.seconds !== void 0) {
+    d = d.second(options.seconds);
+  }
+  return d.toDate();
+};
+const isAfter = (date1, date2, units = "minute") => {
+  return dayjs(date1).isAfter(dayjs(date2), units);
+};
+const isSameAfter = (date1, date2, units = "minute") => {
+  return isAfter(date1, date2, units);
+};
+const isBefore = (date1, date2, units = "minute") => {
+  return dayjs(date1).isBefore(dayjs(date2), units);
+};
+const isSameBefore = (date1, date2, units = "minute") => {
+  return isBefore(date1, date2, units);
+};
+const format = (date, formatStr) => {
+  return dayjs(date).format(formatStr);
+};
+const add = (date, duration) => {
+  let d = dayjs(date);
+  if (duration.years) d = d.add(duration.years, "year");
+  if (duration.months) d = d.add(duration.months, "month");
+  if (duration.weeks) d = d.add(duration.weeks, "week");
+  if (duration.days) d = d.add(duration.days, "day");
+  if (duration.hours) d = d.add(duration.hours, "hour");
+  if (duration.minutes) d = d.add(duration.minutes, "minute");
+  if (duration.seconds) d = d.add(duration.seconds, "second");
+  return d.toDate();
+};
+const sub = (date, duration) => {
+  let d = dayjs(date);
+  if (duration.years) d = d.subtract(duration.years, "year");
+  if (duration.months) d = d.subtract(duration.months, "month");
+  if (duration.weeks) d = d.subtract(duration.weeks, "week");
+  if (duration.days) d = d.subtract(duration.days, "day");
+  if (duration.hours) d = d.subtract(duration.hours, "hour");
+  if (duration.minutes) d = d.subtract(duration.minutes, "minute");
+  if (duration.seconds) d = d.subtract(duration.seconds, "second");
+  return d.toDate();
+};
+const addFp = (duration, date) => {
+  return add(date, duration);
+};
+const subFp = (duration, date) => {
+  return sub(date, duration);
+};
+export {
+  add,
+  addDays,
+  addFp,
+  format,
+  formatDate,
+  getHours,
+  getMinutes,
+  getSeconds,
+  isAfter,
+  isBefore,
+  isSameAfter,
+  isSameBefore,
+  parseDate,
+  setTime,
+  sub,
+  subFp,
+  subtractDays
+};

package/library/utils/excelParser/configs.mjs

@@ -0,0 +1,29 @@
+const sheetJSFT = [
+  "xlsx",
+  "xlsb",
+  "xlsm",
+  "xls",
+  "xml",
+  "csv",
+  "txt",
+  "ods",
+  "fods",
+  "uos",
+  "sylk",
+  "dif",
+  "dbf",
+  "prn",
+  "qpw",
+  "123",
+  "wb*",
+  "wq*",
+  "html",
+  "htm"
+].map(function(x) {
+  return "." + x;
+}).join(",");
+const ignoredAsciiCodeSymbols = [8234, 8236];
+export {
+  ignoredAsciiCodeSymbols,
+  sheetJSFT
+};

package/library/utils/excelParser/helper.mjs

@@ -0,0 +1,70 @@
+import { ignoredAsciiCodeSymbols } from "./configs.mjs";
+let xlsxPromise = null;
+function getXlsx() {
+  if (!xlsxPromise) {
+    xlsxPromise = import("xlsx");
+  }
+  return xlsxPromise;
+}
+const readXLSXFile = async (bStr) => {
+  const XLSX = await getXlsx();
+  return XLSX.read(bStr, { type: "binary" });
+};
+const convertSheetToJson = async (sheetData) => {
+  const XLSX = await getXlsx();
+  const rows = XLSX.utils.sheet_to_json(sheetData, { header: 1 });
+  return rows.filter((i) => i[0]);
+};
+const normalizeData = (data) => {
+  return JSON.parse(JSON.stringify(data));
+};
+const makeCols = async (refStr) => {
+  const XLSX = await getXlsx();
+  return Array(XLSX.utils.decode_range(refStr).e.c + 1).fill(0).map((x, i) => ({
+    name: XLSX.utils.encode_col(i),
+    key: i,
+    x
+  }));
+};
+const iError = (column, errors) => {
+  return {
+    column,
+    errors
+  };
+};
+const mapRows = (sheet, head, cols) => {
+  const result = [];
+  sheet.forEach((row) => {
+    const data = {};
+    row.forEach((column, k) => {
+      const key = head[k] ? head[k] : cols[k].name || "Column -" + k;
+      let value = column;
+      if (typeof value === "string") {
+        for (let i = 0; i < ignoredAsciiCodeSymbols.length; i++) {
+          value = value.replaceAll(
+            String.fromCodePoint(ignoredAsciiCodeSymbols[i]),
+            ""
+          );
+        }
+      }
+      data[key] = value ?? null;
+    });
+    result.push(data);
+  });
+  return result;
+};
+const bindErrors = (index, errors) => {
+  return {
+    row: index,
+    errors
+  };
+};
+export {
+  bindErrors,
+  convertSheetToJson,
+  iError,
+  makeCols,
+  mapRows,
+  normalizeData,
+  readXLSXFile
+};

package/library/utils/excelParser/parser.mjs

@@ -0,0 +1,398 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import { sheetJSFT } from "./configs.mjs";
+import { normalizeData, readXLSXFile, convertSheetToJson, makeCols, mapRows, bindErrors, iError } from "./helper.mjs";
+import { validateColumn } from "./validations.mjs";
+class Parser {
+  /**
+   * Constructor
+   *
+   * @param hasHeader
+   */
+  constructor(hasHeader = true) {
+    /**
+     * Represents whether a given block of code or element is a header.
+     */
+    __publicField(this, "isHeader");
+    /**
+     * Represents a file object.
+     */
+    __publicField(this, "file");
+    /**
+     * Represents an array of ParserDataObjectType.
+     */
+    __publicField(this, "data");
+    /**
+     * Represents the original data in the form of an array of ParserDataObjectType.
+     */
+    __publicField(this, "originalData");
+    /**
+     * Represents the data for binding rows.
+     */
+    __publicField(this, "bindData");
+    /**
+     * Represents an array of binding errors.
+     */
+    __publicField(this, "errors");
+    this.isHeader = hasHeader;
+    this.file = {
+      fileName: "",
+      size: 0
+    };
+    this.data = [];
+    this.originalData = [];
+    this.bindData = void 0;
+    this.errors = [];
+  }
+  /**
+   * Checks if the object has a header.
+   */
+  get hasHeader() {
+    return this.isHeader;
+  }
+  /**
+   * Set whether the header is enabled or disabled.
+   */
+  set hasHeader(val) {
+    this.isHeader = val;
+  }
+  /**
+   * Checks if the object has an original file.
+   */
+  get hasOriginalFile() {
+    return this.file;
+  }
+  /**
+   * Retrieves the accepted file types for uploading in the application.
+   */
+  getFileAccept() {
+    return sheetJSFT;
+  }
+  /**
+   * Sets the header value.
+   */
+  setHeader(val) {
+    this.hasHeader = val;
+  }
+  /**
+   * Retrieves the data in a normalized format.
+   */
+  getData() {
+    return normalizeData(this.data);
+  }
+  /**
+   * Sets the data for the object.
+   */
+  setData(data) {
+    this.data = normalizeData(data);
+  }
+  /**
+   * Retrieves the original data from the parser.
+   */
+  getOriginalData() {
+    return normalizeData(this.originalData);
+  }
+  /**
+   * Sets the original data for the parser.
+   */
+  setOriginalData(data) {
+    this.originalData = normalizeData(data);
+  }
+  /**
+   * Retrieves the binding data.
+   */
+  getBindData() {
+    return this.bindData ? normalizeData(this.bindData) : [];
+  }
+  /**
+   * Sets the bind data for the method.
+   */
+  setBindData(data) {
+    this.bindData = normalizeData(data);
+  }
+  /**
+   * Sets the errors for the current instance.
+   */
+  setError(errors) {
+    this.errors = [...errors];
+  }
+  /**
+   * Retrieves the errors associated with the current instance.
+   */
+  getErrors() {
+    return normalizeData(this.errors);
+  }
+  /**
+   * Checks if there are any errors present in the object.
+   */
+  hasErrors() {
+    return !!this.errors.length;
+  }
+  /**
+   * Check if the given index is a valid index within the bindData array.
+   */
+  _isValidIndex(index) {
+    var _a;
+    const bindDataLen = ((_a = this.bindData) == null ? void 0 : _a.length) || 0;
+    return index > -1 && index < bindDataLen;
+  }
+  /**
+   * Deletes the error at the specified index.
+   */
+  _deleteError(index) {
+    delete this.errors[index];
+  }
+  /**
+   * Reads the content of a file and returns parsed data.
+   */
+  readFile(file) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      this.file.fileName = file.name;
+      this.file.size = file.size;
+      reader.onload = async (e) => {
+        var _a;
+        try {
+          const bStr = (_a = e.target) == null ? void 0 : _a.result;
+          this.file.content = bStr;
+          const wb = await readXLSXFile(bStr);
+          const result = [];
+          if (Array.isArray(wb.SheetNames) && wb.SheetNames.length > 0) {
+            for (const sheet of wb.SheetNames) {
+              const workSheet = wb.Sheets[sheet];
+              const sheetData = await convertSheetToJson(workSheet);
+              if (!sheetData.length || !workSheet["!ref"]) {
+                continue;
+              }
+              const cols = await makeCols(workSheet["!ref"]);
+              let head;
+              if (this.hasHeader) {
+                const firstRow = sheetData.shift() ?? [];
+                head = firstRow.map((item) => `${item ?? ""}`);
+              } else {
+                head = cols.map((item) => item.name);
+              }
+              const dataRows = mapRows(sheetData, head, cols);
+              result.push({
+                sheetName: sheet,
+                data: dataRows,
+                header: head,
+                cols,
+                countRows: dataRows.length
+              });
+            }
+          }
+          this.setData([...result]);
+          this.setOriginalData([...result]);
+          resolve({ data: [...result] });
+        } catch (err) {
+          reject(err);
+        }
+      };
+      reader.onerror = reject;
+      reader.readAsBinaryString(file);
+    });
+  }
+  /**
+   * Parsed the data in the specified sheet based on the provided row header index.
+   */
+  reparseHeadRowData(sheetIndex, rowHeader) {
+    return new Promise((resolve, reject) => {
+      try {
+        if (+rowHeader === 0) {
+          this.data[sheetIndex].data = this.originalData[sheetIndex].data;
+          this.data[sheetIndex].header = this.originalData[sheetIndex].header;
+        } else if (+rowHeader > 0) {
+          const dataIndex = rowHeader - 1;
+          const dataHeader = this.originalData[sheetIndex].data[dataIndex];
+          if (dataHeader) {
+            const header = Object.values(dataHeader).map((i) => `${i}`);
+            const newData = this.originalData[sheetIndex].data.slice(rowHeader).map((dataItem) => {
+              const res = {};
+              Object.entries(dataHeader).forEach(([oldKey, newKey]) => {
+                res[`${newKey ?? ""}`] = dataItem[oldKey] ?? null;
+              });
+              return res;
+            });
+            this.data[sheetIndex].data = [...newData];
+            this.data[sheetIndex].header = [...header];
+          }
+        }
+        resolve({ data: [...this.getData()] });
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+  /**
+   * Binds columns from sheet data to header data.
+   */
+  bindColumns(index, headerData) {
+    return new Promise((resolve) => {
+      const result = [];
+      const errors = [];
+      const sheetData = this.data[index];
+      if (sheetData === void 0) {
+        throw new Error("Wrong Index!");
+      }
+      if (headerData && Object.keys(headerData).length) {
+        sheetData.data.forEach((row, index2) => {
+          const errorRows = [];
+          const newRow = { ID: index2 };
+          const innerBags = {};
+          Object.values(headerData).forEach((item) => {
+            if (item.inner && item.inner.length) {
+              const innerBag = innerBags[item.property] ?? {};
+              item.inner.forEach((innerItem) => {
+                const indexColumn2 = sheetData.header.findIndex((h) => h === innerItem.key);
+                const colName2 = sheetData.header[indexColumn2];
+                const colValue2 = row[colName2] ? row[colName2] : null;
+                const property2 = innerItem.property;
+                const isPrefix = innerItem.prefix && innerItem.prefix.length;
+                innerBag[isPrefix ? `${innerItem.prefix}${property2}` : property2] = colValue2;
+              });
+              innerBags[item.property] = innerBag;
+              newRow[item.property] = innerBag;
+              return;
+            }
+            const indexColumn = sheetData.header.findIndex((h) => h === item.key);
+            const colName = sheetData.header[indexColumn];
+            const colValue = row[colName] ? row[colName] : null;
+            const property = item.property;
+            newRow[property] = colValue;
+            const validateOptions = item.validationOptions;
+            if (validateOptions) {
+              const resultValid = validateColumn(validateOptions, colValue);
+              if (!resultValid.valid) {
+                errorRows.push(iError(property, resultValid));
+              }
+            }
+          });
+          if (errorRows.length) {
+            errors[index2] = bindErrors(index2, errorRows);
+          }
+          result.push(newRow);
+        });
+      }
+      this.setBindData(result);
+      this.setError(errors);
+      resolve({
+        result: [...result],
+        errors: [...errors]
+      });
+    });
+  }
+  /**
+   * Validates the binding data using the given header options.
+   */
+  validateBindData(headerOptions) {
+    if (!headerOptions) {
+      return [];
+    }
+    const rows = this.bindData || [];
+    const errors = [];
+    rows.forEach((row, index) => {
+      const errorRows = [];
+      Object.values(headerOptions).forEach((item) => {
+        const validateOptions = item.validationOptions;
+        const colData = row[item.property];
+        if (validateOptions) {
+          const resultValid = validateColumn(validateOptions, colData);
+          if (!resultValid.valid) {
+            errorRows.push(iError(item.property, resultValid));
+          }
+        }
+      });
+      if (errorRows.length) {
+        errors[index] = bindErrors(index, errorRows);
+      }
+    });
+    this.setError(errors);
+    return Object.values(errors);
+  }
+  /**
+   * Updates the error row in the "errors" array based on the given parameters.
+   */
+  updateErrorRow(row, errorRows, valid) {
+    const temp = this.errors[row];
+    if (temp && temp.row === +row) {
+      if (valid) {
+        delete this.errors[row];
+      } else {
+        this.errors[row] = bindErrors(row, errorRows);
+      }
+    } else {
+      if (!valid) {
+        this.errors[row] = bindErrors(row, errorRows);
+      }
+    }
+  }
+  /**
+   * Validates a row of data based on the provided header options.
+   */
+  validateRow(index, headerOptions) {
+    if (!headerOptions || index < 0 || !this.bindData) {
+      throw new Error("Wrong wrong initial params!");
+    }
+    const row = this.bindData[index];
+    const errorRow = [];
+    const result = {
+      valid: true,
+      row: index,
+      errors: []
+    };
+    Object.entries(row).forEach((column) => {
+      const headerOption = headerOptions.find((item) => item.property === column[0]);
+      if (headerOption && headerOption.validationOptions) {
+        const resultValid = validateColumn(headerOption.validationOptions, column[1]);
+        if (!resultValid.valid) {
+          errorRow.push(iError(column[0], resultValid));
+        }
+      }
+    });
+    if (errorRow.length) {
+      result.valid = false;
+    }
+    result.errors = errorRow;
+    this.updateErrorRow(index, errorRow, result.valid);
+    return result;
+  }
+  /**
+   * Updates a row in the binding data at the specified index.
+   */
+  updateRow(rowIndex, row, headerOptions) {
+    if (!this._isValidIndex(rowIndex) || rowIndex < 0 || !this.bindData) {
+      throw new Error("Wrong wrong initial params!");
+    }
+    this.bindData[rowIndex] = row;
+    this.validateRow(rowIndex, headerOptions);
+    return row;
+  }
+  /**
+   * Deletes a row from the bindData array at the specified index.
+   */
+  deleteRow(rowIndex) {
+    if (!this._isValidIndex(rowIndex) || !this.bindData) {
+      throw new Error("Wrong Index Row!");
+    }
+    const row = this.bindData[rowIndex];
+    this.bindData.splice(rowIndex, 1);
+    if (this.errors[row.ID]) {
+      this._deleteError(row.ID);
+    }
+  }
+  resetData() {
+    this.data = [];
+    this.originalData = [];
+    this.bindData = void 0;
+    this.errors = [];
+    this.file = {
+      fileName: "",
+      size: 0
+    };
+  }
+}
+export {
+  Parser as default
+};