@mindexec/cli 0.2.384 → 0.2.385

package/wwwroot/_content/MindExecution.Shared/js/mind-map-dev-guards.js

@@ -0,0 +1,325 @@
+(function () {
+    'use strict';
+
+    const DEV_GUARDS_BUILD_ID = '20260520-fullres-motion-optimization-v157';
+    const DEFAULT_TRACE_EVENT_LIMIT = 3000;
+    const STORAGE_KEYS = Object.freeze({
+        guardsEnabled: 'mindcanvas.devGuards.enabled',
+        guardsDisabled: 'mindcanvas.devGuards.disabled',
+        failFast: 'mindcanvas.devGuards.failFast',
+        traceEnabled: 'mindcanvas.trace.enabled',
+        traceConsole: 'mindcanvas.trace.console'
+    });
+
+    function readStorageBool(key) {
+        try {
+            const raw = localStorage.getItem(key);
+            if (raw == null) return null;
+            const normalized = String(raw).trim().toLowerCase();
+            if (normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on') {
+                return true;
+            }
+            if (normalized === '0' || normalized === 'false' || normalized === 'no' || normalized === 'off') {
+                return false;
+            }
+        } catch { }
+
+        return null;
+    }
+
+    function sanitizeDetails(value, depth = 0) {
+        if (depth >= 3) {
+            return '[MaxDepth]';
+        }
+
+        if (value == null) {
+            return value;
+        }
+
+        const valueType = typeof value;
+        if (valueType === 'string' || valueType === 'number' || valueType === 'boolean') {
+            return value;
+        }
+
+        if (valueType === 'bigint') {
+            return Number(value);
+        }
+
+        if (valueType === 'function') {
+            return `[Function:${value.name || 'anonymous'}]`;
+        }
+
+        if (value instanceof Error) {
+            return {
+                name: value.name,
+                message: value.message,
+                stack: value.stack
+            };
+        }
+
+        if (Array.isArray(value)) {
+            return value.slice(0, 20).map(item => sanitizeDetails(item, depth + 1));
+        }
+
+        if (value instanceof Set) {
+            return Array.from(value).slice(0, 20).map(item => sanitizeDetails(item, depth + 1));
+        }
+
+        if (value instanceof Map) {
+            const mapObject = {};
+            let index = 0;
+            for (const [key, entryValue] of value.entries()) {
+                if (index >= 20) {
+                    mapObject.__truncated__ = Math.max(0, value.size - 20);
+                    break;
+                }
+                mapObject[String(key)] = sanitizeDetails(entryValue, depth + 1);
+                index++;
+            }
+            return mapObject;
+        }
+
+        if (valueType === 'object') {
+            const clone = {};
+            const keys = Object.keys(value);
+            const limitedKeys = keys.slice(0, 32);
+            for (let i = 0; i < limitedKeys.length; i++) {
+                const key = limitedKeys[i];
+                try {
+                    clone[key] = sanitizeDetails(value[key], depth + 1);
+                } catch {
+                    clone[key] = '[Unreadable]';
+                }
+            }
+            if (keys.length > limitedKeys.length) {
+                clone.__truncatedKeys__ = keys.length - limitedKeys.length;
+            }
+            return clone;
+        }
+
+        return String(value);
+    }
+
+    function getCurrentHost() {
+        try {
+            return String(location?.hostname || '').trim().toLowerCase();
+        } catch {
+            return '';
+        }
+    }
+
+    const currentHost = getCurrentHost();
+    const isLocalHost =
+        currentHost === 'localhost' ||
+        currentHost === '127.0.0.1' ||
+        currentHost === '0.0.0.0';
+
+    const globalGuardsEnabled =
+        typeof window.MINDCANVAS_DEV_GUARDS === 'boolean'
+            ? window.MINDCANVAS_DEV_GUARDS
+            : null;
+    const storageGuardsEnabled = readStorageBool(STORAGE_KEYS.guardsEnabled);
+    const storageGuardsDisabled = readStorageBool(STORAGE_KEYS.guardsDisabled);
+    const guardsEnabled = globalGuardsEnabled === true ||
+        (globalGuardsEnabled !== false &&
+            storageGuardsDisabled !== true &&
+            (storageGuardsEnabled === true || isLocalHost));
+
+    const failFast =
+        window.MINDCANVAS_FAIL_FAST === true ||
+        readStorageBool(STORAGE_KEYS.failFast) === true;
+
+    const traceConsole =
+        window.MINDCANVAS_TRACE_CONSOLE === true ||
+        readStorageBool(STORAGE_KEYS.traceConsole) === true;
+
+    const traceEnabled =
+        guardsEnabled === true ||
+        window.MINDCANVAS_TRACE_ENABLED === true ||
+        readStorageBool(STORAGE_KEYS.traceEnabled) === true ||
+        traceConsole === true;
+
+    const buildInfo = window.MindCanvasBuildInfo || {
+        parts: {},
+        runtime: {},
+        registerPart(partName, version, details = {}) {
+            const normalizedPart = String(partName || '').trim();
+            if (!normalizedPart) return null;
+
+            const snapshot = {
+                version: String(version || ''),
+                loadedAt: new Date().toISOString(),
+                ...sanitizeDetails(details)
+            };
+
+            this.parts[normalizedPart] = snapshot;
+            return snapshot;
+        },
+        setRuntime(key, value) {
+            const normalizedKey = String(key || '').trim();
+            if (!normalizedKey) return null;
+
+            this.runtime[normalizedKey] = sanitizeDetails(value);
+            return this.runtime[normalizedKey];
+        },
+        validateRequiredParts(requiredParts) {
+            const missing = [];
+            const parts = Array.isArray(requiredParts) ? requiredParts : [];
+            for (let i = 0; i < parts.length; i++) {
+                const partName = String(parts[i] || '').trim();
+                if (!partName) continue;
+                if (!this.parts[partName]) {
+                    missing.push(partName);
+                }
+            }
+
+            if (missing.length > 0) {
+                console.warn('[MindCanvas BuildInfo] Missing required parts', {
+                    missing,
+                    registeredParts: Object.keys(this.parts || {})
+                });
+                return false;
+            }
+
+            return true;
+        },
+        dump() {
+            return {
+                parts: sanitizeDetails(this.parts),
+                runtime: sanitizeDetails(this.runtime)
+            };
+        }
+    };
+    window.MindCanvasBuildInfo = buildInfo;
+
+    const trace = window.MindCanvasTrace || {
+        enabled: traceEnabled === true,
+        consoleEnabled: traceConsole === true,
+        events: [],
+        maxEvents: DEFAULT_TRACE_EVENT_LIMIT,
+        emit(type, data = {}) {
+            if (this.enabled !== true && this.consoleEnabled !== true) {
+                return null;
+            }
+
+            const event = {
+                t: Number((typeof performance !== 'undefined' ? performance.now() : Date.now()).toFixed(3)),
+                type: String(type || 'unknown'),
+                ...sanitizeDetails(data)
+            };
+
+            this.events.push(event);
+            if (this.events.length > this.maxEvents) {
+                this.events.splice(0, this.events.length - this.maxEvents);
+            }
+
+            if (this.consoleEnabled === true) {
+                console.log('[MindCanvas Trace]', event);
+            }
+
+            return event;
+        },
+        dump() {
+            return this.events.slice();
+        },
+        clear() {
+            this.events.length = 0;
+        },
+        size() {
+            return this.events.length;
+        }
+    };
+    window.MindCanvasTrace = trace;
+
+    const guards = window.MindCanvasDevGuards || {
+        enabled: guardsEnabled === true,
+        failFast: failFast === true,
+        counts: {},
+        captureModuleState(module, details = {}) {
+            const activeBoardId = window.mindMap?.activeBoardId || null;
+            return {
+                boardId: activeBoardId,
+                phase: module?.canvasPhase || null,
+                isLoading: module?.isLoading === true,
+                isPanning: module?.isPanning === true,
+                isZooming: module?.isZooming === true,
+                isDraggingNode: module?.isDraggingNode === true,
+                isDraggingMultipleNodes: module?.isDraggingMultipleNodes === true,
+                forceUpdateFrames: Number(module?._forceUpdateFrames || 0),
+                ...sanitizeDetails(details)
+            };
+        },
+        _bump(name) {
+            const normalizedName = String(name || 'unknown').trim() || 'unknown';
+            this.counts[normalizedName] = Number(this.counts[normalizedName] || 0) + 1;
+            return this.counts[normalizedName];
+        },
+        assert(condition, name, details = {}) {
+            if (condition) {
+                return true;
+            }
+
+            const normalizedName = String(name || 'unknown').trim() || 'unknown';
+            this._bump(normalizedName);
+            const payload = sanitizeDetails(details);
+            trace.emit('guard.fail', {
+                name: normalizedName,
+                ...payload
+            });
+
+            const stack = new Error().stack;
+            console.error(`[MindCanvas invariant failed] ${normalizedName}`, payload, { stack });
+
+            if (this.failFast === true) {
+                throw new Error(`[MindCanvas invariant failed] ${normalizedName}`);
+            }
+
+            return false;
+        },
+        warn(name, details = {}) {
+            const normalizedName = String(name || 'unknown').trim() || 'unknown';
+            this._bump(normalizedName);
+            const payload = sanitizeDetails(details);
+            trace.emit('guard.warn', {
+                name: normalizedName,
+                ...payload
+            });
+            console.warn(`[MindCanvas guard warning] ${normalizedName}`, payload);
+            return false;
+        },
+        note(type, details = {}) {
+            trace.emit(type, sanitizeDetails(details));
+            return true;
+        },
+        getCounts() {
+            return { ...this.counts };
+        },
+        assertNoResidentFullRebuildDuringMotion(module, reason, details = {}) {
+            return this.assert(
+                !(module?.isPanning === true || module?.isZooming === true),
+                'no-full-resident-rebuild-during-motion',
+                this.captureModuleState(module, {
+                    reason,
+                    ...details
+                })
+            );
+        }
+    };
+    window.MindCanvasDevGuards = guards;
+
+    buildInfo.registerPart('devGuards', DEV_GUARDS_BUILD_ID, {
+        enabled: guards.enabled === true,
+        failFast: guards.failFast === true,
+        traceEnabled: trace.enabled === true,
+        host: currentHost || null
+    });
+
+    if (guards.enabled === true) {
+        console.log('[MindCanvasDevGuards] enabled', {
+            build: DEV_GUARDS_BUILD_ID,
+            failFast: guards.failFast === true,
+            traceEnabled: trace.enabled === true,
+            host: currentHost || null
+        });
+    }
+})();