lucid-extension-sdk 0.0.141 → 0.0.143

package/document/blockclasses/blockproxyregistry.js

@@ -5,11 +5,13 @@ const cardblockproxy_1 = require("./cardblockproxy");
 const customblockproxy_1 = require("./customblockproxy");
 const erdblockproxy_1 = require("./erdblockproxy");
 const linkunfurlblockproxy_1 = require("./linkunfurlblockproxy");
+const tableblockproxy_1 = require("./tableblockproxy");
 const allProxyClasses = [
     erdblockproxy_1.ERDBlockProxy,
     customblockproxy_1.CustomBlockProxy,
     linkunfurlblockproxy_1.LinkUnfurlBlockProxy,
     cardblockproxy_1.CardBlockProxy,
+    tableblockproxy_1.TableBlockProxy,
 ];
 function findProxyClass(className) {
     return allProxyClasses.find((proxy) => proxy.classNameRegex.test(className));

package/document/blockclasses/tableblockproxy.d.ts

@@ -0,0 +1,67 @@
+import { SimpleFillStyle } from '../../core/properties/fillcolor';
+import { BlockProxy } from '../blockproxy';
+import { TextStyle } from '../text/textstyle';
+export declare class TableCellProxy {
+    readonly table: TableBlockProxy;
+    readonly row: number;
+    readonly column: number;
+    constructor(table: TableBlockProxy, row: number, column: number);
+    getText(): string;
+    setText(text: string): undefined;
+    getTextStyle(): TextStyle;
+    setTextStyle(style: Partial<TextStyle>): void;
+    setFill(fill: SimpleFillStyle): void;
+    /**
+     * Cells in a table can be merged together with adjacent cells into one larger cell. In this case, the upper-
+     * left cell remains visible but is enlarged to cover additional cells, and the other cells are hidden.
+     *
+     * @returns the size of this cell, in how many cells horizontally and vertically have been merged into it.
+     * For most cells, this will be {w:1, h:1}, but if it has been merged with the cell to the right of it, it
+     * would be {w:2, h:1}.
+     */
+    getMergedCellSize(): {
+        w: number;
+        h: number;
+    };
+    /**
+    /**
+     * Cells in a table can be merged together with adjacent cells into one larger cell. In this case, the upper-
+     * left cell remains visible but is enlarged to cover additional cells, and the other cells are hidden.
+     *
+     * @param size the desired size of this cell, in how many cells horizontally and vertically are merged into it.
+     * This normally {w:1, h:1} for a normal cell, or {w:2, h:1} to merge a cell with the one to the right of it, etc.
+     */
+    setMergedCellSize(size: {
+        w: number;
+        h: number;
+    }): void;
+    /**
+     * @returns the pixel width of the cell, including any cells it is merged with.
+     */
+    getWidth(): number;
+    /**
+     * @returns the pixel height of the cell, including any cells it is merged with.
+     */
+    getHeight(): number;
+}
+export declare class TableRowProxy {
+    readonly table: TableBlockProxy;
+    readonly row: number;
+    constructor(table: TableBlockProxy, row: number);
+    getCells(): TableCellProxy[];
+    getHeight(): number;
+}
+export declare class TableBlockProxy extends BlockProxy {
+    static classNameRegex: RegExp;
+    getRowCount(): number;
+    getColumnCount(): number;
+    getRows(): TableRowProxy[];
+    getRowHeights(): number[];
+    getColumnWidths(): number[];
+    setColumnWidths(widths: number[]): void;
+    setRowHeights(heights: number[]): void;
+    getAutoResizeColumns(): boolean;
+    getAutoResizeRows(): boolean;
+    setAutoResizeColumns(auto: boolean): void;
+    setAutoResizeRows(auto: boolean): void;
+}

package/document/blockclasses/tableblockproxy.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableBlockProxy = exports.TableRowProxy = exports.TableCellProxy = void 0;
+const fillcolor_1 = require("../../core/properties/fillcolor");
+const blockproxy_1 = require("../blockproxy");
+class TableCellProxy {
+    constructor(table, row, column) {
+        this.table = table;
+        this.row = row;
+        this.column = column;
+    }
+    getText() {
+        return this.table.textAreas.get(`Cell_${this.row},${this.column}`);
+    }
+    setText(text) {
+        return this.table.textAreas.set(`Cell_${this.row},${this.column}`, text);
+    }
+    getTextStyle() {
+        return this.table.textStyles.get(`Cell_${this.row},${this.column}`);
+    }
+    setTextStyle(style) {
+        this.table.textStyles.set(`Cell_${this.row},${this.column}`, style);
+    }
+    setFill(fill) {
+        this.table.properties.set(`CellFill_${this.row},${this.column}`, (0, fillcolor_1.serializeSimpleFill)(fill));
+    }
+    /**
+     * Cells in a table can be merged together with adjacent cells into one larger cell. In this case, the upper-
+     * left cell remains visible but is enlarged to cover additional cells, and the other cells are hidden.
+     *
+     * @returns the size of this cell, in how many cells horizontally and vertically have been merged into it.
+     * For most cells, this will be {w:1, h:1}, but if it has been merged with the cell to the right of it, it
+     * would be {w:2, h:1}.
+     */
+    getMergedCellSize() {
+        var _a;
+        return ((_a = this.table.properties.get(`CellSize_${this.row},${this.column}`)) !== null && _a !== void 0 ? _a : { w: 1, h: 1 });
+    }
+    /**
+    /**
+     * Cells in a table can be merged together with adjacent cells into one larger cell. In this case, the upper-
+     * left cell remains visible but is enlarged to cover additional cells, and the other cells are hidden.
+     *
+     * @param size the desired size of this cell, in how many cells horizontally and vertically are merged into it.
+     * This normally {w:1, h:1} for a normal cell, or {w:2, h:1} to merge a cell with the one to the right of it, etc.
+     */
+    setMergedCellSize(size) {
+        this.table.properties.set(`CellSize_${this.row},${this.column}`, size);
+    }
+    /**
+     * @returns the pixel width of the cell, including any cells it is merged with.
+     */
+    getWidth() {
+        return this.table
+            .getColumnWidths()
+            .slice(this.column, this.column + this.getMergedCellSize().w)
+            .reduce((a, b) => a + b, 0);
+    }
+    /**
+     * @returns the pixel height of the cell, including any cells it is merged with.
+     */
+    getHeight() {
+        return this.table
+            .getRowHeights()
+            .slice(this.row, this.row + this.getMergedCellSize().h)
+            .reduce((a, b) => a + b, 0);
+    }
+}
+exports.TableCellProxy = TableCellProxy;
+class TableRowProxy {
+    constructor(table, row) {
+        this.table = table;
+        this.row = row;
+    }
+    getCells() {
+        return this.table.getColumnWidths().map((_, index) => new TableCellProxy(this.table, this.row, index));
+    }
+    getHeight() {
+        var _a;
+        return (_a = this.table.getRowHeights()[this.row]) !== null && _a !== void 0 ? _a : 1;
+    }
+}
+exports.TableRowProxy = TableRowProxy;
+class TableBlockProxy extends blockproxy_1.BlockProxy {
+    getRowCount() {
+        return this.getRowHeights().length;
+    }
+    getColumnCount() {
+        return this.getColumnWidths().length;
+    }
+    getRows() {
+        return this.getRowHeights().map((_, index) => new TableRowProxy(this, index));
+    }
+    getRowHeights() {
+        return this.properties.get('RowHeights');
+    }
+    getColumnWidths() {
+        return this.properties.get('ColWidths');
+    }
+    setColumnWidths(widths) {
+        this.properties.set('ColWidths', widths);
+    }
+    setRowHeights(heights) {
+        this.properties.set('RowHeights', heights);
+    }
+    getAutoResizeColumns() {
+        return this.properties.get('AutoColWidth');
+    }
+    getAutoResizeRows() {
+        return this.properties.get('AutoRowHeight');
+    }
+    setAutoResizeColumns(auto) {
+        this.properties.set('AutoColWidth', auto);
+    }
+    setAutoResizeRows(auto) {
+        this.properties.set('AutoRowHeight', auto);
+    }
+}
+exports.TableBlockProxy = TableBlockProxy;
+TableBlockProxy.classNameRegex = /^DefaultTableBlock$/;

package/document/blockproxy.d.ts

@@ -1,3 +1,4 @@
+import { BadgeEnumPosition } from '../core/properties/datagraphic/badgeposition';
 import { SimpleStaticDataGraphicSettings } from '../core/properties/datagraphic/staticdatagraphicsettings';
 import { SimpleFillStyle } from '../core/properties/fillcolor';
 import { Shadow } from '../core/properties/shadow';
@@ -79,4 +80,9 @@ export declare class BlockProxy extends ItemProxy {
      * @param field
      */
     linkText(textAreaKey: string, referenceKey: string | number, field: string): void;
+    /**
+     * @param position The postion where the data sync state icon should be displayed on the block. If this position is
+     * set to undefined then the state icon position will fallback to the default position for the block.
+     */
+    setDataSyncStateIconPosition(position: BadgeEnumPosition | undefined): void;
 }

package/document/blockproxy.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BlockProxy = void 0;
+const badgeposition_1 = require("../core/properties/datagraphic/badgeposition");
 const staticdatagraphicsettings_1 = require("../core/properties/datagraphic/staticdatagraphicsettings");
 const fillcolor_1 = require("../core/properties/fillcolor");
 const shadow_1 = require("../core/properties/shadow");
@@ -141,5 +142,12 @@ class BlockProxy extends itemproxy_1.ItemProxy {
             'f': field,
         });
     }
+    /**
+     * @param position The postion where the data sync state icon should be displayed on the block. If this position is
+     * set to undefined then the state icon position will fallback to the default position for the block.
+     */
+    setDataSyncStateIconPosition(position) {
+        this.properties.set('DataSyncStateIconPosition', position ? (0, badgeposition_1.serializeBadgeEnumPosition)(position) : null);
+    }
 }
 exports.BlockProxy = BlockProxy;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "lucid-extension-sdk",
-    "version": "0.0.141",
+    "version": "0.0.143",
     "description": "Utility classes for writing Lucid Software editor extensions",
     "main": "index.js",
     "types": "index.d.ts",