@alibarbar/common 1.0.8 → 1.0.10

package/dist/transform.js

@@ -1,33 +1,300 @@
-'use strict';
+// src/data/transform.ts
+function csvToJson(csv, options = {}) {
+  const { delimiter = ",", headers, skipEmptyLines = true } = options;
+  const lines = csv.split(/\r?\n/).filter((line) => {
+    if (skipEmptyLines) {
+      return line.trim().length > 0;
+    }
+    return true;
+  });
+  if (lines.length === 0) return [];
+  const headerRow = headers || lines[0].split(delimiter).map((h) => h.trim());
+  const dataLines = headers ? lines : lines.slice(1);
+  return dataLines.map((line) => {
+    const values = parseCsvLine(line, delimiter);
+    const obj = {};
+    headerRow.forEach((header, index) => {
+      const val = values[index];
+      obj[header] = val !== void 0 ? val : "";
+    });
+    return obj;
+  });
+}
+function parseCsvLine(line, delimiter) {
+  const result = [];
+  let current = "";
+  let inQuotes = false;
+  for (let i = 0; i < line.length; i++) {
+    const char = line[i];
+    const nextChar = line[i + 1];
+    if (char === '"') {
+      if (inQuotes && nextChar === '"') {
+        current += '"';
+        i++;
+      } else {
+        inQuotes = !inQuotes;
+      }
+    } else if (char === delimiter && !inQuotes) {
+      result.push(current.trim());
+      current = "";
+    } else {
+      current += char;
+    }
+  }
+  result.push(current.trim());
+  return result;
+}
+function jsonToCsv(data, options = {}) {
+  const { delimiter = ",", headers, includeHeaders = true } = options;
+  if (data.length === 0) return "";
+  const headerRow = headers || Object.keys(data[0]);
+  const lines = [];
+  if (includeHeaders) {
+    lines.push(headerRow.map(escapeCsvValue).join(delimiter));
+  }
+  data.forEach((item) => {
+    const values = headerRow.map((header) => {
+      const value = item[header];
+      return escapeCsvValue(value != null ? String(value) : "");
+    });
+    lines.push(values.join(delimiter));
+  });
+  return lines.join("\n");
+}
+function escapeCsvValue(value) {
+  if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+function xmlToJson(xml) {
+  const parser = new DOMParser();
+  const doc = parser.parseFromString(xml, "text/xml");
+  const parseError = doc.querySelector("parsererror");
+  if (parseError) {
+    throw new Error("Invalid XML: " + parseError.textContent);
+  }
+  const result = xmlNodeToJson(doc.documentElement);
+  if (typeof result === "object" && result !== null && !Array.isArray(result)) {
+    return result;
+  }
+  return { value: result };
+}
+function xmlNodeToJson(node) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    const text = node.textContent?.trim();
+    return text || null;
+  }
+  if (node.nodeType === Node.ELEMENT_NODE) {
+    const element = node;
+    const result = {};
+    if (element.attributes.length > 0) {
+      const attrs = {};
+      for (let i = 0; i < element.attributes.length; i++) {
+        const attr = element.attributes[i];
+        attrs[attr.name] = attr.value;
+      }
+      result["@attributes"] = attrs;
+    }
+    const children = {};
+    let hasText = false;
+    let textContent = "";
+    for (let i = 0; i < element.childNodes.length; i++) {
+      const child = element.childNodes[i];
+      if (child.nodeType === Node.TEXT_NODE) {
+        const text = child.textContent?.trim();
+        if (text) {
+          textContent += text;
+          hasText = true;
+        }
+      } else if (child.nodeType === Node.ELEMENT_NODE) {
+        const childElement = child;
+        const childName = childElement.tagName;
+        const childValue = xmlNodeToJson(childElement);
+        if (!children[childName]) {
+          children[childName] = [];
+        }
+        children[childName].push(childValue);
+      }
+    }
+    if (hasText && Object.keys(children).length === 0) {
+      return textContent;
+    }
+    Object.keys(children).forEach((key) => {
+      result[key] = children[key].length === 1 ? children[key][0] : children[key];
+    });
+    if (hasText) {
+      result["#text"] = textContent;
+    }
+    return result;
+  }
+  return null;
+}
+function jsonToXml(json, rootTag = "root") {
+  return jsonToXmlElement(json, rootTag);
+}
+function jsonToXmlElement(obj, tagName) {
+  if (obj === null || obj === void 0) {
+    return `<${tagName}></${tagName}>`;
+  }
+  if (typeof obj === "string" || typeof obj === "number" || typeof obj === "boolean") {
+    return `<${tagName}>${escapeXml(String(obj))}</${tagName}>`;
+  }
+  if (Array.isArray(obj)) {
+    return obj.map((item) => jsonToXmlElement(item, tagName)).join("");
+  }
+  if (typeof obj === "object") {
+    const record = obj;
+    let xml = `<${tagName}`;
+    if (record["@attributes"]) {
+      const attrs = record["@attributes"];
+      Object.keys(attrs).forEach((key) => {
+        xml += ` ${key}="${escapeXml(String(attrs[key]))}"`;
+      });
+    }
+    xml += ">";
+    if (record["#text"]) {
+      xml += escapeXml(String(record["#text"]));
+    }
+    Object.keys(record).forEach((key) => {
+      if (key !== "@attributes" && key !== "#text") {
+        const value = record[key];
+        if (Array.isArray(value)) {
+          value.forEach((item) => {
+            xml += jsonToXmlElement(item, key);
+          });
+        } else {
+          xml += jsonToXmlElement(value, key);
+        }
+      }
+    });
+    xml += `</${tagName}>`;
+    return xml;
+  }
+  return `<${tagName}></${tagName}>`;
+}
+function escapeXml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function yamlToJson(yaml) {
+  const lines = yaml.split(/\r?\n/);
+  const result = {};
+  const stack = [
+    { obj: result, indent: -1 }
+  ];
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const indent = line.length - line.trimStart().length;
+    const current = stack[stack.length - 1];
+    while (stack.length > 1 && indent <= current.indent) {
+      stack.pop();
+    }
+    const match = trimmed.match(/^([^:]+):\s*(.*)$/);
+    if (match) {
+      const key = match[1].trim();
+      const valueStr = match[2].trim();
+      let parsedValue;
+      if (valueStr === "") {
+        parsedValue = {};
+      } else if (valueStr === "[]") {
+        parsedValue = [];
+      } else if (valueStr.startsWith("[") && valueStr.endsWith("]")) {
+        parsedValue = parseYamlArray(valueStr);
+      } else if (valueStr === "true" || valueStr === "True") {
+        parsedValue = true;
+      } else if (valueStr === "false" || valueStr === "False") {
+        parsedValue = false;
+      } else if (valueStr === "null" || valueStr === "Null" || valueStr === "~") {
+        parsedValue = null;
+      } else if (/^-?\d+$/.test(valueStr)) {
+        parsedValue = parseInt(valueStr, 10);
+      } else if (/^-?\d+\.\d+$/.test(valueStr)) {
+        parsedValue = parseFloat(valueStr);
+      } else if (valueStr.startsWith('"') && valueStr.endsWith('"')) {
+        parsedValue = valueStr.slice(1, -1).replace(/\\"/g, '"');
+      } else if (valueStr.startsWith("'") && valueStr.endsWith("'")) {
+        parsedValue = valueStr.slice(1, -1);
+      } else {
+        parsedValue = valueStr;
+      }
+      const currentObj = stack[stack.length - 1].obj;
+      if (typeof parsedValue === "object" && parsedValue !== null && !Array.isArray(parsedValue)) {
+        stack.push({ obj: parsedValue, indent });
+      }
+      currentObj[key] = parsedValue;
+    }
+  }
+  return result;
+}
+function parseYamlArray(str) {
+  const content = str.slice(1, -1).trim();
+  if (!content) return [];
+  const items = [];
+  const parts = content.split(",").map((s) => s.trim());
+  parts.forEach((part) => {
+    if (part.startsWith('"') && part.endsWith('"')) {
+      items.push(part.slice(1, -1).replace(/\\"/g, '"'));
+    } else if (part.startsWith("'") && part.endsWith("'")) {
+      items.push(part.slice(1, -1));
+    } else if (part === "true" || part === "True") {
+      items.push(true);
+    } else if (part === "false" || part === "False") {
+      items.push(false);
+    } else if (part === "null" || part === "Null") {
+      items.push(null);
+    } else if (/^-?\d+$/.test(part)) {
+      items.push(parseInt(part, 10));
+    } else if (/^-?\d+\.\d+$/.test(part)) {
+      items.push(parseFloat(part));
+    } else {
+      items.push(part);
+    }
+  });
+  return items;
+}
+function jsonToYaml(json, indent = 2) {
+  return jsonToYamlValue(json, 0, indent);
+}
+function jsonToYamlValue(value, level, indent) {
+  const spaces = " ".repeat(level * indent);
+  if (value === null) {
+    return "null";
+  }
+  if (typeof value === "string") {
+    if (value.includes(":") || value.includes("\n") || value.includes('"')) {
+      return `"${value.replace(/"/g, '\\"')}"`;
+    }
+    return value;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    return value.map((item) => `${spaces}- ${jsonToYamlValue(item, level + 1, indent)}`).join("\n");
+  }
+  if (typeof value === "object") {
+    const obj = value;
+    const keys = Object.keys(obj);
+    if (keys.length === 0) {
+      return "{}";
+    }
+    return keys.map((key) => {
+      const val = obj[key];
+      const keyStr = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(key) ? key : `"${key}"`;
+      const valStr = jsonToYamlValue(val, level + 1, indent);
+      if (typeof val === "object" && val !== null) {
+        return `${spaces}${keyStr}:
+${valStr}`;
+      }
+      return `${spaces}${keyStr}: ${valStr}`;
+    }).join("\n");
+  }
+  return String(value);
+}
 
-var chunkZDMFMUDR_js = require('./chunk-ZDMFMUDR.js');
-require('./chunk-PR4QN5HX.js');
-
-
-
-Object.defineProperty(exports, "csvToJson", {
-  enumerable: true,
-  get: function () { return chunkZDMFMUDR_js.csvToJson; }
-});
-Object.defineProperty(exports, "jsonToCsv", {
-  enumerable: true,
-  get: function () { return chunkZDMFMUDR_js.jsonToCsv; }
-});
-Object.defineProperty(exports, "jsonToXml", {
-  enumerable: true,
-  get: function () { return chunkZDMFMUDR_js.jsonToXml; }
-});
-Object.defineProperty(exports, "jsonToYaml", {
-  enumerable: true,
-  get: function () { return chunkZDMFMUDR_js.jsonToYaml; }
-});
-Object.defineProperty(exports, "xmlToJson", {
-  enumerable: true,
-  get: function () { return chunkZDMFMUDR_js.xmlToJson; }
-});
-Object.defineProperty(exports, "yamlToJson", {
-  enumerable: true,
-  get: function () { return chunkZDMFMUDR_js.yamlToJson; }
-});
-//# sourceMappingURL=transform.js.map
-//# sourceMappingURL=transform.js.map
+export { csvToJson, jsonToCsv, jsonToXml, jsonToYaml, xmlToJson, yamlToJson };

package/dist/{chunk-NJARVI6X.mjs → upload.cjs}

@@ -1,15 +1,42 @@
-import { splitFileIntoChunks, calculateBlobMD5 } from './chunk-ZVJ6NQUM.mjs';
+'use strict';
 
-// src/types/upload.ts
-var UploadStatus = /* @__PURE__ */ ((UploadStatus2) => {
-  UploadStatus2["PENDING"] = "pending";
-  UploadStatus2["UPLOADING"] = "uploading";
-  UploadStatus2["PAUSED"] = "paused";
-  UploadStatus2["COMPLETED"] = "completed";
-  UploadStatus2["FAILED"] = "failed";
-  UploadStatus2["CANCELLED"] = "cancelled";
-  return UploadStatus2;
-})(UploadStatus || {});
+// src/browser/file.ts
+async function calculateBlobMD5(blob) {
+  return new Promise((resolve, reject) => {
+    if (typeof FileReader === "undefined") {
+      reject(new Error("FileReader is not supported in this environment"));
+      return;
+    }
+    const reader = new FileReader();
+    reader.onload = async (e) => {
+      try {
+        const arrayBuffer = e.target?.result;
+        if (!arrayBuffer) {
+          reject(new Error("Failed to read blob"));
+          return;
+        }
+        const hashBuffer = await crypto.subtle.digest("SHA-256", arrayBuffer);
+        const hashArray = Array.from(new Uint8Array(hashBuffer));
+        const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+        resolve(hashHex);
+      } catch (error) {
+        reject(error);
+      }
+    };
+    reader.onerror = reject;
+    reader.readAsArrayBuffer(blob);
+  });
+}
+function splitFileIntoChunks(file, chunkSize) {
+  const chunks = [];
+  let start = 0;
+  while (start < file.size) {
+    const end = Math.min(start + chunkSize, file.size);
+    chunks.push(file.slice(start, end));
+    start = end;
+  }
+  return chunks;
+}
 
 // src/browser/upload.ts
 var ChunkUploader = class {
@@ -376,6 +403,6 @@ async function uploadFile(file, options) {
   return uploader.upload();
 }
 
-export { ChunkUploader, UploadStatus, createUploader, uploadFile };
-//# sourceMappingURL=chunk-NJARVI6X.mjs.map
-//# sourceMappingURL=chunk-NJARVI6X.mjs.map
+exports.ChunkUploader = ChunkUploader;
+exports.createUploader = createUploader;
+exports.uploadFile = uploadFile;