@softium/table-core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,769 @@
+'use strict';
+
+// src/adapters/adaptArray.ts
+function adaptArray(raw) {
+  if (!Array.isArray(raw)) {
+    throw new TypeError(
+      `adaptArray expected an array, received ${raw === null ? "null" : typeof raw}.`
+    );
+  }
+  return raw;
+}
+
+// src/adapters/util.ts
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function getProp(value, key) {
+  return isRecord(value) ? value[key] : void 0;
+}
+function asNumber(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+// src/adapters/adaptPaginated.ts
+function adaptPaginated(raw, options = {}) {
+  const {
+    dataKey = "data",
+    totalKey = "total",
+    pageKey = "page",
+    pageSizeKey = "pageSize"
+  } = options;
+  const rawData = getProp(raw, dataKey);
+  if (!Array.isArray(rawData)) {
+    throw new TypeError(
+      `adaptPaginated expected an array at "${dataKey}", received ${rawData === void 0 ? "undefined" : typeof rawData}.`
+    );
+  }
+  const data = rawData;
+  const total = asNumber(getProp(raw, totalKey), data.length);
+  const page = asNumber(getProp(raw, pageKey), 1);
+  const pageSize = asNumber(getProp(raw, pageSizeKey), data.length);
+  return { data, total, page, pageSize };
+}
+
+// src/adapters/adaptDynamicSchema.ts
+var KNOWN_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "number",
+  "date",
+  "boolean",
+  "select",
+  "custom"
+]);
+function toColumnType(value) {
+  return typeof value === "string" && KNOWN_TYPES.has(value) ? value : void 0;
+}
+function adaptDynamicSchema(raw, options = {}) {
+  const {
+    columnsKey = "columns",
+    rowsKey = "rows",
+    fieldKey = "field",
+    labelKey = "label",
+    typeKey = "type"
+  } = options;
+  const rawColumns = getProp(raw, columnsKey);
+  if (!Array.isArray(rawColumns)) {
+    throw new TypeError(
+      `adaptDynamicSchema expected an array at "${columnsKey}", received ${typeof rawColumns}.`
+    );
+  }
+  const rawRows = getProp(raw, rowsKey);
+  if (!Array.isArray(rawRows)) {
+    throw new TypeError(
+      `adaptDynamicSchema expected an array at "${rowsKey}", received ${typeof rawRows}.`
+    );
+  }
+  const columns = rawColumns.map((descriptor, i) => {
+    if (!isRecord(descriptor)) {
+      throw new TypeError(`adaptDynamicSchema: column descriptor at index ${i} is not an object.`);
+    }
+    const field = descriptor[fieldKey];
+    if (typeof field !== "string" || field.length === 0) {
+      throw new TypeError(
+        `adaptDynamicSchema: column descriptor at index ${i} has no string "${fieldKey}".`
+      );
+    }
+    const rawLabel = descriptor[labelKey];
+    const label = typeof rawLabel === "string" && rawLabel.length > 0 ? rawLabel : field;
+    const type = toColumnType(descriptor[typeKey]);
+    return {
+      key: field,
+      label,
+      ...type ? { type } : {}
+    };
+  });
+  return { columns, data: rawRows };
+}
+
+// src/derive/columns.ts
+function createInitialColumnState(defs) {
+  return defs.map((def, index) => ({
+    key: def.key,
+    visible: true,
+    order: index,
+    width: def.width,
+    pinned: null
+  }));
+}
+function reconcileColumnState(defs, stored) {
+  const storedByKey = new Map(stored.map((s) => [s.key, s]));
+  const maxOrder = stored.reduce((m, s) => Math.max(m, s.order), -1);
+  let nextOrder = maxOrder + 1;
+  return defs.map((def) => {
+    const existing = storedByKey.get(def.key);
+    if (existing) return existing;
+    return {
+      key: def.key,
+      visible: true,
+      order: nextOrder++,
+      width: def.width,
+      pinned: null
+    };
+  });
+}
+var PIN_GROUP = {
+  left: 0,
+  none: 1,
+  right: 2
+};
+function pinGroup(pinned) {
+  if (pinned === "left") return PIN_GROUP.left;
+  if (pinned === "right") return PIN_GROUP.right;
+  return PIN_GROUP.none;
+}
+function resolveColumns(defs, state) {
+  const stateByKey = /* @__PURE__ */ new Map();
+  for (const s of state) stateByKey.set(s.key, s);
+  const resolved = [];
+  defs.forEach((def, index) => {
+    const s = stateByKey.get(def.key);
+    const visible = s?.visible ?? true;
+    if (!visible) return;
+    const order = s?.order ?? index;
+    const pinned = s?.pinned ?? null;
+    const labelOverride = s?.labelOverride;
+    const type = def.type ?? "text";
+    const width = s?.width ?? def.width ?? (def.flex ? void 0 : defaultWidthForType(type));
+    resolved.push({
+      key: def.key,
+      label: def.label,
+      displayLabel: labelOverride && labelOverride.length > 0 ? labelOverride : def.label,
+      type,
+      align: s?.align ?? def.align ?? defaultAlign(def.type),
+      order,
+      visible: true,
+      pinned,
+      width,
+      minWidth: def.minWidth,
+      maxWidth: def.maxWidth,
+      flex: def.flex,
+      // interaction defaults: on unless opted out; filtering is opt-in via `filterable`
+      sortable: def.sortable ?? true,
+      filterable: def.filterable ?? false,
+      resizable: def.resizable ?? true,
+      pinnable: def.pinnable ?? true,
+      hideable: def.hideable ?? true,
+      editable: def.editable ?? false,
+      copyable: def.copyable ?? true,
+      renderCell: def.renderCell,
+      renderHeader: def.renderHeader,
+      def
+    });
+  });
+  return resolved.sort((a, b) => {
+    const groupDiff = pinGroup(a.pinned) - pinGroup(b.pinned);
+    if (groupDiff !== 0) return groupDiff;
+    return a.order - b.order;
+  });
+}
+function defaultAlign(type) {
+  if (type === "number") return "right";
+  if (type === "boolean") return "center";
+  return "left";
+}
+function defaultWidthForType(type) {
+  switch (type) {
+    case "boolean":
+      return 72;
+    case "number":
+      return 120;
+    case "date":
+      return 128;
+    case "select":
+      return 150;
+    default:
+      return 140;
+  }
+}
+
+// src/derive/columnOps.ts
+function patchColumnState(state, key, patch) {
+  return state.map((s) => s.key === key ? { ...s, ...patch } : s);
+}
+function setColumnVisible(state, key, visible) {
+  return patchColumnState(state, key, { visible });
+}
+function setColumnPinned(state, key, pinned) {
+  return patchColumnState(state, key, { pinned });
+}
+function setColumnWidth(state, key, width) {
+  return patchColumnState(state, key, { width: Math.max(0, Math.round(width)) });
+}
+function setColumnAlign(state, key, align) {
+  return patchColumnState(state, key, { align });
+}
+function setColumnLabelOverride(state, key, labelOverride) {
+  const trimmed = labelOverride?.trim();
+  return patchColumnState(state, key, {
+    labelOverride: trimmed && trimmed.length > 0 ? trimmed : void 0
+  });
+}
+function arrayMove(arr, from, to) {
+  const next = arr.slice();
+  const [moved] = next.splice(from, 1);
+  if (moved === void 0) return next;
+  next.splice(to, 0, moved);
+  return next;
+}
+function moveColumn(state, activeKey, overKey) {
+  if (activeKey === overKey) return state;
+  const ordered = [...state].sort((a, b) => a.order - b.order);
+  const from = ordered.findIndex((s) => s.key === activeKey);
+  const to = ordered.findIndex((s) => s.key === overKey);
+  if (from === -1 || to === -1) return state;
+  const moved = arrayMove(ordered, from, to);
+  const orderByKey = /* @__PURE__ */ new Map();
+  moved.forEach((s, i) => orderByKey.set(s.key, i));
+  return state.map((s) => ({ ...s, order: orderByKey.get(s.key) ?? s.order }));
+}
+
+// src/derive/sort.ts
+function toComparable(value, type) {
+  if (value === null || value === void 0)
+    return type === "number" ? Number.NEGATIVE_INFINITY : "";
+  if (type === "number") {
+    const n = typeof value === "number" ? value : Number(value);
+    return Number.isNaN(n) ? Number.NEGATIVE_INFINITY : n;
+  }
+  if (type === "date") {
+    const t = value instanceof Date ? value.getTime() : new Date(String(value)).getTime();
+    return Number.isNaN(t) ? Number.NEGATIVE_INFINITY : t;
+  }
+  if (type === "boolean") return value ? 1 : 0;
+  return String(value).toLocaleLowerCase();
+}
+function compare(a, b, type) {
+  const ca = toComparable(a, type);
+  const cb = toComparable(b, type);
+  if (typeof ca === "number" && typeof cb === "number") return ca - cb;
+  return String(ca).localeCompare(String(cb));
+}
+function sortRows(data, rules, getSort) {
+  if (rules.length === 0) return data;
+  return [...data].sort((ra, rb) => {
+    for (const rule of rules) {
+      const cfg = getSort(rule.columnKey);
+      let diff;
+      if (cfg?.comparator) {
+        diff = cfg.comparator(ra, rb);
+      } else {
+        const key = rule.columnKey;
+        const av = cfg?.accessor ? cfg.accessor(ra) : ra[key];
+        const bv = cfg?.accessor ? cfg.accessor(rb) : rb[key];
+        diff = compare(av, bv, cfg?.type);
+      }
+      if (diff !== 0) return rule.direction === "asc" ? diff : -diff;
+    }
+    return 0;
+  });
+}
+function toggleSort(rules, columnKey, multi = false) {
+  const existing = rules.find((r) => r.columnKey === columnKey);
+  const others = multi ? rules.filter((r) => r.columnKey !== columnKey) : [];
+  if (!existing) return [...others, { columnKey, direction: "asc" }];
+  if (existing.direction === "asc") return [...others, { columnKey, direction: "desc" }];
+  return others;
+}
+
+// src/derive/filter.ts
+function num(value) {
+  if (typeof value === "number") return value;
+  if (value instanceof Date) return value.getTime();
+  const n = Number(value);
+  return Number.isNaN(n) ? Number.NaN : n;
+}
+function text(value) {
+  return value === null || value === void 0 ? "" : String(value).toLocaleLowerCase();
+}
+function matchesFilter(value, filter, type) {
+  const { operator, value: target, value2 } = filter;
+  switch (operator) {
+    case "eq":
+      return type === "number" ? num(value) === num(target) : text(value) === text(target);
+    case "neq":
+      return type === "number" ? num(value) !== num(target) : text(value) !== text(target);
+    case "gt":
+      return num(value) > num(target);
+    case "lt":
+      return num(value) < num(target);
+    case "gte":
+      return num(value) >= num(target);
+    case "lte":
+      return num(value) <= num(target);
+    case "contains":
+      return text(value).includes(text(target));
+    case "between": {
+      const v = num(value);
+      return v >= num(target) && v <= num(value2);
+    }
+    case "in":
+      return Array.isArray(target) && target.some((t) => text(value) === text(t));
+    default:
+      return true;
+  }
+}
+function applyFilters(data, filters, getType) {
+  if (filters.length === 0) return data;
+  return data.filter(
+    (row) => filters.every((f) => matchesFilter(row[f.columnKey], f, getType(f.columnKey)))
+  );
+}
+
+// src/derive/search.ts
+function applySearch(data, search, allKeys) {
+  const query = search.query.trim().toLocaleLowerCase();
+  if (query.length === 0) return data;
+  const keys = search.scope === "all" ? allKeys : search.scope;
+  return data.filter(
+    (row) => keys.some((key) => {
+      const value = row[key];
+      if (value === null || value === void 0) return false;
+      return String(value).toLocaleLowerCase().includes(query);
+    })
+  );
+}
+
+// src/derive/paginate.ts
+function getPageCount(total, pageSize) {
+  if (pageSize <= 0) return 1;
+  return Math.max(1, Math.ceil(total / pageSize));
+}
+function clampPage(page, total, pageSize) {
+  const count = getPageCount(total, pageSize);
+  return Math.min(Math.max(1, Math.floor(page)), count);
+}
+function paginate(data, page, pageSize) {
+  if (pageSize <= 0) {
+    return { items: data, offset: 0, page: 1, pageCount: 1 };
+  }
+  const safePage = clampPage(page, data.length, pageSize);
+  const offset = (safePage - 1) * pageSize;
+  return {
+    items: data.slice(offset, offset + pageSize),
+    offset,
+    page: safePage,
+    pageCount: getPageCount(data.length, pageSize)
+  };
+}
+
+// src/derive/pivot.ts
+function newAcc() {
+  return { sum: 0, n: 0, rows: 0, min: Number.POSITIVE_INFINITY, max: Number.NEGATIVE_INFINITY };
+}
+function add(acc, value) {
+  acc.rows += 1;
+  const num2 = typeof value === "number" ? value : Number(value);
+  if (!Number.isNaN(num2) && value !== null && value !== void 0 && value !== "") {
+    acc.sum += num2;
+    acc.n += 1;
+    if (num2 < acc.min) acc.min = num2;
+    if (num2 > acc.max) acc.max = num2;
+  }
+}
+function finalize(acc, agg) {
+  if (!acc) return null;
+  if (agg === "count") return acc.rows;
+  if (acc.n === 0) return null;
+  switch (agg) {
+    case "sum":
+      return acc.sum;
+    case "avg":
+      return acc.sum / acc.n;
+    case "min":
+      return acc.min;
+    case "max":
+      return acc.max;
+    default:
+      return null;
+  }
+}
+function pathOf(row, fields) {
+  return fields.map((f) => {
+    const v = row[f];
+    return v === null || v === void 0 ? "" : String(v);
+  });
+}
+function pivot(data, config) {
+  const { rows: rowFields, columns: colFields, value, aggregate } = config;
+  const cells = /* @__PURE__ */ new Map();
+  const rowAcc = /* @__PURE__ */ new Map();
+  const colAcc = /* @__PURE__ */ new Map();
+  const grand = newAcc();
+  const rowKeyPaths = /* @__PURE__ */ new Map();
+  const colKeyPaths = /* @__PURE__ */ new Map();
+  for (const row of data) {
+    const rPath = pathOf(row, rowFields);
+    const cPath = pathOf(row, colFields);
+    const rKey = rPath.join("\0");
+    const cKey = cPath.join("\0");
+    rowKeyPaths.set(rKey, rPath);
+    colKeyPaths.set(cKey, cPath);
+    const v = row[value];
+    let byCol = cells.get(rKey);
+    if (!byCol) {
+      byCol = /* @__PURE__ */ new Map();
+      cells.set(rKey, byCol);
+    }
+    let acc = byCol.get(cKey);
+    if (!acc) {
+      acc = newAcc();
+      byCol.set(cKey, acc);
+    }
+    add(acc, v);
+    let ra = rowAcc.get(rKey);
+    if (!ra) {
+      ra = newAcc();
+      rowAcc.set(rKey, ra);
+    }
+    add(ra, v);
+    let ca = colAcc.get(cKey);
+    if (!ca) {
+      ca = newAcc();
+      colAcc.set(cKey, ca);
+    }
+    add(ca, v);
+    add(grand, v);
+  }
+  const byPath = (a, b) => a.join("\0").localeCompare(b.join("\0"));
+  const rowKeys = [...rowKeyPaths.values()].sort(byPath);
+  const columnKeys = [...colKeyPaths.values()].sort(byPath);
+  const values = rowKeys.map((rPath) => {
+    const byCol = cells.get(rPath.join("\0"));
+    return columnKeys.map((cPath) => finalize(byCol?.get(cPath.join("\0")), aggregate));
+  });
+  const rowTotals = rowKeys.map((rPath) => finalize(rowAcc.get(rPath.join("\0")), aggregate));
+  const columnTotals = columnKeys.map((cPath) => finalize(colAcc.get(cPath.join("\0")), aggregate));
+  return {
+    rowFields,
+    columnFields: colFields,
+    value,
+    aggregate,
+    rowKeys,
+    columnKeys,
+    values,
+    rowTotals,
+    columnTotals,
+    grandTotal: finalize(grand, aggregate)
+  };
+}
+
+// src/derive/rows.ts
+function buildRows(data, options = {}) {
+  const { getRowId, offset = 0 } = options;
+  return data.map((item, i) => {
+    const displayIndex = i + 1;
+    const globalIndex = offset + i + 1;
+    return {
+      rowId: getRowId ? getRowId(item) : String(globalIndex),
+      displayIndex,
+      globalIndex,
+      data: item
+    };
+  });
+}
+
+// src/export/csv.ts
+function escapeCell(value, delimiter) {
+  const s = value == null ? "" : String(value);
+  if (s.includes(delimiter) || s.includes('"') || s.includes("\n") || s.includes("\r")) {
+    return `"${s.replace(/"/g, '""')}"`;
+  }
+  return s;
+}
+function toCSV(table, options = {}) {
+  const delimiter = options.delimiter ?? ",";
+  const lines = [table.headers.map((h) => escapeCell(h, delimiter)).join(delimiter)];
+  for (const row of table.rows) {
+    lines.push(row.map((c) => escapeCell(c, delimiter)).join(delimiter));
+  }
+  return lines.join("\r\n");
+}
+
+// src/export/json.ts
+function toJSON(table, options = {}) {
+  const records = table.rows.map((row) => {
+    const obj = {};
+    table.headers.forEach((h, i) => {
+      obj[h] = row[i] ?? null;
+    });
+    return obj;
+  });
+  return JSON.stringify(records, null, options.pretty === false ? void 0 : 2);
+}
+
+// src/export/xml.ts
+function escapeXml(value) {
+  const s = value == null ? "" : String(value);
+  return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
+function toTagName(header, index) {
+  let name = header.replace(/[^A-Za-z0-9_.-]/g, "_");
+  if (!name || !/^[A-Za-z_]/.test(name)) name = `_${name}`;
+  return name || `col${index}`;
+}
+function toXML(table, options = {}) {
+  const root = options.rootTag ?? "rows";
+  const rowTag = options.rowTag ?? "row";
+  const tags = table.headers.map((h, i) => toTagName(h, i));
+  const lines = ['<?xml version="1.0" encoding="UTF-8"?>', `<${root}>`];
+  for (const row of table.rows) {
+    lines.push(`  <${rowTag}>`);
+    row.forEach((cell, i) => {
+      const tag = tags[i] ?? `col${i}`;
+      lines.push(`    <${tag}>${escapeXml(cell)}</${tag}>`);
+    });
+    lines.push(`  </${rowTag}>`);
+  }
+  lines.push(`</${root}>`);
+  return lines.join("\n");
+}
+
+// src/export/zip.ts
+var CRC_TABLE = (() => {
+  const table = new Uint32Array(256);
+  for (let n = 0; n < 256; n++) {
+    let c = n;
+    for (let k = 0; k < 8; k++) c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 1;
+    table[n] = c >>> 0;
+  }
+  return table;
+})();
+function crc32(bytes) {
+  let c = 4294967295;
+  for (let i = 0; i < bytes.length; i++) {
+    const byte = bytes[i] ?? 0;
+    const idx = (c ^ byte) & 255;
+    c = (CRC_TABLE[idx] ?? 0) ^ c >>> 8;
+  }
+  return (c ^ 4294967295) >>> 0;
+}
+function utf8Bytes(str) {
+  const out = [];
+  for (let i = 0; i < str.length; i++) {
+    let code = str.charCodeAt(i);
+    if (code >= 55296 && code <= 56319 && i + 1 < str.length) {
+      const next = str.charCodeAt(i + 1);
+      if (next >= 56320 && next <= 57343) {
+        code = (code - 55296 << 10) + (next - 56320) + 65536;
+        i++;
+      }
+    }
+    if (code < 128) {
+      out.push(code);
+    } else if (code < 2048) {
+      out.push(192 | code >> 6, 128 | code & 63);
+    } else if (code < 65536) {
+      out.push(224 | code >> 12, 128 | code >> 6 & 63, 128 | code & 63);
+    } else {
+      out.push(
+        240 | code >> 18,
+        128 | code >> 12 & 63,
+        128 | code >> 6 & 63,
+        128 | code & 63
+      );
+    }
+  }
+  return Uint8Array.from(out);
+}
+function zipStore(entries) {
+  const prepped = entries.map((e) => {
+    const name = utf8Bytes(e.name);
+    return { name, data: e.data, crc: crc32(e.data), size: e.data.length };
+  });
+  let total = 22;
+  for (const p of prepped) total += 30 + p.name.length + p.size + 46 + p.name.length;
+  const buf = new Uint8Array(total);
+  const dv = new DataView(buf.buffer);
+  let pos = 0;
+  const u16 = (v) => {
+    dv.setUint16(pos, v & 65535, true);
+    pos += 2;
+  };
+  const u32 = (v) => {
+    dv.setUint32(pos, v >>> 0, true);
+    pos += 4;
+  };
+  const write = (b) => {
+    buf.set(b, pos);
+    pos += b.length;
+  };
+  const localOffsets = [];
+  for (const p of prepped) {
+    localOffsets.push(pos);
+    u32(67324752);
+    u16(20);
+    u16(0);
+    u16(0);
+    u16(0);
+    u16(0);
+    u32(p.crc);
+    u32(p.size);
+    u32(p.size);
+    u16(p.name.length);
+    u16(0);
+    write(p.name);
+    write(p.data);
+  }
+  const cdStart = pos;
+  prepped.forEach((p, i) => {
+    u32(33639248);
+    u16(20);
+    u16(20);
+    u16(0);
+    u16(0);
+    u16(0);
+    u16(0);
+    u32(p.crc);
+    u32(p.size);
+    u32(p.size);
+    u16(p.name.length);
+    u16(0);
+    u16(0);
+    u16(0);
+    u16(0);
+    u32(0);
+    u32(localOffsets[i] ?? 0);
+    write(p.name);
+  });
+  const cdSize = pos - cdStart;
+  u32(101010256);
+  u16(0);
+  u16(0);
+  u16(prepped.length);
+  u16(prepped.length);
+  u32(cdSize);
+  u32(cdStart);
+  u16(0);
+  return buf;
+}
+
+// src/export/xlsx.ts
+function colLetter(index) {
+  let s = "";
+  let i = index + 1;
+  while (i > 0) {
+    const rem = (i - 1) % 26;
+    s = String.fromCharCode(65 + rem) + s;
+    i = Math.floor((i - 1) / 26);
+  }
+  return s;
+}
+function cellXml(ref, value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return `<c r="${ref}"><v>${value}</v></c>`;
+  }
+  const s = value == null ? "" : String(value);
+  return `<c r="${ref}" t="inlineStr"><is><t xml:space="preserve">${escapeXml(s)}</t></is></c>`;
+}
+function safeSheetName(name) {
+  return (name.replace(/[[\]:*?/\\]/g, " ").trim() || "Sheet1").slice(0, 31);
+}
+var CONTENT_TYPES = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="xml" ContentType="application/xml"/><Override PartName="/xl/workbook.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml"/><Override PartName="/xl/worksheets/sheet1.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml"/></Types>`;
+var ROOT_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/></Relationships>`;
+var WORKBOOK_RELS = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="worksheets/sheet1.xml"/></Relationships>`;
+function toXLSX(table, options = {}) {
+  const sheetName = safeSheetName(options.sheetName ?? "Sheet1");
+  const matrix = [table.headers, ...table.rows];
+  const rowsXml = matrix.map((row, r) => {
+    const cells = row.map((v, c) => cellXml(`${colLetter(c)}${r + 1}`, v)).join("");
+    return `<row r="${r + 1}">${cells}</row>`;
+  }).join("");
+  const sheet = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"><sheetData>${rowsXml}</sheetData></worksheet>`;
+  const workbook = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets><sheet name="${escapeXml(sheetName)}" sheetId="1" r:id="rId1"/></sheets></workbook>`;
+  return zipStore([
+    { name: "[Content_Types].xml", data: utf8Bytes(CONTENT_TYPES) },
+    { name: "_rels/.rels", data: utf8Bytes(ROOT_RELS) },
+    { name: "xl/workbook.xml", data: utf8Bytes(workbook) },
+    { name: "xl/_rels/workbook.xml.rels", data: utf8Bytes(WORKBOOK_RELS) },
+    { name: "xl/worksheets/sheet1.xml", data: utf8Bytes(sheet) }
+  ]);
+}
+
+// src/export/index.ts
+var EXPORT_FORMAT_META = {
+  csv: { mime: "text/csv;charset=utf-8", ext: "csv" },
+  json: { mime: "application/json;charset=utf-8", ext: "json" },
+  xml: { mime: "application/xml;charset=utf-8", ext: "xml" },
+  xlsx: {
+    mime: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+    ext: "xlsx"
+  }
+};
+function serializeExport(table, format) {
+  switch (format) {
+    case "csv":
+      return toCSV(table);
+    case "json":
+      return toJSON(table);
+    case "xml":
+      return toXML(table);
+    case "xlsx":
+      return toXLSX(table);
+    default:
+      return toCSV(table);
+  }
+}
+
+// src/index.ts
+var VERSION = "0.0.0";
+
+exports.EXPORT_FORMAT_META = EXPORT_FORMAT_META;
+exports.VERSION = VERSION;
+exports.adaptArray = adaptArray;
+exports.adaptDynamicSchema = adaptDynamicSchema;
+exports.adaptPaginated = adaptPaginated;
+exports.applyFilters = applyFilters;
+exports.applySearch = applySearch;
+exports.buildRows = buildRows;
+exports.clampPage = clampPage;
+exports.createInitialColumnState = createInitialColumnState;
+exports.escapeXml = escapeXml;
+exports.getPageCount = getPageCount;
+exports.matchesFilter = matchesFilter;
+exports.moveColumn = moveColumn;
+exports.paginate = paginate;
+exports.patchColumnState = patchColumnState;
+exports.pivot = pivot;
+exports.reconcileColumnState = reconcileColumnState;
+exports.resolveColumns = resolveColumns;
+exports.serializeExport = serializeExport;
+exports.setColumnAlign = setColumnAlign;
+exports.setColumnLabelOverride = setColumnLabelOverride;
+exports.setColumnPinned = setColumnPinned;
+exports.setColumnVisible = setColumnVisible;
+exports.setColumnWidth = setColumnWidth;
+exports.sortRows = sortRows;
+exports.toCSV = toCSV;
+exports.toJSON = toJSON;
+exports.toXLSX = toXLSX;
+exports.toXML = toXML;
+exports.toggleSort = toggleSort;
+exports.zipStore = zipStore;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map