3dviewer-sdk 1.0.2 → 1.0.3

package/dist/modules/model-tree.module.js

@@ -0,0 +1,42 @@
+import { ViewerMessageType } from "../contracts/messages";
+function createRequestId() {
+    return `tree_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+export class ModelTreeModule {
+    constructor(viewer) {
+        this.viewer = viewer;
+    }
+    open() {
+        this.viewer.postToViewer(ViewerMessageType.PANEL_OPEN, {
+            panel: "model-tree",
+            format: "3d",
+        });
+    }
+    selectNode(nodeId) {
+        this.viewer.postToViewer(ViewerMessageType.TREE_SELECT_NODE, {
+            nodeId: String(nodeId),
+        });
+    }
+    getNodeIds(options) {
+        var _a;
+        const requestId = createRequestId();
+        const timeoutMs = Math.max(1000, (_a = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _a !== void 0 ? _a : 10000);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                off();
+                reject(new Error("Timeout while getting node ids from viewer"));
+            }, timeoutMs);
+            const off = this.viewer._on("modelTree:node-ids", (payload) => {
+                if (payload.requestId !== requestId)
+                    return;
+                clearTimeout(timer);
+                off();
+                resolve(payload.nodeIds);
+            });
+            this.viewer.postToViewer(ViewerMessageType.TREE_GET_NODE_IDS, {
+                requestId,
+                onlyRealNodes: (options === null || options === void 0 ? void 0 : options.onlyRealNodes) !== false,
+            });
+        });
+    }
+}

package/dist/modules/node.module.d.ts

@@ -0,0 +1,11 @@
+import { Viewer3D } from "../viewer";
+export declare class NodeModule {
+    private viewer;
+    on: {
+        select: (cb: (payload: {
+            nodeId: string;
+            timestamp: number;
+        }) => void) => () => void;
+    };
+    constructor(viewer: Viewer3D);
+}

package/dist/modules/node.module.js

@@ -0,0 +1,6 @@
+export class NodeModule {
+    constructor(viewer) {
+        this.viewer = viewer;
+        this.on = { select: (cb) => this.viewer._on("node:select", cb) };
+    }
+}

package/dist/modules/toolbar.module.d.ts

@@ -0,0 +1,83 @@
+import { Viewer3D } from "../viewer";
+import { type SheetListItem } from "../contracts/messages";
+export declare type ToolbarFormat = "3d" | "pdf";
+export declare type GetSheetsOptions = {
+    timeoutMs?: number;
+};
+export declare class ToolbarModule {
+    private viewer;
+    on: {
+        planMode: (cb: (payload: {
+            mode: "plan" | "document";
+            timestamp: number;
+        }) => void) => () => void;
+        documentMode: (cb: (payload: {
+            mode: "plan" | "document";
+            timestamp: number;
+        }) => void) => () => void;
+        firstPage: (cb: (payload: {
+            timestamp: number;
+        }) => void) => () => void;
+        previousPage: (cb: (payload: {
+            timestamp: number;
+        }) => void) => () => void;
+        nextPage: (cb: (payload: {
+            timestamp: number;
+        }) => void) => () => void;
+        lastPage: (cb: (payload: {
+            timestamp: number;
+        }) => void) => () => void;
+        currentPage: (cb: (payload: {
+            pageIndex: number;
+            pageNumber: number;
+            timestamp: number;
+        }) => void) => () => void;
+    };
+    constructor(viewer: Viewer3D);
+    setDisabled3D(operators: string[]): void;
+    setDisabledPdf(operators: string[]): void;
+    clearDisabled3D(): void;
+    clearDisabledPdf(): void;
+    disableAll3D(): void;
+    disableAllPdf(): void;
+    enableAll3D(): void;
+    enableAllPdf(): void;
+    openClippingPlanes(): void;
+    closeClippingPlanes(): void;
+    openSetting(): void;
+    closeSetting(): void;
+    openSetting3D(): void;
+    closeSetting3D(): void;
+    openSettingPdf(): void;
+    closeSettingPdf(): void;
+    openStatesObjects(): void;
+    closeStatesObjects(): void;
+    openLinkedObjects(): void;
+    closeLinkedObjects(): void;
+    openModelTree(): void;
+    closeModelTree(): void;
+    openObjectProperties(): void;
+    closeObjectProperties(): void;
+    openSheets(): void;
+    closeSheets(): void;
+    getSheets(options?: GetSheetsOptions): Promise<SheetListItem[]>;
+    applySheet(sheetId: string | number): void;
+    cuttingCloseSections(): void;
+    cuttingMultipleSides(): void;
+    cuttingToggleSelection(): void;
+    cuttingTogglePlanes(): void;
+    cuttingPlaneX(): void;
+    cuttingPlaneY(): void;
+    cuttingPlaneZ(): void;
+    cuttingPlaneBox(): void;
+    cuttingRotateBox(): void;
+    cuttingReversePlaneX(): void;
+    cuttingReversePlaneY(): void;
+    cuttingReversePlaneZ(): void;
+    private postConfig;
+    private postPanelOpen;
+    private postPanelClose;
+    private postCuttingAction;
+    private postSheetsGetList;
+    private postSheetsApply;
+}

package/dist/modules/toolbar.module.js

@@ -0,0 +1,219 @@
+import { ViewerMessageType, } from "../contracts/messages";
+function createRequestId() {
+    return `sheets_${Date.now()}_${Math.random().toString(36).slice(2, 10)}`;
+}
+const ALL_3D_TOOLBAR_OPERATORS = [
+    "home",
+    "select",
+    "areaSelect",
+    "pan",
+    "zoomIn",
+    "zoomOut",
+    "zoomWindow",
+    "zoomFit",
+    "orbit",
+    "rotateZ",
+    "walkThrough",
+    "drawMode-shaded",
+    "drawMode-wireframe",
+    "drawMode-shaded-wire",
+    "drawMode-hidden-line",
+    "drawMode-xray",
+    "drawMode-ghosting",
+    "cutting-plane",
+    "clipping-commands",
+    "explode",
+    "setting",
+    "propertyPanel",
+    "model-tree",
+    "linkedObjects",
+    "statesObjects",
+    "synchronized",
+];
+const ALL_PDF_TOOLBAR_OPERATORS = [
+    "home",
+    "select",
+    "pan",
+    "zoomIn",
+    "zoomOut",
+    "zoomWindow",
+    "zoomFit",
+    "rotateZ",
+    "save",
+    "setting",
+    "plan-mode",
+    "document-mode",
+    "first-page",
+    "previous-page",
+    "next-page",
+    "last-page",
+    "current-page",
+];
+export class ToolbarModule {
+    constructor(viewer) {
+        this.viewer = viewer;
+        this.on = {
+            planMode: (cb) => this.viewer._on("toolbar:pdf-plan-mode", cb),
+            documentMode: (cb) => this.viewer._on("toolbar:pdf-document-mode", cb),
+            firstPage: (cb) => this.viewer._on("toolbar:pdf-first-page", cb),
+            previousPage: (cb) => this.viewer._on("toolbar:pdf-previous-page", cb),
+            nextPage: (cb) => this.viewer._on("toolbar:pdf-next-page", cb),
+            lastPage: (cb) => this.viewer._on("toolbar:pdf-last-page", cb),
+            currentPage: (cb) => this.viewer._on("toolbar:pdf-current-page", cb),
+        };
+    }
+    setDisabled3D(operators) {
+        this.postConfig({ format: "3d", mode: "set", operators });
+    }
+    setDisabledPdf(operators) {
+        this.postConfig({ format: "pdf", mode: "set", operators });
+    }
+    clearDisabled3D() {
+        this.postConfig({ format: "3d", mode: "clear" });
+    }
+    clearDisabledPdf() {
+        this.postConfig({ format: "pdf", mode: "clear" });
+    }
+    disableAll3D() {
+        this.setDisabled3D(ALL_3D_TOOLBAR_OPERATORS);
+    }
+    disableAllPdf() {
+        this.setDisabledPdf(ALL_PDF_TOOLBAR_OPERATORS);
+    }
+    enableAll3D() {
+        this.clearDisabled3D();
+    }
+    enableAllPdf() {
+        this.clearDisabledPdf();
+    }
+    openClippingPlanes() {
+        this.postPanelOpen({ panel: "clipping-commands", format: "3d" });
+    }
+    closeClippingPlanes() {
+        this.postPanelClose({ panel: "clipping-commands", format: "3d" });
+    }
+    openSetting() {
+        this.postPanelOpen({ panel: "setting" });
+    }
+    closeSetting() {
+        this.postPanelClose({ panel: "setting" });
+    }
+    openSetting3D() {
+        this.postPanelOpen({ panel: "setting", format: "3d" });
+    }
+    closeSetting3D() {
+        this.postPanelClose({ panel: "setting", format: "3d" });
+    }
+    openSettingPdf() {
+        this.postPanelOpen({ panel: "setting", format: "pdf" });
+    }
+    closeSettingPdf() {
+        this.postPanelClose({ panel: "setting", format: "pdf" });
+    }
+    openStatesObjects() {
+        this.postPanelOpen({ panel: "statesObjects", format: "3d" });
+    }
+    closeStatesObjects() {
+        this.postPanelClose({ panel: "statesObjects", format: "3d" });
+    }
+    openLinkedObjects() {
+        this.postPanelOpen({ panel: "linkedObjects", format: "3d" });
+    }
+    closeLinkedObjects() {
+        this.postPanelClose({ panel: "linkedObjects", format: "3d" });
+    }
+    openModelTree() {
+        this.postPanelOpen({ panel: "model-tree", format: "3d" });
+    }
+    closeModelTree() {
+        this.postPanelClose({ panel: "model-tree", format: "3d" });
+    }
+    openObjectProperties() {
+        this.postPanelOpen({ panel: "object-properties", format: "3d" });
+    }
+    closeObjectProperties() {
+        this.postPanelClose({ panel: "object-properties", format: "3d" });
+    }
+    openSheets() {
+        this.postPanelOpen({ panel: "sheets", format: "3d" });
+    }
+    closeSheets() {
+        this.postPanelClose({ panel: "sheets", format: "3d" });
+    }
+    getSheets(options) {
+        var _a;
+        const requestId = createRequestId();
+        const timeoutMs = Math.max(1000, (_a = options === null || options === void 0 ? void 0 : options.timeoutMs) !== null && _a !== void 0 ? _a : 10000);
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                off();
+                reject(new Error("Timeout while getting sheets list from viewer"));
+            }, timeoutMs);
+            const off = this.viewer._on("sheets:list", (payload) => {
+                if (payload.requestId !== requestId)
+                    return;
+                clearTimeout(timer);
+                off();
+                resolve(payload.sheets);
+            });
+            this.postSheetsGetList({ requestId });
+        });
+    }
+    applySheet(sheetId) {
+        this.postSheetsApply({ sheetId });
+    }
+    cuttingCloseSections() {
+        this.postCuttingAction({ action: "close" });
+    }
+    cuttingMultipleSides() {
+        this.postCuttingAction({ action: "multi" });
+    }
+    cuttingToggleSelection() {
+        this.postCuttingAction({ action: "toggle-section" });
+    }
+    cuttingTogglePlanes() {
+        this.postCuttingAction({ action: "toggle-plane" });
+    }
+    cuttingPlaneX() {
+        this.postCuttingAction({ action: "plane-x" });
+    }
+    cuttingPlaneY() {
+        this.postCuttingAction({ action: "plane-y" });
+    }
+    cuttingPlaneZ() {
+        this.postCuttingAction({ action: "plane-z" });
+    }
+    cuttingPlaneBox() {
+        this.postCuttingAction({ action: "plane-box" });
+    }
+    cuttingRotateBox() {
+        this.postCuttingAction({ action: "rotate-box" });
+    }
+    cuttingReversePlaneX() {
+        this.postCuttingAction({ action: "reverse-plane-x" });
+    }
+    cuttingReversePlaneY() {
+        this.postCuttingAction({ action: "reverse-plane-y" });
+    }
+    cuttingReversePlaneZ() {
+        this.postCuttingAction({ action: "reverse-plane-z" });
+    }
+    postConfig(payload) {
+        this.viewer.postToViewer(ViewerMessageType.TOOLBAR_CONFIG, payload);
+    }
+    postPanelOpen(payload) {
+        this.viewer.postToViewer(ViewerMessageType.PANEL_OPEN, payload);
+    }
+    postPanelClose(payload) {
+        this.viewer.postToViewer(ViewerMessageType.PANEL_CLOSE, payload);
+    }
+    postCuttingAction(payload) {
+        this.viewer.postToViewer(ViewerMessageType.CUTTING_PLANE_ACTION, payload);
+    }
+    postSheetsGetList(payload) {
+        this.viewer.postToViewer(ViewerMessageType.SHEETS_GET_LIST, payload);
+    }
+    postSheetsApply(payload) {
+        this.viewer.postToViewer(ViewerMessageType.SHEETS_APPLY, payload);
+    }
+}

package/dist/viewer.d.ts

@@ -0,0 +1,51 @@
+import type { PreparedViewerData, SdkEventKey, SdkEventPayload } from "./contracts/events";
+import { CameraModule } from "./modules/camera.module";
+import { InteractionModule } from "./modules/interaction.module";
+import { NodeModule } from "./modules/node.module";
+import { FilesModule } from "./modules/files.module";
+import { ToolbarModule } from "./modules/toolbar.module";
+import { ModelTreeModule } from "./modules/model-tree.module";
+import { MarkupModule } from "./modules/markup.module";
+import { LanguageModule } from "./modules/language.module";
+import { ViewerMessageType } from "./contracts/messages";
+export declare type Viewer3DOptions = {
+    container: HTMLElement | string;
+    url?: string;
+    baseUrl?: string;
+    viewerPath?: string;
+    uploadPath?: string;
+    file?: File;
+    width?: string;
+    height?: string;
+    sandbox?: string;
+    allowedOrigin?: string;
+};
+export declare class Viewer3D {
+    private options;
+    private containerEl;
+    private iframeEl;
+    private initialized;
+    private emitter;
+    camera: CameraModule;
+    interaction: InteractionModule;
+    node: NodeModule;
+    files: FilesModule;
+    toolbar: ToolbarModule;
+    modelTree: ModelTreeModule;
+    markup: MarkupModule;
+    language: LanguageModule;
+    constructor(options: Viewer3DOptions);
+    getOptions(): Viewer3DOptions;
+    patchOptions(next: Partial<Viewer3DOptions>): void;
+    getUrl(): string | null;
+    init(): void;
+    render(file?: File): Promise<PreparedViewerData | void>;
+    open(url: string): void;
+    destroy(): void;
+    private ensureInit;
+    _on<K extends SdkEventKey>(event: K, cb: (payload: SdkEventPayload<K>) => void): () => void;
+    _off<K extends SdkEventKey>(event: K, cb: (payload: SdkEventPayload<K>) => void): void;
+    _emit<K extends SdkEventKey>(event: K, payload: SdkEventPayload<K>): void;
+    postToViewer<TPayload = unknown>(type: ViewerMessageType, payload?: TPayload): void;
+    private handleMessage;
+}

package/dist/viewer.js

@@ -0,0 +1,277 @@
+// sdk/src/viewer.ts
+import { Emitter } from "./core/emitter";
+import { CameraModule } from "./modules/camera.module";
+import { InteractionModule } from "./modules/interaction.module";
+import { NodeModule } from "./modules/node.module";
+import { FilesModule } from "./modules/files.module";
+import { ToolbarModule } from "./modules/toolbar.module";
+import { ModelTreeModule } from "./modules/model-tree.module";
+import { MarkupModule } from "./modules/markup.module";
+import { LanguageModule } from "./modules/language.module";
+import { ViewerMessageType, ViewerMessageSource, } from "./contracts/messages";
+export class Viewer3D {
+    constructor(options) {
+        this.options = options;
+        this.containerEl = null;
+        this.iframeEl = null;
+        this.initialized = false;
+        this.emitter = new Emitter();
+        this.handleMessage = (event) => {
+            var _a, _b, _c, _d;
+            const data = event.data;
+            if (!data || typeof data !== "object")
+                return;
+            switch (data.type) {
+                case ViewerMessageType.HOME_CLICK:
+                    this._emit("camera:home", { timestamp: Date.now() });
+                    break;
+                case ViewerMessageType.NODE_SELECT:
+                    this._emit("node:select", { nodeId: String((_b = (_a = data.payload) === null || _a === void 0 ? void 0 : _a.nodeId) !== null && _b !== void 0 ? _b : ""), timestamp: Date.now() });
+                    break;
+                case ViewerMessageType.PAN_CHANGE:
+                    this._emit("interaction:pan-change", { enabled: Boolean((_c = data.payload) === null || _c === void 0 ? void 0 : _c.enabled) });
+                    break;
+                case ViewerMessageType.PDF_PLAN_MODE: {
+                    const payload = data.payload;
+                    this._emit("toolbar:pdf-plan-mode", {
+                        mode: "plan",
+                        timestamp: Number(payload === null || payload === void 0 ? void 0 : payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.PDF_DOCUMENT_MODE: {
+                    const payload = data.payload;
+                    this._emit("toolbar:pdf-document-mode", {
+                        mode: "document",
+                        timestamp: Number(payload === null || payload === void 0 ? void 0 : payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.PDF_FIRST_PAGE: {
+                    const payload = data.payload;
+                    this._emit("toolbar:pdf-first-page", {
+                        timestamp: Number(payload === null || payload === void 0 ? void 0 : payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.PDF_PREVIOUS_PAGE: {
+                    const payload = data.payload;
+                    this._emit("toolbar:pdf-previous-page", {
+                        timestamp: Number(payload === null || payload === void 0 ? void 0 : payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.PDF_NEXT_PAGE: {
+                    const payload = data.payload;
+                    this._emit("toolbar:pdf-next-page", {
+                        timestamp: Number(payload === null || payload === void 0 ? void 0 : payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.PDF_LAST_PAGE: {
+                    const payload = data.payload;
+                    this._emit("toolbar:pdf-last-page", {
+                        timestamp: Number(payload === null || payload === void 0 ? void 0 : payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.PDF_CURRENT_PAGE: {
+                    const payload = data.payload;
+                    if (!payload)
+                        break;
+                    this._emit("toolbar:pdf-current-page", {
+                        pageIndex: Number(payload.pageIndex) || 0,
+                        pageNumber: Number(payload.pageNumber) || 1,
+                        timestamp: Number(payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.TREE_NODE_IDS: {
+                    const payload = data.payload;
+                    if (!payload || !payload.requestId || !Array.isArray(payload.nodeIds))
+                        break;
+                    this._emit("modelTree:node-ids", {
+                        requestId: String(payload.requestId),
+                        nodeIds: payload.nodeIds.map(String),
+                        timestamp: Number(payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.SHEETS_LIST: {
+                    const payload = data.payload;
+                    if (!payload || !payload.requestId || !Array.isArray(payload.sheets))
+                        break;
+                    this._emit("sheets:list", {
+                        requestId: String(payload.requestId),
+                        sheets: payload.sheets.map((sheet) => {
+                            var _a;
+                            return ({
+                                id: sheet.id,
+                                name: String((_a = sheet.name) !== null && _a !== void 0 ? _a : ""),
+                                is3D: Boolean(sheet.is3D),
+                                viewId: sheet.viewId ? String(sheet.viewId) : undefined,
+                            });
+                        }),
+                        activeSheetId: (_d = payload.activeSheetId) !== null && _d !== void 0 ? _d : null,
+                        timestamp: Number(payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.MARKUP_LIST: {
+                    const payload = data.payload;
+                    if (!payload || !payload.requestId || !Array.isArray(payload.markups))
+                        break;
+                    this._emit("markup:list", {
+                        requestId: String(payload.requestId),
+                        markups: payload.markups.map((markup) => {
+                            var _a, _b;
+                            return ({
+                                id: String(markup.id),
+                                viewId: String(markup.viewId),
+                                viewName: markup.viewName ? String(markup.viewName) : undefined,
+                                title: String((_a = markup.title) !== null && _a !== void 0 ? _a : ""),
+                                type: String((_b = markup.type) !== null && _b !== void 0 ? _b : ""),
+                                shapeName: markup.shapeName ? String(markup.shapeName) : undefined,
+                                createdDate: markup.createdDate ? String(markup.createdDate) : undefined,
+                                modifiedDate: markup.modifiedDate ? String(markup.modifiedDate) : undefined,
+                                createdBy: markup.createdBy ? String(markup.createdBy) : undefined,
+                                lastModifiedBy: markup.lastModifiedBy ? String(markup.lastModifiedBy) : undefined,
+                            });
+                        }),
+                        timestamp: Number(payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.MARKUP_SAVE_RESULT: {
+                    const payload = data.payload;
+                    if (!payload || !payload.requestId)
+                        break;
+                    this._emit("markup:save", {
+                        requestId: String(payload.requestId),
+                        success: Boolean(payload.success),
+                        error: payload.error ? String(payload.error) : undefined,
+                        timestamp: Number(payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                case ViewerMessageType.MARKUP_CANCEL_RESULT: {
+                    const payload = data.payload;
+                    if (!payload || !payload.requestId)
+                        break;
+                    this._emit("markup:cancel", {
+                        requestId: String(payload.requestId),
+                        success: Boolean(payload.success),
+                        error: payload.error ? String(payload.error) : undefined,
+                        timestamp: Number(payload.timestamp) || Date.now(),
+                    });
+                    break;
+                }
+                default:
+                    break;
+            }
+        };
+        this.camera = new CameraModule(this);
+        this.interaction = new InteractionModule(this);
+        this.node = new NodeModule(this);
+        this.files = new FilesModule(this);
+        this.toolbar = new ToolbarModule(this);
+        this.modelTree = new ModelTreeModule(this);
+        this.markup = new MarkupModule(this);
+        this.language = new LanguageModule(this);
+    }
+    // ===== options helpers =====
+    getOptions() {
+        return this.options;
+    }
+    patchOptions(next) {
+        this.options = { ...this.options, ...next };
+    }
+    getUrl() {
+        var _a;
+        return (_a = this.options.url) !== null && _a !== void 0 ? _a : null;
+    }
+    // ===== lifecycle =====
+    init() {
+        if (this.initialized)
+            return;
+        this.containerEl =
+            typeof this.options.container === "string"
+                ? document.querySelector(this.options.container)
+                : this.options.container;
+        if (!this.containerEl)
+            throw new Error("Container element not found");
+        window.addEventListener("message", this.handleMessage);
+        this.initialized = true;
+    }
+    async render(file) {
+        this.ensureInit();
+        if (this.iframeEl)
+            return;
+        // If URL is missing, render falls back to files pipeline.
+        if (!this.options.url)
+            return this.files.render(file);
+        const iframe = document.createElement("iframe");
+        iframe.src = this.options.url;
+        iframe.style.border = "none";
+        iframe.style.width = this.options.width || "100%";
+        iframe.style.height = this.options.height || "100%";
+        iframe.width = this.options.width || "100%";
+        iframe.height = this.options.height || "100%";
+        if (this.options.sandbox)
+            iframe.setAttribute("sandbox", this.options.sandbox);
+        this.containerEl.appendChild(iframe);
+        this.iframeEl = iframe;
+    }
+    open(url) {
+        this.ensureInit();
+        this.options.url = url;
+        if (!this.iframeEl) {
+            this.render();
+            return;
+        }
+        this.iframeEl.src = url;
+    }
+    destroy() {
+        // remove listener using the same function reference
+        window.removeEventListener("message", this.handleMessage);
+        // remove iframe
+        if (this.iframeEl && this.containerEl) {
+            try {
+                this.containerEl.removeChild(this.iframeEl);
+            }
+            catch {
+                // ignore
+            }
+        }
+        this.iframeEl = null;
+        this.containerEl = null;
+        this.initialized = false;
+    }
+    ensureInit() {
+        if (!this.initialized)
+            throw new Error("Call viewer.init() before using viewer");
+    }
+    // ===== typed internal events used by modules =====
+    _on(event, cb) {
+        return this.emitter.on(event, cb);
+    }
+    _off(event, cb) {
+        this.emitter.off(event, cb);
+    }
+    _emit(event, payload) {
+        this.emitter.emit(event, payload);
+    }
+    // ===== postMessage bridge =====
+    postToViewer(type, payload) {
+        var _a;
+        if (!((_a = this.iframeEl) === null || _a === void 0 ? void 0 : _a.contentWindow))
+            return;
+        const message = {
+            source: ViewerMessageSource.SDK,
+            type,
+            payload,
+        };
+        const targetOrigin = this.options.allowedOrigin || "*";
+        this.iframeEl.contentWindow.postMessage(message, targetOrigin);
+    }
+}