@mlightcad/cad-editor 0.0.0-stage → 1.8.0-preview.0

package/dist/composable/useMemoryProfile.d.ts

@@ -0,0 +1,586 @@
+import { AcApMemorySnapshot, formatMemoryBytes } from '@mlightcad/cad-simple-viewer';
+export { formatMemoryBytes };
+export type { AcApMemorySnapshot };
+/**
+ * Stores a snapshot collected by {@link AcApMemCmd} for the palette to pick up.
+ */
+export declare function publishMemorySnapshot(snapshot: AcApMemorySnapshot): void;
+/**
+ * Takes any snapshot published by the MEM command (one-shot).
+ */
+export declare function takePublishedMemorySnapshot(): AcApMemorySnapshot | null;
+/**
+ * Collects and holds the current drawing memory snapshot for the Memory palette.
+ */
+export declare function useMemoryProfile(): {
+    snapshot: import('vue').Ref<{
+        collectedAt: number;
+        heap?: {
+            usedJSHeapSize: number;
+            totalJSHeapSize: number;
+            jsHeapSizeLimit: number;
+        } | undefined;
+        summary: {
+            id: string;
+            bytes: number;
+            isEstimated: boolean;
+            detail?: string | undefined;
+        }[];
+        geometry: {
+            scene: {
+                layouts: {
+                    layers: {
+                        summary: {
+                            entityCount: number;
+                            totalGeometrySize: number;
+                            totalMappingSize: number;
+                        };
+                        mesh: {
+                            indexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                            nonIndexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                        };
+                        line: {
+                            indexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                            nonIndexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                        };
+                        point: {
+                            indexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                            nonIndexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                        };
+                        unbatched: {
+                            count: number;
+                            geometrySize: number;
+                            byType: {
+                                line: number;
+                                mesh: number;
+                                point: number;
+                                other: number;
+                            };
+                        };
+                        name: string;
+                    }[];
+                    summary: {
+                        entityCount: number;
+                        totalSize: {
+                            line: number;
+                            mesh: number;
+                            point: number;
+                            unbatched: number;
+                            geometry: number;
+                            mapping: number;
+                            unbatchedCount: number;
+                            unbatchedByType: {
+                                line: number;
+                                mesh: number;
+                                point: number;
+                                other: number;
+                            };
+                        };
+                    };
+                }[];
+                summary: {
+                    layoutCount: number;
+                    entityCount: number;
+                    totalSize: {
+                        line: number;
+                        mesh: number;
+                        point: number;
+                        unbatched: number;
+                        geometry: number;
+                        mapping: number;
+                        unbatchedCount: number;
+                        unbatchedByType: {
+                            line: number;
+                            mesh: number;
+                            point: number;
+                            other: number;
+                        };
+                    };
+                };
+            };
+            layers: {
+                layoutKey: string;
+                layoutIndex: number;
+                layerName: string;
+                entityCount: number;
+                lineBytes: number;
+                meshBytes: number;
+                pointBytes: number;
+                unbatchedBytes: number;
+                geometryBytes: number;
+                mappingBytes: number;
+                unbatchedCount: number;
+            }[];
+        };
+        spatial: {
+            layouts: {
+                layoutKey: string;
+                stats: {
+                    kind: import('@mlightcad/cad-simple-viewer/lib/spatialIndex').AcTrSpatialIndexKind;
+                    itemCount: number;
+                    estimatedBytes: number;
+                    rootItemCount?: number | undefined;
+                    childIndexCount?: number | undefined;
+                    childItemCount?: number | undefined;
+                    rbushChildCount?: number | undefined;
+                    linearChildCount?: number | undefined;
+                };
+            }[];
+            totalEstimatedBytes: number;
+            totalRootItems: number;
+            totalChildItems: number;
+        };
+        dataModel: {
+            estimate: {
+                totalBytes: number;
+                objectCount: number;
+                entityCount: number;
+                byCategory: Record<string, import('@mlightcad/data-model').AcDbMemoryEstimateBucket>;
+                byEntityType: Record<string, import('@mlightcad/data-model').AcDbMemoryEstimateBucket>;
+            };
+            categories: {
+                name: string;
+                count: number;
+                estimatedBytes: number;
+            }[];
+            entitiesByType: {
+                name: string;
+                count: number;
+                estimatedBytes: number;
+            }[];
+            estimatedBytes: number;
+            entityCount: number;
+            objectCount: number;
+            isEstimated: true;
+        };
+        materials: {
+            point: {
+                count: number;
+                estimatedBytes: number;
+            };
+            line: {
+                count: number;
+                estimatedBytes: number;
+            };
+            fill: {
+                count: number;
+                estimatedBytes: number;
+            };
+            totalCount: number;
+            totalEstimatedBytes: number;
+        };
+        fonts: {
+            missedCount: number;
+            missedNames: string[];
+            estimatedBytes: number;
+            mainThreadBytes: number;
+            workerBytes: number;
+            loadedFontCount: number;
+            indexedDbBytes: number;
+            indexedDbFontCount: number;
+            fonts: {
+                name: string;
+                type: string;
+                estimatedBytes: number;
+            }[];
+            report?: {
+                collectedAt: number;
+                totalEstimatedBytes: number;
+                mainThread: {
+                    id: string;
+                    inFlightRequests?: number | undefined;
+                    fonts: {
+                        names: string[];
+                        type: "mesh" | "shx";
+                        sourceByteLength: number;
+                        parsedFontEstimatedBytes: number;
+                        charGeometryCache: {
+                            entries: number;
+                            maxEntries: number;
+                            estimatedBytes: number;
+                        };
+                        meshGlyphs?: {
+                            glyphCount: number;
+                            outlineStringBytes: number;
+                        } | undefined;
+                        shxLayoutCache?: {
+                            entries: number;
+                            maxEntries: number;
+                            estimatedBytes: number;
+                        } | undefined;
+                        estimatedBytes: number;
+                    }[];
+                    materials: {
+                        meshCount: number;
+                        lineCount: number;
+                        estimatedBytes: number;
+                    };
+                    totalEstimatedBytes: number;
+                };
+                workers: {
+                    id: string;
+                    inFlightRequests?: number | undefined;
+                    fonts: {
+                        names: string[];
+                        type: "mesh" | "shx";
+                        sourceByteLength: number;
+                        parsedFontEstimatedBytes: number;
+                        charGeometryCache: {
+                            entries: number;
+                            maxEntries: number;
+                            estimatedBytes: number;
+                        };
+                        meshGlyphs?: {
+                            glyphCount: number;
+                            outlineStringBytes: number;
+                        } | undefined;
+                        shxLayoutCache?: {
+                            entries: number;
+                            maxEntries: number;
+                            estimatedBytes: number;
+                        } | undefined;
+                        estimatedBytes: number;
+                    }[];
+                    materials: {
+                        meshCount: number;
+                        lineCount: number;
+                        estimatedBytes: number;
+                    };
+                    totalEstimatedBytes: number;
+                }[];
+                indexedDbFontCache: {
+                    fontCount: number;
+                    totalBytes: number;
+                    fonts: {
+                        name: string;
+                        type: string;
+                        bytes: number;
+                    }[];
+                };
+                jsHeap?: {
+                    usedJSHeapSize: number;
+                    totalJSHeapSize: number;
+                    jsHeapSizeLimit: number;
+                } | undefined;
+            } | undefined;
+            isEstimated: true;
+        };
+    } | null, AcApMemorySnapshot | {
+        collectedAt: number;
+        heap?: {
+            usedJSHeapSize: number;
+            totalJSHeapSize: number;
+            jsHeapSizeLimit: number;
+        } | undefined;
+        summary: {
+            id: string;
+            bytes: number;
+            isEstimated: boolean;
+            detail?: string | undefined;
+        }[];
+        geometry: {
+            scene: {
+                layouts: {
+                    layers: {
+                        summary: {
+                            entityCount: number;
+                            totalGeometrySize: number;
+                            totalMappingSize: number;
+                        };
+                        mesh: {
+                            indexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                            nonIndexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                        };
+                        line: {
+                            indexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                            nonIndexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                        };
+                        point: {
+                            indexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                            nonIndexed: {
+                                count: number;
+                                geometrySize: number;
+                                mappingSize: number;
+                            };
+                        };
+                        unbatched: {
+                            count: number;
+                            geometrySize: number;
+                            byType: {
+                                line: number;
+                                mesh: number;
+                                point: number;
+                                other: number;
+                            };
+                        };
+                        name: string;
+                    }[];
+                    summary: {
+                        entityCount: number;
+                        totalSize: {
+                            line: number;
+                            mesh: number;
+                            point: number;
+                            unbatched: number;
+                            geometry: number;
+                            mapping: number;
+                            unbatchedCount: number;
+                            unbatchedByType: {
+                                line: number;
+                                mesh: number;
+                                point: number;
+                                other: number;
+                            };
+                        };
+                    };
+                }[];
+                summary: {
+                    layoutCount: number;
+                    entityCount: number;
+                    totalSize: {
+                        line: number;
+                        mesh: number;
+                        point: number;
+                        unbatched: number;
+                        geometry: number;
+                        mapping: number;
+                        unbatchedCount: number;
+                        unbatchedByType: {
+                            line: number;
+                            mesh: number;
+                            point: number;
+                            other: number;
+                        };
+                    };
+                };
+            };
+            layers: {
+                layoutKey: string;
+                layoutIndex: number;
+                layerName: string;
+                entityCount: number;
+                lineBytes: number;
+                meshBytes: number;
+                pointBytes: number;
+                unbatchedBytes: number;
+                geometryBytes: number;
+                mappingBytes: number;
+                unbatchedCount: number;
+            }[];
+        };
+        spatial: {
+            layouts: {
+                layoutKey: string;
+                stats: {
+                    kind: import('@mlightcad/cad-simple-viewer/lib/spatialIndex').AcTrSpatialIndexKind;
+                    itemCount: number;
+                    estimatedBytes: number;
+                    rootItemCount?: number | undefined;
+                    childIndexCount?: number | undefined;
+                    childItemCount?: number | undefined;
+                    rbushChildCount?: number | undefined;
+                    linearChildCount?: number | undefined;
+                };
+            }[];
+            totalEstimatedBytes: number;
+            totalRootItems: number;
+            totalChildItems: number;
+        };
+        dataModel: {
+            estimate: {
+                totalBytes: number;
+                objectCount: number;
+                entityCount: number;
+                byCategory: Record<string, import('@mlightcad/data-model').AcDbMemoryEstimateBucket>;
+                byEntityType: Record<string, import('@mlightcad/data-model').AcDbMemoryEstimateBucket>;
+            };
+            categories: {
+                name: string;
+                count: number;
+                estimatedBytes: number;
+            }[];
+            entitiesByType: {
+                name: string;
+                count: number;
+                estimatedBytes: number;
+            }[];
+            estimatedBytes: number;
+            entityCount: number;
+            objectCount: number;
+            isEstimated: true;
+        };
+        materials: {
+            point: {
+                count: number;
+                estimatedBytes: number;
+            };
+            line: {
+                count: number;
+                estimatedBytes: number;
+            };
+            fill: {
+                count: number;
+                estimatedBytes: number;
+            };
+            totalCount: number;
+            totalEstimatedBytes: number;
+        };
+        fonts: {
+            missedCount: number;
+            missedNames: string[];
+            estimatedBytes: number;
+            mainThreadBytes: number;
+            workerBytes: number;
+            loadedFontCount: number;
+            indexedDbBytes: number;
+            indexedDbFontCount: number;
+            fonts: {
+                name: string;
+                type: string;
+                estimatedBytes: number;
+            }[];
+            report?: {
+                collectedAt: number;
+                totalEstimatedBytes: number;
+                mainThread: {
+                    id: string;
+                    inFlightRequests?: number | undefined;
+                    fonts: {
+                        names: string[];
+                        type: "mesh" | "shx";
+                        sourceByteLength: number;
+                        parsedFontEstimatedBytes: number;
+                        charGeometryCache: {
+                            entries: number;
+                            maxEntries: number;
+                            estimatedBytes: number;
+                        };
+                        meshGlyphs?: {
+                            glyphCount: number;
+                            outlineStringBytes: number;
+                        } | undefined;
+                        shxLayoutCache?: {
+                            entries: number;
+                            maxEntries: number;
+                            estimatedBytes: number;
+                        } | undefined;
+                        estimatedBytes: number;
+                    }[];
+                    materials: {
+                        meshCount: number;
+                        lineCount: number;
+                        estimatedBytes: number;
+                    };
+                    totalEstimatedBytes: number;
+                };
+                workers: {
+                    id: string;
+                    inFlightRequests?: number | undefined;
+                    fonts: {
+                        names: string[];
+                        type: "mesh" | "shx";
+                        sourceByteLength: number;
+                        parsedFontEstimatedBytes: number;
+                        charGeometryCache: {
+                            entries: number;
+                            maxEntries: number;
+                            estimatedBytes: number;
+                        };
+                        meshGlyphs?: {
+                            glyphCount: number;
+                            outlineStringBytes: number;
+                        } | undefined;
+                        shxLayoutCache?: {
+                            entries: number;
+                            maxEntries: number;
+                            estimatedBytes: number;
+                        } | undefined;
+                        estimatedBytes: number;
+                    }[];
+                    materials: {
+                        meshCount: number;
+                        lineCount: number;
+                        estimatedBytes: number;
+                    };
+                    totalEstimatedBytes: number;
+                }[];
+                indexedDbFontCache: {
+                    fontCount: number;
+                    totalBytes: number;
+                    fonts: {
+                        name: string;
+                        type: string;
+                        bytes: number;
+                    }[];
+                };
+                jsHeap?: {
+                    usedJSHeapSize: number;
+                    totalJSHeapSize: number;
+                    jsHeapSizeLimit: number;
+                } | undefined;
+            } | undefined;
+            isEstimated: true;
+        };
+    } | null>;
+    loading: import('vue').Ref<boolean, boolean>;
+    error: import('vue').Ref<string | null, string | null>;
+    collectedAtLabel: import('vue').ComputedRef<string>;
+    summaryRows: import('vue').ComputedRef<{
+        id: string;
+        bytes: number;
+        isEstimated: boolean;
+        detail?: string | undefined;
+    }[]>;
+    maxSummaryBytes: import('vue').ComputedRef<number>;
+    fileName: Readonly<import('vue').Ref<string, string>>;
+    docTitle: Readonly<import('vue').Ref<string, string>>;
+    refresh: () => Promise<void>;
+    adoptPublishedSnapshot: () => boolean;
+    hydrateOrRefresh: () => Promise<void>;
+    formatMemoryBytes: typeof formatMemoryBytes;
+};
+//# sourceMappingURL=useMemoryProfile.d.ts.map

package/dist/composable/useMemoryProfile.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMemoryProfile.d.ts","sourceRoot":"","sources":["../../src/composable/useMemoryProfile.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,kBAAkB,EAEvB,iBAAiB,EAClB,MAAM,8BAA8B,CAAA;AAMrC,OAAO,EAAE,iBAAiB,EAAE,CAAA;AAC5B,YAAY,EAAE,kBAAkB,EAAE,CAAA;AAKlC;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,kBAAkB,GAAG,IAAI,CAExE;AAED;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,kBAAkB,GAAG,IAAI,CAIvE;AAED;;GAEG;AACH,wBAAgB,gBAAgB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kCAmCK,OAAO;;;EA+C3C"}

package/dist/composable/useMissedData.d.ts

@@ -0,0 +1,59 @@
+import { AcDbObjectId } from '@mlightcad/data-model';
+/**
+ * Missed Data Composable
+ *
+ * Tracks fonts, raster images, and unresolved xrefs that the current drawing
+ * references but that are missing. State is shared module-wide so every caller
+ * sees the same reactive maps (status-bar warning, Resources palette).
+ */
+/**
+ * One unresolved external reference reported by the viewer.
+ */
+export interface MissedXrefInfo {
+    name: string;
+    pathName: string;
+    isOverlay: boolean;
+}
+/**
+ * One row in the missed-image replacement table.
+ */
+export interface ImageMappingData {
+    /** File name reported by the viewer for the missing image resource. */
+    fileName: string;
+    /**
+     * User-selected replacement file, set by the replacement dialog before confirm.
+     * Undefined until the user picks a file.
+     */
+    file?: File;
+    /**
+     * File name of the replacement {@link file} (browsers do not expose absolute paths).
+     */
+    filePath?: string;
+    /** Entity object IDs whose raster image reference resolves to {@link fileName}. */
+    ids: Set<AcDbObjectId>;
+}
+/**
+ * Loaded overlay state keyed by xref block name.
+ */
+export interface XrefOverlayState {
+    overlayId: string;
+    visible: boolean;
+    /** File name of the loaded source. */
+    sourceName: string;
+}
+/**
+ * Reactive state returned by {@link useMissedData}.
+ */
+export interface UseMissedDataReturn {
+    fonts: Map<string, string>;
+    images: Map<string, ImageMappingData>;
+    /** Unresolved xrefs from the active drawing */
+    xrefs: MissedXrefInfo[];
+    /** Overlay load state per xref block name */
+    xrefOverlays: Map<string, XrefOverlayState>;
+}
+/**
+ * Access shared reactive state for missing fonts, images, and xrefs.
+ */
+export declare function useMissedData(): UseMissedDataReturn;
+//# sourceMappingURL=useMissedData.d.ts.map

package/dist/composable/useMissedData.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMissedData.d.ts","sourceRoot":"","sources":["../../src/composable/useMissedData.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAGpD;;;;;;GAMG;AAEH;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,OAAO,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,uEAAuE;IACvE,QAAQ,EAAE,MAAM,CAAA;IAChB;;;OAGG;IACH,IAAI,CAAC,EAAE,IAAI,CAAA;IACX;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,mFAAmF;IACnF,GAAG,EAAE,GAAG,CAAC,YAAY,CAAC,CAAA;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,SAAS,EAAE,MAAM,CAAA;IACjB,OAAO,EAAE,OAAO,CAAA;IAChB,sCAAsC;IACtC,UAAU,EAAE,MAAM,CAAA;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC1B,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;IACrC,+CAA+C;IAC/C,KAAK,EAAE,cAAc,EAAE,CAAA;IACvB,6CAA6C;IAC7C,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAAA;CAC5C;AAyID;;GAEG;AACH,wBAAgB,aAAa,IAAI,mBAAmB,CASnD"}

package/dist/composable/useNotificationCenter.d.ts

@@ -0,0 +1,43 @@
+import { AcApNotification, AcApNotificationAction, AcApNotificationGroup, AcApNotificationSource } from '@mlightcad/cad-simple-viewer';
+/**
+ * @deprecated Prefer {@link AcApNotificationSource} from cad-simple-viewer.
+ */
+export type NotificationSource = AcApNotificationSource;
+/** @deprecated Prefer {@link ACAP_GROUPABLE_NOTIFICATION_SOURCES}. */
+export declare const GROUPABLE_NOTIFICATION_SOURCES: readonly AcApNotificationSource[];
+/**
+ * Vue notification entry. Structurally compatible with {@link AcApNotification}.
+ */
+export type Notification = AcApNotification;
+export type NotificationGroup = AcApNotificationGroup;
+export type NotificationAction = AcApNotificationAction;
+/**
+ * Groups notifications for the Vue notification center panel.
+ */
+export declare function groupNotifications(notifications: Notification[]): NotificationGroup[];
+/**
+ * Composable that exposes the Vue notification center used by cad-viewer UI.
+ *
+ * Registered as the host override via {@link registerCadViewerNotificationCenter}
+ * so the shared cad-simple-viewer event bridge writes into this store.
+ */
+export declare function useNotificationCenter(): {
+    notifications: import('vue').ComputedRef<AcApNotification[]>;
+    unreadCount: import('vue').ComputedRef<number>;
+    hasNotifications: import('vue').ComputedRef<boolean>;
+    setActiveSession: (sessionId: string | null) => void;
+    clearSession: (sessionId: string) => void;
+    dispose: () => void;
+    add: (notification: Omit<Notification, "id" | "timestamp">) => string;
+    remove: (id: string) => void;
+    clear: () => void;
+    clearAll: () => void;
+    removeWhere: (predicate: (notification: Notification) => boolean) => void;
+    removeBySource: (source: NotificationSource) => void;
+    removeResolvedFontMissedNotifications: (missedFontNames: Iterable<string>) => void;
+    info: (title: string, message?: string, options?: Partial<Notification>) => string;
+    warning: (title: string, message?: string, options?: Partial<Notification>) => string;
+    error: (title: string, message?: string, options?: Partial<Notification>) => string;
+    success: (title: string, message?: string, options?: Partial<Notification>) => string;
+};
+//# sourceMappingURL=useNotificationCenter.d.ts.map