@twip/web 0.0.0 → 0.1.0-alpha.1

package/dist/RowHeightRule.d.ts

@@ -0,0 +1,34 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * How a row height is applied.
+ */
+export class RowHeightRule {
+
+    /** @internal */
+    static fromValue(value: RowHeightRule | string): RowHeightRule;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    /**
+     * The row fits its content.
+     */
+    static Auto : RowHeightRule;
+    /**
+     * The row is at least the given height.
+     */
+    static AtLeast : RowHeightRule;
+    /**
+     * The row is exactly the given height.
+     */
+    static Exact : RowHeightRule;
+
+
+    constructor(value: RowHeightRule | string );
+}

package/dist/RowHeightRule.mjs

@@ -0,0 +1,84 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * How a row height is applied.
+ */
+export class RowHeightRule {
+    #value = undefined;
+
+    static #values = new Map([
+        ["Auto", 0],
+        ["AtLeast", 1],
+        ["Exact", 2]
+    ]);
+
+    static getAllEntries() {
+        return RowHeightRule.#values.entries();
+    }
+
+    #internalConstructor(value) {
+        if (arguments.length > 1 && arguments[0] === diplomatRuntime.internalConstructor) {
+            // We pass in two internalConstructor arguments to create *new*
+            // instances of this type, otherwise the enums are treated as singletons.
+            if (arguments[1] === diplomatRuntime.internalConstructor ) {
+                this.#value = arguments[2];
+                return this;
+            }
+            return RowHeightRule.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof RowHeightRule) {
+            return value;
+        }
+
+        let intVal = RowHeightRule.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return RowHeightRule.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a RowHeightRule and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new RowHeightRule(value);
+    }
+
+    get value(){
+        return [...RowHeightRule.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new RowHeightRule(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new RowHeightRule(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+        new RowHeightRule(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 2),
+    ];
+
+    /**
+     * The row fits its content.
+     */
+    static Auto = RowHeightRule.#objectValues[0];
+    /**
+     * The row is at least the given height.
+     */
+    static AtLeast = RowHeightRule.#objectValues[1];
+    /**
+     * The row is exactly the given height.
+     */
+    static Exact = RowHeightRule.#objectValues[2];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/dist/RowSide.d.ts

@@ -0,0 +1,24 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Where a new row goes relative to the selected rows.
+ */
+export class RowSide {
+
+    /** @internal */
+    static fromValue(value: RowSide | string): RowSide;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static Above : RowSide;
+    static Below : RowSide;
+
+
+    constructor(value: RowSide | string );
+}

package/dist/RowSide.mjs

@@ -0,0 +1,72 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * Where a new row goes relative to the selected rows.
+ */
+export class RowSide {
+    #value = undefined;
+
+    static #values = new Map([
+        ["Above", 0],
+        ["Below", 1]
+    ]);
+
+    static getAllEntries() {
+        return RowSide.#values.entries();
+    }
+
+    #internalConstructor(value) {
+        if (arguments.length > 1 && arguments[0] === diplomatRuntime.internalConstructor) {
+            // We pass in two internalConstructor arguments to create *new*
+            // instances of this type, otherwise the enums are treated as singletons.
+            if (arguments[1] === diplomatRuntime.internalConstructor ) {
+                this.#value = arguments[2];
+                return this;
+            }
+            return RowSide.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof RowSide) {
+            return value;
+        }
+
+        let intVal = RowSide.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return RowSide.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a RowSide and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new RowSide(value);
+    }
+
+    get value(){
+        return [...RowSide.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new RowSide(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new RowSide(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+    ];
+
+    static Above = RowSide.#objectValues[0];
+    static Below = RowSide.#objectValues[1];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/dist/SaveError.d.ts

@@ -0,0 +1,24 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Why a document didn't save.
+ */
+export class SaveError {
+
+    /** @internal */
+    static fromValue(value: SaveError | string): SaveError;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static NoDocument : SaveError;
+    static Failed : SaveError;
+
+
+    constructor(value: SaveError | string );
+}

package/dist/SaveError.mjs

@@ -0,0 +1,72 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * Why a document didn't save.
+ */
+export class SaveError {
+    #value = undefined;
+
+    static #values = new Map([
+        ["NoDocument", 0],
+        ["Failed", 1]
+    ]);
+
+    static getAllEntries() {
+        return SaveError.#values.entries();
+    }
+
+    #internalConstructor(value) {
+        if (arguments.length > 1 && arguments[0] === diplomatRuntime.internalConstructor) {
+            // We pass in two internalConstructor arguments to create *new*
+            // instances of this type, otherwise the enums are treated as singletons.
+            if (arguments[1] === diplomatRuntime.internalConstructor ) {
+                this.#value = arguments[2];
+                return this;
+            }
+            return SaveError.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof SaveError) {
+            return value;
+        }
+
+        let intVal = SaveError.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return SaveError.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a SaveError and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new SaveError(value);
+    }
+
+    get value(){
+        return [...SaveError.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new SaveError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new SaveError(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+    ];
+
+    static NoDocument = SaveError.#objectValues[0];
+    static Failed = SaveError.#objectValues[1];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/dist/SelectionInfo.d.ts

@@ -0,0 +1,39 @@
+// generated by diplomat-tool
+import type { SelectionKind } from "./SelectionKind"
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+export type SelectionInfo_obj = {
+    kind: SelectionKind;
+    anchorParagraph: bigint;
+    anchorOffset: number;
+    focusParagraph: bigint;
+    focusOffset: number;
+};
+
+
+
+/**
+ * The selection. For a caret, text or a block: the paragraph ids and character offsets of its anchor (where it
+ * started) and focus (where it ends now); pass them to `select_range`. Zero for cells and objects.
+ */
+export class SelectionInfo {
+    get kind(): SelectionKind;
+    set kind(value: SelectionKind);
+    get anchorParagraph(): bigint;
+    set anchorParagraph(value: bigint);
+    get anchorOffset(): number;
+    set anchorOffset(value: number);
+    get focusParagraph(): bigint;
+    set focusParagraph(value: bigint);
+    get focusOffset(): number;
+    set focusOffset(value: number);
+    /** @internal */
+    static fromFields(structObj : SelectionInfo_obj) : SelectionInfo;
+
+    /**
+    * Create `SelectionInfo` from an object that contains all of `SelectionInfo`s fields.
+    * Optional fields do not need to be included in the provided object.
+    */
+    constructor(structObj: SelectionInfo_obj);
+
+}

package/dist/SelectionInfo.mjs

@@ -0,0 +1,166 @@
+// generated by diplomat-tool
+import { SelectionKind } from "./SelectionKind.mjs"
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * The selection. For a caret, text or a block: the paragraph ids and character offsets of its anchor (where it
+ * started) and focus (where it ends now); pass them to `select_range`. Zero for cells and objects.
+ */
+export class SelectionInfo {
+    #kind;
+    get kind() {
+        return this.#kind;
+    }
+    set kind(value){
+        this.#kind = value;
+    }
+    #anchorParagraph;
+    get anchorParagraph() {
+        return this.#anchorParagraph;
+    }
+    set anchorParagraph(value){
+        this.#anchorParagraph = value;
+    }
+    #anchorOffset;
+    get anchorOffset() {
+        return this.#anchorOffset;
+    }
+    set anchorOffset(value){
+        this.#anchorOffset = value;
+    }
+    #focusParagraph;
+    get focusParagraph() {
+        return this.#focusParagraph;
+    }
+    set focusParagraph(value){
+        this.#focusParagraph = value;
+    }
+    #focusOffset;
+    get focusOffset() {
+        return this.#focusOffset;
+    }
+    set focusOffset(value){
+        this.#focusOffset = value;
+    }
+    /** @internal */
+    static fromFields(structObj) {
+        return new SelectionInfo(structObj);
+    }
+
+    #internalConstructor(structObj) {
+        if (typeof structObj !== "object") {
+            throw new Error("SelectionInfo's constructor takes an object of SelectionInfo's fields.");
+        }
+
+        if ("kind" in structObj) {
+            this.#kind = new SelectionKind(structObj.kind);
+        } else {
+            throw new Error("Missing required field kind.");
+        }
+
+        if ("anchorParagraph" in structObj) {
+            this.#anchorParagraph = structObj.anchorParagraph;
+        } else {
+            throw new Error("Missing required field anchorParagraph.");
+        }
+
+        if ("anchorOffset" in structObj) {
+            this.#anchorOffset = structObj.anchorOffset;
+        } else {
+            throw new Error("Missing required field anchorOffset.");
+        }
+
+        if ("focusParagraph" in structObj) {
+            this.#focusParagraph = structObj.focusParagraph;
+        } else {
+            throw new Error("Missing required field focusParagraph.");
+        }
+
+        if ("focusOffset" in structObj) {
+            this.#focusOffset = structObj.focusOffset;
+        } else {
+            throw new Error("Missing required field focusOffset.");
+        }
+
+        return this;
+    }
+
+    // Return this struct in FFI function friendly format.
+    // Returns an array that can be expanded with spread syntax (...)
+    _intoFFI(
+        dst,
+        functionCleanupArena,
+        appendArrayMap
+    ) {
+
+        this._writeToArrayBuffer(wasm.memory.buffer, dst, functionCleanupArena, appendArrayMap);
+
+        return dst;
+    }
+
+    static get _sizeBytes() {
+        return 40;
+    }
+
+    /// Currently unused, we may want to use later on though:
+    static get _sizeAlign() {
+        return 8;
+    }
+
+    static _fromSuppliedValue(internalConstructor, obj) {
+        if (internalConstructor !== diplomatRuntime.internalConstructor) {
+            throw new Error("_fromSuppliedValue cannot be called externally.");
+        }
+
+        if (obj instanceof SelectionInfo) {
+            return obj;
+        }
+
+        return SelectionInfo.fromFields(obj);
+    }
+
+    _writeToArrayBuffer(
+        arrayBuffer,
+        offset,
+        functionCleanupArena,
+        appendArrayMap
+    ) {
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 0, new SelectionKind(this.#kind).ffiValue, Int32Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 8, this.#anchorParagraph, BigUint64Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 16, this.#anchorOffset, Uint32Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 24, this.#focusParagraph, BigUint64Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 32, this.#focusOffset, Uint32Array);
+    }
+
+    // This struct contains borrowed fields, so this takes in a list of
+    // "edges" corresponding to where each lifetime's data may have been borrowed from
+    // and passes it down to individual fields containing the borrow.
+    // This method does not attempt to handle any dependencies between lifetimes, the caller
+    // should handle this when constructing edge arrays.
+    static _fromFFI(internalConstructor, ptr) {
+        if (internalConstructor !== diplomatRuntime.internalConstructor) {
+            throw new Error("SelectionInfo._fromFFI is not meant to be called externally. Please use the default constructor.");
+        }
+        let structObj = {};
+        const kindDeref = diplomatRuntime.enumDiscriminant(wasm, ptr);
+        structObj.kind = new SelectionKind(diplomatRuntime.internalConstructor, kindDeref);
+        const anchorParagraphDeref = (new BigUint64Array(wasm.memory.buffer, ptr + 8, 1))[0];
+        structObj.anchorParagraph = anchorParagraphDeref;
+        const anchorOffsetDeref = (new Uint32Array(wasm.memory.buffer, ptr + 16, 1))[0];
+        structObj.anchorOffset = anchorOffsetDeref;
+        const focusParagraphDeref = (new BigUint64Array(wasm.memory.buffer, ptr + 24, 1))[0];
+        structObj.focusParagraph = focusParagraphDeref;
+        const focusOffsetDeref = (new Uint32Array(wasm.memory.buffer, ptr + 32, 1))[0];
+        structObj.focusOffset = focusOffsetDeref;
+
+        return new SelectionInfo(structObj);
+    }
+
+
+    constructor(structObj) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/dist/SelectionKind.d.ts

@@ -0,0 +1,37 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+export class SelectionKind {
+
+    /** @internal */
+    static fromValue(value: SelectionKind | string): SelectionKind;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    /**
+     * No document.
+     */
+    static None : SelectionKind;
+    static Caret : SelectionKind;
+    static Text : SelectionKind;
+    /**
+     * A block of table cells.
+     */
+    static Cells : SelectionKind;
+    /**
+     * A picture or text box.
+     */
+    static Object : SelectionKind;
+    /**
+     * A vertical block of text.
+     */
+    static Block : SelectionKind;
+
+
+    constructor(value: SelectionKind | string );
+}

package/dist/SelectionKind.mjs

@@ -0,0 +1,93 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+export class SelectionKind {
+    #value = undefined;
+
+    static #values = new Map([
+        ["None", 0],
+        ["Caret", 1],
+        ["Text", 2],
+        ["Cells", 3],
+        ["Object", 4],
+        ["Block", 5]
+    ]);
+
+    static getAllEntries() {
+        return SelectionKind.#values.entries();
+    }
+
+    #internalConstructor(value) {
+        if (arguments.length > 1 && arguments[0] === diplomatRuntime.internalConstructor) {
+            // We pass in two internalConstructor arguments to create *new*
+            // instances of this type, otherwise the enums are treated as singletons.
+            if (arguments[1] === diplomatRuntime.internalConstructor ) {
+                this.#value = arguments[2];
+                return this;
+            }
+            return SelectionKind.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof SelectionKind) {
+            return value;
+        }
+
+        let intVal = SelectionKind.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return SelectionKind.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a SelectionKind and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new SelectionKind(value);
+    }
+
+    get value(){
+        return [...SelectionKind.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new SelectionKind(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new SelectionKind(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+        new SelectionKind(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 2),
+        new SelectionKind(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 3),
+        new SelectionKind(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 4),
+        new SelectionKind(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 5),
+    ];
+
+    /**
+     * No document.
+     */
+    static None = SelectionKind.#objectValues[0];
+    static Caret = SelectionKind.#objectValues[1];
+    static Text = SelectionKind.#objectValues[2];
+    /**
+     * A block of table cells.
+     */
+    static Cells = SelectionKind.#objectValues[3];
+    /**
+     * A picture or text box.
+     */
+    static Object = SelectionKind.#objectValues[4];
+    /**
+     * A vertical block of text.
+     */
+    static Block = SelectionKind.#objectValues[5];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}