@dasidev/dasi-ui 1.0.0

package/src/lib/utils.ts

@@ -0,0 +1,643 @@
+import { type ClassValue, clsx } from "clsx";
+import { twMerge } from "tailwind-merge";
+import moment from "moment";
+import { saveAs } from "file-saver";
+import jsPDF from "jspdf";
+import autoTable from "jspdf-autotable";
+import * as XLSX from "xlsx";
+import menu from "@/menu";
+
+export const monthNames = ["-", "Januari", "Februari", "Maret", "April", "Mei", "Juni", "Juli", "Agustus", "September", "Oktober", "November", "Desember"];
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs));
+}
+
+export function clearFormSchema(schema: any[]) {
+  for (const [_, item] of schema) {
+    item.default = item.nullValue;
+    if (item.disabledValue) item.disabled = item.disabledValue;
+    if (item.schema) clearFormSchema(Object.entries(item.schema));
+  }
+}
+
+// Helper function to check if a value is meaningful
+export function isValidValue(value: any): boolean {
+  if (value === null || value === undefined || value === false) return false;
+  if (typeof value === "string" && value.trim() === "") return false;
+  if (typeof value === "number" && String(value).trim() === "") return false;
+  if (value === "0001-01-01") return false; // Invalid date placeholder
+  if (Array.isArray(value) && value.length === 0) return false;
+  return true;
+}
+
+// Helper function to check if a value is meaningful
+function isValidFormValue(value: any): boolean {
+  if (value === null || value === undefined) return false;
+  if (typeof value === "string" && value.trim() === "") return false;
+  if (typeof value === "number" && String(value).trim() === "") return false;
+  if (value === "0001-01-01") return false; // Invalid date placeholder
+  if (Array.isArray(value) && value.length === 0) return false;
+  return true;
+}
+
+export function fillFormSchema(schema: any, items: any) {
+  /**
+   * Clear schema before filling new data
+   *
+   */
+  clearFormSchema(schema);
+
+  /**
+   * Now fill the schema with data
+   *
+   */
+  for (const [key, item] of schema) {
+    // Handle array items with nested object structure
+    // Generic pattern: if key ends with "Items" and is an array, transform to selector format
+    if (key.endsWith("Items") && Array.isArray(items[key]) && items[key].length > 0) {
+      const transformedData = items[key]
+        .filter((item: any) => item && item !== null && item !== undefined)
+        .map((item: any) => {
+          if (!item) return null;
+
+          const id = item.id || item[`${key.replace("Items", "")}Id`];
+          const nameKey = key.replace("Items", "");
+          const name = item[nameKey]?.name || item[nameKey]?.nama || item.name || item.nama || `ID: ${id}`;
+
+          if (id) {
+            return { id, name };
+          }
+          return null;
+        })
+        .filter((item: any) => item !== null);
+
+      if (transformedData.length > 0) {
+        item.default = transformedData;
+        continue;
+      }
+    }
+
+    // Handle dasi_v2_date_range type specifically
+    if (item.type === "dasi_v2_date_range") {
+      const keyAwal = `${key}Awal`;
+      const keyAkhir = `${key}Akhir`;
+
+      const awalValue = items[keyAwal];
+      const akhirValue = items[keyAkhir];
+
+      // Only set if both dates are valid and not placeholder dates
+      if (isValidFormValue(awalValue) && isValidFormValue(akhirValue) && awalValue !== "0001-01-01" && akhirValue !== "0001-01-01") {
+        item.default = [new Date(awalValue), new Date(akhirValue)];
+      }
+      // If invalid, keep the original default value from schema
+      continue;
+    }
+
+    if (item.type === "dasi_v2_selector_single_v2") {
+      const theKey = key.substring(key.length - 2, key.length) === "Id" ? key.substring(0, key.length - 2) : key;
+      const value: any = items[theKey];
+      if (value && item.subItem) {
+        if (item.subItem.fillFromFunc) value.subItemSelected = item.subItem.fillFromFunc(items);
+        else value.subItemSelected = items[item.subItem.fillFrom];
+      }
+      item.default = { value };
+      continue;
+    }
+
+    for (const [key2, item2] of Object.entries(items)) {
+      if (key.substring(key.length - 2, key.length) === "Id") {
+        // Handle ID fields
+        if (key.substring(0, key.length - 2) === key2) {
+          // Skip if already processed by custom field mapping
+          if (item._processed) {
+            continue;
+          }
+          if (isValidFormValue(item2)) {
+            if (item2 && (item2 as any).mimetype) {
+              item.default = item2;
+            } else {
+              item.default = [item2];
+            }
+          }
+          // If invalid, keep the original default value from schema
+        }
+
+        /**
+         * @deprecated
+         * ___Code no need to pass object,
+         * this is normal dropdown
+         *
+         */
+        // } else if (key.substring(key.length - 4, key.length) === "Code") {
+        //   // Handle ID fields
+        //   if (key.substring(0, key.length - 4) === key2) {
+        //     if (isValidFormValue(item2)) {
+        //       if (item2 && (item2 as any).mimetype) {
+        //         item.default = item2;
+        //       } else {
+        //         item.default = [item2];
+        //       }
+        //     }
+        //     // If invalid, keep the original default value from schema
+        //   }
+      } else if (key.substring(key.length - 3, key.length) === "Ids") {
+        // Handle multiple selector
+        if (key.substring(0, key.length - 3) === key2) {
+          if (isValidFormValue(item2)) item.default = item2;
+        }
+      } else {
+        // Handle regular fields
+        if (key === key2 && key.substring(key.length - 2, key.length) !== "Id") {
+          if (isValidFormValue(item2)) item.default = item2;
+          // If invalid, keep the original default value from schema
+        }
+      }
+    }
+
+    // Recursively handle nested schemas
+    if (item.schema) {
+      fillFormSchema(Object.entries(item.schema), items);
+    }
+  }
+}
+
+export function validateFormSilent(el: any, schema: any, path: string = ""): any {
+  let isValid = true;
+  for (const [key, item] of Object.entries(schema) as any) {
+    let conditionMeet = true;
+    if (item.conditions && item.conditions.length > 0) {
+      for (const condition of item.conditions) {
+        if (condition[1] === "==") {
+          const val = el.el$(condition[0]).value;
+          if (val !== condition[2]) {
+            conditionMeet = false;
+            break;
+          }
+        } else if (condition[1] === "in") {
+          const val = el.el$(condition[0]).value;
+          if (!condition[2].includes(val)) {
+            conditionMeet = false;
+            break;
+          }
+        }
+      }
+    }
+    if (!conditionMeet) continue;
+    if (item.rules && item.rules.length > 0 && !el.el$(path + key).value) {
+      isValid = false;
+      break;
+    }
+    if (item.schema) {
+      isValid = validateFormSilent(el, item.schema, key + ".");
+      if (!isValid) break;
+    }
+  }
+  console.log("Validation result", isValid);
+  return isValid;
+}
+
+export function formatNumber(number: Number): string {
+  return Number(number || 0).toLocaleString("id", { maximumFractionDigits: 1 });
+}
+
+export function formatNumberIntl(number: number | undefined, minFraction = 0, maxFraction = 3): string {
+  return Number(number || 0).toLocaleString("us", {
+    maximumFractionDigits: maxFraction,
+    minimumFractionDigits: minFraction
+  });
+}
+
+export function displayNumberFormatedIntl(number: number, before: string, after: string) {
+  if (!number) return "-";
+  return `${before} <b>${formatNumberIntl(number || 0)}</b> ${after}`;
+}
+
+export function intlFormatedToNumber(v: string): number | null {
+  return v ? Number(String(v).replace(/\,/g, "")) : null;
+}
+
+export function formatToCommaFloat(value: number): string {
+  return value
+    .toFixed(0) // Round to 2 decimal places
+    .replace(",", ".") // Replace dot with comma
+    .replace(/\B(?=(\d{3})+(?!\d))/g, ","); // Add thousand separators
+}
+
+export function getMenuItemByUrl(url: string) {
+  for (const item of menu ?? []) {
+    for (const submenu of item.submenu ?? []) {
+      if (submenu.url === url) {
+        return submenu;
+      }
+    }
+  }
+}
+
+export function numberToWords(n: any) {
+  // If input is a string, remove commas
+  if (typeof n === "string") {
+    n = n.replace(/,/g, "");
+  }
+
+  // Validate input and convert to string
+  if (typeof n !== "number" && typeof n !== "string") {
+    return "Input must be a number";
+  }
+  if (isNaN(Number(n))) {
+    return "Input must be a number";
+  }
+
+  // Convert input to string for splitting on the decimal point.
+  let numStr = n.toString();
+  let result = "";
+
+  // Handle negative numbers
+  if (numStr[0] === "-") {
+    result = "minus ";
+    numStr = numStr.slice(1);
+  }
+
+  // Split the number by the decimal point.
+  let parts = numStr.split(".");
+  let integerPart = parseInt(parts[0]);
+  let fractionalPart = parts[1]; // undefined if no decimal
+
+  // Convert the integer part
+  result += convertInteger(integerPart);
+
+  // If there is a fractional part, convert each digit individually.
+  if (fractionalPart !== undefined && fractionalPart.length > 0) {
+    result += " koma";
+    for (let i = 0; i < fractionalPart.length; i++) {
+      let digit = parseInt(fractionalPart[i]);
+      result += " " + digitToWord(digit);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Number to month name start with 1,
+ * 1 = Januari,
+ * 2 = Februari,
+ * ...
+ *
+ */
+export function numberToMonth(n: number = 0) {
+  return monthNames[n];
+}
+
+export function formatMonthYear(monthYear: string | Date): string {
+  if (!monthYear) return "";
+  return `${numberToMonth(moment(monthYear).month() + 1)} ${moment(monthYear).year()}`;
+}
+
+function convertInteger(n: number): any {
+  // Special case for zero
+  if (n === 0) return "nol";
+
+  const angka = ["", "satu", "dua", "tiga", "empat", "lima", "enam", "tujuh", "delapan", "sembilan", "sepuluh", "sebelas"];
+
+  if (n < 12) {
+    return angka[n];
+  } else if (n < 20) {
+    return convertInteger(n - 10) + " belas";
+  } else if (n < 100) {
+    return convertInteger(Math.floor(n / 10)) + " puluh" + (n % 10 !== 0 ? " " + convertInteger(n % 10) : "");
+  } else if (n < 200) {
+    return "seratus" + (n % 100 !== 0 ? " " + convertInteger(n - 100) : "");
+  } else if (n < 1000) {
+    return convertInteger(Math.floor(n / 100)) + " ratus" + (n % 100 !== 0 ? " " + convertInteger(n % 100) : "");
+  } else if (n < 2000) {
+    return "seribu" + (n % 1000 !== 0 ? " " + convertInteger(n - 1000) : "");
+  } else if (n < 1000000) {
+    return convertInteger(Math.floor(n / 1000)) + " ribu" + (n % 1000 !== 0 ? " " + convertInteger(n % 1000) : "");
+  } else if (n < 1000000000) {
+    return convertInteger(Math.floor(n / 1000000)) + " juta" + (n % 1000000 !== 0 ? " " + convertInteger(n % 1000000) : "");
+  } else if (n < 1000000000000) {
+    return convertInteger(Math.floor(n / 1000000000)) + " milyar" + (n % 1000000000 !== 0 ? " " + convertInteger(n % 1000000000) : "");
+  } else if (n < 1000000000000000) {
+    return convertInteger(Math.floor(n / 1000000000000)) + " triliun" + (n % 1000000000000 !== 0 ? " " + convertInteger(n % 1000000000000) : "");
+  } else {
+    return "Number too large";
+  }
+}
+
+function digitToWord(digit: number) {
+  const angka = ["nol", "satu", "dua", "tiga", "empat", "lima", "enam", "tujuh", "delapan", "sembilan"];
+  return angka[digit];
+}
+
+export function isValidDate(value: string) {
+  const parsedDate = moment(new Date(value));
+
+  return parsedDate.isValid();
+}
+
+export function upFirst(str: string) {
+  return `${str.substring(0, 1).toUpperCase()}${str.substring(1)}`;
+}
+
+export function convertFormatDate(value: string): string | null {
+  if (!value) return null;
+
+  // Try to detect common date patterns using regex
+  const dateRegex = /\b\d{1,4}[-/]\d{1,2}[-/]\d{1,4}\b/;
+
+  if (dateRegex.test(value)) {
+    const parsedDate = moment(value, ["YYYY-MM-DD", "DD-MM-YYYY", "MM-DD-YYYY", "YYYY/MM/DD", "DD/MM/YYYY", "MM/DD/YYYY"], true); // 'true' = strict parsing
+
+    if (parsedDate.isValid()) {
+      return parsedDate.format("DD/MM/YYYY");
+    }
+  }
+
+  return null;
+}
+
+export function parseDate(dateString: string) {
+  if (!dateString) {
+    return null; 
+  }
+  const formats = [moment.ISO_8601, "YYYY-MM"];
+  
+  const parsedMoment = moment(dateString, formats);
+  
+  return parsedMoment.isValid() ? parsedMoment : null;
+}
+
+// Helper function to get nested property value
+export function getNestedValue(obj: any, path: string): any {
+  return path.split(".").reduce((current, key) => current?.[key], obj);
+}
+
+
+export function isValidVariable(variable: string) {
+  const regex = /^[a-zA-Z][a-zA-Z0-9_]*$/;
+  const disallowedVariables = [
+    "null",
+    "undefined",
+    "var",
+    "const",
+    "let",
+    "type",
+    "struct",
+    "func",
+    "function",
+    "package",
+    "return",
+    "panic",
+    "log",
+    "error",
+    "open",
+    "db",
+    "nil",
+    "err",
+    "new",
+    "string",
+    "int",
+    "number",
+    "float"
+  ];
+  if (!variable) return false;
+  if (disallowedVariables.includes(variable.toLowerCase())) return false;
+  return regex.test(variable);
+}
+
+export function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+export function exportToCSV(data: any[], filename: string, columns?: { key: string; label: string }[]) {
+  // Handle empty data
+  if (!data || !data.length) {
+    console.warn("No data to export");
+    return;
+  }
+
+  try {
+    // If columns are not specified, use object keys
+    const headers = columns ? columns.map(col => col.label) : Object.keys(data[0]);
+
+    // Create CSV content
+    const csvContent = [
+      // Add headers
+      headers.join(","),
+      // Add data rows
+      ...data.map(row => {
+        return columns
+          ? columns.map(col => formatCSVCell(row[col.key])).join(",")
+          : Object.values(row)
+              .map(cell => formatCSVCell(cell))
+              .join(",");
+      })
+    ].join("\n");
+
+    // Create Blob and download
+    const blob = new Blob([`\uFEFF${csvContent}`], {
+      type: "text/csv;charset=utf-8"
+    });
+    saveAs(blob, `${filename}.csv`);
+  } catch (error) {
+    console.error("Error exporting CSV:", error);
+  }
+}
+
+function formatCSVCell(value: any): string {
+  if (value === null || value === undefined) {
+    return "";
+  }
+
+  const stringValue = String(value);
+
+  // If value contains comma, quotes, or newline, wrap in quotes
+  if (/[,"\n]/.test(stringValue)) {
+    return `"${stringValue.replace(/"/g, '""')}"`;
+  }
+
+  return stringValue;
+}
+
+export function exportToPDF(data: any[], filename: string, columns?: { key: string; label: string }[], title?: string, pltuName?: string, periode?: string) {
+  if (!data || !data.length) {
+    console.warn("No data to export");
+    return;
+  }
+
+  try {
+    const doc = new jsPDF();
+    let currentY = 15;
+
+    // Add PLTU Name as main title
+    if (pltuName) {
+      doc.setFontSize(16);
+      doc.setFont("helvetica", "bold");
+      doc.text(pltuName, 14, currentY);
+      currentY += 10;
+    }
+
+    // Add Periode as subtitle
+    if (periode) {
+      doc.setFontSize(12);
+      doc.setFont("helvetica", "normal");
+      doc.text(periode, 14, currentY);
+      currentY += 10;
+    }
+
+    // Add additional title if provided
+    if (title) {
+      doc.setFontSize(14);
+      doc.setFont("helvetica", "bold");
+      doc.text(title, 14, currentY);
+      currentY += 10;
+    }
+
+    const headers = columns ? columns.map(col => col.label) : Object.keys(data[0]);
+    const rows = data.map(row => {
+      return columns ? columns.map(col => formatPDFCell(row[col.key])) : Object.values(row).map(cell => formatPDFCell(cell));
+    });
+
+    autoTable(doc, {
+      head: [headers],
+      body: rows,
+      startY: currentY + 5,
+      styles: {
+        fontSize: 8,
+        cellPadding: 2
+      },
+      headStyles: {
+        fillColor: [66, 139, 202],
+        textColor: 255,
+        fontStyle: "bold"
+      },
+      alternateRowStyles: {
+        fillColor: [245, 245, 245]
+      },
+      margin: { top: currentY + 5, left: 10, right: 10 }
+    });
+
+    doc.save(`${filename}.pdf`);
+  } catch (error) {
+    console.error("Error exporting PDF:", error);
+  }
+}
+
+export function exportToExcel(data: any[], filename: string, columns?: { key: string; label: string }[], sheetName: string = "Sheet1", pltuName?: string, periode?: string) {
+  if (!data || !data.length) {
+    console.warn("No data to export");
+    return;
+  }
+
+  try {
+    let exportData: any[];
+    let headerRowsCount = 0;
+
+    // Prepare title and subtitle rows
+    const titleRows: any[] = [];
+    
+    if (pltuName) {
+      titleRows.push({ A: pltuName });
+      headerRowsCount++;
+    }
+    
+    if (periode) {
+      titleRows.push({ A: periode });
+      headerRowsCount++;
+    }
+    
+    // Add empty row if we have title/subtitle
+    if (headerRowsCount > 0) {
+      titleRows.push({});
+      headerRowsCount++;
+    }
+
+    if (columns) {
+      const headers = columns.reduce((acc, col) => {
+        acc[col.key] = col.label;
+        return acc;
+      }, {} as any);
+
+      exportData = [
+        ...titleRows,
+        headers,
+        ...data.map(row => {
+          return columns.reduce((acc, col) => {
+            acc[col.key] = formatExcelCell(row[col.key]);
+            return acc;
+          }, {} as any);
+        })
+      ];
+    } else {
+      exportData = [
+        ...titleRows,
+        ...data.map(row => {
+          return Object.keys(row).reduce((acc, key) => {
+            acc[key] = formatExcelCell(row[key]);
+            return acc;
+          }, {} as any);
+        })
+      ];
+    }
+
+    const ws = XLSX.utils.json_to_sheet(exportData, { skipHeader: !!columns });
+    
+    // Style the title and subtitle rows
+    if (pltuName && ws['A1']) {
+      ws['A1'].s = {
+        font: { bold: true, sz: 16 },
+        alignment: { horizontal: 'left' }
+      };
+    }
+    
+    if (periode && ws['A2']) {
+      ws['A2'].s = {
+        font: { sz: 12 },
+        alignment: { horizontal: 'left' }
+      };
+    }
+
+    const wb = XLSX.utils.book_new();
+    XLSX.utils.book_append_sheet(wb, ws, sheetName);
+
+    const excelBuffer = XLSX.write(wb, { bookType: "xlsx", type: "array" });
+    const blob = new Blob([excelBuffer], {
+      type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    });
+
+    saveAs(blob, `${filename}.xlsx`);
+  } catch (error) {
+    console.error("Error exporting Excel:", error);
+  }
+}
+
+function formatPDFCell(value: any): string {
+  if (value === null || value === undefined) {
+    return "";
+  }
+  return String(value);
+}
+
+function formatExcelCell(value: any): any {
+  if (value === null || value === undefined) {
+    return "";
+  }
+
+  if (typeof value === "string" && /^\d{4}-\d{2}-\d{2}/.test(value)) {
+    return new Date(value);
+  }
+
+  return value;
+}
+
+export function convertToUtf8(inputString: string) {
+  const encoder = new TextEncoder();
+  const utf8Bytes = encoder.encode(inputString);
+
+  const hexString = Array.from(utf8Bytes)
+    .map(byte => byte.toString(16).padStart(2, "0"))
+    .join("");
+
+  return `%${hexString}`;
+}