@twip/web 0.0.0 → 0.1.0-alpha.1

package/dist/BorderEdges.mjs

@@ -0,0 +1,114 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * Which cell edges a border applies to.
+ */
+export class BorderEdges {
+    #value = undefined;
+
+    static #values = new Map([
+        ["All", 0],
+        ["Outside", 1],
+        ["Inside", 2],
+        ["InsideHorizontal", 3],
+        ["InsideVertical", 4],
+        ["Top", 5],
+        ["Bottom", 6],
+        ["Left", 7],
+        ["Right", 8],
+        ["Clear", 9]
+    ]);
+
+    static getAllEntries() {
+        return BorderEdges.#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 BorderEdges.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof BorderEdges) {
+            return value;
+        }
+
+        let intVal = BorderEdges.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return BorderEdges.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a BorderEdges and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new BorderEdges(value);
+    }
+
+    get value(){
+        return [...BorderEdges.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new BorderEdges(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new BorderEdges(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+        new BorderEdges(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 2),
+        new BorderEdges(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 3),
+        new BorderEdges(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 4),
+        new BorderEdges(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 5),
+        new BorderEdges(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 6),
+        new BorderEdges(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 7),
+        new BorderEdges(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 8),
+        new BorderEdges(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 9),
+    ];
+
+    /**
+     * Every edge.
+     */
+    static All = BorderEdges.#objectValues[0];
+    /**
+     * The outer edges of the selection.
+     */
+    static Outside = BorderEdges.#objectValues[1];
+    /**
+     * The inner edges, horizontal and vertical.
+     */
+    static Inside = BorderEdges.#objectValues[2];
+    /**
+     * The inner horizontal edges.
+     */
+    static InsideHorizontal = BorderEdges.#objectValues[3];
+    /**
+     * The inner vertical edges.
+     */
+    static InsideVertical = BorderEdges.#objectValues[4];
+    static Top = BorderEdges.#objectValues[5];
+    static Bottom = BorderEdges.#objectValues[6];
+    static Left = BorderEdges.#objectValues[7];
+    static Right = BorderEdges.#objectValues[8];
+    /**
+     * Removes the borders.
+     */
+    static Clear = BorderEdges.#objectValues[9];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/dist/BorderStyle.d.ts

@@ -0,0 +1,27 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * The line style of a border.
+ */
+export class BorderStyle {
+
+    /** @internal */
+    static fromValue(value: BorderStyle | string): BorderStyle;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static Single : BorderStyle;
+    static Double : BorderStyle;
+    static Dotted : BorderStyle;
+    static Dashed : BorderStyle;
+    static Thick : BorderStyle;
+
+
+    constructor(value: BorderStyle | string );
+}

package/dist/BorderStyle.mjs

@@ -0,0 +1,81 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * The line style of a border.
+ */
+export class BorderStyle {
+    #value = undefined;
+
+    static #values = new Map([
+        ["Single", 0],
+        ["Double", 1],
+        ["Dotted", 2],
+        ["Dashed", 3],
+        ["Thick", 4]
+    ]);
+
+    static getAllEntries() {
+        return BorderStyle.#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 BorderStyle.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof BorderStyle) {
+            return value;
+        }
+
+        let intVal = BorderStyle.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return BorderStyle.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a BorderStyle and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new BorderStyle(value);
+    }
+
+    get value(){
+        return [...BorderStyle.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new BorderStyle(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new BorderStyle(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+        new BorderStyle(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 2),
+        new BorderStyle(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 3),
+        new BorderStyle(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 4),
+    ];
+
+    static Single = BorderStyle.#objectValues[0];
+    static Double = BorderStyle.#objectValues[1];
+    static Dotted = BorderStyle.#objectValues[2];
+    static Dashed = BorderStyle.#objectValues[3];
+    static Thick = BorderStyle.#objectValues[4];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/dist/Bytes.d.ts

@@ -0,0 +1,19 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Bytes the engine produced (a saved .docx, a PDF).
+ */
+export class Bytes {
+    /** @internal */
+    get ffiValue(): pointer;
+    /** @internal */
+    constructor();
+
+
+    get len(): number;
+
+    asSlice(): Array<number>;
+}

package/dist/Bytes.mjs

@@ -0,0 +1,76 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+const Bytes_box_destroy_registry = new FinalizationRegistry((ptr) => {
+    wasm.Bytes_destroy(ptr);
+});
+
+/**
+ * Bytes the engine produced (a saved .docx, a PDF).
+ */
+export class Bytes {
+    // Internal ptr reference:
+    #ptr = null;
+
+    // Lifetimes are only to keep dependencies alive.
+    // Since JS won't garbage collect until there are no incoming edges.
+    #selfEdge = [];
+
+    #internalConstructor(symbol, ptr, selfEdge) {
+        if (symbol !== diplomatRuntime.internalConstructor) {
+            console.error("Bytes is an Opaque type. You cannot call its constructor.");
+            return;
+        }
+        this.#ptr = ptr;
+        this.#selfEdge = selfEdge;
+
+        // Are we being borrowed? If not, we can register.
+        if (this.#selfEdge.length === 0) {
+            Bytes_box_destroy_registry.register(this, this.#ptr);
+        }
+
+        return this;
+    }
+    /** @internal */
+    get ffiValue() {
+        return this.#ptr;
+    }
+
+
+    get len() {
+
+        const result = wasm.Bytes_len(this.ffiValue);
+
+        try {
+            return result;
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+        }
+    }
+
+    asSlice() {
+        const diplomatReceive = new diplomatRuntime.DiplomatReceiveBuf(wasm, 8, 4, false);
+
+        // This lifetime edge depends on lifetimes 'a
+        let aEdges = [this];
+
+
+        const result = wasm.Bytes_as_slice(diplomatReceive.buffer, this.ffiValue);
+
+        try {
+            return Array.from(new diplomatRuntime.DiplomatSlicePrimitive(wasm, diplomatReceive.buffer, "u8", aEdges).getValue());
+        }
+
+        finally {
+            diplomatRuntime.FUNCTION_PARAM_ALLOC.clean();
+            diplomatReceive.free();
+        }
+    }
+
+    constructor(symbol, ptr, selfEdge) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/dist/CaretPosition.d.ts

@@ -0,0 +1,34 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+export type CaretPosition_obj = {
+    x: number;
+    y: number;
+    height: number;
+    visible: boolean;
+};
+
+
+
+/**
+ * The caret in content pixels; `visible` is false while text is selected.
+ */
+export class CaretPosition {
+    get x(): number;
+    set x(value: number);
+    get y(): number;
+    set y(value: number);
+    get height(): number;
+    set height(value: number);
+    get visible(): boolean;
+    set visible(value: boolean);
+    /** @internal */
+    static fromFields(structObj : CaretPosition_obj) : CaretPosition;
+
+    /**
+    * Create `CaretPosition` from an object that contains all of `CaretPosition`s fields.
+    * Optional fields do not need to be included in the provided object.
+    */
+    constructor(structObj: CaretPosition_obj);
+
+}

package/dist/CaretPosition.mjs

@@ -0,0 +1,148 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * The caret in content pixels; `visible` is false while text is selected.
+ */
+export class CaretPosition {
+    #x;
+    get x() {
+        return this.#x;
+    }
+    set x(value){
+        this.#x = value;
+    }
+    #y;
+    get y() {
+        return this.#y;
+    }
+    set y(value){
+        this.#y = value;
+    }
+    #height;
+    get height() {
+        return this.#height;
+    }
+    set height(value){
+        this.#height = value;
+    }
+    #visible;
+    get visible() {
+        return this.#visible;
+    }
+    set visible(value){
+        this.#visible = value;
+    }
+    /** @internal */
+    static fromFields(structObj) {
+        return new CaretPosition(structObj);
+    }
+
+    #internalConstructor(structObj) {
+        if (typeof structObj !== "object") {
+            throw new Error("CaretPosition's constructor takes an object of CaretPosition's fields.");
+        }
+
+        if ("x" in structObj) {
+            this.#x = structObj.x;
+        } else {
+            throw new Error("Missing required field x.");
+        }
+
+        if ("y" in structObj) {
+            this.#y = structObj.y;
+        } else {
+            throw new Error("Missing required field y.");
+        }
+
+        if ("height" in structObj) {
+            this.#height = structObj.height;
+        } else {
+            throw new Error("Missing required field height.");
+        }
+
+        if ("visible" in structObj) {
+            this.#visible = structObj.visible;
+        } else {
+            throw new Error("Missing required field visible.");
+        }
+
+        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 32;
+    }
+
+    /// 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 CaretPosition) {
+            return obj;
+        }
+
+        return CaretPosition.fromFields(obj);
+    }
+
+    _writeToArrayBuffer(
+        arrayBuffer,
+        offset,
+        functionCleanupArena,
+        appendArrayMap
+    ) {
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 0, this.#x, Float64Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 8, this.#y, Float64Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 16, this.#height, Float64Array);
+        diplomatRuntime.writeToArrayBuffer(arrayBuffer, offset + 24, this.#visible, Uint8Array);
+    }
+
+    // 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("CaretPosition._fromFFI is not meant to be called externally. Please use the default constructor.");
+        }
+        let structObj = {};
+        const xDeref = (new Float64Array(wasm.memory.buffer, ptr, 1))[0];
+        structObj.x = xDeref;
+        const yDeref = (new Float64Array(wasm.memory.buffer, ptr + 8, 1))[0];
+        structObj.y = yDeref;
+        const heightDeref = (new Float64Array(wasm.memory.buffer, ptr + 16, 1))[0];
+        structObj.height = heightDeref;
+        const visibleDeref = (new Uint8Array(wasm.memory.buffer, ptr + 24, 1))[0] === 1;
+        structObj.visible = visibleDeref;
+
+        return new CaretPosition(structObj);
+    }
+
+
+    constructor(structObj) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/dist/CellAlignment.d.ts

@@ -0,0 +1,25 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Vertical alignment of text in a cell.
+ */
+export class CellAlignment {
+
+    /** @internal */
+    static fromValue(value: CellAlignment | string): CellAlignment;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    static Top : CellAlignment;
+    static Center : CellAlignment;
+    static Bottom : CellAlignment;
+
+
+    constructor(value: CellAlignment | string );
+}

package/dist/CellAlignment.mjs

@@ -0,0 +1,75 @@
+// generated by diplomat-tool
+import wasm from "./diplomat-wasm.mjs";
+import * as diplomatRuntime from "./diplomat-runtime.mjs";
+
+
+
+/**
+ * Vertical alignment of text in a cell.
+ */
+export class CellAlignment {
+    #value = undefined;
+
+    static #values = new Map([
+        ["Top", 0],
+        ["Center", 1],
+        ["Bottom", 2]
+    ]);
+
+    static getAllEntries() {
+        return CellAlignment.#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 CellAlignment.#objectValues[arguments[1]];
+        }
+
+        if (value instanceof CellAlignment) {
+            return value;
+        }
+
+        let intVal = CellAlignment.#values.get(value);
+
+        // Nullish check, checks for null or undefined
+        if (intVal != null) {
+            return CellAlignment.#objectValues[intVal];
+        }
+
+        throw TypeError(value + " is not a CellAlignment and does not correspond to any of its enumerator values.");
+    }
+
+    /** @internal */
+    static fromValue(value) {
+        return new CellAlignment(value);
+    }
+
+    get value(){
+        return [...CellAlignment.#values.keys()][this.#value];
+    }
+
+    /** @internal */
+    get ffiValue(){
+        return this.#value;
+    }
+    static #objectValues = [
+        new CellAlignment(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 0),
+        new CellAlignment(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 1),
+        new CellAlignment(diplomatRuntime.internalConstructor, diplomatRuntime.internalConstructor, 2),
+    ];
+
+    static Top = CellAlignment.#objectValues[0];
+    static Center = CellAlignment.#objectValues[1];
+    static Bottom = CellAlignment.#objectValues[2];
+
+
+    constructor(value) {
+        return this.#internalConstructor(...arguments)
+    }
+}

package/dist/CellShift.d.ts

@@ -0,0 +1,30 @@
+// generated by diplomat-tool
+import type { pointer, codepoint } from "./diplomat-runtime.d.ts";
+
+
+
+/**
+ * Which way the remaining cells move when cells are deleted.
+ */
+export class CellShift {
+
+    /** @internal */
+    static fromValue(value: CellShift | string): CellShift;
+
+    get value(): string;
+
+    /** @internal */
+    get ffiValue(): number;
+
+    /**
+     * The cells to the right move left.
+     */
+    static Left : CellShift;
+    /**
+     * The cells below move up.
+     */
+    static Up : CellShift;
+
+
+    constructor(value: CellShift | string );
+}