restructured currentUserUtils to avoid having import cycles.

1 files changed, 100 insertions, 84 deletions

diff --git a/src/client/util/DocumentManager.ts b/src/client/util/DocumentManager.ts
index 8473ce703..d3ac2f03f 100644
--- a/src/client/util/DocumentManager.ts
+++ b/src/client/util/DocumentManager.ts
@@ -4,44 +4,43 @@ import { Id } from '../../fields/FieldSymbols';
 import { Cast } from '../../fields/Types';
 import { returnFalse } from '../../Utils';
 import { DocumentType } from '../documents/DocumentTypes';
-import { CollectionDockingView } from '../views/collections/CollectionDockingView';
-import { CollectionFreeFormView } from '../views/collections/collectionFreeForm';
-import { CollectionView } from '../views/collections/CollectionView';
 import { LightboxView } from '../views/LightboxView';
 import { DocumentView, ViewAdjustment } from '../views/nodes/DocumentView';
 import { LinkAnchorBox } from '../views/nodes/LinkAnchorBox';
-import { CurrentUserUtils } from './CurrentUserUtils';
+import { CollectionDockingView } from '../views/collections/CollectionDockingView';
+import { CollectionFreeFormView } from '../views/collections/collectionFreeForm';
+import { CollectionView } from '../views/collections/CollectionView';
 import { ScriptingGlobals } from './ScriptingGlobals';
 import { SelectionManager } from './SelectionManager';
 
 export class DocumentManager {
-
     //global holds all of the nodes (regardless of which collection they're in)
     @observable public DocumentViews = new Set<DocumentView>();
     @observable public LinkAnchorBoxViews: DocumentView[] = [];
     @observable public RecordingEvent = 0;
-    @observable public LinkedDocumentViews: { a: DocumentView, b: DocumentView, l: Doc }[] = [];
+    @observable public LinkedDocumentViews: { a: DocumentView; b: DocumentView; l: Doc }[] = [];
 
     private static _instance: DocumentManager;
-    public static get Instance(): DocumentManager { return this._instance || (this._instance = new this()); }
+    public static get Instance(): DocumentManager {
+        return this._instance || (this._instance = new this());
+    }
 
     //private constructor so no other class can create a nodemanager
-    private constructor() { }
+    private constructor() {}
 
     @action
     public AddView = (view: DocumentView) => {
         //console.log("MOUNT " + view.props.Document.title + "/" + view.props.LayoutTemplateString);
         if (view.props.LayoutTemplateString?.includes(LinkAnchorBox.name)) {
-            const viewAnchorIndex = view.props.LayoutTemplateString.includes("anchor2") ? "anchor2" : "anchor1";
+            const viewAnchorIndex = view.props.LayoutTemplateString.includes('anchor2') ? 'anchor2' : 'anchor1';
             DocListCast(view.rootDoc.links).forEach(link => {
-                this.LinkAnchorBoxViews?.filter(dv => Doc.AreProtosEqual(dv.rootDoc, link) && !dv.props.LayoutTemplateString?.includes(viewAnchorIndex)).
-                    forEach(otherView => this.LinkedDocumentViews.push(
-                        {
-                            a: viewAnchorIndex === "anchor2" ? otherView : view,
-                            b: viewAnchorIndex === "anchor2" ? view : otherView,
-                            l: link
-                        })
-                    );
+                this.LinkAnchorBoxViews?.filter(dv => Doc.AreProtosEqual(dv.rootDoc, link) && !dv.props.LayoutTemplateString?.includes(viewAnchorIndex)).forEach(otherView =>
+                    this.LinkedDocumentViews.push({
+                        a: viewAnchorIndex === 'anchor2' ? otherView : view,
+                        b: viewAnchorIndex === 'anchor2' ? view : otherView,
+                        l: link,
+                    })
+                );
             });
             this.LinkAnchorBoxViews.push(view);
             // this.LinkedDocumentViews.forEach(view => console.log("  LV = " + view.a.props.Document.title + "/" + view.a.props.LayoutTemplateString + " --> " +
@@ -49,14 +48,16 @@ export class DocumentManager {
         } else {
             this.DocumentViews.add(view);
         }
-    }
+    };
     public RemoveView = action((view: DocumentView) => {
-        this.LinkedDocumentViews.slice().forEach(action(pair => {
-            if (pair.a === view || pair.b === view) {
-                const li = this.LinkedDocumentViews.indexOf(pair);
-                li !== -1 && this.LinkedDocumentViews.splice(li, 1);
-            }
-        }));
+        this.LinkedDocumentViews.slice().forEach(
+            action(pair => {
+                if (pair.a === view || pair.b === view) {
+                    const li = this.LinkedDocumentViews.indexOf(pair);
+                    li !== -1 && this.LinkedDocumentViews.splice(li, 1);
+                }
+            })
+        );
 
         if (view.props.LayoutTemplateString?.includes(LinkAnchorBox.name)) {
             const index = this.LinkAnchorBoxViews.indexOf(view);
@@ -125,11 +126,11 @@ export class DocumentManager {
         const views: DocumentView[] = [];
         Array.from(DocumentManager.Instance.DocumentViews).map(view => LightboxView.IsLightboxDocView(view.docViewPath) && Doc.AreProtosEqual(view.rootDoc, toFind) && views.push(view));
         return views?.find(view => view.ContentDiv?.getBoundingClientRect().width && view.props.focus !== returnFalse) || views?.find(view => view.props.focus !== returnFalse) || (views.length ? views[0] : undefined);
-    }
+    };
     public getFirstDocumentView = (toFind: Doc, originatingDoc: Opt<Doc> = undefined): DocumentView | undefined => {
         const views = this.getDocumentViews(toFind).filter(view => view.rootDoc !== originatingDoc);
         return views?.find(view => view.ContentDiv?.getBoundingClientRect().width && view.props.focus !== returnFalse) || views?.find(view => view.props.focus !== returnFalse) || (views.length ? views[0] : undefined);
-    }
+    };
     public getDocumentViews(toFind: Doc): DocumentView[] {
         const toReturn: DocumentView[] = [];
         const docViews = Array.from(DocumentManager.Instance.DocumentViews).filter(view => !LightboxView.IsLightboxDocView(view.docViewPath));
@@ -146,17 +147,16 @@ export class DocumentManager {
         return toReturn;
     }
 
-
     static addView = (doc: Doc, finished?: () => void) => {
-        CollectionDockingView.AddSplit(doc, "right");
+        CollectionDockingView.AddSplit(doc, 'right');
         finished?.();
-    }
+    };
     public jumpToDocument = async (
-        targetDoc: Doc,        // document to display
-        willZoom: boolean,     // whether to zoom doc to take up most of screen
+        targetDoc: Doc, // document to display
+        willZoom: boolean, // whether to zoom doc to take up most of screen
         createViewFunc = DocumentManager.addView, // how to create a view of the doc if it doesn't exist
-        docContext: Doc[],  // context to load that should contain the target
-        linkDoc?: Doc,   // link that's being followed
+        docContext: Doc[], // context to load that should contain the target
+        linkDoc?: Doc, // link that's being followed
         closeContextIfNotFound: boolean = false, // after opening a context where the document should be, this determines whether the context should be closed if the Doc isn't actually there
         originatingDoc: Opt<Doc> = undefined, // doc that initiated the display of the target odoc
         finished?: () => void,
@@ -172,14 +172,15 @@ export class DocumentManager {
         var wasHidden = resolvedTarget.hidden;
         if (wasHidden) {
             runInAction(() => {
-                resolvedTarget.hidden = false;  // if the target is hidden, un-hide it here.
+                resolvedTarget.hidden = false; // if the target is hidden, un-hide it here.
                 docView?.props.bringToFront(resolvedTarget);
             });
         }
         const focusAndFinish = (didFocus: boolean) => {
             const finalTargetDoc = resolvedTarget;
             if (originatingDoc?.isPushpin) {
-                if (!didFocus && !wasHidden) {  // don't toggle the hidden state if the doc was already un-hidden as part of this document traversal
+                if (!didFocus && !wasHidden) {
+                    // don't toggle the hidden state if the doc was already un-hidden as part of this document traversal
                     finalTargetDoc.hidden = !finalTargetDoc.hidden;
                 }
             } else {
@@ -192,77 +193,92 @@ export class DocumentManager {
         const contextDocs = docContext.length ? await DocListCastAsync(docContext[0].data) : undefined;
         const contextDoc = contextDocs?.find(doc => Doc.AreProtosEqual(doc, targetDoc) || Doc.AreProtosEqual(doc, annotatedDoc)) ? docContext.lastElement() : undefined;
         const targetDocContext = contextDoc || annotatedDoc;
-        const targetDocContextView = (targetDocContext && getFirstDocView(targetDocContext)) ||
-            (wasHidden && annoContainerView);// if we have an annotation container and the target was hidden, then try again because we just un-hid the document above
+        const targetDocContextView = (targetDocContext && getFirstDocView(targetDocContext)) || (wasHidden && annoContainerView); // if we have an annotation container and the target was hidden, then try again because we just un-hid the document above
         const focusView = !docView && targetDoc.type === DocumentType.MARKER && annoContainerView ? annoContainerView : docView;
         if (annoContainerView) {
-            if (annoContainerView.props.Document.layoutKey === "layout_icon") {
-                annoContainerView.iconify(() => annoContainerView.focus(targetDoc, {
-                    originalTarget, willZoom, scale: presZoom, afterFocus: (didFocus: boolean) =>
-                        new Promise<ViewAdjustment>(res => {
-                            focusAndFinish(true);
-                            res(ViewAdjustment.doNothing);
-                        })
-                }));
+            if (annoContainerView.props.Document.layoutKey === 'layout_icon') {
+                annoContainerView.iconify(() =>
+                    annoContainerView.focus(targetDoc, {
+                        originalTarget,
+                        willZoom,
+                        scale: presZoom,
+                        afterFocus: (didFocus: boolean) =>
+                            new Promise<ViewAdjustment>(res => {
+                                focusAndFinish(true);
+                                res(ViewAdjustment.doNothing);
+                            }),
+                    })
+                );
                 return;
             } else if (!docView && targetDoc.type !== DocumentType.MARKER) {
-                annoContainerView.focus(targetDoc);  // this allows something like a PDF view to remove its doc filters to expose the target so that it can be found in the retry code below
+                annoContainerView.focus(targetDoc); // this allows something like a PDF view to remove its doc filters to expose the target so that it can be found in the retry code below
             }
         }
         if (focusView) {
             !noSelect && Doc.linkFollowHighlight(focusView.rootDoc); //TODO:glr make this a setting in PresBox
-            const doFocus = (forceDidFocus: boolean) => focusView.focus(originalTarget ?? targetDoc, {
-                originalTarget, willZoom, scale: presZoom, afterFocus: (didFocus: boolean) =>
-                    new Promise<ViewAdjustment>(res => {
-                        focusAndFinish(forceDidFocus || didFocus);
-                        res(ViewAdjustment.doNothing);
-                    })
-            });
-            if (focusView.props.Document.layoutKey === "layout_icon") {
+            const doFocus = (forceDidFocus: boolean) =>
+                focusView.focus(originalTarget ?? targetDoc, {
+                    originalTarget,
+                    willZoom,
+                    scale: presZoom,
+                    afterFocus: (didFocus: boolean) =>
+                        new Promise<ViewAdjustment>(res => {
+                            focusAndFinish(forceDidFocus || didFocus);
+                            res(ViewAdjustment.doNothing);
+                        }),
+                });
+            if (focusView.props.Document.layoutKey === 'layout_icon') {
                 focusView.iconify(() => doFocus(true));
             } else {
                 doFocus(false);
             }
         } else {
-            if (!targetDocContext) { // we don't have a view and there's no context specified ... create a new view of the target using the dockFunc or default
+            if (!targetDocContext) {
+                // we don't have a view and there's no context specified ... create a new view of the target using the dockFunc or default
                 createViewFunc(Doc.BrushDoc(targetDoc), finished); // bcz: should we use this?: Doc.MakeAlias(targetDoc)));
-            } else {  // otherwise try to get a view of the context of the target
-                if (targetDocContextView) { // we found a context view and aren't forced to create a new one ... focus on the context first..
+            } else {
+                // otherwise try to get a view of the context of the target
+                if (targetDocContextView) {
+                    // we found a context view and aren't forced to create a new one ... focus on the context first..
                     wasHidden = wasHidden || targetDocContextView.rootDoc.hidden;
                     targetDocContextView.rootDoc.hidden = false; // make sure context isn't hidden
-                    targetDocContext._viewTransition = "transform 500ms";
+                    targetDocContext._viewTransition = 'transform 500ms';
                     targetDocContextView.props.focus(targetDocContextView.rootDoc, {
-                        willZoom, afterFocus: async () => {
+                        willZoom,
+                        afterFocus: async () => {
                             targetDocContext._viewTransition = undefined;
-                            if (targetDocContext.layoutKey === "layout_icon") {
-                                targetDocContextView.iconify(() => this.jumpToDocument(
-                                    resolvedTarget ?? targetDoc, willZoom, createViewFunc, docContext, linkDoc, closeContextIfNotFound, originatingDoc,
-                                    finished, originalTarget, noSelect, presZoom));
+                            if (targetDocContext.layoutKey === 'layout_icon') {
+                                targetDocContextView.iconify(() => this.jumpToDocument(resolvedTarget ?? targetDoc, willZoom, createViewFunc, docContext, linkDoc, closeContextIfNotFound, originatingDoc, finished, originalTarget, noSelect, presZoom));
                             }
                             return ViewAdjustment.doNothing;
-                        }
+                        },
                     });
 
                     // now find the target document within the context
-                    if (targetDoc._timecodeToShow) {  // if the target has a timecode, it should show up once the (presumed) video context scrubs to the display timecode;
+                    if (targetDoc._timecodeToShow) {
+                        // if the target has a timecode, it should show up once the (presumed) video context scrubs to the display timecode;
                         targetDocContext._currentTimecode = targetDoc.anchorTimecodeToShow;
                         finished?.();
-                    } else { // no timecode means we need to find the context view and focus on our target
+                    } else {
+                        // no timecode means we need to find the context view and focus on our target
                         const findView = (delay: number) => {
-                            const retryDocView = getFirstDocView(resolvedTarget);  // test again for the target view snce we presumably created the context above by focusing on it
-                            if (retryDocView) {   // we found the target in the context. 
+                            const retryDocView = getFirstDocView(resolvedTarget); // test again for the target view snce we presumably created the context above by focusing on it
+                            if (retryDocView) {
+                                // we found the target in the context.
                                 Doc.linkFollowHighlight(retryDocView.rootDoc);
                                 retryDocView.focus(targetDoc, {
-                                    willZoom, afterFocus: (didFocus: boolean) =>
+                                    willZoom,
+                                    afterFocus: (didFocus: boolean) =>
                                         new Promise<ViewAdjustment>(res => {
                                             !noSelect && focusAndFinish(true);
                                             res(ViewAdjustment.doNothing);
-                                        })
+                                        }),
                                 }); // focus on the target in the context
                             } else if (delay > 1000) {
                                 // we didn't find the target, so it must have moved out of the context.  Go back to just creating it.
                                 if (closeContextIfNotFound) targetDocContextView.props.removeDocument?.(targetDocContextView.rootDoc);
-                                if (targetDoc.layout) { // there will no layout for a TEXTANCHOR type document
+                                if (targetDoc.layout) {
+                                    // there will no layout for a TEXTANCHOR type document
                                     createViewFunc(Doc.BrushDoc(targetDoc), finished); //  create a new view of the target
                                 }
                             } else {
@@ -272,22 +288,24 @@ export class DocumentManager {
                         setTimeout(() => findView(0), 0);
                     }
                 } else {
-                    if (docContext.length && docContext[0]?.layoutKey === "layout_icon") {
+                    if (docContext.length && docContext[0]?.layoutKey === 'layout_icon') {
                         const docContextView = this.getFirstDocumentView(docContext[0]);
                         if (docContextView) {
-                            return docContextView.iconify(() => this.jumpToDocument(
-                                targetDoc, willZoom, createViewFunc, docContext.slice(1, docContext.length), linkDoc, closeContextIfNotFound, originatingDoc,
-                                finished, originalTarget, noSelect, presZoom));
+                            return docContextView.iconify(() =>
+                                this.jumpToDocument(targetDoc, willZoom, createViewFunc, docContext.slice(1, docContext.length), linkDoc, closeContextIfNotFound, originatingDoc, finished, originalTarget, noSelect, presZoom)
+                            );
                         }
                     }
                     // there's no context view so we need to create one first and try again when that finishes
                     const finishFunc = () => this.jumpToDocument(targetDoc, true, createViewFunc, docContext, linkDoc, true /* if we don't find the target, we want to get rid of the context just created */, undefined, finished, originalTarget);
-                    createViewFunc(targetDocContext, // after creating the context, this calls the finish function that will retry looking for the target
-                        finishFunc);
+                    createViewFunc(
+                        targetDocContext, // after creating the context, this calls the finish function that will retry looking for the target
+                        finishFunc
+                    );
                 }
             }
         }
-    }
+    };
 }
 export function DocFocusOrOpen(doc: Doc, collectionDoc?: Doc) {
     const cv = collectionDoc && DocumentManager.Instance.getDocumentView(collectionDoc);
@@ -295,14 +313,12 @@ export function DocFocusOrOpen(doc: Doc, collectionDoc?: Doc) {
     if (dv && Doc.AreProtosEqual(dv.props.Document, doc)) {
         dv.props.focus(dv.props.Document, { willZoom: true });
         Doc.linkFollowHighlight(dv?.props.Document, false);
-    }
-    else {
-        const context = doc.context !== CurrentUserUtils.MyFilesystem && Cast(doc.context, Doc, null);
+    } else {
+        const context = doc.context !== Doc.MyFilesystem && Cast(doc.context, Doc, null);
         const showDoc = context || doc;
         const bestAlias = showDoc === Doc.GetProto(showDoc) ? DocListCast(showDoc.aliases).find(doc => !doc.context && doc.author === Doc.CurrentUserEmail) : showDoc;
 
-        CollectionDockingView.AddSplit(bestAlias ? bestAlias : Doc.MakeAlias(showDoc), "right") && context &&
-            setTimeout(() => DocumentManager.Instance.getDocumentView(Doc.GetProto(doc))?.focus(doc));
+        CollectionDockingView.AddSplit(bestAlias ? bestAlias : Doc.MakeAlias(showDoc), 'right') && context && setTimeout(() => DocumentManager.Instance.getDocumentView(Doc.GetProto(doc))?.focus(doc));
     }
 }
-ScriptingGlobals.add(DocFocusOrOpen);
\ No newline at end of file
+ScriptingGlobals.add(DocFocusOrOpen);