@gzl10/ts-helpers 4.2.1

package/dist/node-esm/chunk-KBHE3K2F.js

@@ -0,0 +1,505 @@
+import {
+  DataError,
+  createValidationError
+} from "./chunk-75XNTC34.js";
+import {
+  isBrowser,
+  isNode
+} from "./chunk-64TBXJQS.js";
+import {
+  __export
+} from "./chunk-PZ5AY32C.js";
+
+// src/data.ts
+var data_exports = {};
+__export(data_exports, {
+  detectFileExtension: () => detectFileExtension,
+  detectFormatFromFilename: () => detectFormatFromFilename,
+  detectUniversalFormat: () => detectUniversalFormat,
+  exportData: () => exportData,
+  exportTree: () => exportTree,
+  exportTxt: () => exportTxt,
+  importData: () => importData,
+  importTree: () => importTree,
+  importTxt: () => importTxt,
+  readFileAsText: () => readFileAsText,
+  validateCSVData: () => validateCSVData,
+  validateExportData: () => validateExportData
+});
+var readFileAsText = async (fileOrPath, encoding = "utf8") => {
+  if (isNode() && typeof fileOrPath === "string") {
+    const fs = await import("fs/promises");
+    return fs.readFile(fileOrPath, encoding);
+  } else if (isBrowser() && fileOrPath instanceof File) {
+    return new Promise((resolve, reject) => {
+      const reader = new FileReader();
+      reader.onload = (e) => resolve(e.target?.result);
+      reader.onerror = () => reject(new Error("Error reading file"));
+      reader.readAsText(fileOrPath);
+    });
+  } else {
+    throw new DataError(
+      "Invalid parameter for current environment",
+      "ENVIRONMENT_NOT_SUPPORTED" /* ENVIRONMENT_NOT_SUPPORTED */,
+      {
+        data: {
+          isNodeEnv: isNode(),
+          isBrowserEnv: isBrowser(),
+          parameterType: typeof fileOrPath
+        }
+      }
+    );
+  }
+};
+function validateExportData(data) {
+  if (!Array.isArray(data)) {
+    throw createValidationError("Data must be an array", "data", typeof data);
+  }
+  if (data.length === 0) {
+    throw createValidationError("Data array cannot be empty", "data.length", data.length);
+  }
+  const firstItem = data[0];
+  const isObjectArray = typeof firstItem === "object" && firstItem !== null && !Array.isArray(firstItem);
+  const isArrayOfArrays = Array.isArray(firstItem);
+  if (!isObjectArray && !isArrayOfArrays) {
+    throw createValidationError(
+      "Data must be an array of objects or an array of arrays",
+      "data[0]",
+      typeof firstItem
+    );
+  }
+  if (isObjectArray) {
+    for (let i = 1; i < data.length; i++) {
+      const item = data[i];
+      if (typeof item !== "object" || item === null || Array.isArray(item)) {
+        throw createValidationError(
+          "All elements must be objects if first one is an object",
+          `data[${i}]`,
+          typeof item
+        );
+      }
+    }
+  } else if (isArrayOfArrays) {
+    const firstRowLength = firstItem.length;
+    for (let i = 1; i < data.length; i++) {
+      if (!Array.isArray(data[i])) {
+        throw createValidationError(`Row ${i} is not an array`, `data[${i}]`, typeof data[i]);
+      }
+      if (data[i].length !== firstRowLength) {
+        throw createValidationError(
+          `Row ${i} has ${data[i].length} columns, but first has ${firstRowLength}`,
+          `data[${i}].length`,
+          { expected: firstRowLength, actual: data[i].length }
+        );
+      }
+    }
+  }
+  return true;
+}
+var validateCSVData = validateExportData;
+function detectFormatFromFilename(filename) {
+  const parts = filename.toLowerCase().split(".");
+  const extension = parts.length > 1 ? parts.pop() : void 0;
+  switch (extension) {
+    case "csv":
+      return "csv";
+    case "json":
+      return "json";
+    case "tree":
+      return "tree";
+    case "txt":
+      return "txt";
+    default:
+      if (!extension) {
+        throw new DataError(
+          "Could not detect file format. Must have a valid extension (.csv, .json, .tree, .txt)",
+          "UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */,
+          { data: { filename } }
+        );
+      }
+      throw new DataError(
+        `Unsupported file format: .${extension}. Use .csv, .json, .tree or .txt`,
+        "UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */,
+        { data: { filename, extension } }
+      );
+  }
+}
+function detectFileExtension(filename) {
+  if (!filename || typeof filename !== "string") {
+    return null;
+  }
+  const parts = filename.trim().split(".");
+  if (parts.length < 2) {
+    return null;
+  }
+  const extension = parts.pop()?.toLowerCase();
+  return extension || null;
+}
+function detectUniversalFormat(filename) {
+  const extension = detectFileExtension(filename);
+  if (!extension) {
+    return {
+      extension: null,
+      category: "unknown",
+      isText: false,
+      isBinary: false,
+      mimeType: null
+    };
+  }
+  const formatInfo = {
+    // Data formats
+    json: { category: "data", isText: true, isBinary: false, mimeType: "application/json" },
+    csv: { category: "data", isText: true, isBinary: false, mimeType: "text/csv" },
+    xml: { category: "data", isText: true, isBinary: false, mimeType: "application/xml" },
+    yaml: { category: "data", isText: true, isBinary: false, mimeType: "application/yaml" },
+    yml: { category: "data", isText: true, isBinary: false, mimeType: "application/yaml" },
+    tree: { category: "data", isText: true, isBinary: false, mimeType: "text/plain" },
+    tsv: { category: "data", isText: true, isBinary: false, mimeType: "text/tab-separated-values" },
+    sql: { category: "data", isText: true, isBinary: false, mimeType: "application/sql" },
+    db: { category: "data", isText: false, isBinary: true, mimeType: "application/x-sqlite3" },
+    sqlite: { category: "data", isText: false, isBinary: true, mimeType: "application/x-sqlite3" },
+    // Text and code formats
+    txt: { category: "text", isText: true, isBinary: false, mimeType: "text/plain" },
+    md: { category: "text", isText: true, isBinary: false, mimeType: "text/markdown" },
+    rst: { category: "text", isText: true, isBinary: false, mimeType: "text/x-rst" },
+    rtf: { category: "text", isText: true, isBinary: false, mimeType: "application/rtf" },
+    log: { category: "text", isText: true, isBinary: false, mimeType: "text/plain" },
+    // Web formats
+    html: { category: "web", isText: true, isBinary: false, mimeType: "text/html" },
+    htm: { category: "web", isText: true, isBinary: false, mimeType: "text/html" },
+    css: { category: "web", isText: true, isBinary: false, mimeType: "text/css" },
+    scss: { category: "web", isText: true, isBinary: false, mimeType: "text/x-scss" },
+    sass: { category: "web", isText: true, isBinary: false, mimeType: "text/x-sass" },
+    less: { category: "web", isText: true, isBinary: false, mimeType: "text/x-less" },
+    // Programming languages
+    js: { category: "code", isText: true, isBinary: false, mimeType: "application/javascript" },
+    mjs: { category: "code", isText: true, isBinary: false, mimeType: "application/javascript" },
+    jsx: { category: "code", isText: true, isBinary: false, mimeType: "text/jsx" },
+    ts: { category: "code", isText: true, isBinary: false, mimeType: "application/typescript" },
+    tsx: { category: "code", isText: true, isBinary: false, mimeType: "text/tsx" },
+    py: { category: "code", isText: true, isBinary: false, mimeType: "text/x-python" },
+    java: { category: "code", isText: true, isBinary: false, mimeType: "text/x-java-source" },
+    php: { category: "code", isText: true, isBinary: false, mimeType: "application/x-httpd-php" },
+    rb: { category: "code", isText: true, isBinary: false, mimeType: "text/x-ruby" },
+    go: { category: "code", isText: true, isBinary: false, mimeType: "text/x-go" },
+    rs: { category: "code", isText: true, isBinary: false, mimeType: "text/x-rust" },
+    c: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c" },
+    cpp: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c++" },
+    cc: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c++" },
+    h: { category: "code", isText: true, isBinary: false, mimeType: "text/x-c" },
+    cs: { category: "code", isText: true, isBinary: false, mimeType: "text/x-csharp" },
+    sh: { category: "code", isText: true, isBinary: false, mimeType: "application/x-sh" },
+    bash: { category: "code", isText: true, isBinary: false, mimeType: "application/x-sh" },
+    ps1: { category: "code", isText: true, isBinary: false, mimeType: "application/x-powershell" },
+    // Microsoft Office documents
+    doc: { category: "document", isText: false, isBinary: true, mimeType: "application/msword" },
+    docx: {
+      category: "document",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.openxmlformats-officedocument.wordprocessingml.document"
+    },
+    xls: {
+      category: "spreadsheet",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.ms-excel"
+    },
+    xlsx: {
+      category: "spreadsheet",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+    },
+    ppt: {
+      category: "presentation",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.ms-powerpoint"
+    },
+    pptx: {
+      category: "presentation",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.openxmlformats-officedocument.presentationml.presentation"
+    },
+    // LibreOffice/OpenOffice
+    odt: {
+      category: "document",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.oasis.opendocument.text"
+    },
+    ods: {
+      category: "spreadsheet",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.oasis.opendocument.spreadsheet"
+    },
+    odp: {
+      category: "presentation",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.oasis.opendocument.presentation"
+    },
+    // Other document formats
+    pdf: { category: "document", isText: false, isBinary: true, mimeType: "application/pdf" },
+    epub: { category: "document", isText: false, isBinary: true, mimeType: "application/epub+zip" },
+    mobi: {
+      category: "document",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/x-mobipocket-ebook"
+    },
+    // Image formats
+    jpg: { category: "image", isText: false, isBinary: true, mimeType: "image/jpeg" },
+    jpeg: { category: "image", isText: false, isBinary: true, mimeType: "image/jpeg" },
+    png: { category: "image", isText: false, isBinary: true, mimeType: "image/png" },
+    gif: { category: "image", isText: false, isBinary: true, mimeType: "image/gif" },
+    svg: { category: "image", isText: true, isBinary: false, mimeType: "image/svg+xml" },
+    webp: { category: "image", isText: false, isBinary: true, mimeType: "image/webp" },
+    avif: { category: "image", isText: false, isBinary: true, mimeType: "image/avif" },
+    bmp: { category: "image", isText: false, isBinary: true, mimeType: "image/bmp" },
+    tiff: { category: "image", isText: false, isBinary: true, mimeType: "image/tiff" },
+    tif: { category: "image", isText: false, isBinary: true, mimeType: "image/tiff" },
+    ico: { category: "image", isText: false, isBinary: true, mimeType: "image/x-icon" },
+    psd: {
+      category: "image",
+      isText: false,
+      isBinary: true,
+      mimeType: "image/vnd.adobe.photoshop"
+    },
+    // Audio formats
+    mp3: { category: "audio", isText: false, isBinary: true, mimeType: "audio/mpeg" },
+    wav: { category: "audio", isText: false, isBinary: true, mimeType: "audio/wav" },
+    flac: { category: "audio", isText: false, isBinary: true, mimeType: "audio/flac" },
+    ogg: { category: "audio", isText: false, isBinary: true, mimeType: "audio/ogg" },
+    aac: { category: "audio", isText: false, isBinary: true, mimeType: "audio/aac" },
+    m4a: { category: "audio", isText: false, isBinary: true, mimeType: "audio/m4a" },
+    wma: { category: "audio", isText: false, isBinary: true, mimeType: "audio/x-ms-wma" },
+    // Video formats
+    mp4: { category: "video", isText: false, isBinary: true, mimeType: "video/mp4" },
+    avi: { category: "video", isText: false, isBinary: true, mimeType: "video/x-msvideo" },
+    mov: { category: "video", isText: false, isBinary: true, mimeType: "video/quicktime" },
+    wmv: { category: "video", isText: false, isBinary: true, mimeType: "video/x-ms-wmv" },
+    flv: { category: "video", isText: false, isBinary: true, mimeType: "video/x-flv" },
+    webm: { category: "video", isText: false, isBinary: true, mimeType: "video/webm" },
+    mkv: { category: "video", isText: false, isBinary: true, mimeType: "video/x-matroska" },
+    "3gp": { category: "video", isText: false, isBinary: true, mimeType: "video/3gpp" },
+    // Archive formats
+    zip: { category: "archive", isText: false, isBinary: true, mimeType: "application/zip" },
+    rar: {
+      category: "archive",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/x-rar-compressed"
+    },
+    "7z": {
+      category: "archive",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/x-7z-compressed"
+    },
+    tar: { category: "archive", isText: false, isBinary: true, mimeType: "application/x-tar" },
+    gz: { category: "archive", isText: false, isBinary: true, mimeType: "application/gzip" },
+    bz2: { category: "archive", isText: false, isBinary: true, mimeType: "application/x-bzip2" },
+    xz: { category: "archive", isText: false, isBinary: true, mimeType: "application/x-xz" },
+    // Configuration files
+    ini: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    cfg: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    conf: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    toml: { category: "config", isText: true, isBinary: false, mimeType: "application/toml" },
+    env: { category: "config", isText: true, isBinary: false, mimeType: "text/plain" },
+    // Font formats
+    ttf: { category: "font", isText: false, isBinary: true, mimeType: "font/ttf" },
+    otf: { category: "font", isText: false, isBinary: true, mimeType: "font/otf" },
+    woff: { category: "font", isText: false, isBinary: true, mimeType: "font/woff" },
+    woff2: { category: "font", isText: false, isBinary: true, mimeType: "font/woff2" },
+    eot: {
+      category: "font",
+      isText: false,
+      isBinary: true,
+      mimeType: "application/vnd.ms-fontobject"
+    }
+  };
+  const info = formatInfo[extension] || {
+    category: "unknown",
+    isText: false,
+    isBinary: false,
+    mimeType: null
+  };
+  return {
+    extension,
+    ...info
+  };
+}
+async function exportTree(data, filePath, options) {
+  if (!Array.isArray(data)) {
+    throw createValidationError(
+      "Data for tree format must be an array of nodes",
+      "data",
+      typeof data
+    );
+  }
+  const { renderTreeAsText } = await import("./tree.js");
+  const treeText = renderTreeAsText(data, options);
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(filePath, treeText, { encoding: "utf-8" });
+  } else {
+    const blob = new Blob([treeText], { type: "text/plain;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filePath.split("/").pop() || "tree.tree";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+}
+async function importTree(filePath, _options) {
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    return fs.readFile(filePath, { encoding: "utf-8" });
+  } else {
+    throw new DataError(
+      ".tree file import is not supported in browser. Use readFileAsText() with a File object.",
+      "ENVIRONMENT_NOT_SUPPORTED" /* ENVIRONMENT_NOT_SUPPORTED */,
+      { data: { environment: "browser", operation: "importTree" } }
+    );
+  }
+}
+async function exportTxt(data, filePath, options) {
+  const { separator = "\n", stringify, indent = 2 } = options || {};
+  let textContent;
+  if (stringify) {
+    textContent = stringify(data);
+  } else if (typeof data === "string") {
+    textContent = data;
+  } else if (Array.isArray(data)) {
+    textContent = data.map((item) => typeof item === "string" ? item : JSON.stringify(item, null, indent)).join(separator);
+  } else if (typeof data === "object" && data !== null) {
+    textContent = JSON.stringify(data, null, indent);
+  } else {
+    textContent = String(data);
+  }
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    await fs.writeFile(filePath, textContent, { encoding: "utf-8" });
+  } else {
+    const blob = new Blob([textContent], { type: "text/plain;charset=utf-8" });
+    const url = URL.createObjectURL(blob);
+    const link = document.createElement("a");
+    link.href = url;
+    link.download = filePath.split("/").pop() || "file.txt";
+    document.body.appendChild(link);
+    link.click();
+    document.body.removeChild(link);
+    URL.revokeObjectURL(url);
+  }
+}
+function sanitizeTextContent(content) {
+  return content.replace(/\r\n|\r/g, "\n").replace(/[\x00-\x08\x0E-\x1F\x7F]/g, "").replace(/\n{4,}/g, "\n\n\n").replace(/[ \t]+$/gm, "");
+}
+async function importTxt(filePath, options = {}) {
+  const {
+    maxFileSize = 10 * 1024 * 1024,
+    // 10MB default
+    maxLength = 1e6,
+    // 1M characters default
+    validateSecurity = true,
+    sanitize = true
+  } = options;
+  if (isNode()) {
+    const fs = await import("fs/promises");
+    const path = await import("path");
+    const { isValidFilePath, isValidFileSize, isValidTextContent } = await import("./validators.js");
+    if (!isValidFilePath(filePath)) {
+      throw new Error("Invalid or unsafe file path");
+    }
+    const resolvedPath = path.resolve(filePath);
+    try {
+      const stats = await fs.stat(resolvedPath);
+      if (!isValidFileSize(stats.size, maxFileSize)) {
+        throw new Error(`File too large: ${stats.size} bytes (max: ${maxFileSize})`);
+      }
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        throw new Error(`File not found: ${filePath}`);
+      }
+      throw error;
+    }
+    const content = await fs.readFile(resolvedPath, { encoding: "utf-8" });
+    if (validateSecurity && !isValidTextContent(content, { maxLength })) {
+      throw new Error("File contains potentially dangerous content or exceeds security limits");
+    }
+    return sanitize ? sanitizeTextContent(content) : content;
+  } else {
+    throw new Error(
+      ".txt file import is not supported in browser. Use readFileAsText() with a File object."
+    );
+  }
+}
+async function exportData(data, filePath, options) {
+  const format = detectFormatFromFilename(filePath);
+  if (format === "csv") {
+    validateExportData(data);
+  }
+  switch (format) {
+    case "csv": {
+      const { exportCSV } = await import("./csv.js");
+      return exportCSV(data, filePath, options);
+    }
+    case "json": {
+      const { exportJSON } = await import("./json.js");
+      return exportJSON(data, filePath, options);
+    }
+    case "tree": {
+      return exportTree(data, filePath, options);
+    }
+    case "txt": {
+      return exportTxt(data, filePath, options);
+    }
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+async function importData(filePath, options) {
+  const format = detectFormatFromFilename(filePath);
+  switch (format) {
+    case "csv": {
+      const { importCSV } = await import("./csv.js");
+      return importCSV(filePath, options);
+    }
+    case "json": {
+      const { importJSON } = await import("./json.js");
+      return importJSON(filePath, options);
+    }
+    case "tree": {
+      return importTree(filePath, options);
+    }
+    case "txt": {
+      return importTxt(filePath, options);
+    }
+    default:
+      throw new Error(`Unsupported format: ${format}`);
+  }
+}
+
+export {
+  readFileAsText,
+  validateExportData,
+  validateCSVData,
+  detectFormatFromFilename,
+  detectFileExtension,
+  detectUniversalFormat,
+  exportTree,
+  importTree,
+  exportTxt,
+  importTxt,
+  exportData,
+  importData,
+  data_exports
+};
+//# sourceMappingURL=chunk-KBHE3K2F.js.map