ts-visio 1.0.0

package/dist/ShapeReader.d.ts

@@ -0,0 +1,9 @@
+import { VisioPackage } from './VisioPackage';
+import { VisioShape } from './types/VisioTypes';
+export declare class ShapeReader {
+    private pkg;
+    private parser;
+    constructor(pkg: VisioPackage);
+    readShapes(path: string): VisioShape[];
+    private parseShape;
+}

package/dist/ShapeReader.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ShapeReader = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const VisioParsers_1 = require("./utils/VisioParsers");
+class ShapeReader {
+    constructor(pkg) {
+        this.pkg = pkg;
+        this.parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_"
+        });
+    }
+    readShapes(path) {
+        let content;
+        try {
+            content = this.pkg.getFileText(path);
+        }
+        catch {
+            return [];
+        }
+        const parsed = this.parser.parse(content);
+        // Supports PageContents -> Shapes -> Shape or just Shapes -> Shape depending on structure
+        const shapesData = parsed.PageContents?.Shapes?.Shape;
+        if (!shapesData)
+            return [];
+        const shapesArray = (0, VisioParsers_1.asArray)(shapesData);
+        return shapesArray.map(s => this.parseShape(s));
+    }
+    parseShape(s) {
+        const shape = {
+            ID: s['@_ID'],
+            Name: s['@_Name'],
+            NameU: s['@_NameU'],
+            Type: s['@_Type'],
+            Master: s['@_Master'],
+            Text: s.Text?.['#text'] || (typeof s.Text === 'string' ? s.Text : undefined),
+            Cells: (0, VisioParsers_1.parseCells)(s),
+            Sections: {}
+        };
+        const sections = (0, VisioParsers_1.asArray)(s.Section);
+        for (const sec of sections) {
+            const section = sec;
+            if (section['@_N']) {
+                shape.Sections[section['@_N']] = (0, VisioParsers_1.parseSection)(section);
+            }
+        }
+        return shape;
+    }
+}
+exports.ShapeReader = ShapeReader;

package/dist/VisioDocument.d.ts

@@ -0,0 +1,21 @@
+import { Page } from './Page';
+export declare class VisioDocument {
+    private pkg;
+    private pageManager;
+    private _pageCache;
+    private mediaManager;
+    private constructor();
+    static create(): Promise<VisioDocument>;
+    static load(pathOrBuffer: string | Buffer | ArrayBuffer | Uint8Array): Promise<VisioDocument>;
+    addPage(name: string): Promise<Page>;
+    get pages(): Page[];
+    /**
+     * Add a background page to the document
+     */
+    addBackgroundPage(name: string): Promise<Page>;
+    /**
+     * Set a background page for a foreground page
+     */
+    setBackgroundPage(foregroundPage: Page, backgroundPage: Page): Promise<void>;
+    save(filename?: string): Promise<Buffer>;
+}

package/dist/VisioDocument.js

@@ -0,0 +1,119 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisioDocument = void 0;
+const VisioPackage_1 = require("./VisioPackage");
+const PageManager_1 = require("./core/PageManager");
+const Page_1 = require("./Page");
+const MediaManager_1 = require("./core/MediaManager");
+class VisioDocument {
+    constructor(pkg) {
+        this.pkg = pkg;
+        this._pageCache = null;
+        this.pageManager = new PageManager_1.PageManager(pkg);
+        this.mediaManager = new MediaManager_1.MediaManager(pkg);
+    }
+    static async create() {
+        const pkg = await VisioPackage_1.VisioPackage.create();
+        return new VisioDocument(pkg);
+    }
+    static async load(pathOrBuffer) {
+        const pkg = new VisioPackage_1.VisioPackage();
+        if (typeof pathOrBuffer === 'string') {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            const buffer = await fs.readFile(pathOrBuffer);
+            await pkg.load(buffer);
+        }
+        else {
+            await pkg.load(pathOrBuffer);
+        }
+        return new VisioDocument(pkg);
+    }
+    async addPage(name) {
+        const newId = await this.pageManager.createPage(name);
+        this._pageCache = null;
+        const pageStub = {
+            ID: newId,
+            Name: name,
+            Shapes: [],
+            Connects: []
+        };
+        return new Page_1.Page(pageStub, this.pkg, this.mediaManager);
+    }
+    get pages() {
+        if (!this._pageCache) {
+            const internalPages = this.pageManager.load();
+            this._pageCache = internalPages.map(p => {
+                // Adapter for VisioPage interface
+                const pageStub = {
+                    ID: p.id.toString(),
+                    Name: p.name,
+                    Shapes: [],
+                    Connects: [],
+                    isBackground: p.isBackground,
+                    backPageId: p.backPageId
+                };
+                return new Page_1.Page(pageStub, this.pkg, this.mediaManager);
+            });
+        }
+        return this._pageCache;
+    }
+    /**
+     * Add a background page to the document
+     */
+    async addBackgroundPage(name) {
+        const newId = await this.pageManager.createBackgroundPage(name);
+        this._pageCache = null;
+        const pageStub = {
+            ID: newId,
+            Name: name,
+            Shapes: [],
+            Connects: [],
+            isBackground: true
+        };
+        return new Page_1.Page(pageStub, this.pkg, this.mediaManager);
+    }
+    /**
+     * Set a background page for a foreground page
+     */
+    async setBackgroundPage(foregroundPage, backgroundPage) {
+        await this.pageManager.setBackgroundPage(foregroundPage.id, backgroundPage.id);
+        this._pageCache = null;
+    }
+    async save(filename) {
+        return this.pkg.save(filename);
+    }
+}
+exports.VisioDocument = VisioDocument;

package/dist/VisioPackage.d.ts

@@ -0,0 +1,10 @@
+export declare class VisioPackage {
+    private zip;
+    private _files;
+    get filesMap(): Map<string, string | Buffer>;
+    static create(): Promise<VisioPackage>;
+    load(buffer: Buffer | ArrayBuffer | Uint8Array): Promise<void>;
+    updateFile(path: string, content: string | Buffer): void;
+    save(filename?: string): Promise<Buffer>;
+    getFileText(path: string): string;
+}

package/dist/VisioPackage.js

@@ -0,0 +1,112 @@
+"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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VisioPackage = void 0;
+const jszip_1 = __importDefault(require("jszip"));
+const T = __importStar(require("./templates/MinimalVsdx"));
+const MediaConstants_1 = require("./core/MediaConstants");
+class VisioPackage {
+    constructor() {
+        this.zip = null;
+        this._files = new Map();
+    }
+    get filesMap() {
+        return this._files;
+    }
+    static async create() {
+        const pkg = new VisioPackage();
+        pkg.zip = new jszip_1.default();
+        // Populate minimal structure
+        pkg.updateFile('[Content_Types].xml', T.CONTENT_TYPES_XML);
+        pkg.updateFile('_rels/.rels', T.RELS_XML);
+        pkg.updateFile('visio/document.xml', T.DOCUMENT_XML);
+        pkg.updateFile('visio/_rels/document.xml.rels', T.DOCUMENT_RELS_XML);
+        pkg.updateFile('visio/pages/pages.xml', T.PAGES_XML);
+        pkg.updateFile('visio/pages/_rels/pages.xml.rels', T.PAGES_RELS_XML);
+        pkg.updateFile('visio/pages/page1.xml', T.PAGE1_XML);
+        pkg.updateFile('visio/windows.xml', T.WINDOWS_XML);
+        pkg.updateFile('docProps/core.xml', T.CORE_XML);
+        pkg.updateFile('docProps/app.xml', T.APP_XML);
+        return pkg;
+    }
+    async load(buffer) {
+        this._files.clear();
+        this.zip = await jszip_1.default.loadAsync(buffer);
+        const promises = [];
+        this.zip.forEach((relativePath, file) => {
+            if (!file.dir) {
+                const ext = relativePath.split('.').pop() || '';
+                const isBinary = (0, MediaConstants_1.isBinaryExtension)(ext);
+                const type = isBinary ? 'nodebuffer' : 'string';
+                promises.push(file.async(type).then(content => {
+                    this._files.set(relativePath, content);
+                }));
+            }
+        });
+        await Promise.all(promises);
+    }
+    updateFile(path, content) {
+        if (!this.zip) {
+            throw new Error("Package not loaded");
+        }
+        this._files.set(path, content);
+        this.zip.file(path, content);
+    }
+    async save(filename) {
+        if (!this.zip) {
+            throw new Error("Package not loaded");
+        }
+        const buffer = await this.zip.generateAsync({ type: 'nodebuffer' });
+        if (filename) {
+            const fs = await Promise.resolve().then(() => __importStar(require('fs/promises')));
+            await fs.writeFile(filename, buffer);
+        }
+        return buffer;
+    }
+    getFileText(path) {
+        const content = this._files.get(path);
+        if (content === undefined) {
+            throw new Error(`File not found: ${path}`);
+        }
+        if (Buffer.isBuffer(content)) {
+            throw new Error(`File is binary: ${path}`);
+        }
+        return content;
+    }
+}
+exports.VisioPackage = VisioPackage;

package/dist/core/MasterManager.d.ts

@@ -0,0 +1,15 @@
+import { VisioPackage } from '../VisioPackage';
+export interface Master {
+    id: string;
+    name: string;
+    nameU: string;
+    type: string;
+    xmlPath: string;
+}
+export declare class MasterManager {
+    private pkg;
+    private parser;
+    private masters;
+    constructor(pkg: VisioPackage);
+    load(): Master[];
+}

package/dist/core/MasterManager.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MasterManager = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+class MasterManager {
+    constructor(pkg) {
+        this.pkg = pkg;
+        this.masters = [];
+        this.parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_"
+        });
+    }
+    load() {
+        const path = 'visio/masters/masters.xml';
+        let content;
+        try {
+            content = this.pkg.getFileText(path);
+        }
+        catch (e) {
+            // It's possible the file doesn't exist if no masters are used
+            return [];
+        }
+        const parsed = this.parser.parse(content);
+        let masterNodes = parsed.Masters ? parsed.Masters.Master : [];
+        if (!Array.isArray(masterNodes)) {
+            masterNodes = [masterNodes];
+        }
+        this.masters = masterNodes.map((node) => ({
+            id: node['@_ID'],
+            name: node['@_Name'],
+            nameU: node['@_NameU'],
+            type: node['@_Type'],
+            // Implicit path convention in Visio typically follows patterns,
+            // but precise mapping usually requires checking relationships (.rels).
+            // For Phase 1, we'll assume standard naming or just store what we have.
+            // Relationships are handled in Phase 3.
+            xmlPath: ''
+        }));
+        return this.masters;
+    }
+}
+exports.MasterManager = MasterManager;

package/dist/core/MediaConstants.d.ts

@@ -0,0 +1,5 @@
+export declare const MIME_TYPES: {
+    [key: string]: string;
+};
+export declare const SUPPORTED_IMAGE_EXTENSIONS: string[];
+export declare function isBinaryExtension(ext: string): boolean;

package/dist/core/MediaConstants.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUPPORTED_IMAGE_EXTENSIONS = exports.MIME_TYPES = void 0;
+exports.isBinaryExtension = isBinaryExtension;
+exports.MIME_TYPES = {
+    'png': 'image/png',
+    'jpg': 'image/jpeg',
+    'jpeg': 'image/jpeg',
+    'gif': 'image/gif',
+    'bmp': 'image/bmp',
+    'tiff': 'image/tiff'
+};
+exports.SUPPORTED_IMAGE_EXTENSIONS = Object.keys(exports.MIME_TYPES);
+function isBinaryExtension(ext) {
+    return exports.SUPPORTED_IMAGE_EXTENSIONS.includes(ext.toLowerCase());
+}

package/dist/core/MediaManager.d.ts

@@ -0,0 +1,13 @@
+import { VisioPackage } from '../VisioPackage';
+export declare class MediaManager {
+    private pkg;
+    private parser;
+    private builder;
+    private deduplicationMap;
+    private indexed;
+    constructor(pkg: VisioPackage);
+    private ensureIndex;
+    private getContentType;
+    addMedia(name: string, data: Buffer): string;
+    private ensureContentType;
+}

package/dist/core/MediaManager.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MediaManager = void 0;
+const fast_xml_parser_1 = require("fast-xml-parser");
+const MediaConstants_1 = require("./MediaConstants");
+class MediaManager {
+    constructor(pkg) {
+        this.pkg = pkg;
+        this.deduplicationMap = new Map(); // hash -> paths
+        this.indexed = false;
+        this.parser = new fast_xml_parser_1.XMLParser({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_"
+        });
+        this.builder = new fast_xml_parser_1.XMLBuilder({
+            ignoreAttributes: false,
+            attributeNamePrefix: "@_",
+            format: true
+        });
+    }
+    ensureIndex() {
+        if (this.indexed)
+            return;
+        const crypto = require('crypto');
+        for (const [path, content] of this.pkg.filesMap.entries()) {
+            if (path.startsWith('visio/media/') && Buffer.isBuffer(content)) {
+                const hash = crypto.createHash('sha1').update(content).digest('hex');
+                // Store relative path suitable for relationships
+                const filename = path.split('/').pop();
+                if (filename) {
+                    this.deduplicationMap.set(hash, `../media/${filename}`);
+                }
+            }
+        }
+        this.indexed = true;
+    }
+    getContentType(extension) {
+        return MediaConstants_1.MIME_TYPES[extension.toLowerCase()] || 'application/octet-stream';
+    }
+    addMedia(name, data) {
+        this.ensureIndex();
+        const crypto = require('crypto');
+        const hash = crypto.createHash('sha1').update(data).digest('hex');
+        if (this.deduplicationMap.has(hash)) {
+            return this.deduplicationMap.get(hash);
+        }
+        const extension = name.split('.').pop() || '';
+        // If name already exists, we might need a unique name.
+        // Note: Visio doesn't strictly require unique filenames in the media folder if we manage rels,
+        // but it's safer to avoid collisions.
+        // Use hash in filename to ensure uniqueness and automatic deduplication naming
+        const uniqueFileName = `${name.replace(`.${extension}`, '')}_${hash.substring(0, 8)}.${extension}`;
+        const mediaPath = `visio/media/${uniqueFileName}`;
+        const relPath = `../media/${uniqueFileName}`;
+        this.pkg.updateFile(mediaPath, data);
+        if (extension) {
+            this.ensureContentType(extension);
+        }
+        this.deduplicationMap.set(hash, relPath);
+        return relPath;
+    }
+    ensureContentType(extension) {
+        const ctPath = '[Content_Types].xml';
+        const content = this.pkg.getFileText(ctPath);
+        const parsed = this.parser.parse(content);
+        // Ensure structure
+        if (!parsed.Types)
+            parsed.Types = {};
+        if (!parsed.Types.Default)
+            parsed.Types.Default = [];
+        // Ensure array
+        if (!Array.isArray(parsed.Types.Default)) {
+            parsed.Types.Default = [parsed.Types.Default];
+        }
+        const defaults = parsed.Types.Default;
+        const exists = defaults.some((d) => d['@_Extension']?.toLowerCase() === extension);
+        if (!exists) {
+            defaults.push({
+                '@_Extension': extension,
+                '@_ContentType': this.getContentType(extension)
+            });
+            // Array reference is already mutating object
+            const newXml = this.builder.build(parsed);
+            this.pkg.updateFile(ctPath, newXml);
+        }
+    }
+}
+exports.MediaManager = MediaManager;

package/dist/core/PageManager.d.ts

@@ -0,0 +1,28 @@
+import { VisioPackage } from '../VisioPackage';
+export interface PageEntry {
+    id: number;
+    name: string;
+    relId: string;
+    xmlPath: string;
+    isBackground: boolean;
+    backPageId?: number;
+}
+export declare class PageManager {
+    private pkg;
+    private parser;
+    private builder;
+    private relsManager;
+    private pages;
+    private loaded;
+    constructor(pkg: VisioPackage);
+    load(force?: boolean): PageEntry[];
+    createPage(name: string): Promise<string>;
+    /**
+     * Create a background page
+     */
+    createBackgroundPage(name: string): Promise<string>;
+    /**
+     * Set a background page for a foreground page
+     */
+    setBackgroundPage(foregroundPageId: string, backgroundPageId: string): Promise<void>;
+}