persian-data-grid 0.5.0 → 0.7.0

package/dist/chunk-CMQ4VLCW.cjs

@@ -0,0 +1,840 @@
+'use strict';
+
+var chunk72IVAOTK_cjs = require('./chunk-72IVAOTK.cjs');
+var chunkIMPCRWYP_cjs = require('./chunk-IMPCRWYP.cjs');
+var chunkF6EMC75A_cjs = require('./chunk-F6EMC75A.cjs');
+var fflate = require('fflate');
+
+// packages/plugins/excel/src/ExcelExportPlugin.ts
+var ExcelExportPlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.name = "excel-export";
+    this.unsub = null;
+  }
+  register(ctx) {
+    this.unsub = ctx.bus.subscribeAll((event) => {
+      void this.onEvent(ctx, event);
+    });
+  }
+  dispose() {
+    this.unsub?.();
+    this.unsub = null;
+  }
+  async onEvent(ctx, event) {
+    if (event.type !== "EXPORT_REQUESTED") return;
+    if (event.tableId !== ctx.tableId) return;
+    const payload = event.payload;
+    if (payload.format !== "xlsx") return;
+    try {
+      const source = ctx.query.getExportSource(payload.collectionScope ?? "active");
+      if (!source) {
+        throw new Error("NO_EXPORT_SOURCE");
+      }
+      const table = chunk72IVAOTK_cjs.buildExportTable(source);
+      if (table.columns.length === 0 && table.rows.length === 0) {
+        throw new Error("NO_COLUMNS");
+      }
+      const fileName = payload.fileName ?? `export-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.xlsx`;
+      const blob = chunkIMPCRWYP_cjs.buildXlsxBlob(table, {
+        sheetName: payload.sheetName,
+        direction: payload.direction ?? "rtl"
+      });
+      const columnCount = table.columns.length + 1;
+      const rowCount = table.rows.length;
+      if (this.options.download !== false) {
+        chunkIMPCRWYP_cjs.downloadBlob(blob, fileName);
+      }
+      this.options.onBlob?.(blob, { fileName, rowCount, columnCount });
+      await ctx.bus.publish({
+        eventId: `${Date.now()}-xlsx-ok`,
+        type: "XLSX_EXPORT_COMPLETED",
+        tableId: ctx.tableId,
+        streamId: `table/${ctx.tableId}/view`,
+        version: 0,
+        occurredAt: Date.now(),
+        actorId: event.actorId,
+        correlationId: event.correlationId,
+        causationId: event.eventId,
+        payload: {
+          format: "xlsx",
+          rowCount,
+          columnCount
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      await ctx.bus.publish({
+        eventId: `${Date.now()}-xlsx-fail`,
+        type: "XLSX_EXPORT_FAILED",
+        tableId: ctx.tableId,
+        streamId: `table/${ctx.tableId}/view`,
+        version: 0,
+        occurredAt: Date.now(),
+        actorId: event.actorId,
+        correlationId: event.correlationId,
+        causationId: event.eventId,
+        payload: {
+          format: "xlsx",
+          code: message === "NO_COLUMNS" || message === "NO_EXPORT_SOURCE" ? message : "EXPORT_FAILED",
+          message
+        }
+      });
+    }
+  }
+};
+
+// packages/plugins/excel/src/applyImportedRows.ts
+async function applyImportedRows(session, rows) {
+  if (rows.length === 0) {
+    return { rowCount: 0 };
+  }
+  const stamp = Date.now();
+  const engine = session.getEngine();
+  const payload = rows.map((cells, i) => [
+    {
+      key: "index",
+      value: `import-${stamp}-${i}`,
+      display: `import-${stamp}-${i}`
+    },
+    ...cells.filter((c) => c.key !== "index")
+  ]);
+  await engine.dispatch({
+    type: "ADD_NEW_ROWS",
+    store: session.store,
+    tableKey: session.tableKey,
+    detailFieldKey: "index",
+    rows: payload,
+    autoActivate: false
+  });
+  return { rowCount: rows.length };
+}
+
+// packages/plugins/excel/src/mapImportedSheet.ts
+function normalizeHeader(h) {
+  return h.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function coerceValue(raw, fieldType) {
+  const text = raw.trim();
+  if (text === "") return "";
+  switch (fieldType) {
+    case "number":
+    case "price": {
+      const n = Number(text.replace(/,/g, ""));
+      return Number.isFinite(n) ? n : text;
+    }
+    case "checkbox": {
+      const lower = text.toLowerCase();
+      if (["1", "true", "yes", "\u2714", "y"].includes(lower)) return true;
+      if (["0", "false", "no", "\u2718", "n"].includes(lower)) return false;
+      return text;
+    }
+    default:
+      return text;
+  }
+}
+function mapImportedSheet(sheet, columns) {
+  const importable = columns.filter(
+    (c) => c.fieldName !== "index" && c.fieldType !== "index" && c.fieldType !== "static"
+  );
+  const byCaption = /* @__PURE__ */ new Map();
+  const byField = /* @__PURE__ */ new Map();
+  for (const col of importable) {
+    byField.set(normalizeHeader(col.fieldName), col);
+    if (col.fieldCaption) {
+      byCaption.set(normalizeHeader(col.fieldCaption), col);
+    }
+  }
+  const mappedCols = [];
+  sheet.headers.forEach((header, colIndex) => {
+    const key = normalizeHeader(header);
+    if (!key) return;
+    const col = byCaption.get(key) ?? byField.get(key);
+    if (!col) return;
+    if (mappedCols.some((m) => m.fieldName === col.fieldName)) return;
+    mappedCols.push({
+      fieldName: col.fieldName,
+      fieldType: col.fieldType,
+      colIndex
+    });
+  });
+  if (mappedCols.length === 0 && sheet.headers.length > 0) {
+    importable.forEach((col, i) => {
+      if (i < sheet.headers.length) {
+        mappedCols.push({
+          fieldName: col.fieldName,
+          fieldType: col.fieldType,
+          colIndex: i
+        });
+      }
+    });
+  }
+  const rows = sheet.rows.map(
+    (line) => mappedCols.map((m) => {
+      const raw = line[m.colIndex] ?? "";
+      const value = coerceValue(raw, m.fieldType);
+      return { key: m.fieldName, value, display: value };
+    })
+  );
+  return {
+    columns: mappedCols.map(({ fieldName, fieldType }) => ({
+      fieldName,
+      fieldType
+    })),
+    rows
+  };
+}
+var textDecoder = new TextDecoder("utf-8");
+function toUint8Array(data) {
+  if (data instanceof Uint8Array) return Promise.resolve(data);
+  if (data instanceof ArrayBuffer) return Promise.resolve(new Uint8Array(data));
+  return data.arrayBuffer().then((buf) => new Uint8Array(buf));
+}
+function decodeXml(bytes) {
+  return fflate.strFromU8(bytes) || textDecoder.decode(bytes);
+}
+function colIndexFromRef(ref) {
+  const letters = ref.match(/^([A-Za-z]+)/)?.[1];
+  if (!letters) return 0;
+  let n = 0;
+  for (const ch of letters.toUpperCase()) {
+    n = n * 26 + (ch.charCodeAt(0) - 64);
+  }
+  return n - 1;
+}
+function parseSharedStrings(xml) {
+  const out = [];
+  const siRe = /<si\b[^>]*>([\s\S]*?)<\/si>/gi;
+  let m;
+  while (m = siRe.exec(xml)) {
+    const inner = m[1];
+    const parts = [];
+    const tRe = /<t\b[^>]*>([\s\S]*?)<\/t>/gi;
+    let tm;
+    while (tm = tRe.exec(inner)) {
+      parts.push(decodeXmlEntities(tm[1]));
+    }
+    out.push(parts.join(""));
+  }
+  return out;
+}
+function decodeXmlEntities(s) {
+  return s.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&apos;/g, "'").replace(/&amp;/g, "&");
+}
+function findSheetPath(files, sheetName) {
+  const preferred = "xl/worksheets/sheet1.xml";
+  if (!sheetName) {
+    if (files[preferred]) return preferred;
+    const first = Object.keys(files).find(
+      (k) => /^xl\/worksheets\/sheet\d+\.xml$/i.test(k)
+    );
+    if (!first) throw new Error("NO_SHEET");
+    return first;
+  }
+  const workbook = files["xl/workbook.xml"];
+  if (!workbook) throw new Error("NO_WORKBOOK");
+  const wbXml = decodeXml(workbook);
+  const sheetRe = /<sheet\b[^>]*name="([^"]+)"[^>]*r:id="([^"]+)"[^>]*\/?>/gi;
+  const nameToRid = /* @__PURE__ */ new Map();
+  let sm;
+  while (sm = sheetRe.exec(wbXml)) {
+    nameToRid.set(sm[1], sm[2]);
+  }
+  const rid = nameToRid.get(sheetName);
+  if (!rid) throw new Error("SHEET_NOT_FOUND");
+  const rels = files["xl/_rels/workbook.xml.rels"];
+  if (!rels) throw new Error("NO_RELS");
+  const relsXml = decodeXml(rels);
+  const relRe = /<Relationship\b[^>]*Id="([^"]+)"[^>]*Target="([^"]+)"[^>]*\/?>/gi;
+  let rm;
+  while (rm = relRe.exec(relsXml)) {
+    if (rm[1] === rid) {
+      const target = rm[2].replace(/^\//, "");
+      const path = target.startsWith("xl/") ? target : `xl/${target}`;
+      if (!files[path]) throw new Error("NO_SHEET");
+      return path;
+    }
+  }
+  throw new Error("SHEET_NOT_FOUND");
+}
+function parseSheetRows(sheetXml, shared) {
+  const rowRe = /<row\b[^>]*>([\s\S]*?)<\/row>/gi;
+  const matrix = [];
+  let rowMatch;
+  while (rowMatch = rowRe.exec(sheetXml)) {
+    const rowXml = rowMatch[1];
+    const cells = [];
+    const cellRe = /<c\b([^>]*)>([\s\S]*?)<\/c>|<c\b([^>]*)\/>/gi;
+    let cm;
+    while (cm = cellRe.exec(rowXml)) {
+      const attrs = cm[1] ?? cm[3] ?? "";
+      const body = cm[2] ?? "";
+      const ref = attrs.match(/\br="([^"]+)"/)?.[1] ?? "";
+      const t = attrs.match(/\bt="([^"]+)"/)?.[1] ?? "";
+      const col = colIndexFromRef(ref);
+      let text = "";
+      if (t === "inlineStr") {
+        const tm = body.match(/<t\b[^>]*>([\s\S]*?)<\/t>/i);
+        text = tm ? decodeXmlEntities(tm[1]) : "";
+      } else if (t === "s") {
+        const vm = body.match(/<v\b[^>]*>([\s\S]*?)<\/v>/i);
+        const idx = vm ? Number(vm[1]) : -1;
+        text = idx >= 0 ? shared[idx] ?? "" : "";
+      } else {
+        const vm = body.match(/<v\b[^>]*>([\s\S]*?)<\/v>/i);
+        text = vm ? decodeXmlEntities(vm[1]) : "";
+      }
+      cells.push({ col, text });
+    }
+    matrix.push(cells);
+  }
+  if (matrix.length === 0) {
+    return { headers: [], rows: [] };
+  }
+  const maxCol = Math.max(
+    0,
+    ...matrix.flatMap((r) => r.map((c) => c.col))
+  );
+  const dense = matrix.map((rowCells) => {
+    const line = Array.from({ length: maxCol + 1 }, () => "");
+    for (const c of rowCells) {
+      if (c.col >= 0 && c.col <= maxCol) line[c.col] = c.text;
+    }
+    return line;
+  });
+  const header = dense[0] ?? [];
+  const rowHeaderHints = /* @__PURE__ */ new Set(["\u0631\u062F\u06CC\u0641", "row", "#", "row \xB7 actions", "row number"]);
+  const dropFirst = header.length > 1 && rowHeaderHints.has(header[0].trim().toLowerCase());
+  const slice = (line) => dropFirst ? line.slice(1) : line;
+  const headers = slice(header).map((h) => h.trim());
+  const rows = dense.slice(1).map(slice).map((line) => {
+    const padded = Array.from({ length: headers.length }, (_, i) => line[i] ?? "");
+    return padded;
+  }).filter((line) => line.some((c) => c.trim() !== ""));
+  return { headers, rows };
+}
+async function parseXlsxBlob(data, options) {
+  const bytes = await toUint8Array(data);
+  let files;
+  try {
+    files = fflate.unzipSync(bytes);
+  } catch {
+    throw new Error("INVALID_XLSX");
+  }
+  const sharedPath = Object.keys(files).find(
+    (k) => /xl\/sharedStrings\.xml$/i.test(k)
+  );
+  const shared = sharedPath ? parseSharedStrings(decodeXml(files[sharedPath])) : [];
+  const sheetPath = findSheetPath(files, options?.sheetName);
+  return parseSheetRows(decodeXml(files[sheetPath]), shared);
+}
+
+// packages/plugins/excel/src/ExcelImportPlugin.ts
+var ExcelImportPlugin = class {
+  constructor(options = {}) {
+    this.options = options;
+    this.name = "excel-import";
+    this.unsub = null;
+  }
+  register(ctx) {
+    this.unsub = ctx.bus.subscribeAll((event) => {
+      void this.onEvent(ctx, event);
+    });
+  }
+  dispose() {
+    this.unsub?.();
+    this.unsub = null;
+  }
+  async onEvent(ctx, event) {
+    if (event.type !== "IMPORT_REQUESTED") return;
+    if (event.tableId !== ctx.tableId) return;
+    const payload = event.payload;
+    if (payload.format !== "xlsx") return;
+    try {
+      const correlationId = event.correlationId;
+      if (!correlationId) {
+        throw new Error("NO_IMPORT_DATA");
+      }
+      const bytes = ctx.resolveImportData?.(correlationId);
+      if (!bytes || bytes.byteLength === 0) {
+        throw new Error("NO_IMPORT_DATA");
+      }
+      const source = ctx.query.getExportSource(payload.collectionScope ?? "active");
+      if (!source) {
+        throw new Error("NO_IMPORT_TARGET");
+      }
+      const sheet = await parseXlsxBlob(bytes, {
+        sheetName: payload.sheetName
+      });
+      if (sheet.headers.length === 0) {
+        throw new Error("NO_COLUMNS");
+      }
+      const mapped = mapImportedSheet(sheet, source.columns);
+      if (mapped.columns.length === 0) {
+        throw new Error("NO_COLUMN_MATCH");
+      }
+      const { rowCount } = await applyImportedRows(ctx.session, mapped.rows);
+      const columnCount = mapped.columns.length;
+      this.options.onImported?.({ rowCount, columnCount });
+      await ctx.bus.publish({
+        eventId: `${Date.now()}-xlsx-import-ok`,
+        type: "XLSX_IMPORT_COMPLETED",
+        tableId: ctx.tableId,
+        streamId: `table/${ctx.tableId}/view`,
+        version: 0,
+        occurredAt: Date.now(),
+        actorId: event.actorId,
+        correlationId: event.correlationId,
+        causationId: event.eventId,
+        payload: {
+          format: "xlsx",
+          rowCount,
+          columnCount
+        }
+      });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const known = /* @__PURE__ */ new Set([
+        "NO_IMPORT_DATA",
+        "NO_IMPORT_TARGET",
+        "NO_COLUMNS",
+        "NO_COLUMN_MATCH",
+        "INVALID_XLSX",
+        "NO_SHEET",
+        "SHEET_NOT_FOUND"
+      ]);
+      await ctx.bus.publish({
+        eventId: `${Date.now()}-xlsx-import-fail`,
+        type: "XLSX_IMPORT_FAILED",
+        tableId: ctx.tableId,
+        streamId: `table/${ctx.tableId}/view`,
+        version: 0,
+        occurredAt: Date.now(),
+        actorId: event.actorId,
+        correlationId: event.correlationId,
+        causationId: event.eventId,
+        payload: {
+          format: "xlsx",
+          code: known.has(message) ? message : "IMPORT_FAILED",
+          message
+        }
+      });
+    }
+  }
+};
+
+// packages/plugins/excel/src/exportActiveCollectionToExcelStreaming.ts
+var EMPTY_PLACEHOLDERS = /* @__PURE__ */ new Set(["\u0627\u0646\u062A\u062E\u0627\u0628 \u06A9\u0646\u06CC\u062F", "select", "Select"]);
+var escapeXml = (value) => value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+var hasMeaningfulValue = (value) => value !== void 0 && value !== null && value !== "";
+var getExportColumns = (controller) => {
+  const view = controller.getViewState();
+  const columns = view?.activeCollectionColumn?.length ? view.activeCollectionColumn : view?.columns ?? [];
+  return columns.filter((col) => col.fieldType !== "index").sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+};
+var isExportableRecord = (record) => {
+  if (record.rowState === "Delete" /* Deleted */) return false;
+  return Object.entries(record.cells).some(
+    ([key, cell]) => key !== "index" && hasMeaningfulValue(cell.value)
+  );
+};
+var getRecordExportText = (record, column) => {
+  const cell = record.cells[column.fieldName];
+  if (!cell) return "";
+  const raw = cell.display ?? cell.value;
+  if (!hasMeaningfulValue(raw)) return "";
+  const text = chunkF6EMC75A_cjs.formatExportValue(raw, column.fieldType).trim();
+  if (!text || EMPTY_PLACEHOLDERS.has(text)) return "";
+  return text;
+};
+var toColumnLetter = (index) => {
+  let n = index + 1;
+  let result = "";
+  while (n > 0) {
+    const rem = (n - 1) % 26;
+    result = String.fromCharCode(65 + rem) + result;
+    n = Math.floor((n - 1) / 26);
+  }
+  return result;
+};
+var crcTable = (() => {
+  const table = new Uint32Array(256);
+  for (let i = 0; i < 256; i += 1) {
+    let c = i;
+    for (let k = 0; k < 8; k += 1) {
+      c = c & 1 ? 3988292384 ^ c >>> 1 : c >>> 8;
+      c = c >>> 0;
+    }
+    table[i] = c >>> 0;
+  }
+  return table;
+})();
+var crc32 = (data) => {
+  let crc = 4294967295;
+  for (let i = 0; i < data.length; i += 1) {
+    crc = crcTable[(crc ^ data[i]) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+};
+var IncrementalCrc = class {
+  constructor() {
+    this.crc = 4294967295;
+    this.length = 0;
+  }
+  update(data) {
+    for (let i = 0; i < data.length; i += 1) {
+      this.crc = crcTable[(this.crc ^ data[i]) & 255] ^ this.crc >>> 8;
+      this.crc = this.crc >>> 0;
+    }
+    this.length += data.length;
+  }
+  finish() {
+    return { crc: (this.crc ^ 4294967295) >>> 0, size: this.length };
+  }
+};
+var textEncoder = new TextEncoder();
+var buildZip = (entries) => {
+  const parts = [];
+  const centralParts = [];
+  let offset = 0;
+  for (const entry of entries) {
+    const nameBytes = textEncoder.encode(entry.name);
+    const data = entry.data;
+    const size = entry.size ?? (data instanceof Uint8Array ? data.length : data.size);
+    const crc = entry.crc ?? (data instanceof Uint8Array ? crc32(data) : 0);
+    const local = new Uint8Array(30 + nameBytes.length);
+    const lv = new DataView(local.buffer);
+    lv.setUint32(0, 67324752, true);
+    lv.setUint16(4, 20, true);
+    lv.setUint16(6, 0, true);
+    lv.setUint16(8, 0, true);
+    lv.setUint16(10, 0, true);
+    lv.setUint16(12, 0, true);
+    lv.setUint32(14, crc, true);
+    lv.setUint32(18, size, true);
+    lv.setUint32(22, size, true);
+    lv.setUint16(26, nameBytes.length, true);
+    lv.setUint16(28, 0, true);
+    local.set(nameBytes, 30);
+    parts.push(local, data);
+    const central = new Uint8Array(46 + nameBytes.length);
+    const cv = new DataView(central.buffer);
+    cv.setUint32(0, 33639248, true);
+    cv.setUint16(4, 20, true);
+    cv.setUint16(6, 20, true);
+    cv.setUint16(8, 0, true);
+    cv.setUint16(10, 0, true);
+    cv.setUint16(12, 0, true);
+    cv.setUint16(14, 0, true);
+    cv.setUint32(16, crc, true);
+    cv.setUint32(20, size, true);
+    cv.setUint32(24, size, true);
+    cv.setUint16(28, nameBytes.length, true);
+    cv.setUint16(30, 0, true);
+    cv.setUint16(32, 0, true);
+    cv.setUint16(34, 0, true);
+    cv.setUint16(36, 0, true);
+    cv.setUint32(38, 0, true);
+    cv.setUint32(42, offset, true);
+    central.set(nameBytes, 46);
+    centralParts.push(central);
+    offset += local.length + size;
+  }
+  const centralSize = centralParts.reduce((sum, p) => sum + p.length, 0);
+  const end = new Uint8Array(22);
+  const ev = new DataView(end.buffer);
+  ev.setUint32(0, 101010256, true);
+  ev.setUint16(4, 0, true);
+  ev.setUint16(6, 0, true);
+  ev.setUint16(8, entries.length, true);
+  ev.setUint16(10, entries.length, true);
+  ev.setUint32(12, centralSize, true);
+  ev.setUint32(16, offset, true);
+  ev.setUint16(20, 0, true);
+  return new Blob([...parts, ...centralParts, end], {
+    type: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet"
+  });
+};
+var buildStylesXml = (direction) => {
+  const readingOrder = direction === "rtl" ? 2 : 1;
+  const horizontal = direction === "rtl" ? "right" : "left";
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+  <fonts count="3">
+    <font><sz val="10"/><name val="Tahoma"/></font>
+    <font><b/><sz val="11"/><color rgb="FFFFFFFF"/><name val="Tahoma"/></font>
+    <font><b/><sz val="10"/><name val="Tahoma"/></font>
+  </fonts>
+  <fills count="4">
+    <fill><patternFill patternType="none"/></fill>
+    <fill><patternFill patternType="gray125"/></fill>
+    <fill><patternFill patternType="solid"><fgColor rgb="FF2F5496"/></patternFill></fill>
+    <fill><patternFill patternType="solid"><fgColor rgb="FFD6EAF8"/></patternFill></fill>
+  </fills>
+  <borders count="2">
+    <border><left/><right/><top/><bottom/><diagonal/></border>
+    <border>
+      <left style="thin"><color rgb="FFBDD7EE"/></left>
+      <right style="thin"><color rgb="FFBDD7EE"/></right>
+      <top style="thin"><color rgb="FFBDD7EE"/></top>
+      <bottom style="thin"><color rgb="FFBDD7EE"/></bottom>
+    </border>
+  </borders>
+  <cellStyleXfs count="1">
+    <xf numFmtId="0" fontId="0" fillId="0" borderId="0"/>
+  </cellStyleXfs>
+  <cellXfs count="6">
+    <xf numFmtId="0" fontId="0" fillId="0" borderId="0" xfId="0"/>
+    <xf numFmtId="0" fontId="1" fillId="2" borderId="1" xfId="0" applyFont="1" applyFill="1" applyBorder="1" applyAlignment="1">
+      <alignment horizontal="center" vertical="center" wrapText="1" readingOrder="${readingOrder}"/>
+    </xf>
+    <xf numFmtId="0" fontId="0" fillId="3" borderId="1" xfId="0" applyFill="1" applyBorder="1" applyAlignment="1">
+      <alignment horizontal="${horizontal}" vertical="center" readingOrder="${readingOrder}"/>
+    </xf>
+    <xf numFmtId="0" fontId="0" fillId="0" borderId="1" xfId="0" applyBorder="1" applyAlignment="1">
+      <alignment horizontal="${horizontal}" vertical="center" readingOrder="${readingOrder}"/>
+    </xf>
+    <xf numFmtId="0" fontId="2" fillId="3" borderId="1" xfId="0" applyFont="1" applyFill="1" applyBorder="1" applyAlignment="1">
+      <alignment horizontal="center" vertical="center" readingOrder="${readingOrder}"/>
+    </xf>
+    <xf numFmtId="0" fontId="2" fillId="0" borderId="1" xfId="0" applyFont="1" applyBorder="1" applyAlignment="1">
+      <alignment horizontal="center" vertical="center" readingOrder="${readingOrder}"/>
+    </xf>
+  </cellXfs>
+</styleSheet>`;
+};
+var inlineStrCell = (ref, text, styleId) => `<c r="${ref}" t="inlineStr" s="${styleId}"><is><t>${escapeXml(text)}</t></is></c>`;
+var numberCell = (ref, value, styleId) => `<c r="${ref}" s="${styleId}"><v>${value}</v></c>`;
+var recordToRowXml = (record, columns, excelRow) => {
+  const isOdd = (excelRow - 2) % 2 === 0;
+  const dataStyle = isOdd ? 2 : 3;
+  const rowNumStyle = isOdd ? 4 : 5;
+  const cells = [
+    numberCell(`A${excelRow}`, excelRow - 1, rowNumStyle),
+    ...columns.map(
+      (col, i) => inlineStrCell(
+        `${toColumnLetter(i + 1)}${excelRow}`,
+        getRecordExportText(record, col),
+        dataStyle
+      )
+    )
+  ].join("");
+  return `<row r="${excelRow}" ht="18" customHeight="1">${cells}</row>`;
+};
+var buildSheetHeaderXml = (columns, options) => {
+  const { direction, rowHeaderLabel } = options;
+  const rightToLeft = direction === "rtl" ? "1" : "0";
+  const totalCols = columns.length + 1;
+  const colsXml = Array.from({ length: totalCols }, (_, i) => {
+    const width = i === 0 ? 6 : 18;
+    return `<col min="${i + 1}" max="${i + 1}" width="${width}" customWidth="1"/>`;
+  }).join("");
+  const headerCells = [
+    inlineStrCell("A1", rowHeaderLabel, 1),
+    ...columns.map(
+      (col, i) => inlineStrCell(
+        `${toColumnLetter(i + 1)}1`,
+        col.fieldCaption ?? col.fieldName,
+        1
+      )
+    )
+  ].join("");
+  return `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+  <sheetViews>
+    <sheetView workbookViewId="0" rightToLeft="${rightToLeft}"/>
+  </sheetViews>
+  <cols>${colsXml}</cols>
+  <sheetData>
+    <row r="1" ht="22" customHeight="1">${headerCells}</row>`;
+};
+var findColumnsWithData = async (controller, candidates) => {
+  const pending = new Set(candidates.map((c) => c.fieldName));
+  const byField = new Map(candidates.map((c) => [c.fieldName, c]));
+  await controller.iterateRowsFromDb("active", async (records) => {
+    for (const record of records) {
+      if (!isExportableRecord(record)) continue;
+      for (const field of Array.from(pending)) {
+        if (getRecordExportText(record, byField.get(field)) !== "") {
+          pending.delete(field);
+        }
+      }
+      if (pending.size === 0) return false;
+    }
+  });
+  return candidates.filter((c) => !pending.has(c.fieldName));
+};
+var buildSheetBlobStreaming = async (controller, columns, options) => {
+  const crc = new IncrementalCrc();
+  const blobParts = [];
+  let pendingChunks = [];
+  let pendingBytes = 0;
+  let rowCount = 0;
+  const pushChunk = (text) => {
+    const bytes = textEncoder.encode(text);
+    crc.update(bytes);
+    pendingChunks.push(bytes);
+    pendingBytes += bytes.length;
+    if (pendingBytes >= 4 * 1024 * 1024) {
+      blobParts.push(new Blob(pendingChunks));
+      pendingChunks = [];
+      pendingBytes = 0;
+    }
+  };
+  pushChunk(buildSheetHeaderXml(columns, options));
+  await controller.iterateRowsFromDb("active", async (records) => {
+    for (const record of records) {
+      if (!isExportableRecord(record)) continue;
+      rowCount += 1;
+      pushChunk(recordToRowXml(record, columns, rowCount + 1));
+    }
+  });
+  pushChunk(`
+  </sheetData>
+</worksheet>`);
+  if (pendingChunks.length > 0) {
+    blobParts.push(new Blob(pendingChunks));
+  }
+  const { crc: sheetCrc, size } = crc.finish();
+  return { blob: new Blob(blobParts), rowCount, crc: sheetCrc, size };
+};
+var downloadBlob2 = (blob, fileName) => {
+  const url = URL.createObjectURL(blob);
+  const anchor = document.createElement("a");
+  anchor.href = url;
+  anchor.download = fileName;
+  document.body.appendChild(anchor);
+  anchor.click();
+  document.body.removeChild(anchor);
+  URL.revokeObjectURL(url);
+};
+async function exportActiveCollectionToExcelStreaming(controller, options) {
+  const allColumns = getExportColumns(controller);
+  const columns = await findColumnsWithData(controller, allColumns);
+  const direction = options?.direction ?? "rtl";
+  const rowHeaderLabel = options?.rowHeaderLabel ?? "\u0631\u062F\u06CC\u0641";
+  const sheetName = options?.sheetName ?? "Sheet1";
+  const fileName = options?.fileName ?? `export-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.xlsx`;
+  await new Promise((resolve) => {
+    if (typeof setTimeout === "function") setTimeout(resolve, 0);
+    else resolve();
+  });
+  const { blob: sheetBlob, rowCount, crc: sheetCrc, size: sheetSize } = await buildSheetBlobStreaming(controller, columns, {
+    direction,
+    rowHeaderLabel
+  });
+  if (columns.length === 0 && rowCount === 0) {
+    throw new Error("NO_COLUMNS");
+  }
+  const safeSheetName = (sheetName.slice(0, 31) || "Sheet1").replace(
+    /[\\/*?:\[\]]/g,
+    ""
+  );
+  const contentTypes = `<?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"/>
+  <Override PartName="/xl/styles.xml" ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml"/>
+</Types>`;
+  const rootRels = `<?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>`;
+  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(safeSheetName)}" sheetId="1" r:id="rId1"/>
+  </sheets>
+</workbook>`;
+  const workbookRels = `<?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"/>
+  <Relationship Id="rId2" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="styles.xml"/>
+</Relationships>`;
+  const styles = buildStylesXml(direction);
+  const zip = buildZip([
+    { name: "[Content_Types].xml", data: textEncoder.encode(contentTypes) },
+    { name: "_rels/.rels", data: textEncoder.encode(rootRels) },
+    { name: "xl/workbook.xml", data: textEncoder.encode(workbook) },
+    {
+      name: "xl/_rels/workbook.xml.rels",
+      data: textEncoder.encode(workbookRels)
+    },
+    { name: "xl/styles.xml", data: textEncoder.encode(styles) },
+    {
+      name: "xl/worksheets/sheet1.xml",
+      data: sheetBlob,
+      crc: sheetCrc,
+      size: sheetSize
+    }
+  ]);
+  if (options?.download !== false) downloadBlob2(zip, fileName);
+  return { rowCount, columnCount: columns.length + 1 };
+}
+
+// packages/plugins/excel/src/exportActiveCollectionToExcel.ts
+var hasMeaningfulValue2 = (value) => value !== void 0 && value !== null && value !== "";
+async function exportActiveCollectionToExcel(controller, options) {
+  await controller.flushCellEdit();
+  if (controller.isPagedWindow()) {
+    return exportActiveCollectionToExcelStreaming(controller, options);
+  }
+  const view = controller.getViewState();
+  const columns = (view?.activeCollectionColumn?.length ? view.activeCollectionColumn : view?.columns ?? []).filter((col) => col.fieldType !== "index").sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
+  const rows = (controller.getAllRows() ?? []).filter((row) => {
+    if (row.rowState.value === "Delete" /* Deleted */) return false;
+    return Array.from(row.getCells().entries()).some(
+      ([key, cell]) => key !== "index" && hasMeaningfulValue2(cell.getValue())
+    );
+  });
+  const source = {
+    columns: columns.map((col) => ({
+      fieldName: col.fieldName,
+      fieldCaption: col.fieldCaption,
+      fieldType: col.fieldType,
+      order: col.order
+    })),
+    rows: rows.map((row) => ({
+      id: row.id.value,
+      rowState: String(row.rowState.value),
+      cells: Object.fromEntries(
+        [...row.getCells()].map(([key, cell]) => [
+          key,
+          { value: cell.getValue(), display: cell.getDisplay() }
+        ])
+      )
+    }))
+  };
+  const table = chunk72IVAOTK_cjs.buildExportTable(source);
+  if (table.columns.length === 0 && table.rows.length === 0) {
+    throw new Error("NO_COLUMNS");
+  }
+  const direction = options?.direction ?? "rtl";
+  const rowHeaderLabel = options?.rowHeaderLabel ?? "\u0631\u062F\u06CC\u0641";
+  const sheetName = options?.sheetName ?? "Sheet1";
+  const fileName = options?.fileName ?? `export-${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}.xlsx`;
+  await new Promise((resolve) => {
+    if (typeof setTimeout === "function") setTimeout(resolve, 0);
+    else resolve();
+  });
+  const blob = chunkIMPCRWYP_cjs.buildXlsxBlob(table, {
+    direction,
+    rowHeaderLabel,
+    sheetName
+  });
+  if (options?.download !== false) {
+    chunkIMPCRWYP_cjs.downloadBlob(blob, fileName);
+  }
+  return { rowCount: table.rows.length, columnCount: table.columns.length + 1 };
+}
+
+exports.ExcelExportPlugin = ExcelExportPlugin;
+exports.ExcelImportPlugin = ExcelImportPlugin;
+exports.applyImportedRows = applyImportedRows;
+exports.exportActiveCollectionToExcel = exportActiveCollectionToExcel;
+exports.mapImportedSheet = mapImportedSheet;
+exports.parseXlsxBlob = parseXlsxBlob;
+//# sourceMappingURL=chunk-CMQ4VLCW.cjs.map
+//# sourceMappingURL=chunk-CMQ4VLCW.cjs.map