@jupyterlab/lsp 4.0.0-alpha.11

package/lib/utils.js

@@ -0,0 +1,71 @@
+import mergeWith from 'lodash.mergewith';
+export async function sleep(timeout) {
+    return new Promise(resolve => {
+        setTimeout(() => {
+            resolve();
+        }, timeout);
+    });
+}
+export function untilReady(isReady, maxRetrials = 35, interval = 50, intervalModifier = (i) => i) {
+    return (async () => {
+        let i = 0;
+        while (isReady() !== true) {
+            i += 1;
+            if (maxRetrials !== -1 && i > maxRetrials) {
+                throw Error('Too many retrials');
+            }
+            interval = intervalModifier(interval);
+            await sleep(interval);
+        }
+        return isReady;
+    })();
+}
+export const expandDottedPaths = (obj) => {
+    const settings = [];
+    for (let key in obj) {
+        const parsed = expandPath(key.split('.'), obj[key]);
+        settings.push(parsed);
+    }
+    return mergeWith({}, ...settings);
+};
+/**
+ * The docs for many language servers show settings in the
+ * VSCode format, e.g.: "pyls.plugins.pyflakes.enabled"
+ *
+ * VSCode converts that dot notation to JSON behind the scenes,
+ * as the language servers themselves don't accept that syntax.
+ */
+export const expandPath = (path, value) => {
+    const obj = Object.create(null);
+    let curr = obj;
+    path.forEach((prop, i) => {
+        curr[prop] = Object.create(null);
+        if (i === path.length - 1) {
+            curr[prop] = value;
+        }
+        else {
+            curr = curr[prop];
+        }
+    });
+    return obj;
+};
+export class DefaultMap extends Map {
+    constructor(defaultFactory, entries) {
+        super(entries);
+        this.defaultFactory = defaultFactory;
+    }
+    get(k) {
+        return this.getOrCreate(k);
+    }
+    getOrCreate(k, ...args) {
+        if (this.has(k)) {
+            return super.get(k);
+        }
+        else {
+            let v = this.defaultFactory(k, ...args);
+            this.set(k, v);
+            return v;
+        }
+    }
+}
+//# sourceMappingURL=utils.js.map

package/lib/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"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"}

package/lib/virtual/document.d.ts

@@ -0,0 +1,270 @@
+import { IDocumentInfo } from 'lsp-ws-connection';
+import { CodeEditor } from '@jupyterlab/codeeditor';
+import { CellType } from '@jupyterlab/nbformat';
+import { Signal } from '@lumino/signaling';
+import { ILSPCodeExtractorsManager } from '../';
+import { LanguageIdentifier } from '../lsp';
+import { IEditorPosition, IRootPosition, ISourcePosition, IVirtualPosition } from '../positioning';
+import { DefaultMap } from '../utils';
+import type * as CodeMirror from 'codemirror';
+declare type IRange = CodeEditor.IRange;
+declare type language = string;
+interface IVirtualLine {
+    /**
+     * Inspections for which document should be skipped for this virtual line?
+     */
+    skipInspect: Array<VirtualDocument.idPath>;
+    /**
+     * Where does the virtual line belongs to in the source document?
+     */
+    sourceLine: number | null;
+    editor: CodeEditor.IEditor;
+}
+export interface ICodeBlockOptions {
+    ceEditor: CodeEditor.IEditor;
+    value: string;
+    type: CellType;
+}
+export interface IVirtualDocumentBlock {
+    /**
+     * Line corresponding to the block in the entire foreign document
+     */
+    virtualLine: number;
+    virtualDocument: VirtualDocument;
+    editor: CodeEditor.IEditor;
+}
+export declare type ForeignDocumentsMap = Map<IRange, IVirtualDocumentBlock>;
+interface ISourceLine {
+    virtualLine: number;
+    editor: CodeEditor.IEditor;
+    editorLine: number;
+    editorShift: CodeEditor.IPosition;
+    /**
+     * Everything which is not in the range of foreign documents belongs to the host.
+     */
+    foreignDocumentsMap: ForeignDocumentsMap;
+}
+export interface IForeignContext {
+    foreignDocument: VirtualDocument;
+    parentHost: VirtualDocument;
+}
+/**
+ * Check if given position is within range.
+ * Both start and end are inclusive.
+ * @param position
+ * @param range
+ */
+export declare function isWithinRange(position: CodeEditor.IPosition, range: CodeEditor.IRange): boolean;
+/**
+ * a virtual implementation of IDocumentInfo
+ */
+export declare class VirtualDocumentInfo implements IDocumentInfo {
+    private _document;
+    version: number;
+    constructor(document: VirtualDocument);
+    get text(): string;
+    get uri(): string;
+    get languageId(): string;
+}
+export declare namespace VirtualDocument {
+    interface IOptions {
+        language: LanguageIdentifier;
+        foreignCodeExtractors: ILSPCodeExtractorsManager;
+        path: string;
+        fileExtension: string | undefined;
+        /**
+         * Notebooks or any other aggregates of documents are not supported
+         * by the LSP specification, and we need to make appropriate
+         * adjustments for them, pretending they are simple files
+         * so that the LSP servers do not refuse to cooperate.
+         */
+        hasLspSupportedFile: boolean;
+        /**
+         * Being standalone is relevant to foreign documents
+         * and defines whether following chunks of code in the same
+         * language should be appended to this document (false, not standalone)
+         * or should be considered separate documents (true, standalone)
+         *
+         */
+        standalone?: boolean;
+        parent?: VirtualDocument;
+    }
+}
+/**
+ * A notebook can hold one or more virtual documents; there is always one,
+ * "root" document, corresponding to the language of the kernel. All other
+ * virtual documents are extracted out of the notebook, based on magics,
+ * or other syntax constructs, depending on the kernel language.
+ *
+ * Virtual documents represent the underlying code in a single language,
+ * which has been parsed excluding interactive kernel commands (magics)
+ * which could be misunderstood by the specific LSP server.
+ *
+ * VirtualDocument has no awareness of the notebook or editor it lives in,
+ * however it is able to transform its content back to the notebook space,
+ * as it keeps editor coordinates for each virtual line.
+ *
+ * The notebook/editor aware transformations are preferred to be placed in
+ * VirtualEditor descendants rather than here.
+ *
+ * No dependency on editor implementation (such as CodeMirrorEditor)
+ * is allowed for VirtualEditor.
+ */
+export declare class VirtualDocument {
+    language: string;
+    standalone: boolean;
+    isDisposed: boolean;
+    blankLinesBetweenCells: number;
+    lastSourceLine: number;
+    foreignDocumentClosed: Signal<VirtualDocument, IForeignContext>;
+    foreignDocumentOpened: Signal<VirtualDocument, IForeignContext>;
+    lastVirtualLine: number;
+    /**
+     * the remote document uri, version and other server-related info
+     */
+    documentInfo: IDocumentInfo;
+    /**
+     * Virtual lines keep all the lines present in the document AND extracted to the foreign document.
+     */
+    virtualLines: Map<number, IVirtualLine>;
+    changed: Signal<VirtualDocument, VirtualDocument>;
+    path: string;
+    fileExtension: string | undefined;
+    hasLspSupportedFile: boolean;
+    parent?: VirtualDocument | null;
+    updateManager: UpdateManager;
+    foreignDocuments: Map<VirtualDocument.virtualId, VirtualDocument>;
+    readonly instanceId: number;
+    protected sourceLines: Map<number, ISourceLine>;
+    protected lineBlocks: Array<string>;
+    protected unusedDocuments: Set<VirtualDocument>;
+    protected unusedStandaloneDocuments: DefaultMap<language, Array<VirtualDocument>>;
+    private _remainingLifetime;
+    private _editorToSourceLine;
+    private _editorToSourceLineNew;
+    private _foreignCodeExtractors;
+    private previousValue;
+    private static instancesCount;
+    private readonly options;
+    constructor(options: VirtualDocument.IOptions);
+    dispose(): void;
+    /**
+     * When this counter goes down to 0, the document will be destroyed and the associated connection will be closed;
+     * This is meant to reduce the number of open connections when a a foreign code snippet was removed from the document.
+     *
+     * Note: top level virtual documents are currently immortal (unless killed by other means); it might be worth
+     * implementing culling of unused documents, but if and only if JupyterLab will also implement culling of
+     * idle kernels - otherwise the user experience could be a bit inconsistent, and we would need to invent our own rules.
+     */
+    protected get remainingLifetime(): number;
+    protected set remainingLifetime(value: number);
+    clear(): void;
+    documentAtSourcePosition(position: ISourcePosition): VirtualDocument;
+    isWithinForeign(sourcePosition: ISourcePosition): boolean;
+    transformFromEditorToRoot(editor: CodeEditor.IEditor, position: IEditorPosition): IRootPosition | null;
+    virtualPositionAtDocument(sourcePosition: ISourcePosition): IVirtualPosition;
+    appendCodeBlock(block: ICodeBlockOptions, editorShift?: CodeEditor.IPosition, virtualShift?: CodeEditor.IPosition): void;
+    prepareCodeBlock(block: ICodeBlockOptions, editorShift?: CodeEditor.IPosition): {
+        lines: string[];
+        foreignDocumentsMap: Map<CodeEditor.IRange, IVirtualDocumentBlock>;
+    };
+    extractForeignCode(block: ICodeBlockOptions, editorShift: CodeEditor.IPosition): {
+        cellCodeKept: string;
+        foreignDocumentsMap: Map<CodeEditor.IRange, IVirtualDocumentBlock>;
+    };
+    private chooseForeignDocument;
+    private openForeign;
+    private forwardClosedSignal;
+    private forwardOpenedSignal;
+    closeForeign(document: VirtualDocument): void;
+    closeAllForeignDocuments(): void;
+    get value(): string;
+    get lastLine(): string;
+    closeExpiredDocuments(): void;
+    get virtualId(): VirtualDocument.virtualId;
+    get ancestry(): Array<VirtualDocument>;
+    get idPath(): VirtualDocument.idPath;
+    get uri(): VirtualDocument.uri;
+    transformSourceToEditor(pos: ISourcePosition): IEditorPosition;
+    /**
+    Can be null because some lines are added as padding/anchors
+    to the virtual document and those do not exist in the source document
+    and thus they are absent in the editor.
+    */
+    transformVirtualToEditor(virtualPosition: IVirtualPosition): IEditorPosition | null;
+    /**
+    Can be null because some lines are added as padding/anchors
+    to the virtual document and those do not exist in the source document.
+    */
+    transformVirtualToSource(position: IVirtualPosition): ISourcePosition | null;
+    get root(): VirtualDocument;
+    getEditorAtVirtualLine(pos: IVirtualPosition): CodeEditor.IEditor;
+    getEditorAtSourceLine(pos: ISourcePosition): CodeEditor.IEditor;
+    /**
+     * Recursively emits changed signal from the document or any descendant foreign document.
+     */
+    maybeEmitChanged(): void;
+    static ceToCm(position: CodeEditor.IPosition): CodeMirror.Position;
+}
+export declare namespace VirtualDocument {
+    /**
+     * Identifier composed of `virtual_id`s of a nested structure of documents,
+     * used to aide assignment of the connection to the virtual document
+     * handling specific, nested language usage; it will be appended to the file name
+     * when creating a connection.
+     */
+    type idPath = string;
+    /**
+     * Instance identifier for standalone documents (snippets), or language identifier
+     * for documents which should be interpreted as one when stretched across cells.
+     */
+    type virtualId = string;
+    /**
+     * Identifier composed of the file path and id_path.
+     */
+    type uri = string;
+}
+export declare function collectDocuments(virtualDocument: VirtualDocument): Set<VirtualDocument>;
+export interface IBlockAddedInfo {
+    virtualDocument: VirtualDocument;
+    block: ICodeBlockOptions;
+}
+export declare class UpdateManager {
+    private virtualDocument;
+    /**
+     * Virtual documents update guard.
+     */
+    private isUpdateInProgress;
+    private updateLock;
+    protected isDisposed: boolean;
+    /**
+     * Signal emitted by the editor that triggered the update, providing the root document of the updated documents.
+     */
+    private documentUpdated;
+    blockAdded: Signal<UpdateManager, IBlockAddedInfo>;
+    updateDone: Promise<void>;
+    updateBegan: Signal<UpdateManager, ICodeBlockOptions[]>;
+    updateFinished: Signal<UpdateManager, ICodeBlockOptions[]>;
+    constructor(virtualDocument: VirtualDocument);
+    dispose(): void;
+    /**
+     * Once all the foreign documents were refreshed, the unused documents (and their connections)
+     * should be terminated if their lifetime has expired.
+     */
+    private onUpdated;
+    private canUpdate;
+    /**
+     * Execute provided callback within an update-locked context, which guarantees that:
+     *  - the previous updates must have finished before the callback call, and
+     *  - no update will happen when executing the callback
+     * @param fn - the callback to execute in update lock
+     */
+    withUpdateLock(fn: () => void): Promise<void>;
+    /**
+     * Update all the virtual documents, emit documents updated with root document if succeeded,
+     * and resolve a void promise. The promise does not contain the text value of the root document,
+     * as to avoid an easy trap of ignoring the changes in the virtual documents.
+     */
+    updateDocuments(blocks: ICodeBlockOptions[]): Promise<void>;
+}
+export {};