ts-visio 1.0.0

package/dist/core/VisioValidator.js

@@ -0,0 +1,362 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisioValidator = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+// Known Visio section names per Microsoft schema
+const VALID_SECTION_NAMES = new Set([
+    'Geometry', 'Character', 'Paragraph', 'Tabs', 'Scratch', 'Connection',
+    'Field', 'Control', 'Action', 'Layer', 'Property', 'User', 'Hyperlink',
+    'Reviewer', 'Annotation', 'ActionTag', 'Line', 'Fill', 'FillGradient',
+    'LineGradient', 'TextXForm', 'RelQuadBezTo', 'RelCubBezTo', 'RelMoveTo',
+    'RelLineTo', 'RelEllipticalArcTo', 'InfiniteLine', 'Ellipse', 'SplineStart',
+    'SplineKnot', 'PolylineTo', 'NURBSTo'
+]);
+class VisioValidator {
+    constructor() {
+        this.parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: '@_'
+        });
+    }
+    /**
+     * Validate a VisioPackage for structural correctness
+     */
+    async validate(pkg) {
+        const errors = [];
+        const warnings = [];
+        // 1. Check required files exist
+        this.checkRequiredFiles(pkg, errors);
+        // 2. Validate Content Types
+        this.validateContentTypes(pkg, errors, warnings);
+        // 3. Validate document relationships
+        this.validateDocumentRels(pkg, errors);
+        // 4. Validate pages
+        this.validatePages(pkg, errors, warnings);
+        // 5. Validate master references
+        this.validateMasterReferences(pkg, errors, warnings);
+        // 6. Validate relationship file integrity
+        this.validateRelationshipIntegrity(pkg, errors, warnings);
+        return {
+            valid: errors.length === 0,
+            errors,
+            warnings
+        };
+    }
+    checkRequiredFiles(pkg, errors) {
+        const requiredFiles = [
+            '[Content_Types].xml',
+            '_rels/.rels',
+            'visio/document.xml',
+            'visio/_rels/document.xml.rels',
+            'visio/pages/pages.xml',
+            'visio/pages/_rels/pages.xml.rels'
+        ];
+        for (const file of requiredFiles) {
+            try {
+                pkg.getFileText(file);
+            }
+            catch {
+                errors.push(`Missing required file: ${file}`);
+            }
+        }
+    }
+    validateContentTypes(pkg, errors, warnings) {
+        try {
+            const content = pkg.getFileText('[Content_Types].xml');
+            const parsed = this.parser.parse(content);
+            if (!parsed.Types) {
+                errors.push('[Content_Types].xml: Missing root <Types> element');
+                return;
+            }
+            const overrides = parsed.Types.Override ?
+                (Array.isArray(parsed.Types.Override) ? parsed.Types.Override : [parsed.Types.Override])
+                : [];
+            const partNames = overrides.map((o) => o['@_PartName']);
+            if (!partNames.some((p) => p?.includes('document.xml'))) {
+                warnings.push('[Content_Types].xml: Missing content type for document.xml');
+            }
+            if (!partNames.some((p) => p?.includes('pages.xml'))) {
+                warnings.push('[Content_Types].xml: Missing content type for pages.xml');
+            }
+        }
+        catch (e) {
+            errors.push(`[Content_Types].xml: ${e.message}`);
+        }
+    }
+    validateDocumentRels(pkg, errors) {
+        try {
+            const content = pkg.getFileText('visio/_rels/document.xml.rels');
+            const parsed = this.parser.parse(content);
+            if (!parsed.Relationships) {
+                errors.push('document.xml.rels: Missing <Relationships> element');
+                return;
+            }
+            const rels = parsed.Relationships.Relationship ?
+                (Array.isArray(parsed.Relationships.Relationship) ? parsed.Relationships.Relationship : [parsed.Relationships.Relationship])
+                : [];
+            const pagesRel = rels.find((r) => r['@_Target']?.includes('pages'));
+            if (!pagesRel) {
+                errors.push('document.xml.rels: Missing relationship to pages.xml');
+            }
+        }
+        catch (e) {
+            errors.push(`document.xml.rels: ${e.message}`);
+        }
+    }
+    validatePages(pkg, errors, warnings) {
+        try {
+            const pagesContent = pkg.getFileText('visio/pages/pages.xml');
+            const parsedPages = this.parser.parse(pagesContent);
+            let pageNodes = parsedPages.Pages?.Page;
+            if (!pageNodes) {
+                warnings.push('pages.xml: No pages defined');
+                return;
+            }
+            pageNodes = Array.isArray(pageNodes) ? pageNodes : [pageNodes];
+            for (const pageNode of pageNodes) {
+                const pageId = pageNode['@_ID'];
+                const pageName = pageNode['@_Name'] || `Page-${pageId}`;
+                if (!pageId) {
+                    errors.push(`Page "${pageName}": Missing ID attribute`);
+                    continue;
+                }
+                const relId = pageNode.Rel?.['@_r:id'] || pageNode['@_r:id'];
+                if (!relId) {
+                    errors.push(`Page "${pageName}" (ID=${pageId}): Missing Rel element with r:id`);
+                }
+                this.validatePageContent(pkg, pageId, pageName, errors, warnings);
+            }
+        }
+        catch (e) {
+            errors.push(`pages.xml: ${e.message}`);
+        }
+    }
+    validatePageContent(pkg, pageId, pageName, errors, warnings) {
+        const pagePath = `visio/pages/page${pageId}.xml`;
+        try {
+            const content = pkg.getFileText(pagePath);
+            const parsed = this.parser.parse(content);
+            if (!parsed.PageContents) {
+                errors.push(`${pagePath}: Missing <PageContents> element`);
+                return;
+            }
+            this.validateShapeIds(parsed, pagePath, errors);
+            this.validateConnects(parsed, pagePath, errors);
+            this.validateSectionNames(parsed, pagePath, warnings);
+            this.validateCellNames(parsed, pagePath, warnings);
+            this.validateImageShapes(pkg, pageId, parsed, pagePath, errors, warnings);
+        }
+        catch (e) {
+            errors.push(`${pagePath}: ${e.message}`);
+        }
+    }
+    validateShapeIds(parsed, pagePath, errors) {
+        const shapes = this.getAllShapes(parsed);
+        const ids = new Set();
+        for (const shape of shapes) {
+            const id = shape['@_ID'];
+            if (!id) {
+                errors.push(`${pagePath}: Shape missing ID attribute`);
+                continue;
+            }
+            if (ids.has(id)) {
+                errors.push(`${pagePath}: Duplicate shape ID: ${id}`);
+            }
+            ids.add(id);
+        }
+    }
+    validateConnects(parsed, pagePath, errors) {
+        if (!parsed.PageContents.Connects?.Connect)
+            return;
+        const shapes = this.getAllShapes(parsed);
+        const shapeIds = new Set(shapes.map((s) => s['@_ID']));
+        let connects = parsed.PageContents.Connects.Connect;
+        connects = Array.isArray(connects) ? connects : [connects];
+        for (const connect of connects) {
+            const fromSheet = connect['@_FromSheet'];
+            const toSheet = connect['@_ToSheet'];
+            if (fromSheet && !shapeIds.has(fromSheet)) {
+                errors.push(`${pagePath}: Connect references non-existent FromSheet: ${fromSheet}`);
+            }
+            if (toSheet && !shapeIds.has(toSheet)) {
+                errors.push(`${pagePath}: Connect references non-existent ToSheet: ${toSheet}`);
+            }
+        }
+    }
+    validateSectionNames(parsed, pagePath, warnings) {
+        const shapes = this.getAllShapes(parsed);
+        for (const shape of shapes) {
+            if (!shape.Section)
+                continue;
+            const sections = Array.isArray(shape.Section) ? shape.Section : [shape.Section];
+            for (const section of sections) {
+                const name = section['@_N'];
+                if (!name) {
+                    warnings.push(`${pagePath}: Shape ${shape['@_ID']} has Section without N attribute`);
+                }
+            }
+        }
+    }
+    validateCellNames(parsed, pagePath, warnings) {
+        const shapes = this.getAllShapes(parsed);
+        for (const shape of shapes) {
+            // Check top-level cells
+            if (shape.Cell) {
+                const cells = Array.isArray(shape.Cell) ? shape.Cell : [shape.Cell];
+                for (const cell of cells) {
+                    if (!cell['@_N']) {
+                        warnings.push(`${pagePath}: Shape ${shape['@_ID']} has Cell without N attribute`);
+                    }
+                }
+            }
+            // Check cells in sections
+            if (shape.Section) {
+                const sections = Array.isArray(shape.Section) ? shape.Section : [shape.Section];
+                for (const section of sections) {
+                    if (section.Cell) {
+                        const cells = Array.isArray(section.Cell) ? section.Cell : [section.Cell];
+                        for (const cell of cells) {
+                            if (!cell['@_N']) {
+                                warnings.push(`${pagePath}: Shape ${shape['@_ID']} Section ${section['@_N']} has Cell without N attribute`);
+                            }
+                        }
+                    }
+                    if (section.Row) {
+                        const rows = Array.isArray(section.Row) ? section.Row : [section.Row];
+                        for (const row of rows) {
+                            if (row.Cell) {
+                                const cells = Array.isArray(row.Cell) ? row.Cell : [row.Cell];
+                                for (const cell of cells) {
+                                    if (!cell['@_N']) {
+                                        warnings.push(`${pagePath}: Shape ${shape['@_ID']} Row ${row['@_N'] || row['@_IX']} has Cell without N attribute`);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+    validateImageShapes(pkg, pageId, parsed, pagePath, errors, warnings) {
+        const shapes = this.getAllShapes(parsed);
+        for (const shape of shapes) {
+            if (shape['@_Type'] !== 'Foreign')
+                continue;
+            if (!shape.ForeignData) {
+                warnings.push(`${pagePath}: Foreign shape ${shape['@_ID']} missing ForeignData`);
+                continue;
+            }
+            const relId = shape.ForeignData.Rel?.['@_r:id'];
+            if (relId) {
+                try {
+                    const relsPath = `visio/pages/_rels/page${pageId}.xml.rels`;
+                    const relsContent = pkg.getFileText(relsPath);
+                    const parsedRels = this.parser.parse(relsContent);
+                    let rels = parsedRels.Relationships?.Relationship || [];
+                    rels = Array.isArray(rels) ? rels : [rels];
+                    const found = rels.find((r) => r['@_Id'] === relId);
+                    if (!found) {
+                        errors.push(`${pagePath}: Image shape ${shape['@_ID']} references non-existent relationship: ${relId}`);
+                    }
+                }
+                catch {
+                    // No rels file is okay if no relationships needed
+                }
+            }
+        }
+    }
+    validateMasterReferences(pkg, errors, warnings) {
+        const masterIds = new Set();
+        try {
+            const mastersContent = pkg.getFileText('visio/masters/masters.xml');
+            const parsedMasters = this.parser.parse(mastersContent);
+            let masters = parsedMasters.Masters?.Master || [];
+            masters = Array.isArray(masters) ? masters : [masters];
+            for (const master of masters) {
+                if (master['@_ID']) {
+                    masterIds.add(master['@_ID']);
+                }
+            }
+        }
+        catch {
+            return; // No masters.xml is okay
+        }
+        try {
+            const pagesContent = pkg.getFileText('visio/pages/pages.xml');
+            const parsedPages = this.parser.parse(pagesContent);
+            let pageNodes = parsedPages.Pages?.Page || [];
+            pageNodes = Array.isArray(pageNodes) ? pageNodes : [pageNodes];
+            for (const pageNode of pageNodes) {
+                const pageId = pageNode['@_ID'];
+                const pagePath = `visio/pages/page${pageId}.xml`;
+                try {
+                    const pageContent = pkg.getFileText(pagePath);
+                    const parsed = this.parser.parse(pageContent);
+                    const shapes = this.getAllShapes(parsed);
+                    for (const shape of shapes) {
+                        const masterId = shape['@_Master'];
+                        if (masterId && !masterIds.has(masterId)) {
+                            errors.push(`${pagePath}: Shape ${shape['@_ID']} references non-existent Master: ${masterId}`);
+                        }
+                    }
+                }
+                catch {
+                    // Page file issues handled elsewhere
+                }
+            }
+        }
+        catch {
+            // Pages issues handled elsewhere
+        }
+    }
+    validateRelationshipIntegrity(pkg, errors, warnings) {
+        try {
+            const relsContent = pkg.getFileText('visio/pages/_rels/pages.xml.rels');
+            const parsedRels = this.parser.parse(relsContent);
+            let rels = parsedRels.Relationships?.Relationship || [];
+            rels = Array.isArray(rels) ? rels : [rels];
+            for (const rel of rels) {
+                const target = rel['@_Target'];
+                const id = rel['@_Id'];
+                if (!id) {
+                    errors.push('pages.xml.rels: Relationship missing Id attribute');
+                    continue;
+                }
+                if (!target) {
+                    errors.push(`pages.xml.rels: Relationship ${id} missing Target attribute`);
+                    continue;
+                }
+                const fullPath = `visio/pages/${target}`;
+                try {
+                    pkg.getFileText(fullPath);
+                }
+                catch {
+                    errors.push(`pages.xml.rels: Relationship ${id} targets non-existent file: ${target}`);
+                }
+            }
+        }
+        catch {
+            // Rels file issues might be handled elsewhere
+        }
+    }
+    getAllShapes(parsed) {
+        let topLevelShapes = parsed.PageContents.Shapes?.Shape || [];
+        if (!Array.isArray(topLevelShapes)) {
+            topLevelShapes = topLevelShapes ? [topLevelShapes] : [];
+        }
+        const all = [];
+        const gather = (shapeList) => {
+            for (const s of shapeList) {
+                all.push(s);
+                if (s.Shapes?.Shape) {
+                    const children = Array.isArray(s.Shapes.Shape) ? s.Shapes.Shape : [s.Shapes.Shape];
+                    gather(children);
+                }
+            }
+        };
+        gather(topLevelShapes);
+        return all;
+    }
+}
+exports.VisioValidator = VisioValidator;

package/dist/index.d.ts

@@ -0,0 +1,8 @@
+export { VisioPackage } from './VisioPackage';
+export { PageManager } from './PageManager';
+export { ShapeReader } from './ShapeReader';
+export { ShapeModifier } from './ShapeModifier';
+export { VisioDocument } from './VisioDocument';
+export { Page } from './Page';
+export { Shape } from './Shape';
+export * from './types/VisioTypes';

package/dist/index.js

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Shape = exports.Page = exports.VisioDocument = exports.ShapeModifier = exports.ShapeReader = exports.PageManager = exports.VisioPackage = void 0;
+var VisioPackage_1 = require("./VisioPackage");
+Object.defineProperty(exports, "VisioPackage", { enumerable: true, get: function () { return VisioPackage_1.VisioPackage; } });
+var PageManager_1 = require("./PageManager");
+Object.defineProperty(exports, "PageManager", { enumerable: true, get: function () { return PageManager_1.PageManager; } });
+var ShapeReader_1 = require("./ShapeReader");
+Object.defineProperty(exports, "ShapeReader", { enumerable: true, get: function () { return ShapeReader_1.ShapeReader; } });
+var ShapeModifier_1 = require("./ShapeModifier");
+Object.defineProperty(exports, "ShapeModifier", { enumerable: true, get: function () { return ShapeModifier_1.ShapeModifier; } });
+var VisioDocument_1 = require("./VisioDocument");
+Object.defineProperty(exports, "VisioDocument", { enumerable: true, get: function () { return VisioDocument_1.VisioDocument; } });
+var Page_1 = require("./Page");
+Object.defineProperty(exports, "Page", { enumerable: true, get: function () { return Page_1.Page; } });
+var Shape_1 = require("./Shape");
+Object.defineProperty(exports, "Shape", { enumerable: true, get: function () { return Shape_1.Shape; } });
+__exportStar(require("./types/VisioTypes"), exports);

package/dist/shapes/ConnectorBuilder.d.ts

@@ -0,0 +1,37 @@
+export declare class ConnectorBuilder {
+    private static getCellVal;
+    private static getAbsolutePos;
+    private static getEdgePoint;
+    static buildShapeHierarchy(parsed: any): Map<string, {
+        shape: any;
+        parent: any;
+    }>;
+    static calculateConnectorLayout(fromShapeId: string, toShapeId: string, shapeHierarchy: Map<string, {
+        shape: any;
+        parent: any;
+    }>): {
+        beginX: number;
+        beginY: number;
+        endX: number;
+        endY: number;
+        width: number;
+        angle: number;
+    };
+    static createConnectorShapeObject(id: string, layout: any, beginArrow?: string, endArrow?: string): {
+        '@_ID': string;
+        '@_NameU': string;
+        '@_Name': string;
+        '@_Type': string;
+        Cell: ({
+            '@_N': string;
+            '@_V': any;
+            '@_F'?: undefined;
+        } | {
+            '@_N': string;
+            '@_V': any;
+            '@_F': string;
+        })[];
+        Section: import("../utils/StyleHelpers").VisioSection[];
+    };
+    static addConnectorToConnects(parsed: any, connectorId: string, fromShapeId: string, toShapeId: string): void;
+}

package/dist/shapes/ConnectorBuilder.js

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ConnectorBuilder = void 0;
+const StyleHelpers_1 = require("../utils/StyleHelpers");
+class ConnectorBuilder {
+    static getCellVal(shape, name) {
+        if (!shape || !shape.Cell)
+            return '0';
+        const cells = Array.isArray(shape.Cell) ? shape.Cell : [shape.Cell];
+        const cell = cells.find((c) => c['@_N'] === name);
+        return cell ? cell['@_V'] : '0';
+    }
+    static getAbsolutePos(id, shapeHierarchy) {
+        const entry = shapeHierarchy.get(id);
+        if (!entry)
+            return { x: 0, y: 0 };
+        const shape = entry.shape;
+        const pinX = parseFloat(this.getCellVal(shape, 'PinX'));
+        const pinY = parseFloat(this.getCellVal(shape, 'PinY'));
+        if (!entry.parent) {
+            return { x: pinX, y: pinY };
+        }
+        const parentPos = this.getAbsolutePos(entry.parent['@_ID'], shapeHierarchy);
+        const parentLocPinX = parseFloat(this.getCellVal(entry.parent, 'LocPinX'));
+        const parentLocPinY = parseFloat(this.getCellVal(entry.parent, 'LocPinY'));
+        return {
+            x: (parentPos.x - parentLocPinX) + pinX,
+            y: (parentPos.y - parentLocPinY) + pinY
+        };
+    }
+    static getEdgePoint(cx, cy, w, h, targetX, targetY) {
+        const dx = targetX - cx;
+        const dy = targetY - cy;
+        if (dx === 0 && dy === 0)
+            return { x: cx, y: cy };
+        const rad = Math.atan2(dy, dx);
+        const rw = w / 2;
+        const rh = h / 2;
+        const tx = dx !== 0 ? (dx > 0 ? rw : -rw) / Math.cos(rad) : Infinity;
+        const ty = dy !== 0 ? (dy > 0 ? rh : -rh) / Math.sin(rad) : Infinity;
+        const t = Math.min(Math.abs(tx), Math.abs(ty));
+        return {
+            x: cx + t * Math.cos(rad),
+            y: cy + t * Math.sin(rad)
+        };
+    }
+    static buildShapeHierarchy(parsed) {
+        const shapeHierarchy = new Map();
+        const mapHierarchy = (shapes, parent) => {
+            for (const s of shapes) {
+                shapeHierarchy.set(s['@_ID'], { shape: s, parent });
+                if (s.Shapes && s.Shapes.Shape) {
+                    const children = Array.isArray(s.Shapes.Shape) ? s.Shapes.Shape : [s.Shapes.Shape];
+                    mapHierarchy(children, s);
+                }
+            }
+        };
+        const topShapes = parsed.PageContents.Shapes ?
+            (Array.isArray(parsed.PageContents.Shapes.Shape) ? parsed.PageContents.Shapes.Shape : [parsed.PageContents.Shapes.Shape])
+            : [];
+        mapHierarchy(topShapes, null);
+        return shapeHierarchy;
+    }
+    static calculateConnectorLayout(fromShapeId, toShapeId, shapeHierarchy) {
+        let beginX = 0, beginY = 0, endX = 0, endY = 0;
+        let sourceGeom = null;
+        let targetGeom = null;
+        const sourceEntry = shapeHierarchy.get(fromShapeId);
+        const targetEntry = shapeHierarchy.get(toShapeId);
+        if (sourceEntry) {
+            const abs = this.getAbsolutePos(fromShapeId, shapeHierarchy);
+            const w = parseFloat(this.getCellVal(sourceEntry.shape, 'Width'));
+            const h = parseFloat(this.getCellVal(sourceEntry.shape, 'Height'));
+            sourceGeom = { x: abs.x, y: abs.y, w, h };
+            beginX = abs.x;
+            beginY = abs.y;
+        }
+        if (targetEntry) {
+            const abs = this.getAbsolutePos(toShapeId, shapeHierarchy);
+            const w = parseFloat(this.getCellVal(targetEntry.shape, 'Width'));
+            const h = parseFloat(this.getCellVal(targetEntry.shape, 'Height'));
+            targetGeom = { x: abs.x, y: abs.y, w, h };
+            endX = abs.x;
+            endY = abs.y;
+        }
+        if (sourceGeom && targetGeom) {
+            const startNode = this.getEdgePoint(sourceGeom.x, sourceGeom.y, sourceGeom.w, sourceGeom.h, targetGeom.x, targetGeom.y);
+            const endNode = this.getEdgePoint(targetGeom.x, targetGeom.y, targetGeom.w, targetGeom.h, sourceGeom.x, sourceGeom.y);
+            beginX = startNode.x;
+            beginY = startNode.y;
+            endX = endNode.x;
+            endY = endNode.y;
+        }
+        const dx = endX - beginX;
+        const dy = endY - beginY;
+        const width = Math.sqrt(dx * dx + dy * dy);
+        const angle = Math.atan2(dy, dx);
+        return { beginX, beginY, endX, endY, width, angle };
+    }
+    static createConnectorShapeObject(id, layout, beginArrow, endArrow) {
+        const { beginX, beginY, endX, endY, width, angle } = layout;
+        return {
+            '@_ID': id,
+            '@_NameU': 'Dynamic connector',
+            '@_Name': 'Dynamic connector',
+            '@_Type': 'Shape',
+            Cell: [
+                { '@_N': 'BeginX', '@_V': beginX.toString() },
+                { '@_N': 'BeginY', '@_V': beginY.toString() },
+                { '@_N': 'EndX', '@_V': endX.toString() },
+                { '@_N': 'EndY', '@_V': endY.toString() },
+                { '@_N': 'PinX', '@_V': ((beginX + endX) / 2).toString(), '@_F': '(BeginX+EndX)/2' },
+                { '@_N': 'PinY', '@_V': ((beginY + endY) / 2).toString(), '@_F': '(BeginY+EndY)/2' },
+                { '@_N': 'Width', '@_V': width.toString(), '@_F': 'SQRT((EndX-BeginX)^2+(EndY-BeginY)^2)' },
+                { '@_N': 'Height', '@_V': '0' },
+                { '@_N': 'Angle', '@_V': angle.toString(), '@_F': 'ATAN2(EndY-BeginY,EndX-BeginX)' },
+                { '@_N': 'LocPinX', '@_V': (width * 0.5).toString(), '@_F': 'Width*0.5' },
+                { '@_N': 'LocPinY', '@_V': '0', '@_F': 'Height*0.5' },
+                { '@_N': 'ObjType', '@_V': '2' },
+                { '@_N': 'ShapePermeableX', '@_V': '0' },
+                { '@_N': 'ShapePermeableY', '@_V': '0' },
+                { '@_N': 'ShapeRouteStyle', '@_V': '1' },
+                { '@_N': 'ConFixedCode', '@_V': '0' }
+            ],
+            Section: [
+                (0, StyleHelpers_1.createLineSection)({
+                    color: '#000000',
+                    weight: '0.01',
+                    beginArrow: beginArrow || '0',
+                    beginArrowSize: '2',
+                    endArrow: endArrow || '0',
+                    endArrowSize: '2'
+                }),
+                {
+                    '@_N': 'Geometry',
+                    '@_IX': '0',
+                    Row: [
+                        { '@_T': 'MoveTo', '@_IX': '1', Cell: [{ '@_N': 'X', '@_V': '0' }, { '@_N': 'Y', '@_V': '0' }] },
+                        { '@_T': 'LineTo', '@_IX': '2', Cell: [{ '@_N': 'X', '@_V': width.toString(), '@_F': 'Width' }, { '@_N': 'Y', '@_V': '0', '@_F': 'Height*0' }] }
+                    ]
+                }
+            ]
+        };
+    }
+    static addConnectorToConnects(parsed, connectorId, fromShapeId, toShapeId) {
+        if (!parsed.PageContents.Connects) {
+            parsed.PageContents.Connects = { Connect: [] };
+        }
+        let connectCollection = parsed.PageContents.Connects.Connect;
+        // Ensure it's an array if it was a single object or undefined
+        if (!Array.isArray(connectCollection)) {
+            connectCollection = connectCollection ? [connectCollection] : [];
+            parsed.PageContents.Connects.Connect = connectCollection;
+        }
+        connectCollection.push({
+            '@_FromSheet': connectorId,
+            '@_FromCell': 'BeginX',
+            '@_FromPart': '9',
+            '@_ToSheet': fromShapeId,
+            '@_ToCell': 'PinX',
+            '@_ToPart': '3'
+        });
+        connectCollection.push({
+            '@_FromSheet': connectorId,
+            '@_FromCell': 'EndX',
+            '@_FromPart': '12',
+            '@_ToSheet': toShapeId,
+            '@_ToCell': 'PinX',
+            '@_ToPart': '3'
+        });
+    }
+}
+exports.ConnectorBuilder = ConnectorBuilder;

package/dist/shapes/ContainerBuilder.d.ts

@@ -0,0 +1,6 @@
+import { NewShapeProps } from '../types/VisioTypes';
+export declare class ContainerBuilder {
+    static createContainerShape(id: string, props: NewShapeProps): any;
+    static makeContainer(shape: any): void;
+    static makeList(shape: any, direction?: 'vertical' | 'horizontal'): void;
+}