codex-overleaf-link 1.8.5 → 1.9.0

package/extension/src/page/overleafEditor.js

@@ -0,0 +1,282 @@
+(function initOverleafEditor(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafEditorAdapter = factory();
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function overleafEditorFactory() {
+  'use strict';
+
+  function create(deps = {}) {
+    function detectEditor() {
+      if (deps.getCodeMirrorEditorView?.()) {
+        return {
+          ok: true,
+          type: 'codemirror-view'
+        };
+      }
+      if (deps.findEditorTextArea?.()) {
+        return {
+          ok: true,
+          type: 'textarea'
+        };
+      }
+      if (deps.findEditorContentNode?.('.cm-content')) {
+        return {
+          ok: true,
+          type: 'codemirror'
+        };
+      }
+      if (deps.findEditorContentNode?.('[contenteditable="true"]')) {
+        return {
+          ok: true,
+          type: 'contenteditable'
+        };
+      }
+      return {
+        ok: false,
+        type: 'unknown'
+      };
+    }
+
+    function readActiveEditorText() {
+      const editorView = deps.getCodeMirrorEditorView?.();
+      if (editorView) {
+        return deps.getCodeMirrorDocText(editorView);
+      }
+
+      const active = deps.getDeepActiveElement?.();
+      if (active && active.tagName === 'TEXTAREA' && !deps.isInsideCodexPanel?.(active)) {
+        return active.value;
+      }
+
+      const textarea = deps.findEditorTextArea?.();
+      if (textarea) {
+        return textarea.value;
+      }
+
+      const cm = deps.findEditorContentNode?.('.cm-content');
+      if (cm) {
+        return cm.innerText || cm.textContent || '';
+      }
+
+      const editable = deps.findEditorContentNode?.('[contenteditable="true"]');
+      if (editable) {
+        return editable.innerText || editable.textContent || '';
+      }
+
+      return '';
+    }
+
+    function replaceActiveEditorText(text) {
+      const editorView = deps.getCodeMirrorEditorView?.();
+      if (editorView) {
+        const from = 0;
+        const to = deps.getCodeMirrorDocLength(editorView);
+        editorView.dispatch({
+          changes: {
+            from,
+            to,
+            insert: text
+          }
+        });
+        return {
+          ok: true,
+          method: 'codemirror-view'
+        };
+      }
+
+      const active = deps.getDeepActiveElement?.();
+      const textarea = active?.tagName === 'TEXTAREA' && !deps.isInsideCodexPanel?.(active)
+        ? active
+        : deps.findEditorTextArea?.();
+
+      if (textarea) {
+        textarea.focus();
+        textarea.value = text;
+        textarea.dispatchEvent(new deps.InputEvent('input', { bubbles: true, inputType: 'insertReplacementText', data: text }));
+        textarea.dispatchEvent(new deps.Event('change', { bubbles: true }));
+        return {
+          ok: true,
+          method: 'textarea'
+        };
+      }
+
+      const editable = deps.findEditorContentNode?.('.cm-content') || deps.findEditorContentNode?.('[contenteditable="true"]');
+      if (editable) {
+        editable.focus();
+        deps.document.execCommand('selectAll', false, null);
+        deps.document.execCommand('insertText', false, text);
+        editable.dispatchEvent(new deps.InputEvent('input', { bubbles: true, inputType: 'insertReplacementText', data: text }));
+        return {
+          ok: true,
+          method: 'contenteditable'
+        };
+      }
+
+      return {
+        ok: false,
+        reason: 'No editable surface was detected'
+      };
+    }
+
+    function replaceActiveEditorPatches(patches, nextContent) {
+      const normalized = deps.normalizeTextPatches(patches, readActiveEditorText().length);
+      if (!normalized.ok) {
+        return normalized;
+      }
+
+      const editorView = deps.getCodeMirrorEditorView?.();
+      if (editorView) {
+        editorView.dispatch({
+          changes: normalized.patches.map(patch => ({
+            from: patch.from,
+            to: patch.to,
+            insert: patch.insert
+          }))
+        });
+        return {
+          ok: true,
+          method: 'codemirror-view-patch'
+        };
+      }
+
+      const active = deps.getDeepActiveElement?.();
+      const textarea = active?.tagName === 'TEXTAREA' && !deps.isInsideCodexPanel?.(active)
+        ? active
+        : deps.findEditorTextArea?.();
+
+      if (textarea && typeof textarea.setRangeText === 'function') {
+        textarea.focus();
+        for (const patch of normalized.patches.slice().sort((left, right) => right.from - left.from)) {
+          textarea.setRangeText(patch.insert, patch.from, patch.to, 'end');
+        }
+        textarea.dispatchEvent(new deps.InputEvent('input', { bubbles: true, inputType: 'insertReplacementText', data: '' }));
+        textarea.dispatchEvent(new deps.Event('change', { bubbles: true }));
+        return {
+          ok: true,
+          method: 'textarea-patch'
+        };
+      }
+
+      const result = replaceActiveEditorText(nextContent);
+      return result.ok
+        ? {
+          ...result,
+          method: `${result.method}-patch-fallback`
+        }
+        : result;
+    }
+
+    function focusActiveEditorRange(from, to) {
+      const range = normalizeSelectionRange(from, to);
+      if (!range.ok) {
+        return range;
+      }
+
+      const editorView = deps.getCodeMirrorEditorView?.();
+      if (editorView) {
+        const length = getKnownCodeMirrorDocLength(editorView);
+        if (Number.isInteger(length) && !isSelectionRangeInBounds(range, length)) {
+          return rangeOutOfBounds(range, length);
+        }
+        editorView.focus?.();
+        editorView.dispatch({
+          selection: {
+            anchor: range.from,
+            head: range.to
+          },
+          scrollIntoView: true
+        });
+        return {
+          ok: true,
+          method: 'codemirror-view-selection'
+        };
+      }
+
+      const active = deps.getDeepActiveElement?.();
+      const textarea = active?.tagName === 'TEXTAREA' && !deps.isInsideCodexPanel?.(active)
+        ? active
+        : deps.findEditorTextArea?.();
+
+      if (textarea) {
+        const length = typeof textarea.value === 'string' ? textarea.value.length : null;
+        if (Number.isInteger(length) && !isSelectionRangeInBounds(range, length)) {
+          return rangeOutOfBounds(range, length);
+        }
+        textarea.focus();
+        textarea.setSelectionRange(range.from, range.to);
+        return {
+          ok: true,
+          method: 'textarea-selection'
+        };
+      }
+
+      const editable = deps.findEditorContentNode?.('.cm-content') || deps.findEditorContentNode?.('[contenteditable="true"]');
+      if (editable) {
+        editable.focus();
+        return {
+          ok: true,
+          method: 'selection-fallback'
+        };
+      }
+
+      return {
+        ok: false,
+        code: 'editor_not_found',
+        reason: 'No editable surface was detected'
+      };
+    }
+
+    function normalizeSelectionRange(from, to) {
+      if (!Number.isInteger(from) || !Number.isInteger(to) || from < 0 || to < 0) {
+        return {
+          ok: false,
+          code: 'invalid_range',
+          reason: 'Selection offsets must be non-negative integers'
+        };
+      }
+      return {
+        ok: true,
+        from,
+        to
+      };
+    }
+
+    function getKnownCodeMirrorDocLength(editorView) {
+      try {
+        const length = deps.getCodeMirrorDocLength?.(editorView);
+        return Number.isInteger(length) ? length : null;
+      } catch (_error) {
+        return null;
+      }
+    }
+
+    function isSelectionRangeInBounds(range, length) {
+      return range.from <= length && range.to <= length;
+    }
+
+    function rangeOutOfBounds(range, length) {
+      return {
+        ok: false,
+        code: 'range_out_of_bounds',
+        reason: `Selection offsets are out of range for document length ${length}`,
+        from: range.from,
+        to: range.to,
+        length
+      };
+    }
+
+    return {
+      detectEditor,
+      focusActiveEditorRange,
+      readActiveEditorText,
+      replaceActiveEditorPatches,
+      replaceActiveEditorText
+    };
+  }
+
+  return {
+    create
+  };
+});

package/extension/src/page/overleafProjectSnapshot.js

@@ -0,0 +1,234 @@
+(function initOverleafProjectSnapshot(root, factory) {
+  if (typeof module === 'object' && module.exports) {
+    module.exports = factory();
+  } else {
+    root.CodexOverleafProjectSnapshot = factory();
+  }
+})(typeof window !== 'undefined' ? window : globalThis, function overleafProjectSnapshotFactory() {
+  'use strict';
+
+  const SNAPSHOT_DEFAULT_MAX_AGE_MS = 2500;
+  const SNAPSHOT_MAX_CACHE_MS = 15000;
+  const FILE_LIST_DEFAULT_MAX_AGE_MS = 300000;
+
+  function create(deps = {}) {
+    const pageWindow = deps.window || window;
+    const snapshotCache = createKeyedCache();
+    const fileListCache = createCache();
+
+    async function getProjectSnapshot(params = {}) {
+      const cacheKey = getSnapshotCacheKey(params);
+      const maxAgeMs = normalizeSnapshotMaxAge(params.maxAgeMs);
+      const now = Date.now();
+      const cacheEntry = snapshotCache.entries.get(cacheKey);
+
+      if (!params.force && cacheEntry?.pending) {
+        return cacheEntry.pending;
+      }
+
+      if (!params.force && cacheEntry?.value && now - cacheEntry.capturedAt <= maxAgeMs) {
+        return withSnapshotCacheMetadata(cacheEntry.value, 'memory', cacheEntry.capturedAt);
+      }
+
+      const pending = deps.buildProjectSnapshot(params)
+        .then(snapshot => {
+          const capturedAt = Date.now();
+          const currentEntry = snapshotCache.entries.get(cacheKey);
+          if (currentEntry?.pending === pending) {
+            snapshotCache.entries.set(cacheKey, {
+              value: snapshot,
+              capturedAt,
+              pending: null
+            });
+          }
+          return withSnapshotCacheMetadata(snapshot, 'fresh', capturedAt);
+        })
+        .finally(() => {
+          const currentEntry = snapshotCache.entries.get(cacheKey);
+          if (currentEntry?.pending === pending) {
+            currentEntry.pending = null;
+          }
+        });
+
+      snapshotCache.entries.set(cacheKey, {
+        value: cacheEntry?.value || null,
+        capturedAt: cacheEntry?.capturedAt || 0,
+        pending
+      });
+      return pending;
+    }
+
+    async function getProjectFileList(params = {}) {
+      const cacheKey = getProjectFileListCacheKey(params);
+      const maxAgeMs = normalizeFileListMaxAge(params.maxAgeMs);
+      const now = Date.now();
+
+      if (fileListCache.key === cacheKey && fileListCache.pending) {
+        return fileListCache.pending;
+      }
+
+      if (!params.force && fileListCache.key === cacheKey && fileListCache.value && now - fileListCache.capturedAt <= maxAgeMs) {
+        return withFileListCacheMetadata(fileListCache.value, 'memory', fileListCache.capturedAt);
+      }
+
+      const pending = deps.buildProjectFileList(params)
+        .then(fileList => {
+          const capturedAt = Date.now();
+          if (shouldCacheProjectFileList(fileList, params)) {
+            fileListCache.key = cacheKey;
+            fileListCache.value = fileList;
+            fileListCache.capturedAt = capturedAt;
+          } else if (fileListCache.key === cacheKey) {
+            fileListCache.value = null;
+            fileListCache.capturedAt = 0;
+          }
+          return withFileListCacheMetadata(fileList, 'fresh', capturedAt);
+        })
+        .finally(() => {
+          if (fileListCache.pending === pending) {
+            fileListCache.pending = null;
+          }
+        });
+
+      fileListCache.key = cacheKey;
+      fileListCache.pending = pending;
+      return pending;
+    }
+
+    function invalidateProjectSnapshot() {
+      resetKeyedCache(snapshotCache);
+    }
+
+    function getSnapshotCacheKey(params = {}) {
+      const focusKey = Array.isArray(params.focusFiles)
+        ? params.focusFiles.map(path => deps.normalizePath?.(path)).filter(Boolean).sort().join(',')
+        : '';
+      return [
+        pageWindow.location.origin,
+        deps.getProjectId?.() || pageWindow.location.pathname || pageWindow.location.href,
+        params.preferLightweight ? 'lightweight' : 'full',
+        params.zipOnly ? 'zip-only' : 'zip-or-page',
+        params.allowZipFallback === false ? 'no-zip-fallback' : 'zip-fallback',
+        params.allowEditorNavigation === false ? 'no-editor-navigation' : params.allowEditorNavigation === true ? 'editor-navigation' : 'default-editor-navigation',
+        params.requireFullProject ? 'require-full-project' : 'allow-partial-project',
+        params.restrictToRequestedPathsOnly === true ? 'requested-only' : 'allow-project-expansion',
+        params.includeBinaryFiles ? 'binary' : 'text',
+        params.includeContent === false ? 'list' : 'content',
+        `zip-timeout=${normalizeZipTimeoutKey(params.zipTimeoutMs)}`,
+        params.requestedPathsCacheKey || '',
+        focusKey
+      ].join(':');
+    }
+
+  function getProjectFileListCacheKey(params = {}) {
+      return [
+        pageWindow.location.origin,
+        deps.getProjectId?.() || pageWindow.location.pathname || pageWindow.location.href,
+        params.preferExact === false ? 'tree' : 'exact',
+        params.exactOnly === true || params.requireExact === true ? 'required' : 'fallback'
+      ].join(':');
+    }
+
+    return {
+      getProjectFileList,
+      getProjectSnapshot,
+      invalidateProjectSnapshot
+    };
+  }
+
+  function shouldCacheProjectFileList(fileList, params = {}) {
+    if (params.preferExact === false) {
+      return true;
+    }
+    return fileList?.capabilities?.method === 'overleaf-zip-file-list';
+  }
+
+  function createCache() {
+    return {
+      key: '',
+      capturedAt: 0,
+      value: null,
+      pending: null
+    };
+  }
+
+  function createKeyedCache() {
+    return {
+      entries: new Map()
+    };
+  }
+
+  function resetKeyedCache(cache) {
+    cache.entries.clear();
+  }
+
+  function resetCache(cache) {
+    cache.key = '';
+    cache.capturedAt = 0;
+    cache.value = null;
+    cache.pending = null;
+  }
+
+  function normalizeSnapshotMaxAge(value) {
+    if (value === 0) {
+      return 0;
+    }
+    const number = Number(value);
+    if (!Number.isFinite(number)) {
+      return SNAPSHOT_DEFAULT_MAX_AGE_MS;
+    }
+    return Math.max(0, Math.min(number, SNAPSHOT_MAX_CACHE_MS));
+  }
+
+  function normalizeFileListMaxAge(value) {
+    if (value === 0) {
+      return 0;
+    }
+    const number = Number(value);
+    if (!Number.isFinite(number)) {
+      return FILE_LIST_DEFAULT_MAX_AGE_MS;
+    }
+    return Math.max(0, Math.min(number, FILE_LIST_DEFAULT_MAX_AGE_MS));
+  }
+
+  function normalizeZipTimeoutKey(value) {
+    const parsed = Number(value);
+    return Number.isFinite(parsed) ? String(parsed) : 'default';
+  }
+
+  function withSnapshotCacheMetadata(snapshot, cacheState, capturedAt) {
+    const capabilities = snapshot?.capabilities || {};
+    return {
+      ...snapshot,
+      capabilities: {
+        ...capabilities,
+        diagnostics: {
+          ...(capabilities.diagnostics || {}),
+          snapshotCache: cacheState,
+          snapshotCapturedAt: new Date(capturedAt).toISOString()
+        }
+      }
+    };
+  }
+
+  function withFileListCacheMetadata(fileList, cacheState, capturedAt) {
+    const capabilities = fileList?.capabilities || {};
+    return {
+      ...fileList,
+      capabilities: {
+        ...capabilities,
+        diagnostics: {
+          ...(capabilities.diagnostics || {}),
+          fileListCache: cacheState,
+          fileListCapturedAt: new Date(capturedAt).toISOString()
+        }
+      }
+    };
+  }
+
+  return {
+    create,
+    normalizeFileListMaxAge,
+    normalizeSnapshotMaxAge
+  };
+});