@truecalc/workbook 3.0.0 → 3.2.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "@truecalc/workbook",
   "type": "module",
   "description": "Spreadsheet workbook for the browser — full Workbook API compiled to WebAssembly",
-  "version": "3.0.0",
+  "version": "3.2.0",
   "license": "MIT",
   "repository": {
     "type": "git",

package/truecalc_wasm_workbook.d.ts

@@ -1,5 +1,16 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Result of [`translate_formula`]: either the rewritten `formula` text or an
+ * `error` message (mutually exclusive). Mirrors the `TranslateResult` shape
+ * exposed by the calc-only `@truecalc/core` WASM binding so both packages
+ * present the same reference-translation surface.
+ */
+export interface TranslateResult {
+    formula?: string;
+    error?: string;
+}
+
 
 /**
  * A spreadsheet workbook exposed to JavaScript.
@@ -66,12 +77,43 @@ export class JsWorkbook {
      * becomes a `Text` value.
      */
     set(sheet: string, a1: string, input: string): void;
+    /**
+     * Sets the cell at `a1` on `sheet` to a **Date-typed** serial value.
+     *
+     * Unlike [`set`](Self::set) — which stores a numeric string as a plain
+     * `Number` — this stores `serial` as a `Date`, the type a host uses for a
+     * cell it means as a date. The engine's arithmetic type propagation then
+     * keeps it rendering as a date through offset arithmetic: `=A1+1` and
+     * `=A1-7` on a Date cell stay dates (`=A1-B1` between two Date cells is a
+     * plain day count, matching Google Sheets).
+     *
+     * The serial round-trips exactly — it is stored verbatim, never
+     * reconstructed via `DATE(y, m, d)` — so pre-1900 (negative) serials and
+     * fractional time-of-day components are preserved bit-for-bit.
+     */
+    setDate(sheet: string, a1: string, serial: number): void;
     /**
      * Serializes the workbook to its canonical JSON string.
      */
     toJSON(): string;
 }
 
+/**
+ * Shift every relative cell/range reference in `formula` by `(dRow, dCol)` —
+ * the fill / copy-paste reference-adjustment transform — using the engine's
+ * authoritative parser instead of a re-implemented tokenizer.
+ *
+ * `$`-absolute axes stay fixed; range endpoints and cross-sheet refs adjust
+ * while the sheet name is preserved; references inside string literals and
+ * function names are never rewritten; a name bound by `LET`/`LAMBDA` is left
+ * untouched. An axis that shifts out of the grid becomes a literal `#REF!`
+ * for that corner.
+ *
+ * Sheets flavor only (Excel grid bounds are a follow-up); a parse error is
+ * surfaced in the `error` field.
+ */
+export function translateFormula(formula: string, d_row: number, d_col: number): TranslateResult;
+
 export type InitInput = RequestInfo | URL | Response | BufferSource | WebAssembly.Module;
 
 export interface InitOutput {
@@ -86,10 +128,12 @@ export interface InitOutput {
     readonly jsworkbook_redefineName: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly jsworkbook_resolved: (a: number, b: number, c: number, d: number, e: number, f: number) => void;
     readonly jsworkbook_set: (a: number, b: number, c: number, d: number, e: number, f: number, g: number, h: number) => void;
+    readonly jsworkbook_setDate: (a: number, b: number, c: number, d: number, e: number, f: number, g: number) => void;
     readonly jsworkbook_toJSON: (a: number, b: number) => void;
-    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
+    readonly translateFormula: (a: number, b: number, c: number, d: number) => number;
     readonly __wbindgen_export: (a: number, b: number) => number;
     readonly __wbindgen_export2: (a: number, b: number, c: number, d: number) => number;
+    readonly __wbindgen_add_to_stack_pointer: (a: number) => number;
     readonly __wbindgen_export3: (a: number, b: number, c: number) => void;
 }
 

package/truecalc_wasm_workbook.js

@@ -234,6 +234,40 @@ export class JsWorkbook {
             wasm.__wbindgen_add_to_stack_pointer(16);
         }
     }
+    /**
+     * Sets the cell at `a1` on `sheet` to a **Date-typed** serial value.
+     *
+     * Unlike [`set`](Self::set) — which stores a numeric string as a plain
+     * `Number` — this stores `serial` as a `Date`, the type a host uses for a
+     * cell it means as a date. The engine's arithmetic type propagation then
+     * keeps it rendering as a date through offset arithmetic: `=A1+1` and
+     * `=A1-7` on a Date cell stay dates (`=A1-B1` between two Date cells is a
+     * plain day count, matching Google Sheets).
+     *
+     * The serial round-trips exactly — it is stored verbatim, never
+     * reconstructed via `DATE(y, m, d)` — so pre-1900 (negative) serials and
+     * fractional time-of-day components are preserved bit-for-bit.
+     * @param {string} sheet
+     * @param {string} a1
+     * @param {number} serial
+     */
+    setDate(sheet, a1, serial) {
+        try {
+            const retptr = wasm.__wbindgen_add_to_stack_pointer(-16);
+            const ptr0 = passStringToWasm0(sheet, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len0 = WASM_VECTOR_LEN;
+            const ptr1 = passStringToWasm0(a1, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            wasm.jsworkbook_setDate(retptr, this.__wbg_ptr, ptr0, len0, ptr1, len1, serial);
+            var r0 = getDataViewMemory0().getInt32(retptr + 4 * 0, true);
+            var r1 = getDataViewMemory0().getInt32(retptr + 4 * 1, true);
+            if (r1) {
+                throw takeObject(r0);
+            }
+        } finally {
+            wasm.__wbindgen_add_to_stack_pointer(16);
+        }
+    }
     /**
      * Serializes the workbook to its canonical JSON string.
      * @returns {string}
@@ -264,6 +298,31 @@ export class JsWorkbook {
     }
 }
 if (Symbol.dispose) JsWorkbook.prototype[Symbol.dispose] = JsWorkbook.prototype.free;
+
+/**
+ * Shift every relative cell/range reference in `formula` by `(dRow, dCol)` —
+ * the fill / copy-paste reference-adjustment transform — using the engine's
+ * authoritative parser instead of a re-implemented tokenizer.
+ *
+ * `$`-absolute axes stay fixed; range endpoints and cross-sheet refs adjust
+ * while the sheet name is preserved; references inside string literals and
+ * function names are never rewritten; a name bound by `LET`/`LAMBDA` is left
+ * untouched. An axis that shifts out of the grid becomes a literal `#REF!`
+ * for that corner.
+ *
+ * Sheets flavor only (Excel grid bounds are a follow-up); a parse error is
+ * surfaced in the `error` field.
+ * @param {string} formula
+ * @param {number} d_row
+ * @param {number} d_col
+ * @returns {TranslateResult}
+ */
+export function translateFormula(formula, d_row, d_col) {
+    const ptr0 = passStringToWasm0(formula, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+    const len0 = WASM_VECTOR_LEN;
+    const ret = wasm.translateFormula(ptr0, len0, d_row, d_col);
+    return takeObject(ret);
+}
 function __wbg_get_imports() {
     const import0 = {
         __proto__: null,
@@ -271,14 +330,35 @@ function __wbg_get_imports() {
             const ret = Error(getStringFromWasm0(arg0, arg1));
             return addHeapObject(ret);
         },
+        __wbg_String_8564e559799eccda: function(arg0, arg1) {
+            const ret = String(getObject(arg1));
+            const ptr1 = passStringToWasm0(ret, wasm.__wbindgen_export, wasm.__wbindgen_export2);
+            const len1 = WASM_VECTOR_LEN;
+            getDataViewMemory0().setInt32(arg0 + 4 * 1, len1, true);
+            getDataViewMemory0().setInt32(arg0 + 4 * 0, ptr1, true);
+        },
         __wbg___wbindgen_throw_6b64449b9b9ed33c: function(arg0, arg1) {
             throw new Error(getStringFromWasm0(arg0, arg1));
         },
+        __wbg_new_aa8d0fa9762c29bd: function() {
+            const ret = new Object();
+            return addHeapObject(ret);
+        },
+        __wbg_set_6be42768c690e380: function(arg0, arg1, arg2) {
+            getObject(arg0)[takeObject(arg1)] = takeObject(arg2);
+        },
         __wbindgen_cast_0000000000000001: function(arg0, arg1) {
             // Cast intrinsic for `Ref(String) -> Externref`.
             const ret = getStringFromWasm0(arg0, arg1);
             return addHeapObject(ret);
         },
+        __wbindgen_object_clone_ref: function(arg0) {
+            const ret = getObject(arg0);
+            return addHeapObject(ret);
+        },
+        __wbindgen_object_drop_ref: function(arg0) {
+            takeObject(arg0);
+        },
     };
     return {
         __proto__: null,