@univerjs-pro/exchange-node 1.0.0-beta.2

package/README.md

@@ -0,0 +1,71 @@
+# @univerjs-pro/exchange-node
+
+Node.js SDK for converting between Office formats, Univer unit data, and complete Univer snapshots.
+
+The package exposes two API families:
+
+- `importFile` / `importBuffer` and `exportToFile` / `exportToBuffer` convert Univer in-memory unit data.
+- `importFileToSnapshot` / `importBufferToSnapshot` and `exportSnapshotToFile` / `exportSnapshotToBuffer` convert complete snapshot aggregates without creating a Univer runtime.
+
+## Install
+
+Keep this package and its Univer SDK dependencies on the same SDK version:
+
+```sh
+pnpm add @univerjs-pro/exchange-node
+```
+
+## Import
+
+```ts
+import { UniverInstanceType } from '@univerjs/core';
+import { ExchangeFormat, importBuffer } from '@univerjs-pro/exchange-node';
+
+const workbook = await importBuffer(xlsxBuffer, {
+    type: UniverInstanceType.UNIVER_SHEET,
+    format: ExchangeFormat.XLSX,
+    fileName: 'example.xlsx',
+});
+```
+
+`importBuffer` requires `fileName`. File imports use the path basename by default and allow `fileName` to override format inference. An explicit `format` always takes precedence.
+
+## Export
+
+```ts
+import { UniverInstanceType } from '@univerjs/core';
+import {
+    ExchangeFormat,
+    FormulaCalculationMode,
+    exportToBuffer,
+} from '@univerjs-pro/exchange-node';
+
+const xlsxBuffer = await exportToBuffer(workbook, {
+    type: UniverInstanceType.UNIVER_SHEET,
+    format: ExchangeFormat.XLSX,
+    formulaCalculation: FormulaCalculationMode.WHEN_EMPTY,
+});
+```
+
+Sheet export defaults to `FormulaCalculationMode.WHEN_EMPTY`: missing cached formula values are calculated, while existing cached values are preserved. Pass `FormulaCalculationMode.NO` to disable calculation.
+
+## Complete snapshots
+
+Snapshot APIs use `ISnapshotWithBlocks`:
+
+```ts
+interface ISnapshotWithBlocks {
+    snapshot: ISnapshot;
+    sheetBlocks: ISheetBlock[];
+}
+```
+
+Sheet and Base snapshots must include every referenced sheet block. Doc and Slide snapshots normally use an empty `sheetBlocks` array.
+
+Snapshot APIs materialize the complete aggregate in memory. They do not call a Snapshot Server or stream blocks to storage.
+
+## Formats and platforms
+
+The initial release supports Sheet and Base import from XLS, XLSX, CSV, and TSV; Doc import from DOC and DOCX; and Slide import from PPT and PPTX. Export supports XLSX, CSV, TSV, DOCX, and PPTX for their corresponding unit types.
+
+Native packages are published for Linux x64 GNU, Linux arm64 GNU, Windows x64 MSVC, and macOS arm64.

package/lib/cjs/index.cjs

@@ -0,0 +1,432 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf, __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: !0 });
+}, __copyProps = (to, from, except, desc) => {
+  if (from && typeof from == "object" || typeof from == "function")
+    for (let key of __getOwnPropNames(from))
+      !__hasOwnProp.call(to, key) && key !== except && __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: !0 }) : target,
+  mod
+)), __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: !0 }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  BaseAttachmentPolicy: () => BaseAttachmentPolicy,
+  BaseExportMode: () => BaseExportMode,
+  BaseFormulaPolicy: () => BaseFormulaPolicy,
+  BaseHeaderPolicy: () => BaseHeaderPolicy,
+  BaseImagePolicy: () => BaseImagePolicy,
+  BaseImportMode: () => BaseImportMode,
+  BaseTypeInference: () => BaseTypeInference,
+  CsvFormulaMode: () => CsvFormulaMode,
+  CsvLineEnding: () => CsvLineEnding,
+  CsvQuoteStyle: () => CsvQuoteStyle,
+  CsvTypeInferenceMode: () => CsvTypeInferenceMode,
+  CsvValueMode: () => CsvValueMode,
+  DocxCompatibilityMode: () => DocxCompatibilityMode,
+  ExchangeError: () => ExchangeError,
+  ExchangeErrorCode: () => ExchangeErrorCode,
+  ExchangeFormat: () => ExchangeFormat,
+  FormulaCalculationMode: () => FormulaCalculationMode,
+  exportSnapshotToBuffer: () => exportSnapshotToBuffer,
+  exportSnapshotToFile: () => exportSnapshotToFile,
+  exportToBuffer: () => exportToBuffer,
+  exportToFile: () => exportToFile,
+  importBuffer: () => importBuffer,
+  importBufferToSnapshot: () => importBufferToSnapshot,
+  importFile: () => importFile,
+  importFileToSnapshot: () => importFileToSnapshot
+});
+module.exports = __toCommonJS(index_exports);
+var import_collaboration = require("@univerjs-pro/collaboration"), import_core = require("@univerjs/core"), import_node_path = require("node:path"), import_promises = require("node:fs/promises");
+
+// src/binding.ts
+var import_node_module = require("node:module"), import_node_process = __toESM(require("node:process"), 1);
+
+// src/types.ts
+var ExchangeFormat = /* @__PURE__ */ ((ExchangeFormat2) => (ExchangeFormat2.XLS = "xls", ExchangeFormat2.XLSX = "xlsx", ExchangeFormat2.CSV = "csv", ExchangeFormat2.TSV = "tsv", ExchangeFormat2.DOC = "doc", ExchangeFormat2.DOCX = "docx", ExchangeFormat2.PPT = "ppt", ExchangeFormat2.PPTX = "pptx", ExchangeFormat2))(ExchangeFormat || {}), FormulaCalculationMode = /* @__PURE__ */ ((FormulaCalculationMode2) => (FormulaCalculationMode2.FORCED = "forced", FormulaCalculationMode2.WHEN_EMPTY = "when_empty", FormulaCalculationMode2.NO = "no", FormulaCalculationMode2))(FormulaCalculationMode || {}), CsvTypeInferenceMode = /* @__PURE__ */ ((CsvTypeInferenceMode2) => (CsvTypeInferenceMode2.OFF = "off", CsvTypeInferenceMode2.SAFE = "safe", CsvTypeInferenceMode2.AGGRESSIVE = "aggressive", CsvTypeInferenceMode2))(CsvTypeInferenceMode || {}), CsvQuoteStyle = /* @__PURE__ */ ((CsvQuoteStyle2) => (CsvQuoteStyle2.MINIMAL = "minimal", CsvQuoteStyle2.ALWAYS = "always", CsvQuoteStyle2))(CsvQuoteStyle || {}), CsvLineEnding = /* @__PURE__ */ ((CsvLineEnding2) => (CsvLineEnding2.LF = "lf", CsvLineEnding2.CRLF = "cr_lf", CsvLineEnding2))(CsvLineEnding || {}), CsvValueMode = /* @__PURE__ */ ((CsvValueMode2) => (CsvValueMode2.DISPLAY = "display", CsvValueMode2.RAW = "raw", CsvValueMode2))(CsvValueMode || {}), CsvFormulaMode = /* @__PURE__ */ ((CsvFormulaMode2) => (CsvFormulaMode2.CACHED = "cached", CsvFormulaMode2.EXPRESSION = "expression", CsvFormulaMode2))(CsvFormulaMode || {}), BaseImportMode = /* @__PURE__ */ ((BaseImportMode2) => (BaseImportMode2.TABLES = "tables", BaseImportMode2.SHEETS = "sheets", BaseImportMode2.HYBRID = "hybrid", BaseImportMode2.AUTO = "auto", BaseImportMode2))(BaseImportMode || {}), BaseTypeInference = /* @__PURE__ */ ((BaseTypeInference2) => (BaseTypeInference2.NONE = "none", BaseTypeInference2.SAFE = "safe", BaseTypeInference2.AGGRESSIVE = "aggressive", BaseTypeInference2))(BaseTypeInference || {}), BaseFormulaPolicy = /* @__PURE__ */ ((BaseFormulaPolicy2) => (BaseFormulaPolicy2.VALUES = "values", BaseFormulaPolicy2.TEXT = "text", BaseFormulaPolicy2.FAIL = "fail", BaseFormulaPolicy2.CONVERT_THEN_VALUES = "convertThenValues", BaseFormulaPolicy2))(BaseFormulaPolicy || {}), BaseImagePolicy = /* @__PURE__ */ ((BaseImagePolicy2) => (BaseImagePolicy2.SAFE = "safe", BaseImagePolicy2.CELL_ONLY = "cell-only", BaseImagePolicy2.MEDIA_TABLE = "media-table", BaseImagePolicy2.NONE = "none", BaseImagePolicy2))(BaseImagePolicy || {}), BaseHeaderPolicy = /* @__PURE__ */ ((BaseHeaderPolicy2) => (BaseHeaderPolicy2.FIRST_ROW = "firstRow", BaseHeaderPolicy2.NONE = "none", BaseHeaderPolicy2))(BaseHeaderPolicy || {}), BaseExportMode = /* @__PURE__ */ ((BaseExportMode2) => (BaseExportMode2.TABLES = "tables", BaseExportMode2.RANGES = "ranges", BaseExportMode2))(BaseExportMode || {}), BaseAttachmentPolicy = /* @__PURE__ */ ((BaseAttachmentPolicy2) => (BaseAttachmentPolicy2.HYBRID = "hybrid", BaseAttachmentPolicy2.MANIFEST = "manifest", BaseAttachmentPolicy2.LINKS = "links", BaseAttachmentPolicy2.NONE = "none", BaseAttachmentPolicy2))(BaseAttachmentPolicy || {}), DocxCompatibilityMode = /* @__PURE__ */ ((DocxCompatibilityMode2) => (DocxCompatibilityMode2.TRADITIONAL = "traditional", DocxCompatibilityMode2.MODERN = "modern", DocxCompatibilityMode2))(DocxCompatibilityMode || {}), ExchangeErrorCode = /* @__PURE__ */ ((ExchangeErrorCode2) => (ExchangeErrorCode2.INVALID_ARGUMENT = "INVALID_ARGUMENT", ExchangeErrorCode2.UNSUPPORTED_FORMAT = "UNSUPPORTED_FORMAT", ExchangeErrorCode2.INVALID_FILE = "INVALID_FILE", ExchangeErrorCode2.INCOMPLETE_SNAPSHOT = "INCOMPLETE_SNAPSHOT", ExchangeErrorCode2.IO_ERROR = "IO_ERROR", ExchangeErrorCode2.NATIVE_LOAD_FAILED = "NATIVE_LOAD_FAILED", ExchangeErrorCode2.CONVERSION_FAILED = "CONVERSION_FAILED", ExchangeErrorCode2))(ExchangeErrorCode || {}), ExchangeError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+  }
+  code;
+  name = "ExchangeError";
+};
+
+// src/binding.ts
+var nativeBinding = null, nativeBindingSource = null, nodeRequire = (0, import_node_module.createRequire)(__filename);
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function loadNativeBinding() {
+  if (nativeBinding)
+    return nativeBinding;
+  let errors = [];
+  try {
+    return nativeBinding = nodeRequire("@univerjs-pro/exchange-node-binding"), nativeBindingSource = "@univerjs-pro/exchange-node-binding", nativeBinding;
+  } catch (error) {
+    errors.push(`@univerjs-pro/exchange-node-binding: ${errorMessage(error)}`);
+  }
+  throw new ExchangeError(
+    "NATIVE_LOAD_FAILED" /* NATIVE_LOAD_FAILED */,
+    [
+      "Failed to load native exchange binding.",
+      `platform=${import_node_process.default.platform}`,
+      `arch=${import_node_process.default.arch}`,
+      "expected npm package=@univerjs-pro/exchange-node-binding",
+      "attempted paths:",
+      ...errors.map((item) => `- ${item}`)
+    ].join(`
+`)
+  );
+}
+
+// src/snapshot-collector.ts
+var import_protocol = require("@univerjs/protocol");
+function createSnapshotCollector() {
+  let sheetBlocks = /* @__PURE__ */ new Map();
+  return {
+    // The public Pro conversion functions accept the host-wide service
+    // contract even though these conversion paths use its two write methods.
+    service: {
+      async saveSheetBlock(_context, { block }) {
+        return block ? (sheetBlocks.set(block.id, block), {
+          blockID: block.id,
+          error: { code: import_protocol.ErrorCode.OK, message: "" }
+        }) : {
+          blockID: "",
+          error: { code: import_protocol.ErrorCode.UNDEFINED, message: "block is required" }
+        };
+      },
+      async saveSnapshot() {
+        return { error: { code: import_protocol.ErrorCode.OK, message: "" } };
+      }
+    },
+    get sheetBlocks() {
+      return [...sheetBlocks.values()];
+    }
+  };
+}
+
+// src/snapshot.ts
+var import_node_buffer = require("node:buffer");
+function bufferView(bytes) {
+  return import_node_buffer.Buffer.isBuffer(bytes) ? bytes : import_node_buffer.Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function takeMetadata(owner, kind, metadata, ownerId) {
+  if (!owner)
+    return owner;
+  let { originalMeta, ...rest } = owner;
+  if (originalMeta instanceof Uint8Array)
+    metadata.push({ kind, ownerId, data: bufferView(originalMeta) });
+  else if (originalMeta != null)
+    throw new TypeError(`${kind} originalMeta must be a Uint8Array`);
+  return rest;
+}
+function toNativeSnapshot(value) {
+  let metadata = [], source = value.snapshot, snapshot = { ...source }, sourceWorkbook = source.workbook;
+  if (sourceWorkbook) {
+    let workbook = takeMetadata(sourceWorkbook, "workbook", metadata), sourceSheets = sourceWorkbook.sheets;
+    sourceSheets && (workbook.sheets = Object.fromEntries(
+      Object.entries(sourceSheets).map(([sheetId, sheet]) => [
+        sheetId,
+        takeMetadata(sheet, "worksheet", metadata, sheetId)
+      ])
+    )), snapshot.workbook = workbook;
+  }
+  for (let kind of ["doc", "slide"]) {
+    let owner = source[kind];
+    owner && (snapshot[kind] = takeMetadata(owner, kind, metadata));
+  }
+  return {
+    snapshotJson: import_node_buffer.Buffer.from(JSON.stringify(snapshot)),
+    metadata,
+    sheetBlocks: value.sheetBlocks.map((block) => ({
+      id: block.id,
+      startRow: block.startRow,
+      endRow: block.endRow,
+      data: bufferView(block.data)
+    }))
+  };
+}
+function restoreMetadata(snapshot, metadata) {
+  for (let entry of metadata) {
+    let owner;
+    if (entry.kind === "worksheet") {
+      let sheets = snapshot.workbook?.sheets;
+      owner = entry.ownerId ? sheets?.[entry.ownerId] : void 0;
+    } else {
+      if (entry.kind !== "workbook" && entry.kind !== "doc" && entry.kind !== "slide")
+        throw new TypeError(`unsupported native snapshot metadata kind ${entry.kind}`);
+      owner = snapshot[entry.kind];
+    }
+    if (!owner)
+      throw new TypeError(`native snapshot metadata owner ${entry.kind}/${entry.ownerId ?? ""} is missing`);
+    owner.originalMeta = entry.data;
+  }
+}
+function fromNativeSnapshot(value) {
+  let snapshot = JSON.parse(value.snapshotJson.toString("utf8"));
+  return restoreMetadata(snapshot, value.metadata), {
+    snapshot,
+    sheetBlocks: value.sheetBlocks.map((block) => ({
+      id: block.id,
+      startRow: block.startRow,
+      endRow: block.endRow,
+      data: block.data
+    }))
+  };
+}
+
+// src/index.ts
+var FORMAT_BY_EXTENSION = {
+  ".xls": "xls" /* XLS */,
+  ".xlsx": "xlsx" /* XLSX */,
+  ".csv": "csv" /* CSV */,
+  ".tsv": "tsv" /* TSV */,
+  ".doc": "doc" /* DOC */,
+  ".docx": "docx" /* DOCX */,
+  ".ppt": "ppt" /* PPT */,
+  ".pptx": "pptx" /* PPTX */
+};
+function normalizeWorkbookSheetOrder(data) {
+  let existingOrder = Array.isArray(data.sheetOrder) ? data.sheetOrder.filter((sheetId) => typeof sheetId == "string") : [], ordered = new Set(existingOrder), missingSheetIds = Object.keys(data.sheets).filter((sheetId) => !ordered.has(sheetId));
+  return missingSheetIds.length === 0 ? data : { ...data, sheetOrder: [...existingOrder, ...missingSheetIds] };
+}
+function exchangeError(error, fallback) {
+  if (error instanceof ExchangeError)
+    return error;
+  let message = error instanceof Error ? error.message : String(error), nativeCode = /^\[([A-Z_]+)]\s*/.exec(message)?.[1];
+  return nativeCode && Object.values(ExchangeErrorCode).includes(nativeCode) ? new ExchangeError(nativeCode, message.replace(/^\[[A-Z_]+]\s*/, ""), {
+    cause: error
+  }) : error instanceof TypeError ? new ExchangeError("INVALID_ARGUMENT" /* INVALID_ARGUMENT */, message, { cause: error }) : new ExchangeError(fallback, message, { cause: error });
+}
+function resolveFormat(fileName, format) {
+  if (format)
+    return format;
+  let inferred = FORMAT_BY_EXTENSION[(0, import_node_path.extname)(fileName).toLowerCase()];
+  if (!inferred)
+    throw new ExchangeError(
+      "UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */,
+      `Cannot infer an exchange format from fileName: ${fileName}`
+    );
+  return inferred;
+}
+function nativeUnitType(type) {
+  switch (type) {
+    case import_core.UniverInstanceType.UNIVER_SHEET:
+      return "sheet";
+    case import_core.UniverInstanceType.UNIVER_BASE:
+      return "base";
+    case import_core.UniverInstanceType.UNIVER_DOC:
+      return "doc";
+    case import_core.UniverInstanceType.UNIVER_SLIDE:
+      return "slide";
+    default:
+      throw new ExchangeError("INVALID_ARGUMENT" /* INVALID_ARGUMENT */, `Unsupported Univer unit type: ${type}`);
+  }
+}
+function nativeImportOptions(options, fileName) {
+  return {
+    format: resolveFormat(fileName, options.format),
+    unitType: nativeUnitType(options.type),
+    fileName,
+    unitId: options.unitId,
+    minSheetRowCount: "minSheetRowCount" in options ? options.minSheetRowCount : void 0,
+    minSheetColumnCount: "minSheetColumnCount" in options ? options.minSheetColumnCount : void 0,
+    compatibilityMode: "compatibilityMode" in options ? options.compatibilityMode : void 0,
+    csv: "csv" in options ? options.csv : void 0,
+    base: options.type === import_core.UniverInstanceType.UNIVER_BASE ? {
+      mode: options.mode,
+      typeInference: options.typeInference,
+      formulaPolicy: options.formulaPolicy,
+      imagePolicy: options.imagePolicy,
+      maxCells: options.maxCells,
+      mapping: options.mapping
+    } : void 0,
+    formulaCalculation: "formulaCalculation" in options ? options.formulaCalculation : void 0
+  };
+}
+function nativeExportOptions(options) {
+  return {
+    format: options.format,
+    unitType: nativeUnitType(options.type),
+    csv: "csv" in options ? options.csv : void 0,
+    base: options.type === import_core.UniverInstanceType.UNIVER_BASE && options.format === "xlsx" /* XLSX */ ? {
+      mode: options.mode,
+      formulaPolicy: options.formulaPolicy,
+      attachmentPolicy: options.attachmentPolicy,
+      mapping: options.mapping
+    } : void 0,
+    formulaCalculation: "formulaCalculation" in options ? options.formulaCalculation : void 0
+  };
+}
+async function importSnapshot(input, options, fileName) {
+  try {
+    let result = await (await loadNativeBinding()).exchangeImportToSnapshot(
+      input,
+      JSON.stringify(nativeImportOptions(options, fileName))
+    );
+    return fromNativeSnapshot(result);
+  } catch (error) {
+    throw exchangeError(error, "CONVERSION_FAILED" /* CONVERSION_FAILED */);
+  }
+}
+async function snapshotToMemory(snapshot, type) {
+  try {
+    switch (type) {
+      case import_core.UniverInstanceType.UNIVER_SHEET:
+        return await (0, import_collaboration.transformSnapshotToWorkbookData)(snapshot.snapshot, snapshot.sheetBlocks);
+      case import_core.UniverInstanceType.UNIVER_BASE:
+        return await (0, import_collaboration.transformSnapshotToBaseData)(snapshot.snapshot, snapshot.sheetBlocks);
+      case import_core.UniverInstanceType.UNIVER_DOC:
+        return (0, import_collaboration.transformSnapshotToDocumentData)(snapshot.snapshot);
+      case import_core.UniverInstanceType.UNIVER_SLIDE:
+        return (0, import_collaboration.transformSnapshotToSlideData)(snapshot.snapshot);
+      default:
+        throw new TypeError(`Unsupported Univer unit type: ${type}`);
+    }
+  } catch (error) {
+    throw exchangeError(error, "CONVERSION_FAILED" /* CONVERSION_FAILED */);
+  }
+}
+async function memoryToSnapshot(data, options) {
+  try {
+    let unitId = data.id;
+    if (!unitId)
+      throw new ExchangeError("INVALID_ARGUMENT" /* INVALID_ARGUMENT */, "Export data must have a non-empty id");
+    let rev = data.rev ?? 0, collector = createSnapshotCollector();
+    switch (options.type) {
+      case import_core.UniverInstanceType.UNIVER_SHEET: {
+        let workbook = normalizeWorkbookSheetOrder(data), { snapshot } = await (0, import_collaboration.transformWorkbookDataToSnapshot)(
+          { metadata: void 0 },
+          workbook,
+          unitId,
+          rev,
+          collector.service
+        );
+        return { snapshot, sheetBlocks: collector.sheetBlocks };
+      }
+      case import_core.UniverInstanceType.UNIVER_BASE: {
+        let { snapshot } = await (0, import_collaboration.transformBaseDataToSnapshot)(
+          { metadata: void 0 },
+          data,
+          unitId,
+          rev,
+          collector.service
+        );
+        return { snapshot, sheetBlocks: collector.sheetBlocks };
+      }
+      case import_core.UniverInstanceType.UNIVER_DOC: {
+        let { snapshot } = await (0, import_collaboration.transformDocumentDataToSnapshot)(
+          { metadata: void 0 },
+          data,
+          unitId,
+          rev,
+          collector.service
+        );
+        return { snapshot, sheetBlocks: [] };
+      }
+      case import_core.UniverInstanceType.UNIVER_SLIDE: {
+        let slide = data, { snapshot } = await (0, import_collaboration.transformSlideDataToSnapshot)(
+          slide.resources,
+          slide,
+          unitId,
+          rev,
+          collector.service
+        );
+        return { snapshot, sheetBlocks: [] };
+      }
+      default:
+        throw new TypeError("Unsupported Univer unit type");
+    }
+  } catch (error) {
+    throw exchangeError(error, "CONVERSION_FAILED" /* CONVERSION_FAILED */);
+  }
+}
+async function importFile(path, options) {
+  let snapshot = await importFileToSnapshot(path, options);
+  return snapshotToMemory(snapshot, options.type);
+}
+async function importBuffer(input, options) {
+  let snapshot = await importSnapshot(input, options, options.fileName);
+  return snapshotToMemory(snapshot, options.type);
+}
+async function importFileToSnapshot(path, options) {
+  let fileName = options.fileName ?? (0, import_node_path.basename)(path), input;
+  try {
+    input = await (0, import_promises.readFile)(path);
+  } catch (error) {
+    throw exchangeError(error, "IO_ERROR" /* IO_ERROR */);
+  }
+  return importSnapshot(input, options, fileName);
+}
+async function importBufferToSnapshot(input, options) {
+  return importSnapshot(input, options, options.fileName);
+}
+async function exportToBuffer(data, options) {
+  return exportSnapshotToBuffer(await memoryToSnapshot(data, options), options);
+}
+async function exportToFile(data, path, options) {
+  await exportSnapshotToFile(await memoryToSnapshot(data, options), path, options);
+}
+async function exportSnapshotToBuffer(snapshot, options) {
+  try {
+    return await (await loadNativeBinding()).exchangeExportSnapshot(
+      toNativeSnapshot(snapshot),
+      JSON.stringify(nativeExportOptions(options))
+    );
+  } catch (error) {
+    throw exchangeError(error, "CONVERSION_FAILED" /* CONVERSION_FAILED */);
+  }
+}
+async function exportSnapshotToFile(snapshot, path, options) {
+  let output = await exportSnapshotToBuffer(snapshot, options);
+  try {
+    await (0, import_promises.writeFile)(path, output);
+  } catch (error) {
+    throw exchangeError(error, "IO_ERROR" /* IO_ERROR */);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BaseAttachmentPolicy,
+  BaseExportMode,
+  BaseFormulaPolicy,
+  BaseHeaderPolicy,
+  BaseImagePolicy,
+  BaseImportMode,
+  BaseTypeInference,
+  CsvFormulaMode,
+  CsvLineEnding,
+  CsvQuoteStyle,
+  CsvTypeInferenceMode,
+  CsvValueMode,
+  DocxCompatibilityMode,
+  ExchangeError,
+  ExchangeErrorCode,
+  ExchangeFormat,
+  FormulaCalculationMode,
+  exportSnapshotToBuffer,
+  exportSnapshotToFile,
+  exportToBuffer,
+  exportToFile,
+  importBuffer,
+  importBufferToSnapshot,
+  importFile,
+  importFileToSnapshot
+});

package/lib/es/index.js

@@ -0,0 +1,391 @@
+// src/index.ts
+import {
+  transformBaseDataToSnapshot,
+  transformDocumentDataToSnapshot,
+  transformSlideDataToSnapshot,
+  transformSnapshotToBaseData,
+  transformSnapshotToDocumentData,
+  transformSnapshotToSlideData,
+  transformSnapshotToWorkbookData,
+  transformWorkbookDataToSnapshot
+} from "@univerjs-pro/collaboration";
+import { UniverInstanceType } from "@univerjs/core";
+import { basename, extname } from "node:path";
+import { readFile, writeFile } from "node:fs/promises";
+
+// src/binding.ts
+import { createRequire } from "node:module";
+import process from "node:process";
+
+// src/types.ts
+var ExchangeFormat = /* @__PURE__ */ ((ExchangeFormat2) => (ExchangeFormat2.XLS = "xls", ExchangeFormat2.XLSX = "xlsx", ExchangeFormat2.CSV = "csv", ExchangeFormat2.TSV = "tsv", ExchangeFormat2.DOC = "doc", ExchangeFormat2.DOCX = "docx", ExchangeFormat2.PPT = "ppt", ExchangeFormat2.PPTX = "pptx", ExchangeFormat2))(ExchangeFormat || {}), FormulaCalculationMode = /* @__PURE__ */ ((FormulaCalculationMode2) => (FormulaCalculationMode2.FORCED = "forced", FormulaCalculationMode2.WHEN_EMPTY = "when_empty", FormulaCalculationMode2.NO = "no", FormulaCalculationMode2))(FormulaCalculationMode || {}), CsvTypeInferenceMode = /* @__PURE__ */ ((CsvTypeInferenceMode2) => (CsvTypeInferenceMode2.OFF = "off", CsvTypeInferenceMode2.SAFE = "safe", CsvTypeInferenceMode2.AGGRESSIVE = "aggressive", CsvTypeInferenceMode2))(CsvTypeInferenceMode || {}), CsvQuoteStyle = /* @__PURE__ */ ((CsvQuoteStyle2) => (CsvQuoteStyle2.MINIMAL = "minimal", CsvQuoteStyle2.ALWAYS = "always", CsvQuoteStyle2))(CsvQuoteStyle || {}), CsvLineEnding = /* @__PURE__ */ ((CsvLineEnding2) => (CsvLineEnding2.LF = "lf", CsvLineEnding2.CRLF = "cr_lf", CsvLineEnding2))(CsvLineEnding || {}), CsvValueMode = /* @__PURE__ */ ((CsvValueMode2) => (CsvValueMode2.DISPLAY = "display", CsvValueMode2.RAW = "raw", CsvValueMode2))(CsvValueMode || {}), CsvFormulaMode = /* @__PURE__ */ ((CsvFormulaMode2) => (CsvFormulaMode2.CACHED = "cached", CsvFormulaMode2.EXPRESSION = "expression", CsvFormulaMode2))(CsvFormulaMode || {}), BaseImportMode = /* @__PURE__ */ ((BaseImportMode2) => (BaseImportMode2.TABLES = "tables", BaseImportMode2.SHEETS = "sheets", BaseImportMode2.HYBRID = "hybrid", BaseImportMode2.AUTO = "auto", BaseImportMode2))(BaseImportMode || {}), BaseTypeInference = /* @__PURE__ */ ((BaseTypeInference2) => (BaseTypeInference2.NONE = "none", BaseTypeInference2.SAFE = "safe", BaseTypeInference2.AGGRESSIVE = "aggressive", BaseTypeInference2))(BaseTypeInference || {}), BaseFormulaPolicy = /* @__PURE__ */ ((BaseFormulaPolicy2) => (BaseFormulaPolicy2.VALUES = "values", BaseFormulaPolicy2.TEXT = "text", BaseFormulaPolicy2.FAIL = "fail", BaseFormulaPolicy2.CONVERT_THEN_VALUES = "convertThenValues", BaseFormulaPolicy2))(BaseFormulaPolicy || {}), BaseImagePolicy = /* @__PURE__ */ ((BaseImagePolicy2) => (BaseImagePolicy2.SAFE = "safe", BaseImagePolicy2.CELL_ONLY = "cell-only", BaseImagePolicy2.MEDIA_TABLE = "media-table", BaseImagePolicy2.NONE = "none", BaseImagePolicy2))(BaseImagePolicy || {}), BaseHeaderPolicy = /* @__PURE__ */ ((BaseHeaderPolicy2) => (BaseHeaderPolicy2.FIRST_ROW = "firstRow", BaseHeaderPolicy2.NONE = "none", BaseHeaderPolicy2))(BaseHeaderPolicy || {}), BaseExportMode = /* @__PURE__ */ ((BaseExportMode2) => (BaseExportMode2.TABLES = "tables", BaseExportMode2.RANGES = "ranges", BaseExportMode2))(BaseExportMode || {}), BaseAttachmentPolicy = /* @__PURE__ */ ((BaseAttachmentPolicy2) => (BaseAttachmentPolicy2.HYBRID = "hybrid", BaseAttachmentPolicy2.MANIFEST = "manifest", BaseAttachmentPolicy2.LINKS = "links", BaseAttachmentPolicy2.NONE = "none", BaseAttachmentPolicy2))(BaseAttachmentPolicy || {}), DocxCompatibilityMode = /* @__PURE__ */ ((DocxCompatibilityMode2) => (DocxCompatibilityMode2.TRADITIONAL = "traditional", DocxCompatibilityMode2.MODERN = "modern", DocxCompatibilityMode2))(DocxCompatibilityMode || {}), ExchangeErrorCode = /* @__PURE__ */ ((ExchangeErrorCode2) => (ExchangeErrorCode2.INVALID_ARGUMENT = "INVALID_ARGUMENT", ExchangeErrorCode2.UNSUPPORTED_FORMAT = "UNSUPPORTED_FORMAT", ExchangeErrorCode2.INVALID_FILE = "INVALID_FILE", ExchangeErrorCode2.INCOMPLETE_SNAPSHOT = "INCOMPLETE_SNAPSHOT", ExchangeErrorCode2.IO_ERROR = "IO_ERROR", ExchangeErrorCode2.NATIVE_LOAD_FAILED = "NATIVE_LOAD_FAILED", ExchangeErrorCode2.CONVERSION_FAILED = "CONVERSION_FAILED", ExchangeErrorCode2))(ExchangeErrorCode || {}), ExchangeError = class extends Error {
+  constructor(code, message, options) {
+    super(message, options);
+    this.code = code;
+  }
+  code;
+  name = "ExchangeError";
+};
+
+// src/binding.ts
+var nativeBinding = null, nativeBindingSource = null, nodeRequire = createRequire(import.meta.url);
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+async function loadNativeBinding() {
+  if (nativeBinding)
+    return nativeBinding;
+  let errors = [];
+  try {
+    return nativeBinding = nodeRequire("@univerjs-pro/exchange-node-binding"), nativeBindingSource = "@univerjs-pro/exchange-node-binding", nativeBinding;
+  } catch (error) {
+    errors.push(`@univerjs-pro/exchange-node-binding: ${errorMessage(error)}`);
+  }
+  throw new ExchangeError(
+    "NATIVE_LOAD_FAILED" /* NATIVE_LOAD_FAILED */,
+    [
+      "Failed to load native exchange binding.",
+      `platform=${process.platform}`,
+      `arch=${process.arch}`,
+      "expected npm package=@univerjs-pro/exchange-node-binding",
+      "attempted paths:",
+      ...errors.map((item) => `- ${item}`)
+    ].join(`
+`)
+  );
+}
+
+// src/snapshot-collector.ts
+import { ErrorCode } from "@univerjs/protocol";
+function createSnapshotCollector() {
+  let sheetBlocks = /* @__PURE__ */ new Map();
+  return {
+    // The public Pro conversion functions accept the host-wide service
+    // contract even though these conversion paths use its two write methods.
+    service: {
+      async saveSheetBlock(_context, { block }) {
+        return block ? (sheetBlocks.set(block.id, block), {
+          blockID: block.id,
+          error: { code: ErrorCode.OK, message: "" }
+        }) : {
+          blockID: "",
+          error: { code: ErrorCode.UNDEFINED, message: "block is required" }
+        };
+      },
+      async saveSnapshot() {
+        return { error: { code: ErrorCode.OK, message: "" } };
+      }
+    },
+    get sheetBlocks() {
+      return [...sheetBlocks.values()];
+    }
+  };
+}
+
+// src/snapshot.ts
+import { Buffer as NodeBuffer } from "node:buffer";
+function bufferView(bytes) {
+  return NodeBuffer.isBuffer(bytes) ? bytes : NodeBuffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+}
+function takeMetadata(owner, kind, metadata, ownerId) {
+  if (!owner)
+    return owner;
+  let { originalMeta, ...rest } = owner;
+  if (originalMeta instanceof Uint8Array)
+    metadata.push({ kind, ownerId, data: bufferView(originalMeta) });
+  else if (originalMeta != null)
+    throw new TypeError(`${kind} originalMeta must be a Uint8Array`);
+  return rest;
+}
+function toNativeSnapshot(value) {
+  let metadata = [], source = value.snapshot, snapshot = { ...source }, sourceWorkbook = source.workbook;
+  if (sourceWorkbook) {
+    let workbook = takeMetadata(sourceWorkbook, "workbook", metadata), sourceSheets = sourceWorkbook.sheets;
+    sourceSheets && (workbook.sheets = Object.fromEntries(
+      Object.entries(sourceSheets).map(([sheetId, sheet]) => [
+        sheetId,
+        takeMetadata(sheet, "worksheet", metadata, sheetId)
+      ])
+    )), snapshot.workbook = workbook;
+  }
+  for (let kind of ["doc", "slide"]) {
+    let owner = source[kind];
+    owner && (snapshot[kind] = takeMetadata(owner, kind, metadata));
+  }
+  return {
+    snapshotJson: NodeBuffer.from(JSON.stringify(snapshot)),
+    metadata,
+    sheetBlocks: value.sheetBlocks.map((block) => ({
+      id: block.id,
+      startRow: block.startRow,
+      endRow: block.endRow,
+      data: bufferView(block.data)
+    }))
+  };
+}
+function restoreMetadata(snapshot, metadata) {
+  for (let entry of metadata) {
+    let owner;
+    if (entry.kind === "worksheet") {
+      let sheets = snapshot.workbook?.sheets;
+      owner = entry.ownerId ? sheets?.[entry.ownerId] : void 0;
+    } else {
+      if (entry.kind !== "workbook" && entry.kind !== "doc" && entry.kind !== "slide")
+        throw new TypeError(`unsupported native snapshot metadata kind ${entry.kind}`);
+      owner = snapshot[entry.kind];
+    }
+    if (!owner)
+      throw new TypeError(`native snapshot metadata owner ${entry.kind}/${entry.ownerId ?? ""} is missing`);
+    owner.originalMeta = entry.data;
+  }
+}
+function fromNativeSnapshot(value) {
+  let snapshot = JSON.parse(value.snapshotJson.toString("utf8"));
+  return restoreMetadata(snapshot, value.metadata), {
+    snapshot,
+    sheetBlocks: value.sheetBlocks.map((block) => ({
+      id: block.id,
+      startRow: block.startRow,
+      endRow: block.endRow,
+      data: block.data
+    }))
+  };
+}
+
+// src/index.ts
+var FORMAT_BY_EXTENSION = {
+  ".xls": "xls" /* XLS */,
+  ".xlsx": "xlsx" /* XLSX */,
+  ".csv": "csv" /* CSV */,
+  ".tsv": "tsv" /* TSV */,
+  ".doc": "doc" /* DOC */,
+  ".docx": "docx" /* DOCX */,
+  ".ppt": "ppt" /* PPT */,
+  ".pptx": "pptx" /* PPTX */
+};
+function normalizeWorkbookSheetOrder(data) {
+  let existingOrder = Array.isArray(data.sheetOrder) ? data.sheetOrder.filter((sheetId) => typeof sheetId == "string") : [], ordered = new Set(existingOrder), missingSheetIds = Object.keys(data.sheets).filter((sheetId) => !ordered.has(sheetId));
+  return missingSheetIds.length === 0 ? data : { ...data, sheetOrder: [...existingOrder, ...missingSheetIds] };
+}
+function exchangeError(error, fallback) {
+  if (error instanceof ExchangeError)
+    return error;
+  let message = error instanceof Error ? error.message : String(error), nativeCode = /^\[([A-Z_]+)]\s*/.exec(message)?.[1];
+  return nativeCode && Object.values(ExchangeErrorCode).includes(nativeCode) ? new ExchangeError(nativeCode, message.replace(/^\[[A-Z_]+]\s*/, ""), {
+    cause: error
+  }) : error instanceof TypeError ? new ExchangeError("INVALID_ARGUMENT" /* INVALID_ARGUMENT */, message, { cause: error }) : new ExchangeError(fallback, message, { cause: error });
+}
+function resolveFormat(fileName, format) {
+  if (format)
+    return format;
+  let inferred = FORMAT_BY_EXTENSION[extname(fileName).toLowerCase()];
+  if (!inferred)
+    throw new ExchangeError(
+      "UNSUPPORTED_FORMAT" /* UNSUPPORTED_FORMAT */,
+      `Cannot infer an exchange format from fileName: ${fileName}`
+    );
+  return inferred;
+}
+function nativeUnitType(type) {
+  switch (type) {
+    case UniverInstanceType.UNIVER_SHEET:
+      return "sheet";
+    case UniverInstanceType.UNIVER_BASE:
+      return "base";
+    case UniverInstanceType.UNIVER_DOC:
+      return "doc";
+    case UniverInstanceType.UNIVER_SLIDE:
+      return "slide";
+    default:
+      throw new ExchangeError("INVALID_ARGUMENT" /* INVALID_ARGUMENT */, `Unsupported Univer unit type: ${type}`);
+  }
+}
+function nativeImportOptions(options, fileName) {
+  return {
+    format: resolveFormat(fileName, options.format),
+    unitType: nativeUnitType(options.type),
+    fileName,
+    unitId: options.unitId,
+    minSheetRowCount: "minSheetRowCount" in options ? options.minSheetRowCount : void 0,
+    minSheetColumnCount: "minSheetColumnCount" in options ? options.minSheetColumnCount : void 0,
+    compatibilityMode: "compatibilityMode" in options ? options.compatibilityMode : void 0,
+    csv: "csv" in options ? options.csv : void 0,
+    base: options.type === UniverInstanceType.UNIVER_BASE ? {
+      mode: options.mode,
+      typeInference: options.typeInference,
+      formulaPolicy: options.formulaPolicy,
+      imagePolicy: options.imagePolicy,
+      maxCells: options.maxCells,
+      mapping: options.mapping
+    } : void 0,
+    formulaCalculation: "formulaCalculation" in options ? options.formulaCalculation : void 0
+  };
+}
+function nativeExportOptions(options) {
+  return {
+    format: options.format,
+    unitType: nativeUnitType(options.type),
+    csv: "csv" in options ? options.csv : void 0,
+    base: options.type === UniverInstanceType.UNIVER_BASE && options.format === "xlsx" /* XLSX */ ? {
+      mode: options.mode,
+      formulaPolicy: options.formulaPolicy,
+      attachmentPolicy: options.attachmentPolicy,
+      mapping: options.mapping
+    } : void 0,
+    formulaCalculation: "formulaCalculation" in options ? options.formulaCalculation : void 0
+  };
+}
+async function importSnapshot(input, options, fileName) {
+  try {
+    let result = await (await loadNativeBinding()).exchangeImportToSnapshot(
+      input,
+      JSON.stringify(nativeImportOptions(options, fileName))
+    );
+    return fromNativeSnapshot(result);
+  } catch (error) {
+    throw exchangeError(error, "CONVERSION_FAILED" /* CONVERSION_FAILED */);
+  }
+}
+async function snapshotToMemory(snapshot, type) {
+  try {
+    switch (type) {
+      case UniverInstanceType.UNIVER_SHEET:
+        return await transformSnapshotToWorkbookData(snapshot.snapshot, snapshot.sheetBlocks);
+      case UniverInstanceType.UNIVER_BASE:
+        return await transformSnapshotToBaseData(snapshot.snapshot, snapshot.sheetBlocks);
+      case UniverInstanceType.UNIVER_DOC:
+        return transformSnapshotToDocumentData(snapshot.snapshot);
+      case UniverInstanceType.UNIVER_SLIDE:
+        return transformSnapshotToSlideData(snapshot.snapshot);
+      default:
+        throw new TypeError(`Unsupported Univer unit type: ${type}`);
+    }
+  } catch (error) {
+    throw exchangeError(error, "CONVERSION_FAILED" /* CONVERSION_FAILED */);
+  }
+}
+async function memoryToSnapshot(data, options) {
+  try {
+    let unitId = data.id;
+    if (!unitId)
+      throw new ExchangeError("INVALID_ARGUMENT" /* INVALID_ARGUMENT */, "Export data must have a non-empty id");
+    let rev = data.rev ?? 0, collector = createSnapshotCollector();
+    switch (options.type) {
+      case UniverInstanceType.UNIVER_SHEET: {
+        let workbook = normalizeWorkbookSheetOrder(data), { snapshot } = await transformWorkbookDataToSnapshot(
+          { metadata: void 0 },
+          workbook,
+          unitId,
+          rev,
+          collector.service
+        );
+        return { snapshot, sheetBlocks: collector.sheetBlocks };
+      }
+      case UniverInstanceType.UNIVER_BASE: {
+        let { snapshot } = await transformBaseDataToSnapshot(
+          { metadata: void 0 },
+          data,
+          unitId,
+          rev,
+          collector.service
+        );
+        return { snapshot, sheetBlocks: collector.sheetBlocks };
+      }
+      case UniverInstanceType.UNIVER_DOC: {
+        let { snapshot } = await transformDocumentDataToSnapshot(
+          { metadata: void 0 },
+          data,
+          unitId,
+          rev,
+          collector.service
+        );
+        return { snapshot, sheetBlocks: [] };
+      }
+      case UniverInstanceType.UNIVER_SLIDE: {
+        let slide = data, { snapshot } = await transformSlideDataToSnapshot(
+          slide.resources,
+          slide,
+          unitId,
+          rev,
+          collector.service
+        );
+        return { snapshot, sheetBlocks: [] };
+      }
+      default:
+        throw new TypeError("Unsupported Univer unit type");
+    }
+  } catch (error) {
+    throw exchangeError(error, "CONVERSION_FAILED" /* CONVERSION_FAILED */);
+  }
+}
+async function importFile(path, options) {
+  let snapshot = await importFileToSnapshot(path, options);
+  return snapshotToMemory(snapshot, options.type);
+}
+async function importBuffer(input, options) {
+  let snapshot = await importSnapshot(input, options, options.fileName);
+  return snapshotToMemory(snapshot, options.type);
+}
+async function importFileToSnapshot(path, options) {
+  let fileName = options.fileName ?? basename(path), input;
+  try {
+    input = await readFile(path);
+  } catch (error) {
+    throw exchangeError(error, "IO_ERROR" /* IO_ERROR */);
+  }
+  return importSnapshot(input, options, fileName);
+}
+async function importBufferToSnapshot(input, options) {
+  return importSnapshot(input, options, options.fileName);
+}
+async function exportToBuffer(data, options) {
+  return exportSnapshotToBuffer(await memoryToSnapshot(data, options), options);
+}
+async function exportToFile(data, path, options) {
+  await exportSnapshotToFile(await memoryToSnapshot(data, options), path, options);
+}
+async function exportSnapshotToBuffer(snapshot, options) {
+  try {
+    return await (await loadNativeBinding()).exchangeExportSnapshot(
+      toNativeSnapshot(snapshot),
+      JSON.stringify(nativeExportOptions(options))
+    );
+  } catch (error) {
+    throw exchangeError(error, "CONVERSION_FAILED" /* CONVERSION_FAILED */);
+  }
+}
+async function exportSnapshotToFile(snapshot, path, options) {
+  let output = await exportSnapshotToBuffer(snapshot, options);
+  try {
+    await writeFile(path, output);
+  } catch (error) {
+    throw exchangeError(error, "IO_ERROR" /* IO_ERROR */);
+  }
+}
+export {
+  BaseAttachmentPolicy,
+  BaseExportMode,
+  BaseFormulaPolicy,
+  BaseHeaderPolicy,
+  BaseImagePolicy,
+  BaseImportMode,
+  BaseTypeInference,
+  CsvFormulaMode,
+  CsvLineEnding,
+  CsvQuoteStyle,
+  CsvTypeInferenceMode,
+  CsvValueMode,
+  DocxCompatibilityMode,
+  ExchangeError,
+  ExchangeErrorCode,
+  ExchangeFormat,
+  FormulaCalculationMode,
+  exportSnapshotToBuffer,
+  exportSnapshotToFile,
+  exportToBuffer,
+  exportToFile,
+  importBuffer,
+  importBufferToSnapshot,
+  importFile,
+  importFileToSnapshot
+};

package/lib/types/index.d.ts

@@ -0,0 +1,256 @@
+import { ISlideData } from "@univerjs-pro/slides";
+import { IBaseSnapshot, IDocumentData, IWorkbookData, UniverInstanceType } from "@univerjs/core";
+import { Buffer } from "node:buffer";
+import { ISheetBlock, ISnapshot } from "@univerjs/protocol";
+//#region src/types.d.ts
+declare enum ExchangeFormat {
+  XLS = "xls",
+  XLSX = "xlsx",
+  CSV = "csv",
+  TSV = "tsv",
+  DOC = "doc",
+  DOCX = "docx",
+  PPT = "ppt",
+  PPTX = "pptx"
+}
+declare enum FormulaCalculationMode {
+  FORCED = "forced",
+  WHEN_EMPTY = "when_empty",
+  NO = "no"
+}
+declare enum CsvTypeInferenceMode {
+  OFF = "off",
+  SAFE = "safe",
+  AGGRESSIVE = "aggressive"
+}
+declare enum CsvQuoteStyle {
+  MINIMAL = "minimal",
+  ALWAYS = "always"
+}
+declare enum CsvLineEnding {
+  LF = "lf",
+  CRLF = "cr_lf"
+}
+declare enum CsvValueMode {
+  DISPLAY = "display",
+  RAW = "raw"
+}
+declare enum CsvFormulaMode {
+  CACHED = "cached",
+  EXPRESSION = "expression"
+}
+declare enum BaseImportMode {
+  TABLES = "tables",
+  SHEETS = "sheets",
+  HYBRID = "hybrid",
+  AUTO = "auto"
+}
+declare enum BaseTypeInference {
+  NONE = "none",
+  SAFE = "safe",
+  AGGRESSIVE = "aggressive"
+}
+declare enum BaseFormulaPolicy {
+  VALUES = "values",
+  TEXT = "text",
+  FAIL = "fail",
+  CONVERT_THEN_VALUES = "convertThenValues"
+}
+declare enum BaseImagePolicy {
+  SAFE = "safe",
+  CELL_ONLY = "cell-only",
+  MEDIA_TABLE = "media-table",
+  NONE = "none"
+}
+declare enum BaseHeaderPolicy {
+  FIRST_ROW = "firstRow",
+  NONE = "none"
+}
+declare enum BaseExportMode {
+  TABLES = "tables",
+  RANGES = "ranges"
+}
+declare enum BaseAttachmentPolicy {
+  HYBRID = "hybrid",
+  MANIFEST = "manifest",
+  LINKS = "links",
+  NONE = "none"
+}
+declare enum DocxCompatibilityMode {
+  TRADITIONAL = "traditional",
+  MODERN = "modern"
+}
+interface IBaseFieldMapping {
+  name?: string;
+  type?: string;
+  config?: unknown;
+  formulaPolicy?: BaseFormulaPolicy;
+}
+interface IBaseTableMapping {
+  include?: boolean;
+  name?: string;
+  primaryField?: string;
+  header?: BaseHeaderPolicy;
+  formulaPolicy?: BaseFormulaPolicy;
+  fields?: Record<string, IBaseFieldMapping>;
+}
+interface IBaseImportMapping {
+  selectedOnly?: boolean;
+  tables?: Record<string, IBaseTableMapping>;
+  sheets?: Record<string, IBaseTableMapping>;
+}
+interface IBaseExportMapping {
+  tables?: Record<string, {
+    name?: string;
+    fields?: Record<string, {
+      name?: string;
+    }>;
+  }>;
+}
+interface ICsvImportOptions {
+  delimiter?: 'auto' | 'comma' | 'tab' | 'semicolon' | 'pipe' | 'space' | string;
+  quote?: 'auto' | 'none' | 'double' | 'single' | string;
+  encoding?: string;
+  inferTypes?: CsvTypeInferenceMode;
+}
+type ICsvExportSelector = {
+  worksheetId: string;
+  worksheetName?: never;
+  tableId?: never;
+  tableName?: never;
+} | {
+  worksheetId?: never;
+  worksheetName: string;
+  tableId?: never;
+  tableName?: never;
+} | {
+  worksheetId?: never;
+  worksheetName?: never;
+  tableId: string;
+  tableName?: never;
+} | {
+  worksheetId?: never;
+  worksheetName?: never;
+  tableId?: never;
+  tableName: string;
+};
+type ICsvExportOptions = ICsvExportSelector & {
+  delimiter?: 'comma' | 'tab' | 'semicolon' | 'pipe' | 'space' | string;
+  quoteStyle?: CsvQuoteStyle;
+  lineEnding?: CsvLineEnding;
+  encoding?: string;
+  valueMode?: CsvValueMode;
+  formulaMode?: CsvFormulaMode;
+};
+interface IImportOptionsBase<TType extends UniverInstanceType, TFormat extends ExchangeFormat> {
+  type: TType;
+  format?: TFormat;
+  fileName?: string;
+  unitId?: string;
+}
+interface IGridImportOptions {
+  minSheetRowCount?: number;
+  minSheetColumnCount?: number;
+}
+type ISheetImportOptions = IGridImportOptions & ((IImportOptionsBase<UniverInstanceType.UNIVER_SHEET, ExchangeFormat.XLS> & {
+  csv?: never;
+  formulaCalculation?: never;
+}) | (IImportOptionsBase<UniverInstanceType.UNIVER_SHEET, ExchangeFormat.XLSX> & {
+  csv?: never;
+  formulaCalculation?: FormulaCalculationMode;
+}) | (IImportOptionsBase<UniverInstanceType.UNIVER_SHEET, ExchangeFormat.CSV | ExchangeFormat.TSV> & {
+  csv?: ICsvImportOptions;
+  formulaCalculation?: never;
+}));
+interface IBaseImportConfig extends IGridImportOptions {
+  mode?: BaseImportMode;
+  typeInference?: BaseTypeInference;
+  formulaPolicy?: BaseFormulaPolicy;
+  imagePolicy?: BaseImagePolicy;
+  maxCells?: number | null;
+  mapping?: IBaseImportMapping;
+}
+type IBaseImportOptions = IBaseImportConfig & ((IImportOptionsBase<UniverInstanceType.UNIVER_BASE, ExchangeFormat.XLS | ExchangeFormat.XLSX> & {
+  csv?: never;
+}) | (IImportOptionsBase<UniverInstanceType.UNIVER_BASE, ExchangeFormat.CSV | ExchangeFormat.TSV> & {
+  csv?: ICsvImportOptions;
+}));
+interface IDocImportOptions extends IImportOptionsBase<UniverInstanceType.UNIVER_DOC, ExchangeFormat.DOC | ExchangeFormat.DOCX> {
+  compatibilityMode?: DocxCompatibilityMode;
+}
+interface ISlideImportOptions extends IImportOptionsBase<UniverInstanceType.UNIVER_SLIDE, ExchangeFormat.PPT | ExchangeFormat.PPTX> {}
+type ImportOptions = ISheetImportOptions | IBaseImportOptions | IDocImportOptions | ISlideImportOptions;
+type BufferImportOptions<T extends ImportOptions = ImportOptions> = T & {
+  fileName: string;
+};
+interface IExportOptionsBase<TType extends UniverInstanceType, TFormat extends ExchangeFormat> {
+  type: TType;
+  format: TFormat;
+}
+interface ISheetExportConfig {
+  /** @default FormulaCalculationMode.WHEN_EMPTY */
+  formulaCalculation?: FormulaCalculationMode;
+}
+type ISheetExportOptions = ISheetExportConfig & ((IExportOptionsBase<UniverInstanceType.UNIVER_SHEET, ExchangeFormat.XLSX> & {
+  csv?: never;
+}) | (IExportOptionsBase<UniverInstanceType.UNIVER_SHEET, ExchangeFormat.CSV | ExchangeFormat.TSV> & {
+  csv: ICsvExportOptions;
+}));
+interface IBaseXlsxExportConfig {
+  mode?: BaseExportMode;
+  formulaPolicy?: BaseFormulaPolicy;
+  attachmentPolicy?: BaseAttachmentPolicy;
+  mapping?: IBaseExportMapping;
+}
+type IBaseExportOptions = (IExportOptionsBase<UniverInstanceType.UNIVER_BASE, ExchangeFormat.XLSX> & IBaseXlsxExportConfig & {
+  csv?: never;
+}) | (IExportOptionsBase<UniverInstanceType.UNIVER_BASE, ExchangeFormat.CSV | ExchangeFormat.TSV> & {
+  csv: ICsvExportOptions;
+});
+interface IDocExportOptions extends IExportOptionsBase<UniverInstanceType.UNIVER_DOC, ExchangeFormat.DOCX> {}
+interface ISlideExportOptions extends IExportOptionsBase<UniverInstanceType.UNIVER_SLIDE, ExchangeFormat.PPTX> {}
+type ExportOptions = ISheetExportOptions | IBaseExportOptions | IDocExportOptions | ISlideExportOptions;
+interface ISnapshotWithBlocks {
+  snapshot: ISnapshot;
+  sheetBlocks: ISheetBlock[];
+}
+declare enum ExchangeErrorCode {
+  INVALID_ARGUMENT = "INVALID_ARGUMENT",
+  UNSUPPORTED_FORMAT = "UNSUPPORTED_FORMAT",
+  INVALID_FILE = "INVALID_FILE",
+  INCOMPLETE_SNAPSHOT = "INCOMPLETE_SNAPSHOT",
+  IO_ERROR = "IO_ERROR",
+  NATIVE_LOAD_FAILED = "NATIVE_LOAD_FAILED",
+  CONVERSION_FAILED = "CONVERSION_FAILED"
+}
+declare class ExchangeError extends Error {
+  readonly code: ExchangeErrorCode;
+  readonly name = "ExchangeError";
+  constructor(code: ExchangeErrorCode, message: string, options?: {
+    cause?: unknown;
+  });
+}
+//#endregion
+//#region src/index.d.ts
+declare function importFile(path: string, options: ISheetImportOptions): Promise<IWorkbookData>;
+declare function importFile(path: string, options: IBaseImportOptions): Promise<IBaseSnapshot>;
+declare function importFile(path: string, options: IDocImportOptions): Promise<IDocumentData>;
+declare function importFile(path: string, options: ISlideImportOptions): Promise<ISlideData>;
+declare function importBuffer(input: Buffer, options: BufferImportOptions<ISheetImportOptions>): Promise<IWorkbookData>;
+declare function importBuffer(input: Buffer, options: BufferImportOptions<IBaseImportOptions>): Promise<IBaseSnapshot>;
+declare function importBuffer(input: Buffer, options: BufferImportOptions<IDocImportOptions>): Promise<IDocumentData>;
+declare function importBuffer(input: Buffer, options: BufferImportOptions<ISlideImportOptions>): Promise<ISlideData>;
+declare function importFileToSnapshot(path: string, options: ImportOptions): Promise<ISnapshotWithBlocks>;
+declare function importBufferToSnapshot<T extends ImportOptions>(input: Buffer, options: BufferImportOptions<T>): Promise<ISnapshotWithBlocks>;
+declare function exportToBuffer(data: IWorkbookData, options: ISheetExportOptions): Promise<Buffer>;
+declare function exportToBuffer(data: IBaseSnapshot, options: IBaseExportOptions): Promise<Buffer>;
+declare function exportToBuffer(data: IDocumentData, options: IDocExportOptions): Promise<Buffer>;
+declare function exportToBuffer(data: ISlideData, options: ISlideExportOptions): Promise<Buffer>;
+declare function exportToFile(data: IWorkbookData, path: string, options: ISheetExportOptions): Promise<void>;
+declare function exportToFile(data: IBaseSnapshot, path: string, options: IBaseExportOptions): Promise<void>;
+declare function exportToFile(data: IDocumentData, path: string, options: IDocExportOptions): Promise<void>;
+declare function exportToFile(data: ISlideData, path: string, options: ISlideExportOptions): Promise<void>;
+declare function exportSnapshotToBuffer(snapshot: ISnapshotWithBlocks, options: ExportOptions): Promise<Buffer>;
+declare function exportSnapshotToFile(snapshot: ISnapshotWithBlocks, path: string, options: ExportOptions): Promise<void>;
+//#endregion
+export { BaseAttachmentPolicy, BaseExportMode, BaseFormulaPolicy, BaseHeaderPolicy, BaseImagePolicy, BaseImportMode, BaseTypeInference, BufferImportOptions, CsvFormulaMode, CsvLineEnding, CsvQuoteStyle, CsvTypeInferenceMode, CsvValueMode, DocxCompatibilityMode, ExchangeError, ExchangeErrorCode, ExchangeFormat, ExportOptions, FormulaCalculationMode, IBaseExportMapping, IBaseExportOptions, IBaseFieldMapping, IBaseImportMapping, IBaseImportOptions, IBaseTableMapping, ICsvExportOptions, ICsvExportSelector, ICsvImportOptions, IDocExportOptions, IDocImportOptions, IExportOptionsBase, IGridImportOptions, IImportOptionsBase, ISheetExportOptions, ISheetImportOptions, ISlideExportOptions, ISlideImportOptions, ISnapshotWithBlocks, ImportOptions, exportSnapshotToBuffer, exportSnapshotToFile, exportToBuffer, exportToFile, importBuffer, importBufferToSnapshot, importFile, importFileToSnapshot };

package/package.json

@@ -0,0 +1,43 @@
+{
+    "author": "DreamNum Co., Ltd. <developer@univer.ai>",
+    "dependencies": {
+        "@univerjs-pro/collaboration": "1.0.0-beta.2",
+        "@univerjs-pro/exchange-node-binding": "0.1.0",
+        "@univerjs-pro/slides": "1.0.0-beta.2",
+        "@univerjs/core": "1.0.0-beta.2",
+        "@univerjs/protocol": "1.0.0-beta.2"
+    },
+    "description": "Node.js SDK for converting between Office formats, Univer unit data, and snapshots",
+    "files": [
+        "lib",
+        "README.md"
+    ],
+    "name": "@univerjs-pro/exchange-node",
+    "type": "module",
+    "version": "1.0.0-beta.2",
+    "main": "./lib/cjs/index.cjs",
+    "module": "./lib/es/index.js",
+    "types": "./lib/types/index.d.ts",
+    "exports": {
+        ".": {
+            "types": "./lib/types/index.d.ts",
+            "import": "./lib/es/index.js",
+            "require": "./lib/cjs/index.cjs",
+            "default": "./lib/es/index.js"
+        }
+    },
+    "publishConfig": {
+        "main": "./lib/cjs/index.cjs",
+        "module": "./lib/es/index.js",
+        "types": "./lib/types/index.d.ts",
+        "exports": {
+            ".": {
+                "types": "./lib/types/index.d.ts",
+                "import": "./lib/es/index.js",
+                "require": "./lib/cjs/index.cjs",
+                "default": "./lib/es/index.js"
+            }
+        },
+        "access": "public"
+    }
+}