codex-overleaf-link 1.9.13 → 2.1.0

package/extension/src/content/contextTray.js

@@ -47,11 +47,84 @@
     let contextProject = null;
     let contextLoadId = 0;
     let contextExpandedFolders = new Set();
+    let contextExactEnhancementAttempted = false;
+    let contextSyncState = 'idle';
+    let contextPrefetchTimer = null;
+    let contextPrefetchIdleHandle = null;
+
+    function cancelContextPrefetch() {
+      if (contextPrefetchTimer !== null) {
+        const clearTimer = typeof root.clearTimeout === 'function' ? root.clearTimeout.bind(root) : clearTimeout;
+        clearTimer(contextPrefetchTimer);
+        contextPrefetchTimer = null;
+      }
+      if (contextPrefetchIdleHandle !== null && typeof root.cancelIdleCallback === 'function') {
+        root.cancelIdleCallback(contextPrefetchIdleHandle);
+        contextPrefetchIdleHandle = null;
+      }
+    }
+
+    function scheduleContextPrefetch(options = {}) {
+      cancelContextPrefetch();
+      const enabled = Object.prototype.hasOwnProperty.call(options, 'enabled')
+        ? Boolean(options.enabled)
+        : getState()?.preloadProjectContext !== false;
+      const expectedProjectId = String(getCurrentProjectId() || '');
+      if (!enabled || !expectedProjectId) {
+        return;
+      }
+      const delayMs = Number.isFinite(Number(options.delayMs))
+        ? Math.max(0, Number(options.delayMs))
+        : 2500;
+      const setTimer = typeof root.setTimeout === 'function' ? root.setTimeout.bind(root) : setTimeout;
+      contextPrefetchTimer = setTimer(() => {
+        contextPrefetchTimer = null;
+        const currentProjectId = String(getCurrentProjectId() || '');
+        if (getState()?.preloadProjectContext === false || document?.visibilityState === 'hidden') {
+          return;
+        }
+        if (currentProjectId !== expectedProjectId) {
+          scheduleContextPrefetch({ delayMs: 500 });
+          return;
+        }
+        const run = () => {
+          contextPrefetchIdleHandle = null;
+          void loadContextFiles({ force: false, background: true });
+        };
+        if (typeof root.requestIdleCallback === 'function') {
+          contextPrefetchIdleHandle = root.requestIdleCallback(run, { timeout: 2000 });
+        } else {
+          run();
+        }
+      }, delayMs);
+      contextPrefetchTimer?.unref?.();
+    }
 
     function installContextDismiss() {
       if (!document) {
         return;
       }
+      document.addEventListener('change', event => {
+        const target = event?.target;
+        if (!target?.matches?.('[data-preload-project-context]')) {
+          return;
+        }
+        const enabled = Boolean(target.checked);
+        setState({ ...getState(), preloadProjectContext: enabled });
+        saveStateSoon();
+        if (enabled) {
+          scheduleContextPrefetch({ enabled: true, delayMs: 0 });
+        } else {
+          cancelContextPrefetch();
+        }
+      }, true);
+      document.addEventListener('visibilitychange', () => {
+        if (document.visibilityState !== 'hidden') {
+          scheduleContextPrefetch();
+        }
+      });
+      scheduleContextPrefetch();
+
       document.addEventListener('click', event => {
         if (isContextTrayClickTarget(event.target)) {
           return;
@@ -126,17 +199,24 @@
       if (!list) {
         return;
       }
-      if (isExactContextFileListProject(contextProject) && !options.force) {
+      if (isContextFileListProject(contextProject) && !options.force) {
         renderContextFiles(contextProject);
+        if (isExactContextFileListProject(contextProject)) {
+          setContextSyncState('exact-ready');
+        } else if (contextSyncState !== 'partial') {
+          setContextSyncState('exact-loading');
+          void enhanceContextFilesFromExactSnapshot({ loadId: contextLoadId });
+        }
         return;
       }
 
       const loadId = ++contextLoadId;
+      setContextSyncState('tree-loading');
       setContextStatus(tr('contextLoadingFiles'));
       list.textContent = '';
 
       try {
-        const project = await requestExactContextFiles({ force: Boolean(options.force) });
+        const project = await requestContextFiles({ force: Boolean(options.force) });
         if (!project?.ok) {
           throw new Error(project?.error || project?.reason || tr('unknownReason'));
         }
@@ -144,28 +224,82 @@
           return;
         }
         contextProject = project;
+        setContextSyncState(isExactContextFileListProject(project) ? 'exact-ready' : 'exact-loading');
         renderContextFiles(project);
+        if (!isExactContextFileListProject(project)) {
+          void enhanceContextFilesFromExactSnapshot({
+            force: Boolean(options.force),
+            loadId
+          });
+        }
       } catch (error) {
         if (loadId !== contextLoadId) {
           return;
         }
+        setContextSyncState('partial');
         setContextStatus(tr('contextReadFailed', { message: error.message }));
       }
     }
 
+    async function requestContextFiles({ force = false } = {}) {
+      const project = await callPageBridge('getProjectFileList', {
+        force,
+        preferExact: false
+      });
+      if (
+        project?.ok
+        && isContextFileListProject(project)
+        && Array.isArray(project.files)
+        && project.files.length
+      ) {
+        return project;
+      }
+      return requestExactContextFiles({ force });
+    }
+
     async function requestExactContextFiles({ force = false } = {}) {
-      const project = await callPageBridge('getProjectSnapshot', {
+      return callPageBridge('getProjectFileList', {
         force,
-        preferLightweight: true,
-        allowZipFallback: false,
-        allowEditorNavigation: false,
-        requireFullProject: true,
-        zipOnly: true,
+        preferExact: true,
+        exactOnly: true,
         includeBinaryFiles: true,
         includeContent: false,
         zipTimeoutMs: exactFileListZipTimeoutMs
       });
-      return normalizeContextFileListFromZipSnapshot(project);
+    }
+
+    async function enhanceContextFilesFromExactSnapshot({ force = false, loadId = contextLoadId } = {}) {
+      if (isExactContextFileListProject(contextProject)) {
+        setContextSyncState('exact-ready');
+        return;
+      }
+      if (contextExactEnhancementAttempted && !force) {
+        return;
+      }
+      contextExactEnhancementAttempted = true;
+      setContextSyncState('exact-loading');
+      const expectedProjectId = String(contextProject?.id || getCurrentProjectId() || '');
+      try {
+        const project = await requestExactContextFiles({ force });
+        if (
+          loadId !== contextLoadId
+          || expectedProjectId && String(project.id || '') !== expectedProjectId
+        ) {
+          return;
+        }
+        if (!isExactContextFileListProject(project)) {
+          setContextSyncState('partial');
+          return;
+        }
+        contextProject = project;
+        setContextSyncState('exact-ready');
+        renderContextFiles(project);
+      } catch (_error) {
+        // The page file tree remains usable when the optional exact ZIP list is unavailable.
+        if (loadId === contextLoadId) {
+          setContextSyncState('partial');
+        }
+      }
     }
 
     function isExactContextFileListProject(project) {
@@ -601,6 +735,28 @@
       }
     }
 
+    function setContextSyncState(state) {
+      const indicator = getPanel()?.querySelector('[data-context-sync-status]');
+      const copy = indicator?.querySelector('[data-context-sync-copy]');
+      const stateKeys = {
+        'tree-loading': 'contextSyncTreeLoading',
+        'exact-loading': 'contextSyncExactLoading',
+        'exact-ready': 'contextSyncExactReady',
+        partial: 'contextSyncPartial'
+      };
+      contextSyncState = Object.prototype.hasOwnProperty.call(stateKeys, state) ? state : 'idle';
+      if (!indicator) {
+        return;
+      }
+      indicator.dataset.state = contextSyncState;
+      const label = contextSyncState === 'idle' ? '' : tr(stateKeys[contextSyncState]);
+      indicator.title = label;
+      indicator.setAttribute('aria-label', label);
+      if (copy) {
+        copy.textContent = label;
+      }
+    }
+
     async function persistFocusFiles(focusFiles) {
       const nextState = updateActiveSession(getState(), {
         focusFiles
@@ -630,6 +786,9 @@
     function resetContextProject() {
       contextProject = null;
       contextLoadId += 1;
+      contextExactEnhancementAttempted = false;
+      setContextSyncState('idle');
+      scheduleContextPrefetch();
     }
 
     function getContextProject() {
@@ -638,11 +797,15 @@
 
     return {
       installContextDismiss,
+      scheduleContextPrefetch,
+      cancelContextPrefetch,
       isContextTrayClickTarget,
       toggleContextTray,
       closeContextTray,
       loadContextFiles,
+      requestContextFiles,
       requestExactContextFiles,
+      enhanceContextFilesFromExactSnapshot,
       isExactContextFileListProject,
       isContextFileListProject,
       normalizeContextFileListFromZipSnapshot,
@@ -662,6 +825,7 @@
       sortContextFiles,
       getContextFileRank,
       setContextStatus,
+      setContextSyncState,
       resetContextProject,
       getContextProject
     };

package/extension/src/content/markdownText.js

@@ -62,6 +62,21 @@
   }
 
   function buildMarkdownInlineNodes(value) {
+    const source = String(value || '');
+    const mathText = typeof window !== 'undefined'
+      ? window.CodexOverleafMathText
+      : null;
+    if (!mathText?.buildMathNodes) {
+      return buildMarkdownInlineNodesWithoutMath(source);
+    }
+    return mathText.buildMathNodes(source, {
+      document,
+      katex: window.katex,
+      renderText: buildMarkdownInlineNodesWithoutMath
+    });
+  }
+
+  function buildMarkdownInlineNodesWithoutMath(value) {
     const source = String(value || '');
     const nodes = [];
     let index = 0;
@@ -587,7 +602,7 @@
   }
 
   function isMarkdownHeadingLine(line) {
-    return /^\s*(#{1,6}\s+\S|\*\*[^*]+\*\*:?\s*)$/.test(line);
+    return /^\s*(#{1,6}\s+\S.*|\*\*[^*]+\*\*:?\s*)$/.test(line);
   }
 
 

package/extension/src/content/mathText.js

@@ -0,0 +1,233 @@
+(function initCodexOverleafMathText(root) {
+  'use strict';
+
+  const DELIMITERS = Object.freeze([
+    Object.freeze({ open: '$$', close: '$$', display: true, singleDollar: false }),
+    Object.freeze({ open: '\\[', close: '\\]', display: true, singleDollar: false }),
+    Object.freeze({ open: '\\(', close: '\\)', display: false, singleDollar: false }),
+    Object.freeze({ open: '$', close: '$', display: false, singleDollar: true })
+  ]);
+
+  function parseMathSegments(value) {
+    const source = String(value || '');
+    if (!source) {
+      return [];
+    }
+    const codeRanges = collectInlineCodeRanges(source);
+    const segments = [];
+    let cursor = 0;
+    while (cursor < source.length) {
+      const match = findNextMath(source, cursor, codeRanges);
+      if (!match) {
+        segments.push({ type: 'text', value: source.slice(cursor) });
+        break;
+      }
+      if (match.start > cursor) {
+        segments.push({ type: 'text', value: source.slice(cursor, match.start) });
+      }
+      segments.push({
+        type: 'math',
+        value: match.value,
+        raw: source.slice(match.start, match.end),
+        display: match.display
+      });
+      cursor = match.end;
+    }
+    return segments;
+  }
+
+  function findNextMath(source, fromIndex, codeRanges) {
+    let best = null;
+    for (const delimiter of DELIMITERS) {
+      const match = findNextDelimitedMath(source, fromIndex, delimiter, codeRanges);
+      if (!match) {
+        continue;
+      }
+      if (!best || match.start < best.start
+        || (match.start === best.start && delimiter.open.length > best.delimiter.open.length)) {
+        best = { ...match, delimiter };
+      }
+    }
+    return best;
+  }
+
+  function findNextDelimitedMath(source, fromIndex, delimiter, codeRanges) {
+    let searchFrom = fromIndex;
+    while (searchFrom < source.length) {
+      const start = source.indexOf(delimiter.open, searchFrom);
+      if (start < 0) {
+        return null;
+      }
+      if (!isValidOpening(source, start, delimiter, codeRanges)) {
+        searchFrom = start + delimiter.open.length;
+        continue;
+      }
+      const closeStart = findClosingDelimiter(
+        source,
+        start + delimiter.open.length,
+        delimiter,
+        codeRanges
+      );
+      if (closeStart < 0) {
+        searchFrom = start + delimiter.open.length;
+        continue;
+      }
+      const value = source.slice(start + delimiter.open.length, closeStart);
+      const end = closeStart + delimiter.close.length;
+      if (!isValidMathValue(value, delimiter) || overlapsCodeRange(start, end, codeRanges)) {
+        searchFrom = start + delimiter.open.length;
+        continue;
+      }
+      return { start, end, value, display: delimiter.display };
+    }
+    return null;
+  }
+
+  function isValidOpening(source, index, delimiter, codeRanges) {
+    if (isEscaped(source, index) || isInsideRange(index, codeRanges)) {
+      return false;
+    }
+    if (!delimiter.singleDollar) {
+      return true;
+    }
+    const previous = source[index - 1] || '';
+    const next = source[index + 1] || '';
+    return previous !== '$' && next !== '$' && next !== '' && !/\s/.test(next);
+  }
+
+  function findClosingDelimiter(source, fromIndex, delimiter, codeRanges) {
+    let searchFrom = fromIndex;
+    while (searchFrom < source.length) {
+      const index = source.indexOf(delimiter.close, searchFrom);
+      if (index < 0) {
+        return -1;
+      }
+      const previous = source[index - 1] || '';
+      const next = source[index + delimiter.close.length] || '';
+      const invalidSingleDollar = delimiter.singleDollar
+        && (previous === '$' || next === '$' || /\s/.test(previous));
+      if (!isEscaped(source, index) && !isInsideRange(index, codeRanges) && !invalidSingleDollar) {
+        return index;
+      }
+      searchFrom = index + delimiter.close.length;
+    }
+    return -1;
+  }
+
+  function isValidMathValue(value, delimiter) {
+    const source = String(value || '');
+    if (!source.trim()) {
+      return false;
+    }
+    return delimiter.display || !/[\r\n]/.test(source);
+  }
+
+  function collectInlineCodeRanges(source) {
+    const ranges = [];
+    let index = 0;
+    while (index < source.length) {
+      if (source[index] !== '`' || isEscaped(source, index)) {
+        index++;
+        continue;
+      }
+      let runLength = 1;
+      while (source[index + runLength] === '`') {
+        runLength++;
+      }
+      const marker = '`'.repeat(runLength);
+      const closeStart = source.indexOf(marker, index + runLength);
+      if (closeStart < 0) {
+        index += runLength;
+        continue;
+      }
+      ranges.push([index, closeStart + runLength]);
+      index = closeStart + runLength;
+    }
+    return ranges;
+  }
+
+  function isEscaped(source, index) {
+    let slashCount = 0;
+    for (let cursor = index - 1; cursor >= 0 && source[cursor] === '\\'; cursor--) {
+      slashCount++;
+    }
+    return slashCount % 2 === 1;
+  }
+
+  function isInsideRange(index, ranges) {
+    return ranges.some(([start, end]) => index >= start && index < end);
+  }
+
+  function overlapsCodeRange(start, end, ranges) {
+    return ranges.some(([rangeStart, rangeEnd]) => rangeStart < end && rangeEnd > start);
+  }
+
+  function buildMathNodes(value, options = {}) {
+    const documentRef = options.document || root.document;
+    const renderText = typeof options.renderText === 'function'
+      ? options.renderText
+      : text => [documentRef.createTextNode(text)];
+    const nodes = [];
+    for (const segment of parseMathSegments(value)) {
+      if (segment.type === 'text') {
+        if (segment.value) {
+          nodes.push(...toNodeArray(renderText(segment.value)));
+        }
+        continue;
+      }
+      nodes.push(createMathNode(segment, {
+        document: documentRef,
+        katex: options.katex || root.katex
+      }));
+    }
+    return nodes;
+  }
+
+  function createMathNode(segment, options = {}) {
+    const documentRef = options.document || root.document;
+    const node = documentRef.createElement('span');
+    node.className = `run-math ${segment.display ? 'run-math--display' : 'run-math--inline'}`;
+    node.dataset.mathDisplay = segment.display ? 'block' : 'inline';
+    try {
+      if (typeof options.katex?.render !== 'function') {
+        throw new Error('KaTeX is unavailable');
+      }
+      options.katex.render(segment.value, node, {
+        displayMode: segment.display,
+        throwOnError: true,
+        trust: false,
+        strict: 'warn',
+        maxExpand: 200,
+        maxSize: 20,
+        output: 'htmlAndMathml'
+      });
+      node.dataset.mathRendered = 'true';
+      return node;
+    } catch (_error) {
+      node.classList.add('run-math--fallback');
+      node.dataset.mathRendered = 'false';
+      node.textContent = segment.raw;
+      return node;
+    }
+  }
+
+  function toNodeArray(value) {
+    if (Array.isArray(value)) {
+      return value;
+    }
+    if (value === undefined || value === null) {
+      return [];
+    }
+    return [value];
+  }
+
+  const api = {
+    buildMathNodes,
+    createMathNode,
+    parseMathSegments
+  };
+  root.CodexOverleafMathText = api;
+  if (typeof module !== 'undefined' && module.exports) {
+    module.exports = api;
+  }
+})(typeof window !== 'undefined' ? window : globalThis);