logisheets-runtime 1.10.0 → 1.12.0

package/dist/index.d.ts

@@ -49,6 +49,29 @@ export declare class Workbook {
     constructor(bookId: number, path?: string);
     /** Read a single cell's evaluated value. */
     getValue(sheetIdx: number, row: number, col: number): Value;
+    /**
+     * Serialize the workbook back to .xlsx bytes.
+     *
+     * `saveWorkbook` is deliberately absent from {@link Client}: it is a
+     * whole-file operation rather than one of the per-cell/per-sheet
+     * `WorkbookMethods`, so it goes straight through the engine entry here.
+     *
+     * @param appData opaque per-document JSON the host owns (craft state and
+     *                friends). It round-trips through the file; pass what the
+     *                engine's `getAppData` gave you, or nothing.
+     * @param resolveBlockRefs write block formulas as ordinary A1 references
+     *                instead of `BLOCKREF(...)`. Off by default: the named form
+     *                is readable and reopens here intact, but no other
+     *                spreadsheet knows those functions, so a file Excel has to
+     *                recalculate needs coordinates. One-way — see the note on
+     *                the engine's `FormulaFormat`.
+     */
+    save(appData?: string, resolveBlockRefs?: boolean): Uint8Array;
+    /**
+     * Serialize and write the workbook to `path`. Defaults to the path it was
+     * loaded from, so a load -> edit -> `saveAs()` round-trip needs no argument.
+     */
+    saveAs(path?: string, appData?: string, resolveBlockRefs?: boolean): Promise<void>;
     /** Undo the most recent transaction. Returns whether anything was undone. */
     undo(): Promise<boolean>;
     /** Redo the most recently undone transaction. Returns whether anything was redone. */

package/dist/index.js

@@ -10,7 +10,7 @@
 // workbook logic lives in logisheets-core's WorkbookOps; the runtime only
 // adapts the synchronous Node `handle()` entry point into the async Client that
 // WorkbookOps consumes, then exposes that ops layer per workbook.
-import { readFile } from 'node:fs/promises';
+import { readFile, writeFile } from 'node:fs/promises';
 import { basename, resolve } from 'node:path';
 import { createRequire } from 'node:module';
 import { WorkbookOps } from 'logisheets-core';
@@ -98,6 +98,44 @@ export class Workbook {
     getValue(sheetIdx, row, col) {
         return handle({ method: 'getValue', value: { sheetIdx, row, col } }, this.id);
     }
+    /**
+     * Serialize the workbook back to .xlsx bytes.
+     *
+     * `saveWorkbook` is deliberately absent from {@link Client}: it is a
+     * whole-file operation rather than one of the per-cell/per-sheet
+     * `WorkbookMethods`, so it goes straight through the engine entry here.
+     *
+     * @param appData opaque per-document JSON the host owns (craft state and
+     *                friends). It round-trips through the file; pass what the
+     *                engine's `getAppData` gave you, or nothing.
+     * @param resolveBlockRefs write block formulas as ordinary A1 references
+     *                instead of `BLOCKREF(...)`. Off by default: the named form
+     *                is readable and reopens here intact, but no other
+     *                spreadsheet knows those functions, so a file Excel has to
+     *                recalculate needs coordinates. One-way — see the note on
+     *                the engine's `FormulaFormat`.
+     */
+    save(appData = '', resolveBlockRefs = false) {
+        const r = handle({ method: 'saveWorkbook', value: { appData, resolveBlockRefs } }, this.id);
+        if (r.code !== 0) {
+            throw new Error(`failed to save workbook (code ${r.code})`);
+        }
+        // The wasm boundary hands back either a typed array or a plain number
+        // array depending on the serializer path; normalize so callers can
+        // always treat this as bytes.
+        return r.data instanceof Uint8Array ? r.data : Uint8Array.from(r.data);
+    }
+    /**
+     * Serialize and write the workbook to `path`. Defaults to the path it was
+     * loaded from, so a load -> edit -> `saveAs()` round-trip needs no argument.
+     */
+    async saveAs(path, appData = '', resolveBlockRefs = false) {
+        const target = path ?? this.path;
+        if (target === undefined) {
+            throw new Error('saveAs: no path given and this workbook was not loaded from one');
+        }
+        await writeFile(resolve(target), this.save(appData, resolveBlockRefs));
+    }
     /** Undo the most recent transaction. Returns whether anything was undone. */
     async undo() {
         return (await this.client.undo()) === true;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "logisheets-runtime",
-    "version": "1.10.0",
+    "version": "1.12.0",
     "description": "Headless LogiSheets spreadsheet runtime for Node — logisheets-core wired to the Node WASM engine. The Node counterpart of the browser app.",
     "type": "module",
     "main": "./dist/index.js",
@@ -17,9 +17,30 @@
     ],
     "author": "Jeremy He",
     "license": "MIT",
+    "keywords": [
+        "spreadsheet",
+        "xlsx",
+        "excel",
+        "headless",
+        "nodejs",
+        "server",
+        "wasm",
+        "rust",
+        "formula",
+        "workbook"
+    ],
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/logisky/LogiSheets.git",
+        "directory": "packages/runtime"
+    },
+    "bugs": {
+        "url": "https://github.com/logisky/LogiSheets/issues"
+    },
+    "homepage": "https://github.com/logisky/LogiSheets",
     "dependencies": {
-        "logisheets": "^1.10.0",
-        "logisheets-core": "^1.10.0"
+        "logisheets": "^1.12.0",
+        "logisheets-core": "^1.12.0"
     },
     "devDependencies": {
         "@types/node": "^18",