editor-manager-context.tsx 21 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717
  1. import {
  2. createContext,
  3. FC,
  4. useCallback,
  5. useContext,
  6. useEffect,
  7. useMemo,
  8. useRef,
  9. useState,
  10. } from 'react'
  11. import { sendMB } from '@/infrastructure/event-tracking'
  12. import useScopeValue from '@/shared/hooks/use-scope-value'
  13. import { useIdeContext } from '@/shared/context/ide-context'
  14. import { OpenDocuments } from '@/features/ide-react/editor/open-documents'
  15. import EditorWatchdogManager from '@/features/ide-react/connection/editor-watchdog-manager'
  16. import { useIdeReactContext } from '@/features/ide-react/context/ide-react-context'
  17. import { useConnectionContext } from '@/features/ide-react/context/connection-context'
  18. import { debugConsole } from '@/utils/debugging'
  19. import { DocumentContainer } from '@/features/ide-react/editor/document-container'
  20. import { useLayoutContext } from '@/shared/context/layout-context'
  21. import { GotoLineOptions } from '@/features/ide-react/types/goto-line-options'
  22. import { Doc } from '../../../../../types/doc'
  23. import { useFileTreeData } from '@/shared/context/file-tree-data-context'
  24. import { findDocEntityById } from '@/features/ide-react/util/find-doc-entity-by-id'
  25. import useScopeEventEmitter from '@/shared/hooks/use-scope-event-emitter'
  26. import { useModalsContext } from '@/features/ide-react/context/modals-context'
  27. import { useTranslation } from 'react-i18next'
  28. import customLocalStorage from '@/infrastructure/local-storage'
  29. import useEventListener from '@/shared/hooks/use-event-listener'
  30. import { EditorType } from '@/features/ide-react/editor/types/editor-type'
  31. import { DocId } from '../../../../../types/project-settings'
  32. import { Update } from '@/features/history/services/types/update'
  33. import { useDebugDiffTracker } from '../hooks/use-debug-diff-tracker'
  34. import { useEditorContext } from '@/shared/context/editor-context'
  35. export interface GotoOffsetOptions {
  36. gotoOffset: number
  37. }
  38. interface OpenDocOptions
  39. extends Partial<GotoLineOptions>,
  40. Partial<GotoOffsetOptions> {
  41. gotoOffset?: number
  42. forceReopen?: boolean
  43. keepCurrentView?: boolean
  44. }
  45. export type EditorManager = {
  46. getEditorType: () => EditorType | null
  47. showSymbolPalette: boolean
  48. currentDocument: DocumentContainer
  49. currentDocumentId: DocId | null
  50. getCurrentDocValue: () => string | null
  51. getCurrentDocumentId: () => DocId | null
  52. startIgnoringExternalUpdates: () => void
  53. stopIgnoringExternalUpdates: () => void
  54. openDocWithId: (docId: string, options?: OpenDocOptions) => void
  55. openDoc: (document: Doc, options?: OpenDocOptions) => void
  56. openDocs: OpenDocuments
  57. openInitialDoc: (docId: string) => void
  58. jumpToLine: (options: GotoLineOptions) => void
  59. wantTrackChanges: boolean
  60. setWantTrackChanges: React.Dispatch<
  61. React.SetStateAction<EditorManager['wantTrackChanges']>
  62. >
  63. debugTimers: React.MutableRefObject<Record<string, number>>
  64. }
  65. function hasGotoLine(options: OpenDocOptions): options is GotoLineOptions {
  66. return typeof options.gotoLine === 'number'
  67. }
  68. function hasGotoOffset(options: OpenDocOptions): options is GotoOffsetOptions {
  69. return typeof options.gotoOffset === 'number'
  70. }
  71. export type EditorScopeValue = {
  72. showSymbolPalette: false
  73. toggleSymbolPalette: () => void
  74. sharejs_doc: DocumentContainer | null
  75. open_doc_id: string | null
  76. open_doc_name: string | null
  77. opening: boolean
  78. trackChanges: boolean
  79. wantTrackChanges: boolean
  80. showVisual: boolean
  81. newSourceEditor: boolean
  82. error_state: boolean
  83. }
  84. export const EditorManagerContext = createContext<EditorManager | undefined>(
  85. undefined
  86. )
  87. export const EditorManagerProvider: FC = ({ children }) => {
  88. const { t } = useTranslation()
  89. const ide = useIdeContext()
  90. const { projectId } = useIdeReactContext()
  91. const { reportError, eventEmitter } = useIdeReactContext()
  92. const { setOutOfSync } = useEditorContext()
  93. const { socket, closeConnection, connectionState } = useConnectionContext()
  94. const { view, setView } = useLayoutContext()
  95. const { showGenericMessageModal, genericModalVisible, showOutOfSyncModal } =
  96. useModalsContext()
  97. const [showSymbolPalette, setShowSymbolPalette] = useScopeValue<boolean>(
  98. 'editor.showSymbolPalette'
  99. )
  100. const [showVisual] = useScopeValue<boolean>('editor.showVisual')
  101. const [currentDocument, setCurrentDocument] =
  102. useScopeValue<DocumentContainer>('editor.sharejs_doc')
  103. const [currentDocumentId, setCurrentDocumentId] = useScopeValue<DocId | null>(
  104. 'editor.open_doc_id'
  105. )
  106. const [, setOpenDocName] = useScopeValue<string | null>(
  107. 'editor.open_doc_name'
  108. )
  109. const [, setOpening] = useScopeValue<boolean>('editor.opening')
  110. const [, setIsInErrorState] = useScopeValue<boolean>('editor.error_state')
  111. const [, setTrackChanges] = useScopeValue<boolean>('editor.trackChanges')
  112. const [wantTrackChanges, setWantTrackChanges] = useScopeValue<boolean>(
  113. 'editor.wantTrackChanges'
  114. )
  115. const wantTrackChangesRef = useRef(wantTrackChanges)
  116. useEffect(() => {
  117. wantTrackChangesRef.current = wantTrackChanges
  118. }, [wantTrackChanges])
  119. const goToLineEmitter = useScopeEventEmitter('editor:gotoLine')
  120. const { fileTreeData } = useFileTreeData()
  121. const [ignoringExternalUpdates, setIgnoringExternalUpdates] = useState(false)
  122. const { createDebugDiff, debugTimers } = useDebugDiffTracker(
  123. projectId,
  124. currentDocument
  125. )
  126. const [globalEditorWatchdogManager] = useState(
  127. () =>
  128. new EditorWatchdogManager({
  129. onTimeoutHandler: (meta: Record<string, any>) => {
  130. let diffSize: number | null = null
  131. createDebugDiff()
  132. .then(calculatedDiffSize => {
  133. diffSize = calculatedDiffSize
  134. })
  135. .finally(() => {
  136. sendMB('losing-edits', {
  137. ...meta,
  138. diffSize,
  139. timers: debugTimers.current,
  140. })
  141. reportError('losing-edits', {
  142. ...meta,
  143. diffSize,
  144. timers: debugTimers.current,
  145. })
  146. })
  147. },
  148. })
  149. )
  150. // Store the most recent document error and consume it in an effect, which
  151. // prevents circular dependencies in useCallbacks
  152. const [docError, setDocError] = useState<{
  153. doc: Doc
  154. document: DocumentContainer
  155. error: Error | string
  156. meta?: Record<string, any>
  157. editorContent?: string
  158. } | null>(null)
  159. const [docTooLongErrorShown, setDocTooLongErrorShown] = useState(false)
  160. useEffect(() => {
  161. if (!genericModalVisible) {
  162. setDocTooLongErrorShown(false)
  163. }
  164. }, [genericModalVisible])
  165. const [openDocs] = useState(
  166. () => new OpenDocuments(socket, globalEditorWatchdogManager, eventEmitter)
  167. )
  168. const currentDocumentIdStorageKey = `doc.open_id.${projectId}`
  169. // Persist the open document ID to local storage
  170. useEffect(() => {
  171. if (currentDocumentId) {
  172. customLocalStorage.setItem(currentDocumentIdStorageKey, currentDocumentId)
  173. }
  174. }, [currentDocumentId, currentDocumentIdStorageKey])
  175. const editorOpenDocEpochRef = useRef(0)
  176. // TODO: This looks dodgy because it wraps a state setter and is itself
  177. // stored in React state in the scope store. The problem is that it needs to
  178. // be exposed via the scope store because some components access it that way;
  179. // it would be better to simply access it from a context, but the current
  180. // implementation in EditorManager interacts with Angular scope to update
  181. // the layout. Once Angular is gone, this can become a context method.
  182. useEffect(() => {
  183. ide.scopeStore.set('editor.toggleSymbolPalette', () => {
  184. setShowSymbolPalette(show => {
  185. const newValue = !show
  186. sendMB(newValue ? 'symbol-palette-show' : 'symbol-palette-hide')
  187. return newValue
  188. })
  189. })
  190. }, [ide.scopeStore, setShowSymbolPalette])
  191. const getEditorType = useCallback((): EditorType | null => {
  192. if (!currentDocument) {
  193. return null
  194. }
  195. return showVisual ? 'cm6-rich-text' : 'cm6'
  196. }, [currentDocument, showVisual])
  197. const getCurrentDocValue = useCallback(() => {
  198. return currentDocument?.getSnapshot() ?? null
  199. }, [currentDocument])
  200. const getCurrentDocumentId = useCallback(
  201. () => currentDocumentId,
  202. [currentDocumentId]
  203. )
  204. const startIgnoringExternalUpdates = useCallback(
  205. () => setIgnoringExternalUpdates(true),
  206. []
  207. )
  208. const stopIgnoringExternalUpdates = useCallback(
  209. () => setIgnoringExternalUpdates(false),
  210. []
  211. )
  212. const jumpToLine = useCallback(
  213. (options: GotoLineOptions) => {
  214. goToLineEmitter(options)
  215. },
  216. [goToLineEmitter]
  217. )
  218. const unbindFromDocumentEvents = (document: DocumentContainer) => {
  219. document.off()
  220. }
  221. const attachErrorHandlerToDocument = useCallback(
  222. (doc: Doc, document: DocumentContainer) => {
  223. document.on(
  224. 'error',
  225. (
  226. error: Error | string,
  227. meta?: Record<string, any>,
  228. editorContent?: string
  229. ) => {
  230. setDocError({ doc, document, error, meta, editorContent })
  231. }
  232. )
  233. },
  234. []
  235. )
  236. const bindToDocumentEvents = useCallback(
  237. (doc: Doc, document: DocumentContainer) => {
  238. attachErrorHandlerToDocument(doc, document)
  239. document.on('externalUpdate', (update: Update) => {
  240. if (ignoringExternalUpdates) {
  241. return
  242. }
  243. if (
  244. update.meta.type === 'external' &&
  245. update.meta.source === 'git-bridge'
  246. ) {
  247. return
  248. }
  249. if (
  250. update.meta.origin?.kind === 'file-restore' ||
  251. update.meta.origin?.kind === 'project-restore'
  252. ) {
  253. return
  254. }
  255. showGenericMessageModal(
  256. t('document_updated_externally'),
  257. t('document_updated_externally_detail')
  258. )
  259. })
  260. },
  261. [
  262. attachErrorHandlerToDocument,
  263. ignoringExternalUpdates,
  264. showGenericMessageModal,
  265. t,
  266. ]
  267. )
  268. const syncTimeoutRef = useRef<number | null>(null)
  269. const syncTrackChangesState = useCallback(
  270. (doc: DocumentContainer) => {
  271. if (!doc) {
  272. return
  273. }
  274. if (syncTimeoutRef.current) {
  275. window.clearTimeout(syncTimeoutRef.current)
  276. syncTimeoutRef.current = null
  277. }
  278. const want = wantTrackChangesRef.current
  279. const have = doc.getTrackingChanges()
  280. if (want === have) {
  281. setTrackChanges(want)
  282. return
  283. }
  284. const tryToggle = () => {
  285. const saved = doc.getInflightOp() == null && doc.getPendingOp() == null
  286. if (saved) {
  287. doc.setTrackingChanges(want)
  288. setTrackChanges(want)
  289. } else {
  290. syncTimeoutRef.current = window.setTimeout(tryToggle, 100)
  291. }
  292. }
  293. tryToggle()
  294. },
  295. [setTrackChanges]
  296. )
  297. const doOpenNewDocument = useCallback(
  298. (doc: Doc) =>
  299. new Promise<DocumentContainer>((resolve, reject) => {
  300. debugConsole.log('[doOpenNewDocument] Opening...')
  301. const newDocument = openDocs.getDocument(doc._id)
  302. if (!newDocument) {
  303. debugConsole.error(`No open document with ID '${doc._id}' found`)
  304. reject(new Error('no open document found'))
  305. return
  306. }
  307. const preJoinEpoch = ++editorOpenDocEpochRef.current
  308. newDocument.join(error => {
  309. if (error) {
  310. debugConsole.log(
  311. `[doOpenNewDocument] error joining doc ${doc._id}`,
  312. error
  313. )
  314. reject(error)
  315. return
  316. }
  317. if (editorOpenDocEpochRef.current !== preJoinEpoch) {
  318. debugConsole.log(
  319. `[doOpenNewDocument] editorOpenDocEpoch mismatch ${editorOpenDocEpochRef.current} vs ${preJoinEpoch}`
  320. )
  321. newDocument.leaveAndCleanUp()
  322. reject(new Error('another document was loaded'))
  323. }
  324. bindToDocumentEvents(doc, newDocument)
  325. resolve(newDocument)
  326. })
  327. }),
  328. [bindToDocumentEvents, openDocs]
  329. )
  330. const openNewDocument = useCallback(
  331. async (doc: Doc): Promise<DocumentContainer> => {
  332. // Leave the current document
  333. // - when we are opening a different new one, to avoid race conditions
  334. // between leaving and joining the same document
  335. // - when the current one has pending ops that need flushing, to avoid
  336. // race conditions from cleanup
  337. const currentDocumentId = currentDocument?.doc_id
  338. const hasBufferedOps = currentDocument?.hasBufferedOps()
  339. const changingDoc = currentDocument && currentDocumentId !== doc._id
  340. if (changingDoc || hasBufferedOps) {
  341. debugConsole.log('[openNewDocument] Leaving existing open doc...')
  342. // Do not trigger any UI changes from remote operations
  343. unbindFromDocumentEvents(currentDocument)
  344. // Keep listening for out-of-sync and similar errors.
  345. attachErrorHandlerToDocument(doc, currentDocument)
  346. // Teardown the Document -> ShareJsDoc -> sharejs doc
  347. // By the time this completes, the Document instance is no longer
  348. // registered in OpenDocuments and doOpenNewDocument can start
  349. // from scratch -- read: no corrupted internal state.
  350. const preLeaveEpoch = ++editorOpenDocEpochRef.current
  351. try {
  352. await currentDocument.leaveAndCleanUpPromise()
  353. } catch (error) {
  354. debugConsole.log(
  355. `[openNewDocument] error leaving doc ${currentDocumentId}`,
  356. error
  357. )
  358. throw error
  359. }
  360. if (editorOpenDocEpochRef.current !== preLeaveEpoch) {
  361. debugConsole.log(
  362. `[openNewDocument] editorOpenDocEpoch mismatch ${editorOpenDocEpochRef.current} vs ${preLeaveEpoch}`
  363. )
  364. throw new Error('another document was loaded')
  365. }
  366. }
  367. return doOpenNewDocument(doc)
  368. },
  369. [attachErrorHandlerToDocument, doOpenNewDocument, currentDocument]
  370. )
  371. const currentDocumentIdRef = useRef(currentDocumentId)
  372. useEffect(() => {
  373. currentDocumentIdRef.current = currentDocumentId
  374. }, [currentDocumentId])
  375. const openDoc = useCallback(
  376. async (doc: Doc, options: OpenDocOptions = {}) => {
  377. debugConsole.log(`[openDoc] Opening ${doc._id}`)
  378. const { promise, resolve, reject } = Promise.withResolvers<Doc>()
  379. if (view === 'editor') {
  380. // store position of previous doc before switching docs
  381. eventEmitter.emit('store-doc-position')
  382. }
  383. if (!options.keepCurrentView) {
  384. setView('editor')
  385. }
  386. const done = (isNewDoc: boolean) => {
  387. window.dispatchEvent(
  388. new CustomEvent('doc:after-opened', {
  389. detail: { isNewDoc, docId: doc._id },
  390. })
  391. )
  392. if (hasGotoLine(options)) {
  393. window.setTimeout(() => jumpToLine(options))
  394. // Jump to the line again after a stored scroll position has been restored
  395. if (isNewDoc) {
  396. window.addEventListener(
  397. 'editor:scroll-position-restored',
  398. () => jumpToLine(options),
  399. { once: true }
  400. )
  401. }
  402. } else if (hasGotoOffset(options)) {
  403. window.setTimeout(() => {
  404. eventEmitter.emit('editor:gotoOffset', options)
  405. })
  406. }
  407. resolve(doc)
  408. }
  409. // If we already have the document open, or are opening the document, we can return at this point.
  410. // Note: only use forceReopen:true to override this when the document is
  411. // out of sync and needs to be reloaded from the server.
  412. if (doc._id === currentDocumentIdRef.current && !options.forceReopen) {
  413. done(false)
  414. return
  415. }
  416. // We're now either opening a new document or reloading a broken one.
  417. currentDocumentIdRef.current = doc._id as DocId
  418. setCurrentDocumentId(doc._id as DocId)
  419. setOpenDocName(doc.name)
  420. setOpening(true)
  421. try {
  422. const document = await openNewDocument(doc)
  423. syncTrackChangesState(document)
  424. setOpening(false)
  425. setCurrentDocument(document)
  426. done(true)
  427. } catch (error: any) {
  428. if (error?.message === 'another document was loaded') {
  429. debugConsole.log(
  430. `[openDoc] another document was loaded while ${doc._id} was loading`
  431. )
  432. return
  433. }
  434. debugConsole.error('Error opening document', error)
  435. showGenericMessageModal(
  436. t('error_opening_document'),
  437. t('error_opening_document_detail')
  438. )
  439. reject(error)
  440. }
  441. return promise
  442. },
  443. [
  444. eventEmitter,
  445. jumpToLine,
  446. openNewDocument,
  447. setCurrentDocument,
  448. setCurrentDocumentId,
  449. setOpenDocName,
  450. setOpening,
  451. setView,
  452. showGenericMessageModal,
  453. syncTrackChangesState,
  454. t,
  455. view,
  456. ]
  457. )
  458. const openDocWithId = useCallback(
  459. (docId: string, options: OpenDocOptions = {}) => {
  460. const doc = findDocEntityById(fileTreeData, docId)
  461. if (!doc) {
  462. return
  463. }
  464. openDoc(doc, options)
  465. },
  466. [fileTreeData, openDoc]
  467. )
  468. const openInitialDoc = useCallback(
  469. (fallbackDocId: string) => {
  470. const docId =
  471. customLocalStorage.getItem(currentDocumentIdStorageKey) || fallbackDocId
  472. if (docId) {
  473. openDocWithId(docId)
  474. }
  475. },
  476. [currentDocumentIdStorageKey, openDocWithId]
  477. )
  478. useEffect(() => {
  479. if (docError) {
  480. const { doc, document, error, meta } = docError
  481. let { editorContent } = docError
  482. const message = typeof error === 'string' ? error : (error?.message ?? '')
  483. // Clear document error so that it's only handled once
  484. setDocError(null)
  485. if (message.includes('maxDocLength')) {
  486. openDoc(doc, { forceReopen: true })
  487. const hasTrackedDeletes =
  488. document.ranges != null &&
  489. document.ranges.changes.some(change => 'd' in change.op)
  490. const explanation = hasTrackedDeletes
  491. ? `${t('document_too_long_detail')} ${t('document_too_long_tracked_deletes')}`
  492. : t('document_too_long_detail')
  493. showGenericMessageModal(t('document_too_long'), explanation)
  494. setDocTooLongErrorShown(true)
  495. } else if (/too many comments or tracked changes/.test(message)) {
  496. showGenericMessageModal(
  497. t('too_many_comments_or_tracked_changes'),
  498. t('too_many_comments_or_tracked_changes_detail')
  499. )
  500. } else if (!docTooLongErrorShown) {
  501. // Do not allow this doc to open another error modal.
  502. document.off('error')
  503. // Preserve the sharejs contents before the teardown.
  504. // eslint-disable-next-line no-unused-vars
  505. editorContent =
  506. typeof editorContent === 'string'
  507. ? editorContent
  508. : document.doc?._doc.snapshot
  509. // Tear down the ShareJsDoc.
  510. if (document.doc) document.doc.clearInflightAndPendingOps()
  511. // Do not re-join after re-connecting.
  512. document.leaveAndCleanUp()
  513. closeConnection('out-of-sync')
  514. reportError(error, meta)
  515. // Tell the user about the error state.
  516. setIsInErrorState(true)
  517. // Ensure that the editor is locked
  518. setOutOfSync(true)
  519. // Display the "out of sync" modal
  520. showOutOfSyncModal(editorContent || '')
  521. // Do not forceReopen the document.
  522. return
  523. }
  524. const handleProjectJoined = () => {
  525. openDoc(doc, { forceReopen: true })
  526. }
  527. eventEmitter.once('project:joined', handleProjectJoined)
  528. return () => {
  529. eventEmitter.off('project:joined', handleProjectJoined)
  530. }
  531. }
  532. }, [
  533. closeConnection,
  534. docError,
  535. docTooLongErrorShown,
  536. eventEmitter,
  537. openDoc,
  538. reportError,
  539. setIsInErrorState,
  540. showGenericMessageModal,
  541. showOutOfSyncModal,
  542. setOutOfSync,
  543. t,
  544. ])
  545. useEventListener(
  546. 'editor:insert-symbol',
  547. useCallback(() => {
  548. sendMB('symbol-palette-insert')
  549. }, [])
  550. )
  551. useEventListener(
  552. 'flush-changes',
  553. useCallback(() => {
  554. openDocs.flushAll()
  555. }, [openDocs])
  556. )
  557. useEventListener(
  558. 'blur',
  559. useCallback(() => {
  560. openDocs.flushAll()
  561. }, [openDocs])
  562. )
  563. // Flush changes before disconnecting
  564. useEffect(() => {
  565. if (connectionState.forceDisconnected) {
  566. openDocs.flushAll()
  567. }
  568. }, [connectionState.forceDisconnected, openDocs])
  569. // Watch for changes in wantTrackChanges
  570. const previousWantTrackChangesRef = useRef(wantTrackChanges)
  571. useEffect(() => {
  572. if (wantTrackChanges !== previousWantTrackChangesRef.current) {
  573. previousWantTrackChangesRef.current = wantTrackChanges
  574. syncTrackChangesState(currentDocument)
  575. }
  576. }, [currentDocument, syncTrackChangesState, wantTrackChanges])
  577. const editorManager = useMemo(
  578. () => ({
  579. getEditorType,
  580. showSymbolPalette,
  581. currentDocument,
  582. currentDocumentId,
  583. getCurrentDocValue,
  584. getCurrentDocumentId,
  585. startIgnoringExternalUpdates,
  586. stopIgnoringExternalUpdates,
  587. openDocWithId,
  588. openDoc,
  589. openDocs,
  590. openInitialDoc,
  591. jumpToLine,
  592. wantTrackChanges,
  593. setWantTrackChanges,
  594. debugTimers,
  595. }),
  596. [
  597. getEditorType,
  598. showSymbolPalette,
  599. currentDocument,
  600. currentDocumentId,
  601. getCurrentDocValue,
  602. getCurrentDocumentId,
  603. startIgnoringExternalUpdates,
  604. stopIgnoringExternalUpdates,
  605. openDocWithId,
  606. openDoc,
  607. openDocs,
  608. openInitialDoc,
  609. jumpToLine,
  610. wantTrackChanges,
  611. setWantTrackChanges,
  612. debugTimers,
  613. ]
  614. )
  615. // Expose editorManager via ide object because some React code relies on it,
  616. // for now
  617. ide.editorManager = editorManager
  618. return (
  619. <EditorManagerContext.Provider value={editorManager}>
  620. {children}
  621. </EditorManagerContext.Provider>
  622. )
  623. }
  624. export function useEditorManagerContext(): EditorManager {
  625. const context = useContext(EditorManagerContext)
  626. if (!context) {
  627. throw new Error(
  628. 'useEditorManagerContext is only available inside EditorManagerProvider'
  629. )
  630. }
  631. return context
  632. }