@cogitator-ai/wasm-tools 0.4.1 → 0.5.0

package/dist/temp/csv.js

@@ -0,0 +1,154 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/csv.ts
+var csv_exports = {};
+__export(csv_exports, {
+  csv: () => csv
+});
+module.exports = __toCommonJS(csv_exports);
+function parseCsv(data, delimiter, quote, hasHeaders) {
+  const rows = [];
+  let currentRow = [];
+  let currentField = "";
+  let inQuotes = false;
+  let i = 0;
+  while (i < data.length) {
+    const char = data[i];
+    const nextChar = data[i + 1];
+    if (inQuotes) {
+      if (char === quote) {
+        if (nextChar === quote) {
+          currentField += quote;
+          i += 2;
+          continue;
+        } else {
+          inQuotes = false;
+          i++;
+          continue;
+        }
+      } else {
+        currentField += char;
+        i++;
+        continue;
+      }
+    }
+    if (char === quote) {
+      inQuotes = true;
+      i++;
+      continue;
+    }
+    if (char === delimiter) {
+      currentRow.push(currentField);
+      currentField = "";
+      i++;
+      continue;
+    }
+    if (char === "\r" && nextChar === "\n") {
+      currentRow.push(currentField);
+      rows.push(currentRow);
+      currentRow = [];
+      currentField = "";
+      i += 2;
+      continue;
+    }
+    if (char === "\n" || char === "\r") {
+      currentRow.push(currentField);
+      rows.push(currentRow);
+      currentRow = [];
+      currentField = "";
+      i++;
+      continue;
+    }
+    currentField += char;
+    i++;
+  }
+  if (currentField || currentRow.length > 0) {
+    currentRow.push(currentField);
+    rows.push(currentRow);
+  }
+  const filteredRows = rows.filter((row) => row.length > 0 && !(row.length === 1 && row[0] === ""));
+  if (hasHeaders && filteredRows.length > 0) {
+    const headers = filteredRows[0];
+    return { rows: filteredRows.slice(1), headers };
+  }
+  return { rows: filteredRows };
+}
+function stringifyCsv(data, delimiter, quote, headers) {
+  const rows = [];
+  const escapeField = (field) => {
+    if (field === null || field === void 0) return "";
+    const str = String(field);
+    const needsQuotes = str.includes(delimiter) || str.includes(quote) || str.includes("\n") || str.includes("\r");
+    if (needsQuotes) {
+      const escaped = str.replace(new RegExp(quote, "g"), quote + quote);
+      return quote + escaped + quote;
+    }
+    return str;
+  };
+  if (headers && headers.length > 0) {
+    rows.push(headers.map(escapeField).join(delimiter));
+  }
+  for (const row of data) {
+    rows.push(row.map(escapeField).join(delimiter));
+  }
+  return rows.join("\n");
+}
+function csv() {
+  try {
+    const inputStr = Host.inputString();
+    const input = JSON.parse(inputStr);
+    const delimiter = input.delimiter ?? ",";
+    const quote = input.quote ?? '"';
+    let result;
+    let rowCount;
+    let columnCount;
+    let headers;
+    if (input.operation === "parse") {
+      const hasHeaders = input.headers ?? false;
+      const parsed = parseCsv(input.data, delimiter, quote, hasHeaders);
+      result = parsed.rows;
+      headers = parsed.headers;
+      rowCount = parsed.rows.length;
+      columnCount = parsed.rows[0]?.length ?? 0;
+    } else {
+      headers = input.headers;
+      result = stringifyCsv(input.data, delimiter, quote, headers);
+      rowCount = input.data.length;
+      columnCount = input.data[0]?.length ?? 0;
+    }
+    const output = {
+      result,
+      rowCount,
+      columnCount,
+      headers
+    };
+    Host.outputString(JSON.stringify(output));
+    return 0;
+  } catch (error) {
+    const output = {
+      result: [],
+      rowCount: 0,
+      columnCount: 0,
+      error: error instanceof Error ? error.message : String(error)
+    };
+    Host.outputString(JSON.stringify(output));
+    return 1;
+  }
+}

package/dist/temp/datetime.js

@@ -0,0 +1,196 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/datetime.ts
+var datetime_exports = {};
+__export(datetime_exports, {
+  datetime: () => datetime
+});
+module.exports = __toCommonJS(datetime_exports);
+function parseOffset(tz) {
+  if (!tz || tz === "UTC" || tz === "Z") return 0;
+  const match = tz.match(/^([+-])(\d{2}):?(\d{2})$/);
+  if (!match) return 0;
+  const sign = match[1] === "+" ? 1 : -1;
+  const hours = parseInt(match[2], 10);
+  const minutes = parseInt(match[3], 10);
+  return sign * (hours * 60 + minutes) * 60 * 1e3;
+}
+function parseDate(dateStr) {
+  const isoMatch = dateStr.match(
+    /^(\d{4})-(\d{2})-(\d{2})(?:T(\d{2}):(\d{2}):(\d{2})(?:\.(\d{3}))?(?:Z|([+-]\d{2}:?\d{2}))?)?$/
+  );
+  if (isoMatch) {
+    const [, year, month, day, hour = "0", min = "0", sec = "0", ms = "0", tz] = isoMatch;
+    const date = new Date(Date.UTC(
+      parseInt(year, 10),
+      parseInt(month, 10) - 1,
+      parseInt(day, 10),
+      parseInt(hour, 10),
+      parseInt(min, 10),
+      parseInt(sec, 10),
+      parseInt(ms, 10)
+    ));
+    if (tz) {
+      const offset = parseOffset(tz);
+      date.setTime(date.getTime() - offset);
+    }
+    return date;
+  }
+  const timestamp = Date.parse(dateStr);
+  if (!isNaN(timestamp)) {
+    return new Date(timestamp);
+  }
+  throw new Error(`Cannot parse date: ${dateStr}`);
+}
+function formatDate(date, formatStr, offsetMs = 0) {
+  const adjusted = new Date(date.getTime() + offsetMs);
+  const year = adjusted.getUTCFullYear();
+  const month = adjusted.getUTCMonth() + 1;
+  const day = adjusted.getUTCDate();
+  const hours = adjusted.getUTCHours();
+  const minutes = adjusted.getUTCMinutes();
+  const seconds = adjusted.getUTCSeconds();
+  const ms = adjusted.getUTCMilliseconds();
+  const pad = (n, len = 2) => String(n).padStart(len, "0");
+  const offsetHours = Math.floor(Math.abs(offsetMs) / 36e5);
+  const offsetMins = Math.floor(Math.abs(offsetMs) % 36e5 / 6e4);
+  const offsetSign = offsetMs >= 0 ? "+" : "-";
+  const offsetStr = offsetMs === 0 ? "Z" : `${offsetSign}${pad(offsetHours)}:${pad(offsetMins)}`;
+  return formatStr.replace("YYYY", String(year)).replace("MM", pad(month)).replace("DD", pad(day)).replace("HH", pad(hours)).replace("mm", pad(minutes)).replace("ss", pad(seconds)).replace("SSS", pad(ms, 3)).replace("Z", offsetStr);
+}
+function addToDate(date, amount, unit) {
+  const result = new Date(date.getTime());
+  switch (unit) {
+    case "years":
+      result.setUTCFullYear(result.getUTCFullYear() + amount);
+      break;
+    case "months":
+      result.setUTCMonth(result.getUTCMonth() + amount);
+      break;
+    case "days":
+      result.setUTCDate(result.getUTCDate() + amount);
+      break;
+    case "hours":
+      result.setUTCHours(result.getUTCHours() + amount);
+      break;
+    case "minutes":
+      result.setUTCMinutes(result.getUTCMinutes() + amount);
+      break;
+    case "seconds":
+      result.setUTCSeconds(result.getUTCSeconds() + amount);
+      break;
+    case "milliseconds":
+      result.setTime(result.getTime() + amount);
+      break;
+    default:
+      throw new Error(`Unknown unit: ${unit}`);
+  }
+  return result;
+}
+function dateDiff(date1, date2, unit) {
+  const diffMs = date2.getTime() - date1.getTime();
+  switch (unit) {
+    case "years":
+      return date2.getUTCFullYear() - date1.getUTCFullYear();
+    case "months":
+      return (date2.getUTCFullYear() - date1.getUTCFullYear()) * 12 + (date2.getUTCMonth() - date1.getUTCMonth());
+    case "days":
+      return Math.floor(diffMs / (24 * 60 * 60 * 1e3));
+    case "hours":
+      return Math.floor(diffMs / (60 * 60 * 1e3));
+    case "minutes":
+      return Math.floor(diffMs / (60 * 1e3));
+    case "seconds":
+      return Math.floor(diffMs / 1e3);
+    case "milliseconds":
+      return diffMs;
+    default:
+      return diffMs;
+  }
+}
+function datetime() {
+  try {
+    const inputStr = Host.inputString();
+    const input = JSON.parse(inputStr);
+    const offsetMs = parseOffset(input.timezone);
+    let date;
+    let result;
+    switch (input.operation) {
+      case "now":
+        date = /* @__PURE__ */ new Date();
+        result = date.toISOString();
+        break;
+      case "parse":
+        if (!input.date) throw new Error("date is required for parse operation");
+        date = parseDate(input.date);
+        result = date.toISOString();
+        break;
+      case "format":
+        if (!input.date) throw new Error("date is required for format operation");
+        date = parseDate(input.date);
+        const format = input.format ?? "YYYY-MM-DDTHH:mm:ssZ";
+        result = formatDate(date, format, offsetMs);
+        break;
+      case "add":
+        if (!input.date) throw new Error("date is required for add operation");
+        if (input.amount === void 0) throw new Error("amount is required for add operation");
+        if (!input.unit) throw new Error("unit is required for add operation");
+        date = parseDate(input.date);
+        date = addToDate(date, input.amount, input.unit);
+        result = date.toISOString();
+        break;
+      case "subtract":
+        if (!input.date) throw new Error("date is required for subtract operation");
+        if (input.amount === void 0) throw new Error("amount is required for subtract operation");
+        if (!input.unit) throw new Error("unit is required for subtract operation");
+        date = parseDate(input.date);
+        date = addToDate(date, -input.amount, input.unit);
+        result = date.toISOString();
+        break;
+      case "diff":
+        if (!input.date) throw new Error("date is required for diff operation");
+        if (!input.endDate) throw new Error("endDate is required for diff operation");
+        date = parseDate(input.date);
+        const endDate = parseDate(input.endDate);
+        result = dateDiff(date, endDate, input.unit ?? "milliseconds");
+        break;
+      default:
+        throw new Error(`Unknown operation: ${input.operation}`);
+    }
+    const outputDate = input.operation === "diff" ? parseDate(input.date) : date;
+    const output = {
+      result,
+      iso: outputDate.toISOString(),
+      unix: Math.floor(outputDate.getTime() / 1e3),
+      formatted: input.format ? formatDate(outputDate, input.format, offsetMs) : void 0
+    };
+    Host.outputString(JSON.stringify(output));
+    return 0;
+  } catch (error) {
+    const output = {
+      result: "",
+      iso: "",
+      unix: 0,
+      error: error instanceof Error ? error.message : String(error)
+    };
+    Host.outputString(JSON.stringify(output));
+    return 1;
+  }
+}

package/dist/temp/diff.js

@@ -0,0 +1,198 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/plugins/diff.ts
+var diff_exports = {};
+__export(diff_exports, {
+  diff: () => diff
+});
+module.exports = __toCommonJS(diff_exports);
+function myersDiff(oldArr, newArr) {
+  const n = oldArr.length;
+  const m = newArr.length;
+  const max = n + m;
+  if (max === 0) return [];
+  const v = { 1: 0 };
+  const trace = [];
+  outer: for (let d = 0; d <= max; d++) {
+    trace.push({ ...v });
+    for (let k = -d; k <= d; k += 2) {
+      let x2;
+      if (k === -d || k !== d && v[k - 1] < v[k + 1]) {
+        x2 = v[k + 1];
+      } else {
+        x2 = v[k - 1] + 1;
+      }
+      let y2 = x2 - k;
+      while (x2 < n && y2 < m && oldArr[x2] === newArr[y2]) {
+        x2++;
+        y2++;
+      }
+      v[k] = x2;
+      if (x2 >= n && y2 >= m) {
+        break outer;
+      }
+    }
+  }
+  const changes = [];
+  let x = n;
+  let y = m;
+  for (let d = trace.length - 1; d >= 0; d--) {
+    const vPrev = trace[d];
+    const k = x - y;
+    let prevK;
+    if (k === -d || k !== d && vPrev[k - 1] < vPrev[k + 1]) {
+      prevK = k + 1;
+    } else {
+      prevK = k - 1;
+    }
+    const prevX = vPrev[prevK];
+    const prevY = prevX - prevK;
+    while (x > prevX && y > prevY) {
+      changes.unshift({
+        type: "equal",
+        value: oldArr[x - 1],
+        lineNumber: { original: x, modified: y }
+      });
+      x--;
+      y--;
+    }
+    if (d > 0) {
+      if (x === prevX) {
+        changes.unshift({
+          type: "add",
+          value: newArr[y - 1],
+          lineNumber: { modified: y }
+        });
+        y--;
+      } else {
+        changes.unshift({
+          type: "remove",
+          value: oldArr[x - 1],
+          lineNumber: { original: x }
+        });
+        x--;
+      }
+    }
+  }
+  return changes;
+}
+function formatUnified(changes, context) {
+  const lines = [];
+  let i = 0;
+  while (i < changes.length) {
+    let start = i;
+    while (start > 0 && i - start < context && changes[start - 1].type === "equal") {
+      start--;
+    }
+    let end = i;
+    while (end < changes.length) {
+      if (changes[end].type !== "equal") {
+        let nextChange = end + 1;
+        while (nextChange < changes.length && changes[nextChange].type === "equal") {
+          nextChange++;
+        }
+        if (nextChange - end <= context * 2 && nextChange < changes.length) {
+          end = nextChange;
+        } else {
+          end = Math.min(end + context, changes.length - 1);
+          break;
+        }
+      }
+      end++;
+    }
+    if (end >= changes.length) end = changes.length - 1;
+    let hasChanges = false;
+    for (let j = start; j <= end; j++) {
+      if (changes[j].type !== "equal") {
+        hasChanges = true;
+        break;
+      }
+    }
+    if (hasChanges) {
+      for (let j = start; j <= end; j++) {
+        const change = changes[j];
+        if (change.type === "add") {
+          lines.push(`+ ${change.value}`);
+        } else if (change.type === "remove") {
+          lines.push(`- ${change.value}`);
+        } else {
+          lines.push(`  ${change.value}`);
+        }
+      }
+    }
+    i = end + 1;
+    while (i < changes.length && changes[i].type === "equal") {
+      i++;
+    }
+  }
+  return lines.join("\n");
+}
+function formatInline(changes) {
+  const lines = [];
+  for (const change of changes) {
+    if (change.type === "add") {
+      lines.push(`[+] ${change.value}`);
+    } else if (change.type === "remove") {
+      lines.push(`[-] ${change.value}`);
+    } else {
+      lines.push(`    ${change.value}`);
+    }
+  }
+  return lines.join("\n");
+}
+function diff() {
+  try {
+    const inputStr = Host.inputString();
+    const input = JSON.parse(inputStr);
+    const format = input.format ?? "unified";
+    const context = input.context ?? 3;
+    const oldLines = input.original.split("\n");
+    const newLines = input.modified.split("\n");
+    const changes = myersDiff(oldLines, newLines);
+    const additions = changes.filter((c) => c.type === "add").length;
+    const deletions = changes.filter((c) => c.type === "remove").length;
+    let diffStr;
+    if (format === "json") {
+      diffStr = JSON.stringify(changes);
+    } else if (format === "inline") {
+      diffStr = formatInline(changes);
+    } else {
+      diffStr = formatUnified(changes, context);
+    }
+    const output = {
+      diff: diffStr,
+      additions,
+      deletions,
+      changes
+    };
+    Host.outputString(JSON.stringify(output));
+    return 0;
+  } catch (error) {
+    const output = {
+      diff: "",
+      additions: 0,
+      deletions: 0,
+      changes: [],
+      error: error instanceof Error ? error.message : String(error)
+    };
+    Host.outputString(JSON.stringify(output));
+    return 1;
+  }
+}