noteconnection 1.6.8 → 1.8.0

package/dist/src/frontend/godot_tree_interactions.js

@@ -0,0 +1,178 @@
+(function () {
+    const CLICK_DRAG_THRESHOLD = 6;
+    const LONG_PRESS_DURATION_MS = 650;
+
+    function normalizeText(value) {
+        return String(value == null ? '' : value).replace(/\s+/g, ' ').trim();
+    }
+
+    function closestNode(target) {
+        return target && typeof target.closest === 'function'
+            ? target.closest('[data-godot-tree-node-id], [data-agent-future-path-node-id]')
+            : null;
+    }
+
+    function readNodeId(nodeElement) {
+        return normalizeText(
+            nodeElement
+            && (
+                nodeElement.getAttribute('data-agent-future-path-node-id')
+                || nodeElement.getAttribute('data-godot-tree-node-id')
+            )
+        );
+    }
+
+    function isSpineNode(nodeElement) {
+        return nodeElement && (
+            nodeElement.getAttribute('data-agent-future-path-node-spine') === 'true'
+            || nodeElement.getAttribute('data-godot-tree-node-spine') === 'true'
+        );
+    }
+
+    function isExpandedNode(nodeElement) {
+        return nodeElement && (
+            nodeElement.getAttribute('data-agent-future-path-node-expanded') === 'true'
+            || nodeElement.getAttribute('data-godot-tree-node-expanded') === 'true'
+        );
+    }
+
+    function canTogglePrerequisites(nodeElement) {
+        return isSpineNode(nodeElement);
+    }
+
+    function emit(callbacks, name, nodeId, event) {
+        const callback = callbacks && callbacks[name];
+        if (typeof callback !== 'function') {
+            return false;
+        }
+        callback(nodeId, event);
+        return true;
+    }
+
+    function emitExpansionSignal(nodeElement, callbacks, event) {
+        if (!canTogglePrerequisites(nodeElement)) {
+            return false;
+        }
+        const nodeId = readNodeId(nodeElement);
+        if (!nodeId) {
+            return false;
+        }
+        return isExpandedNode(nodeElement)
+            ? emit(callbacks, 'nodeCollapsePrereqsRequested', nodeId, event)
+            : emit(callbacks, 'nodeExpandPrereqsRequested', nodeId, event);
+    }
+
+    function bindTreeRenderer(root, callbacks) {
+        if (!root || typeof root.querySelectorAll !== 'function') {
+            return;
+        }
+        let longPressState = null;
+        let longPressTimer = null;
+        let suppressClickNodeId = '';
+
+        const clearLongPress = function () {
+            if (longPressTimer) {
+                clearTimeout(longPressTimer);
+                longPressTimer = null;
+            }
+            longPressState = null;
+        };
+
+        root.querySelectorAll('[data-godot-tree-node-id], [data-agent-future-path-node-id]').forEach((nodeElement) => {
+            nodeElement.addEventListener('mousedown', function (event) {
+                if (event.button !== 0) {
+                    return;
+                }
+                const nodeId = readNodeId(nodeElement);
+                if (!nodeId) {
+                    return;
+                }
+                clearLongPress();
+                longPressState = {
+                    nodeId,
+                    clientX: Number(event.clientX) || 0,
+                    clientY: Number(event.clientY) || 0,
+                };
+                longPressTimer = setTimeout(function () {
+                    if (!longPressState || longPressState.nodeId !== nodeId) {
+                        return;
+                    }
+                    suppressClickNodeId = nodeId;
+                    emit(callbacks, 'nodeNavigateRequested', nodeId, event);
+                    clearLongPress();
+                }, LONG_PRESS_DURATION_MS);
+            });
+
+            nodeElement.addEventListener('mouseup', function (event) {
+                if (!longPressState) {
+                    return;
+                }
+                const dx = (Number(event.clientX) || 0) - longPressState.clientX;
+                const dy = (Number(event.clientY) || 0) - longPressState.clientY;
+                if (Math.sqrt((dx * dx) + (dy * dy)) > CLICK_DRAG_THRESHOLD) {
+                    clearLongPress();
+                    return;
+                }
+                clearLongPress();
+            });
+
+            nodeElement.addEventListener('click', function (event) {
+                const nodeId = readNodeId(nodeElement);
+                if (!nodeId || event.detail > 1) {
+                    return;
+                }
+                if (suppressClickNodeId === nodeId) {
+                    suppressClickNodeId = '';
+                    event.preventDefault();
+                    event.stopPropagation();
+                    return;
+                }
+                emit(callbacks, 'nodeClicked', nodeId, event);
+            });
+
+            nodeElement.addEventListener('dblclick', function (event) {
+                event.preventDefault();
+                event.stopPropagation();
+                clearLongPress();
+                if (emit(callbacks, 'nodeReaderRequested', readNodeId(nodeElement), event)) {
+                    return;
+                }
+                emitExpansionSignal(nodeElement, callbacks, event);
+            });
+
+            nodeElement.addEventListener('contextmenu', function (event) {
+                event.preventDefault();
+                event.stopPropagation();
+                clearLongPress();
+                emitExpansionSignal(nodeElement, callbacks, event);
+            });
+        });
+
+        const viewport = root.querySelector('[data-godot-tree-viewport="true"]') || root;
+        viewport.addEventListener('mousedown', function (event) {
+            if (event.button !== 1) {
+                return;
+            }
+            event.preventDefault();
+            event.stopPropagation();
+            clearLongPress();
+            const nodeElement = closestNode(event.target);
+            if (nodeElement) {
+                return;
+            }
+            emit(callbacks, 'collapseAllRequested', '', event);
+        });
+    }
+
+    window.NoteConnectionGodotTreeInteractions = {
+        bindTreeRenderer,
+        resolveExpansionSignal: function (nodeElement) {
+            if (!canTogglePrerequisites(nodeElement)) {
+                return '';
+            }
+            return isExpandedNode(nodeElement)
+                ? 'node_collapse_prereqs_requested'
+                : 'node_expand_prereqs_requested';
+        },
+    };
+}());

package/dist/src/frontend/graph_state.mjs

@@ -0,0 +1,105 @@
+/**
+ * graph_state.mjs — Extracted graph visualization state management.
+ * Manages focus mode, layout mode, semantic accessibility, and platform detection.
+ * Formerly inline in app.js.
+ */
+
+/** Resolve the runtime platform from capabilities, navigator, and Capacitor. */
+export function resolveRuntimePlatform(runtimeCaps) {
+    const rawPlatform = runtimeCaps && typeof runtimeCaps.platform === 'string'
+        ? runtimeCaps.platform.trim().toLowerCase()
+        : '';
+
+    if (rawPlatform.includes('android')) return 'android';
+    if (rawPlatform.includes('ios')) return 'ios';
+    if (rawPlatform.includes('windows') || rawPlatform === 'win32') return 'windows';
+    if (rawPlatform.includes('macos') || rawPlatform.includes('darwin') || rawPlatform === 'mac') return 'macos';
+    if (rawPlatform.includes('linux')) return 'linux';
+    if (rawPlatform.includes('web')) return 'web';
+
+    if (typeof navigator !== 'undefined' && typeof navigator.userAgent === 'string') {
+        const ua = navigator.userAgent;
+        if (/Android/i.test(ua)) return 'android';
+        if (/iPhone|iPad|iPod/i.test(ua)) return 'ios';
+        if (/Windows/i.test(ua)) return 'windows';
+        if (/Macintosh|Mac OS X/i.test(ua)) return 'macos';
+        if (/Linux/i.test(ua)) return 'linux';
+    }
+
+    if (typeof window !== 'undefined' && window.Capacitor && typeof window.Capacitor.getPlatform === 'function') {
+        try {
+            const capPlatform = String(window.Capacitor.getPlatform() || '').toLowerCase();
+            if (capPlatform === 'android') return 'android';
+            if (capPlatform === 'ios') return 'ios';
+            if (capPlatform === 'web') return 'web';
+        } catch (_err) { /* ignore */ }
+    }
+
+    return 'web';
+}
+
+/** Create the graph semantic accessibility state. */
+export function createGraphA11yState() {
+    return {
+        lastSummaryKey: '',
+        lastAnnouncementAt: 0,
+        pendingReason: '',
+        pendingTimer: null,
+    };
+}
+
+/** Focus mode state for the graph visualization. */
+export function createFocusState() {
+    return {
+        nodeId: null,
+        frozen: false,
+        verticalSpacing: 120,
+        horizontalSpacing: 180,
+    };
+}
+
+/** Layout mode for the graph. */
+export const LAYOUT_MODES = {
+    FORCE: 'force',
+    DAG: 'dag',
+};
+
+/** Read the startup performance profile override from localStorage. */
+export function readStartupPerfProfile() {
+    if (typeof localStorage === 'undefined') return '';
+    try {
+        const value = localStorage.getItem('nc.startupPerfProfile');
+        return typeof value === 'string' ? value.trim() : '';
+    } catch (_err) {
+        return '';
+    }
+}
+
+/** Get the rendering engine preference. */
+export function getRenderEnginePreference(nodeCount) {
+    // Auto-switch to Canvas above 3000 nodes
+    const savedPref = typeof localStorage !== 'undefined'
+        ? localStorage.getItem('nc.renderEngine')
+        : null;
+    if (savedPref === 'svg' || savedPref === 'canvas') return savedPref;
+    return nodeCount > 3000 ? 'canvas' : 'svg';
+}
+
+/** Performance timestamp helper. */
+export function nowMs() {
+    return (typeof performance !== 'undefined' && typeof performance.now === 'function')
+        ? performance.now()
+        : Date.now();
+}
+
+/** Build a diagnostic summary of the graph state. */
+export function getGraphDiagnostics(state) {
+    return {
+        layoutMode: state.layoutMode || 'force',
+        renderEngine: state.renderEngine || 'svg',
+        focusNodeId: state.focusNodeId || null,
+        nodeCount: state.nodes ? state.nodes.length : 0,
+        edgeCount: state.edges ? state.edges.length : 0,
+        platform: state.platform || 'unknown',
+    };
+}

package/dist/src/frontend/hosted_future_path_runtime.js

@@ -0,0 +1,157 @@
+(function () {
+    function getNow() {
+        if (typeof performance !== 'undefined' && performance && typeof performance.now === 'function') {
+            return performance.now();
+        }
+        return Date.now();
+    }
+
+    function cloneDiagnostics(source) {
+        if (!source || typeof source !== 'object') {
+            return null;
+        }
+        return JSON.parse(JSON.stringify(source));
+    }
+
+    function createRuntimeCacheManager(options) {
+        const createRuntime = options && typeof options.createRuntime === 'function'
+            ? options.createRuntime
+            : null;
+        const buildSignature = options && typeof options.buildSignature === 'function'
+            ? options.buildSignature
+            : null;
+        const readStats = options && typeof options.readStats === 'function'
+            ? options.readStats
+            : null;
+        const label = options && typeof options.label === 'string'
+            ? options.label.trim()
+            : 'hosted-future-path-runtime';
+        let cacheEntry = null;
+        let lastDiagnostics = null;
+        const aggregate = {
+            cacheHitCount: 0,
+            cacheMissCount: 0,
+            runtimeBuildCount: 0,
+            lastCacheState: 'empty',
+            lastSignature: '',
+            lastResolveMs: 0,
+            lastBuildMs: 0,
+        };
+
+        function buildDiagnosticsBase(sourceData, signature) {
+            const stats = readStats ? readStats(sourceData) : {};
+            return {
+                cacheLabel: label,
+                signature: String(signature || ''),
+                sourceNodeCount: Number.isFinite(Number(stats && stats.nodeCount))
+                    ? Number(stats.nodeCount)
+                    : 0,
+                sourceEdgeCount: Number.isFinite(Number(stats && stats.edgeCount))
+                    ? Number(stats.edgeCount)
+                    : 0,
+                cacheHit: false,
+                cacheMiss: false,
+                cacheState: cacheEntry ? 'warm' : 'cold',
+                runtimeBuildCount: Number(aggregate.runtimeBuildCount || 0),
+                cacheHitCount: Number(aggregate.cacheHitCount || 0),
+                cacheMissCount: Number(aggregate.cacheMissCount || 0),
+                resolveMs: 0,
+                buildMs: 0,
+                reason: '',
+            };
+        }
+
+        return {
+            resolve: function (sourceData) {
+                const resolveStartedAt = getNow();
+                const signature = buildSignature ? buildSignature(sourceData) : '';
+                const diagnostics = buildDiagnosticsBase(sourceData, signature);
+                if (
+                    cacheEntry
+                    && cacheEntry.sourceData === sourceData
+                    && cacheEntry.signature === signature
+                ) {
+                    aggregate.cacheHitCount += 1;
+                    aggregate.lastCacheState = 'hit';
+                    diagnostics.cacheHit = true;
+                    diagnostics.cacheState = 'hit';
+                    diagnostics.cacheHitCount = Number(aggregate.cacheHitCount || 0);
+                    diagnostics.cacheMissCount = Number(aggregate.cacheMissCount || 0);
+                    diagnostics.runtimeBuildCount = Number(aggregate.runtimeBuildCount || 0);
+                    diagnostics.resolveMs = Number((getNow() - resolveStartedAt).toFixed(3));
+                    diagnostics.buildMs = 0;
+                    diagnostics.reason = 'runtime_reused';
+                    aggregate.lastResolveMs = diagnostics.resolveMs;
+                    aggregate.lastBuildMs = 0;
+                    aggregate.lastSignature = diagnostics.signature;
+                    lastDiagnostics = diagnostics;
+                    return {
+                        runtime: cacheEntry.runtime,
+                        diagnostics: cloneDiagnostics(diagnostics),
+                    };
+                }
+
+                aggregate.cacheMissCount += 1;
+                aggregate.lastCacheState = cacheEntry ? 'miss_rebuild' : 'miss_cold';
+                diagnostics.cacheMiss = true;
+                diagnostics.cacheState = cacheEntry ? 'miss_rebuild' : 'miss_cold';
+                diagnostics.cacheHitCount = Number(aggregate.cacheHitCount || 0);
+                diagnostics.cacheMissCount = Number(aggregate.cacheMissCount || 0);
+
+                const buildStartedAt = getNow();
+                const runtime = createRuntime ? createRuntime(sourceData) : null;
+                diagnostics.buildMs = Number((getNow() - buildStartedAt).toFixed(3));
+                diagnostics.resolveMs = Number((getNow() - resolveStartedAt).toFixed(3));
+                aggregate.lastResolveMs = diagnostics.resolveMs;
+                aggregate.lastBuildMs = diagnostics.buildMs;
+                aggregate.lastSignature = diagnostics.signature;
+                if (runtime) {
+                    aggregate.runtimeBuildCount += 1;
+                    diagnostics.runtimeBuildCount = Number(aggregate.runtimeBuildCount || 0);
+                    cacheEntry = {
+                        sourceData,
+                        signature,
+                        runtime,
+                    };
+                    diagnostics.reason = cacheEntry && cacheEntry.runtime ? 'runtime_ready' : '';
+                } else {
+                    diagnostics.runtimeBuildCount = Number(aggregate.runtimeBuildCount || 0);
+                    diagnostics.reason = 'runtime_unavailable';
+                    cacheEntry = null;
+                }
+                lastDiagnostics = diagnostics;
+                return {
+                    runtime,
+                    diagnostics: cloneDiagnostics(diagnostics),
+                };
+            },
+            clear: function () {
+                cacheEntry = null;
+                aggregate.lastCacheState = 'cleared';
+                aggregate.lastSignature = '';
+                aggregate.lastResolveMs = 0;
+                aggregate.lastBuildMs = 0;
+                lastDiagnostics = null;
+            },
+            getDiagnostics: function () {
+                return cloneDiagnostics(lastDiagnostics);
+            },
+            getAggregateSnapshot: function () {
+                return cloneDiagnostics({
+                    cacheLabel: label,
+                    cacheHitCount: Number(aggregate.cacheHitCount || 0),
+                    cacheMissCount: Number(aggregate.cacheMissCount || 0),
+                    runtimeBuildCount: Number(aggregate.runtimeBuildCount || 0),
+                    lastCacheState: String(aggregate.lastCacheState || ''),
+                    lastSignature: String(aggregate.lastSignature || ''),
+                    lastResolveMs: Number(aggregate.lastResolveMs || 0),
+                    lastBuildMs: Number(aggregate.lastBuildMs || 0),
+                });
+            },
+        };
+    }
+
+    window.NoteConnectionHostedFuturePathRuntime = {
+        createRuntimeCacheManager,
+    };
+}());

package/dist/src/frontend/i18n.mjs

@@ -0,0 +1,186 @@
+/**
+ * i18n.mjs - ES Module version of Internationalization Manager
+ * Replaces window.i18n global with proper module exports.
+ * A thin backward-compat shim in i18n.js re-exports through window for legacy code.
+ */
+
+class I18nManager {
+    constructor() {
+        this.tauriSyncStorageKey = 'nc_tauri_lang_synced';
+        this.currentLanguage = 'en';
+        this.translations = {};
+        this.fallbackLanguage = 'en';
+        this.supportedLanguages = ['en', 'zh'];
+        this.listeners = [];
+        this.isInitialized = false;
+        this.lastSyncedLanguage = null;
+
+        try {
+            this.lastSyncedLanguage = sessionStorage.getItem(this.tauriSyncStorageKey);
+        } catch (_e) {
+            this.lastSyncedLanguage = null;
+        }
+    }
+
+    async init() {
+        const savedLang = localStorage.getItem('user_language');
+        let tauriLang = null;
+
+        if (window.__TAURI__) {
+            try {
+                tauriLang = await window.__TAURI__.core.invoke('get_user_language');
+            } catch (error) {
+                console.warn('[i18n] Failed to read language from Tauri backend:', error);
+            }
+        }
+
+        let detectedLang = savedLang || tauriLang || this.detectBrowserLanguage() || 'en';
+
+        if (!this.supportedLanguages.includes(detectedLang)) {
+            detectedLang = this.fallbackLanguage;
+        }
+
+        await this.setLanguage(detectedLang);
+        console.log(`[i18n] Initialized with language: ${this.currentLanguage}`);
+    }
+
+    detectBrowserLanguage() {
+        const browserLang = navigator.language || navigator.userLanguage;
+        if (!browserLang) return null;
+        const langCode = browserLang.split('-')[0].toLowerCase();
+        return this.supportedLanguages.includes(langCode) ? langCode : null;
+    }
+
+    async setLanguage(lang) {
+        if (!this.supportedLanguages.includes(lang)) {
+            console.warn(`[i18n] Unsupported language: ${lang}, falling back to ${this.fallbackLanguage}`);
+            lang = this.fallbackLanguage;
+        }
+
+        if (this.isInitialized && this.currentLanguage === lang) {
+            return;
+        }
+
+        try {
+            const response = await fetch(`locales/${lang}.json`);
+            if (!response.ok) {
+                throw new Error(`Failed to load locale file: ${lang}.json`);
+            }
+
+            this.translations = await response.json();
+            this.currentLanguage = lang;
+            localStorage.setItem('user_language', lang);
+            this.isInitialized = true;
+            this.notifyListeners(lang);
+
+            if (window.__TAURI__) {
+                let syncedInSession = null;
+                try { syncedInSession = sessionStorage.getItem(this.tauriSyncStorageKey); } catch (_e) {}
+
+                if (this.lastSyncedLanguage !== lang && syncedInSession !== lang) {
+                    await window.__TAURI__.core.invoke('set_user_language', { lang });
+                    this.lastSyncedLanguage = lang;
+                    try { sessionStorage.setItem(this.tauriSyncStorageKey, lang); } catch (_e) {}
+                } else {
+                    this.lastSyncedLanguage = lang;
+                }
+            }
+        } catch (error) {
+            console.error(`[i18n] Error loading language ${lang}:`, error);
+            if (lang !== this.fallbackLanguage) {
+                await this.setLanguage(this.fallbackLanguage);
+            }
+        }
+    }
+
+    t(key, params = {}) {
+        const keys = key.split('.');
+        let value = this.translations;
+
+        for (const k of keys) {
+            if (value && typeof value === 'object' && k in value) {
+                value = value[k];
+            } else {
+                console.warn(`[i18n] Translation key not found: ${key}`);
+                return key;
+            }
+        }
+
+        if (typeof value === 'string' && Object.keys(params).length > 0) {
+            return value.replace(/\{(\w+)\}/g, (match, paramKey) => {
+                return params[paramKey] !== undefined ? params[paramKey] : match;
+            });
+        }
+
+        return value;
+    }
+
+    getLanguage() {
+        return this.currentLanguage;
+    }
+
+    getSupportedLanguages() {
+        return [
+            { code: 'en', name: 'English', nativeName: 'English' },
+            { code: 'zh', name: 'Chinese', nativeName: '中文' }
+        ];
+    }
+
+    onLanguageChange(callback) {
+        this.listeners.push(callback);
+    }
+
+    notifyListeners(lang) {
+        this.listeners.forEach(callback => {
+            try { callback(lang); } catch (error) {
+                console.error('[i18n] Error in language change listener:', error);
+            }
+        });
+    }
+
+    updateDOM() {
+        document.querySelectorAll('[data-i18n]').forEach(el => {
+            const key = el.getAttribute('data-i18n');
+            if (key) {
+                const translation = this.t(key);
+                if (typeof translation === 'string' && translation.includes('<')) {
+                    el.innerHTML = translation;
+                } else {
+                    el.textContent = typeof translation === 'string' ? translation : String(translation);
+                }
+            }
+        });
+
+        document.querySelectorAll('[data-i18n-placeholder]').forEach(el => {
+            const key = el.getAttribute('data-i18n-placeholder');
+            if (key) el.placeholder = this.t(key);
+        });
+
+        document.querySelectorAll('[data-i18n-title]').forEach(el => {
+            const key = el.getAttribute('data-i18n-title');
+            if (key) el.title = this.t(key);
+        });
+    }
+}
+
+const instance = new I18nManager();
+
+// Backward compatibility: expose on window for legacy scripts
+window.i18n = instance;
+window.t = instance.t.bind(instance);
+
+// Auto-initialize
+if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', async () => {
+        await instance.init();
+        instance.updateDOM();
+    });
+} else {
+    instance.init().then(() => instance.updateDOM());
+}
+
+instance.onLanguageChange(() => instance.updateDOM());
+
+export { instance as i18n, I18nManager };
+export const t = instance.t.bind(instance);
+export default instance;