ts-visio 1.0.0

package/dist/SchemaDiagram.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SchemaDiagram = void 0;
+class SchemaDiagram {
+    constructor(page) {
+        this.page = page;
+    }
+    /**
+     * Adds a table entity to the diagram.
+     * @param tableName Name of the table
+     * @param columns List of column names (e.g., "id: int")
+     * @param x X coordinate
+     * @param y Y coordinate
+     */
+    async addTable(tableName, columns, x = 0, y = 0) {
+        return this.page.addTable(x, y, tableName, columns);
+    }
+    /**
+     * Connects two tables with a specific relationship type.
+     * @param fromTable Source table shape
+     * @param toTable Target table shape
+     * @param type Relationship type ('1:1' or '1:N')
+     */
+    async addRelation(fromTable, toTable, type) {
+        let beginArrow = '0'; // No arrow at start
+        let endArrow = '1'; // Default standard arrow
+        if (type === '1:1') {
+            endArrow = '1'; // Standard Arrow
+        }
+        else if (type === '1:N') {
+            endArrow = '29'; // Crow's Foot
+        }
+        await this.page.connectShapes(fromTable, toTable, beginArrow, endArrow);
+    }
+}
+exports.SchemaDiagram = SchemaDiagram;

package/dist/Shape.d.ts

@@ -0,0 +1,68 @@
+import { VisioShape } from './types/VisioTypes';
+import { VisioPackage } from './VisioPackage';
+import { ShapeStyle } from './ShapeModifier';
+import { VisioPropType } from './types/VisioTypes';
+import { Layer } from './Layer';
+export interface ShapeData {
+    value: string | number | boolean | Date;
+    label?: string;
+    hidden?: boolean;
+    type?: VisioPropType;
+}
+export declare class Shape {
+    private internalShape;
+    private pageId;
+    private pkg;
+    constructor(internalShape: VisioShape, pageId: string, pkg: VisioPackage);
+    get id(): string;
+    get name(): string;
+    get text(): string;
+    setText(newText: string): Promise<void>;
+    get width(): number;
+    get height(): number;
+    get x(): number;
+    get y(): number;
+    connectTo(targetShape: Shape, beginArrow?: string, endArrow?: string): Promise<this>;
+    setStyle(style: ShapeStyle): Promise<this>;
+    placeRightOf(targetShape: Shape, options?: {
+        gap: number;
+    }): Promise<this>;
+    placeBelow(targetShape: Shape, options?: {
+        gap: number;
+    }): Promise<this>;
+    addPropertyDefinition(name: string, type: number, options?: {
+        label?: string;
+        invisible?: boolean;
+    }): this;
+    setPropertyValue(name: string, value: string | number | boolean | Date): this;
+    addData(key: string, data: ShapeData): this;
+    addMember(memberShape: Shape): Promise<this>;
+    addListItem(item: Shape): Promise<this>;
+    resizeToFit(padding?: number): Promise<this>;
+    private refreshLocalState;
+    addHyperlink(address: string, description?: string): Promise<this>;
+    linkToPage(targetPage: {
+        name: string;
+    }, description?: string): Promise<this>;
+    /**
+     * Adds an external hyperlink to the shape.
+     * Shows up in the right-click menu in Visio.
+     * @param url External URL (e.g. https://google.com)
+     * @param description Text to show in the menu
+     */
+    toUrl(url: string, description?: string): Promise<this>;
+    /**
+     * Adds an internal link to another page.
+     * Shows up in the right-click menu in Visio.
+     * @param targetPage The Page object to link to
+     * @param description Text to show in the menu
+     */
+    toPage(targetPage: {
+        name: string;
+    }, description?: string): Promise<this>;
+    assignLayer(layer: Layer | number): Promise<this>;
+    /**
+     * Alias for assignLayer. Adds this shape to a layer.
+     */
+    addToLayer(layer: Layer | number): Promise<this>;
+}

package/dist/Shape.js

@@ -0,0 +1,203 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shape = void 0;
+const ShapeModifier_1 = require("./ShapeModifier");
+const VisioTypes_1 = require("./types/VisioTypes");
+class Shape {
+    constructor(internalShape, pageId, pkg) {
+        this.internalShape = internalShape;
+        this.pageId = pageId;
+        this.pkg = pkg;
+    }
+    get id() {
+        return this.internalShape.ID;
+    }
+    get name() {
+        return this.internalShape.Name;
+    }
+    get text() {
+        return this.internalShape.Text || '';
+    }
+    async setText(newText) {
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        await modifier.updateShapeText(this.pageId, this.id, newText);
+        // Update local state to reflect change
+        this.internalShape.Text = newText;
+    }
+    get width() {
+        return this.internalShape.Cells['Width'] ? Number(this.internalShape.Cells['Width'].V) : 0;
+    }
+    get height() {
+        return this.internalShape.Cells['Height'] ? Number(this.internalShape.Cells['Height'].V) : 0;
+    }
+    get x() {
+        return this.internalShape.Cells['PinX'] ? Number(this.internalShape.Cells['PinX'].V) : 0;
+    }
+    get y() {
+        return this.internalShape.Cells['PinY'] ? Number(this.internalShape.Cells['PinY'].V) : 0;
+    }
+    async connectTo(targetShape, beginArrow, endArrow) {
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        await modifier.addConnector(this.pageId, this.id, targetShape.id, beginArrow, endArrow);
+        return this;
+    }
+    async setStyle(style) {
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        await modifier.updateShapeStyle(this.pageId, this.id, style);
+        // Minimal local state update to reflect changes if necessary
+        // For now, valid XML is the priority.
+        return this;
+    }
+    async placeRightOf(targetShape, options = { gap: 1 }) {
+        const newX = targetShape.x + targetShape.width + options.gap;
+        const newY = targetShape.y; // Keep same Y (per instructions, aligns center-to-center if PinY is center)
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        await modifier.updateShapePosition(this.pageId, this.id, newX, newY);
+        // Update local state is crucial for chaining successive placements
+        if (this.internalShape.Cells['PinX'])
+            this.internalShape.Cells['PinX'].V = newX.toString();
+        else
+            this.internalShape.Cells['PinX'] = { V: newX.toString(), N: 'PinX' };
+        if (this.internalShape.Cells['PinY'])
+            this.internalShape.Cells['PinY'].V = newY.toString();
+        else
+            this.internalShape.Cells['PinY'] = { V: newY.toString(), N: 'PinY' };
+        return this;
+    }
+    async placeBelow(targetShape, options = { gap: 1 }) {
+        const newX = targetShape.x; // Align Centers
+        // Target Bottom = target.y - target.height / 2
+        // My Top = Target Bottom - gap
+        // My Center = My Top - my.height / 2
+        // My Center = target.y - target.height/2 - gap - my.height/2
+        const newY = targetShape.y - (targetShape.height + this.height) / 2 - options.gap;
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        await modifier.updateShapePosition(this.pageId, this.id, newX, newY);
+        if (this.internalShape.Cells['PinX'])
+            this.internalShape.Cells['PinX'].V = newX.toString();
+        else
+            this.internalShape.Cells['PinX'] = { V: newX.toString(), N: 'PinX' };
+        if (this.internalShape.Cells['PinY'])
+            this.internalShape.Cells['PinY'].V = newY.toString();
+        else
+            this.internalShape.Cells['PinY'] = { V: newY.toString(), N: 'PinY' };
+        return this;
+    }
+    addPropertyDefinition(name, type, options = {}) {
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        modifier.addPropertyDefinition(this.pageId, this.id, name, type, options);
+        return this;
+    }
+    setPropertyValue(name, value) {
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        modifier.setPropertyValue(this.pageId, this.id, name, value);
+        return this;
+    }
+    addData(key, data) {
+        // Auto-detect type if not provided
+        let type = data.type;
+        if (type === undefined) {
+            if (data.value instanceof Date) {
+                type = VisioTypes_1.VisioPropType.Date;
+            }
+            else if (typeof data.value === 'number') {
+                type = VisioTypes_1.VisioPropType.Number;
+            }
+            else if (typeof data.value === 'boolean') {
+                type = VisioTypes_1.VisioPropType.Boolean;
+            }
+            else {
+                type = VisioTypes_1.VisioPropType.String;
+            }
+        }
+        // 1. Define Property
+        this.addPropertyDefinition(key, type, {
+            label: data.label,
+            invisible: data.hidden
+        });
+        // 2. Set Value
+        this.setPropertyValue(key, data.value);
+        return this;
+    }
+    async addMember(memberShape) {
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        // Type="Container" is the standard for Container relationships
+        await modifier.addRelationship(this.pageId, this.id, memberShape.id, 'Container');
+        return this;
+    }
+    async addListItem(item) {
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        await modifier.addListItem(this.pageId, this.id, item.id);
+        // Refresh local state after modifer updates (resizeToFit called internally)
+        await this.refreshLocalState();
+        return this;
+    }
+    async resizeToFit(padding = 0.25) {
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        await modifier.resizeContainerToFit(this.pageId, this.id, padding);
+        await this.refreshLocalState();
+        return this;
+    }
+    async refreshLocalState() {
+        // Reloads internal Cells from modifier's fresh XML
+        // This is a bit expensive but ensures consistency
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        const geo = modifier.getShapeGeometry(this.pageId, this.id);
+        const update = (n, v) => {
+            if (this.internalShape.Cells[n])
+                this.internalShape.Cells[n].V = v;
+            else
+                this.internalShape.Cells[n] = { V: v, N: n };
+        };
+        update('PinX', geo.x.toString());
+        update('PinY', geo.y.toString());
+        update('Width', geo.width.toString());
+        update('Height', geo.height.toString());
+    }
+    async addHyperlink(address, description) {
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        await modifier.addHyperlink(this.pageId, this.id, { address, description });
+        return this;
+    }
+    async linkToPage(targetPage, description) {
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        // Internal links use SubAddress='PageName' and empty Address
+        await modifier.addHyperlink(this.pageId, this.id, {
+            address: '',
+            subAddress: targetPage.name,
+            description
+        });
+        return this;
+    }
+    /**
+     * Adds an external hyperlink to the shape.
+     * Shows up in the right-click menu in Visio.
+     * @param url External URL (e.g. https://google.com)
+     * @param description Text to show in the menu
+     */
+    async toUrl(url, description) {
+        return this.addHyperlink(url, description);
+    }
+    /**
+     * Adds an internal link to another page.
+     * Shows up in the right-click menu in Visio.
+     * @param targetPage The Page object to link to
+     * @param description Text to show in the menu
+     */
+    async toPage(targetPage, description) {
+        return this.linkToPage(targetPage, description);
+    }
+    async assignLayer(layer) {
+        const index = typeof layer === 'number' ? layer : layer.index;
+        const modifier = new ShapeModifier_1.ShapeModifier(this.pkg);
+        await modifier.assignLayer(this.pageId, this.id, index);
+        return this;
+    }
+    /**
+     * Alias for assignLayer. Adds this shape to a layer.
+     */
+    async addToLayer(layer) {
+        return this.assignLayer(layer);
+    }
+}
+exports.Shape = Shape;

package/dist/ShapeModifier.d.ts

@@ -0,0 +1,66 @@
+import { VisioPackage } from './VisioPackage';
+import { NewShapeProps } from './types/VisioTypes';
+export declare class ShapeModifier {
+    private pkg;
+    addContainer(pageId: string, props: NewShapeProps): Promise<string>;
+    addList(pageId: string, props: NewShapeProps, direction?: 'vertical' | 'horizontal'): Promise<string>;
+    private parser;
+    private builder;
+    private relsManager;
+    private pageCache;
+    private dirtyPages;
+    autoSave: boolean;
+    constructor(pkg: VisioPackage);
+    private getPagePath;
+    private getAllShapes;
+    private getNextId;
+    private ensurePageSheet;
+    private updateNextShapeId;
+    private getParsed;
+    private saveParsed;
+    private performSave;
+    flush(): void;
+    addConnector(pageId: string, fromShapeId: string, toShapeId: string, beginArrow?: string, endArrow?: string): Promise<string>;
+    addShape(pageId: string, props: NewShapeProps, parentId?: string): Promise<string>;
+    updateShapeText(pageId: string, shapeId: string, newText: string): Promise<void>;
+    updateShapeStyle(pageId: string, shapeId: string, style: ShapeStyle): Promise<void>;
+    updateShapeDimensions(pageId: string, shapeId: string, w: number, h: number): Promise<void>;
+    updateShapePosition(pageId: string, shapeId: string, x: number, y: number): Promise<void>;
+    addPropertyDefinition(pageId: string, shapeId: string, name: string, type: number, options?: {
+        label?: string;
+        invisible?: boolean;
+    }): void;
+    private dateToVisioString;
+    setPropertyValue(pageId: string, shapeId: string, name: string, value: string | number | boolean | Date): void;
+    getShapeGeometry(pageId: string, shapeId: string): {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    addRelationship(pageId: string, shapeId: string, relatedShapeId: string, type: string): Promise<void>;
+    getContainerMembers(pageId: string, containerId: string): string[];
+    reorderShape(pageId: string, shapeId: string, position: 'front' | 'back'): Promise<void>;
+    addListItem(pageId: string, listId: string, itemId: string): Promise<void>;
+    resizeContainerToFit(pageId: string, containerId: string, padding?: number): Promise<void>;
+    addHyperlink(pageId: string, shapeId: string, details: {
+        address?: string;
+        subAddress?: string;
+        description?: string;
+    }): Promise<void>;
+    addLayer(pageId: string, name: string, options?: {
+        visible?: boolean;
+        lock?: boolean;
+        print?: boolean;
+    }): Promise<{
+        name: string;
+        index: number;
+    }>;
+    assignLayer(pageId: string, shapeId: string, layerIndex: number): Promise<void>;
+    updateLayerProperty(pageId: string, layerIndex: number, propName: string, value: string): Promise<void>;
+}
+export interface ShapeStyle {
+    fillColor?: string;
+    fontColor?: string;
+    bold?: boolean;
+}