@jupytergis/schema 0.1.6 → 0.2.0

package/lib/interfaces.d.ts

@@ -1,15 +1,28 @@
-import { ICollaborativeDrive } from '@jupyter/docprovider';
 import { Delta, DocumentChange, MapChange, StateChange, YDocument } from '@jupyter/ydoc';
 import { IWidgetTracker } from '@jupyterlab/apputils';
 import { IChangedArgs } from '@jupyterlab/coreutils';
 import { DocumentRegistry, IDocumentWidget } from '@jupyterlab/docregistry';
-import { User } from '@jupyterlab/services';
+import { Contents, User } from '@jupyterlab/services';
 import { ISignal, Signal } from '@lumino/signaling';
 import { SplitPanel } from '@lumino/widgets';
 import { GeoJSON } from './_interface/geojsonsource';
 import { IJGISContent, IJGISLayer, IJGISLayerGroup, IJGISLayerItem, IJGISLayers, IJGISLayerTree, IJGISOptions, IJGISSource, IJGISSources, SourceType } from './_interface/jgis';
 import { IRasterSource } from './_interface/rastersource';
 export { IGeoJSONSource } from './_interface/geojsonsource';
+export type JgisCoordinates = {
+    x: number;
+    y: number;
+};
+export interface IViewPortState {
+    coordinates: JgisCoordinates;
+    zoom: number;
+}
+export type Pointer = {
+    coordinates: {
+        x: number;
+        y: number;
+    };
+};
 export interface IDict<T = any> {
     [key: string]: T;
 }
@@ -41,6 +54,18 @@ export interface IJupyterGISClientState {
         };
         emitter?: string | null;
     };
+    viewportState: {
+        value?: IViewPortState;
+        emitter?: string | null;
+    };
+    pointer: {
+        value?: Pointer;
+        emitter?: string | null;
+    };
+    identifiedFeatures: {
+        value?: any;
+        emitter?: string | null;
+    };
     user: User.IIdentity;
     remoteUser?: number;
     toolbarForm?: IDict;
@@ -50,6 +75,7 @@ export interface IJupyterGISDoc extends YDocument<IJupyterGISDocChange> {
     layers: IJGISLayers;
     sources: IJGISSources;
     layerTree: IJGISLayerTree;
+    metadata: any;
     readonly editable: boolean;
     readonly toJGISEndpoint?: string;
     layerExists(id: string): boolean;
@@ -58,7 +84,7 @@ export interface IJupyterGISDoc extends YDocument<IJupyterGISDocChange> {
     addLayer(id: string, value: IJGISLayer, groupName?: string, position?: number): void;
     updateLayer(id: string, value: IJGISLayer): void;
     sourceExists(id: string): boolean;
-    getSource(id: string): IJGISSource | undefined;
+    getLayerSource(id: string): IJGISSource | undefined;
     removeSource(id: string): void;
     addSource(id: string, value: IJGISSource): void;
     updateSource(id: string, value: IJGISSource): void;
@@ -68,10 +94,14 @@ export interface IJupyterGISDoc extends YDocument<IJupyterGISDocChange> {
     getObject(id: string): IJGISLayer | IJGISSource | undefined;
     getOption(key: keyof IJGISOptions): IDict | undefined;
     setOption(key: keyof IJGISOptions, value: IDict): void;
+    getMetadata(key: string): string | undefined;
+    setMetadata(key: string, value: string): void;
+    removeMetadata(key: string): void;
     optionsChanged: ISignal<IJupyterGISDoc, MapChange>;
     layersChanged: ISignal<IJupyterGISDoc, IJGISLayerDocChange>;
     sourcesChanged: ISignal<IJupyterGISDoc, IJGISSourceDocChange>;
     layerTreeChanged: ISignal<IJupyterGISDoc, IJGISLayerTreeDocChange>;
+    metadataChanged: ISignal<IJupyterGISDoc, MapChange>;
 }
 export interface IJupyterGISDocChange extends DocumentChange {
     contextChange?: MapChange;
@@ -89,13 +119,16 @@ export interface IJupyterGISModel extends DocumentRegistry.IModel {
     isDisposed: boolean;
     sharedModel: IJupyterGISDoc;
     localState: IJupyterGISClientState | null;
+    annotationModel?: IAnnotationModel;
     themeChanged: Signal<IJupyterGISModel, IChangedArgs<string, string | null, string>>;
     clientStateChanged: ISignal<IJupyterGISModel, Map<number, IJupyterGISClientState>>;
     sharedOptionsChanged: ISignal<IJupyterGISDoc, MapChange>;
     sharedLayersChanged: ISignal<IJupyterGISDoc, IJGISLayerDocChange>;
     sharedLayerTreeChanged: ISignal<IJupyterGISDoc, IJGISLayerTreeDocChange>;
     sharedSourcesChanged: ISignal<IJupyterGISDoc, IJGISSourceDocChange>;
-    setDrive(value: ICollaborativeDrive, filePath: string): void;
+    sharedMetadataChanged: ISignal<IJupyterGISModel, MapChange>;
+    zoomToAnnotationSignal: ISignal<IJupyterGISModel, string>;
+    setContentsManager(value: Contents.IManager | undefined, filePath: string): void;
     getContent(): IJGISContent;
     getLayers(): IJGISLayers;
     getLayer(id: string): IJGISLayer | undefined;
@@ -118,11 +151,19 @@ export interface IJupyterGISModel extends DocumentRegistry.IModel {
     addNewLayerGroup(selected: {
         [key: string]: ISelection;
     }, group: IJGISLayerGroup): void;
+    syncViewport(viewport?: IViewPortState, emitter?: string): void;
     syncSelected(value: {
         [key: string]: ISelection;
     }, emitter?: string): void;
+    syncPointer(pointer?: Pointer, emitter?: string): void;
+    syncIdentifiedFeatures(features: IDict<any>, emitter?: string): void;
     setUserToFollow(userId?: number): void;
     getClientId(): number;
+    addMetadata(key: string, value: string): void;
+    removeMetadata(key: string): void;
+    centerOnAnnotation(id: string): void;
+    toggleIdentify(): void;
+    isIdentifying: boolean;
     disposed: ISignal<any, void>;
 }
 export interface IUserData {
@@ -183,3 +224,29 @@ export interface IJGISLayerBrowserRegistry {
     removeRegistryLayer(name: string): void;
     clearRegistry(): void;
 }
+export interface IAnnotationModel {
+    updateSignal: ISignal<this, null>;
+    user: User.IIdentity | undefined;
+    context: DocumentRegistry.IContext<IJupyterGISModel> | undefined;
+    contextChanged: ISignal<this, void>;
+    update(): void;
+    getAnnotation(id: string): IAnnotation | undefined;
+    getAnnotationIds(): string[];
+    addAnnotation(key: string, value: IAnnotation): void;
+    removeAnnotation(key: string): void;
+    addContent(id: string, value: string): void;
+}
+export interface IAnnotationContent {
+    user?: User.IIdentity;
+    value: string;
+}
+export interface IAnnotation {
+    label: string;
+    position: {
+        x: number;
+        y: number;
+    };
+    zoom: number;
+    contents: IAnnotationContent[];
+    parent: string;
+}

package/lib/model.d.ts

@@ -1,4 +1,3 @@
-import { ICollaborativeDrive } from '@jupyter/docprovider';
 import { MapChange } from '@jupyter/ydoc';
 import { IChangedArgs } from '@jupyterlab/coreutils';
 import { DocumentRegistry } from '@jupyterlab/docregistry';
@@ -6,11 +5,12 @@ import { PartialJSONObject } from '@lumino/coreutils';
 import { ISignal, Signal } from '@lumino/signaling';
 import { GeoJSON } from './_interface/geojsonsource';
 import { IJGISContent, IJGISLayer, IJGISLayerGroup, IJGISLayerTree, IJGISLayers, IJGISOptions, IJGISSource, IJGISSources } from './_interface/jgis';
-import { IJGISLayerDocChange, IJGISLayerTreeDocChange, IJGISSourceDocChange, IJupyterGISClientState, IJupyterGISDoc, IJupyterGISModel, ISelection, IUserData } from './interfaces';
+import { IViewPortState, Pointer, IAnnotationModel, IJGISLayerDocChange, IJGISLayerTreeDocChange, IJGISSourceDocChange, IJupyterGISClientState, IJupyterGISDoc, IJupyterGISModel, ISelection, IUserData, IDict } from './interfaces';
+import { Contents } from '@jupyterlab/services';
 export declare class JupyterGISModel implements IJupyterGISModel {
-    constructor(options: DocumentRegistry.IModelOptions<IJupyterGISDoc>);
+    constructor(options: JupyterGISModel.IOptions);
     private _onSharedModelChanged;
-    readonly collaborative = true;
+    readonly collaborative: boolean;
     get sharedModel(): IJupyterGISDoc;
     get isDisposed(): boolean;
     get contentChanged(): ISignal<this, void>;
@@ -30,6 +30,14 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     get sharedLayerTreeChanged(): ISignal<IJupyterGISDoc, IJGISLayerTreeDocChange>;
     get sharedSourcesChanged(): ISignal<IJupyterGISDoc, IJGISSourceDocChange>;
     get disposed(): ISignal<JupyterGISModel, void>;
+    get sharedMetadataChanged(): ISignal<this, MapChange>;
+    get zoomToAnnotationSignal(): ISignal<this, string>;
+    set isIdentifying(isIdentifying: boolean);
+    get isIdentifying(): boolean;
+    centerOnAnnotation(id: string): void;
+    private _metadataChangedHandler;
+    addMetadata(key: string, value: string): void;
+    removeMetadata(key: string): void;
     dispose(): void;
     toString(): string;
     fromString(data: string): void;
@@ -38,7 +46,7 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     initialize(): void;
     getWorker(): Worker;
     getContent(): IJGISContent;
-    setDrive(value: ICollaborativeDrive, filePath: string): void;
+    setContentsManager(value: Contents.IManager | undefined, filePath: string): void;
     getLayers(): IJGISLayers;
     getSources(): IJGISSources;
     getLayerTree(): IJGISLayerTree;
@@ -89,9 +97,12 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     removeLayer(layer_id: string): void;
     setOptions(value: IJGISOptions): void;
     getOptions(): IJGISOptions;
+    syncViewport(viewport?: IViewPortState, emitter?: string): void;
+    syncPointer(pointer?: Pointer, emitter?: string): void;
     syncSelected(value: {
         [key: string]: ISelection;
     }, emitter?: string): void;
+    syncIdentifiedFeatures(features: IDict<any>, emitter?: string): void;
     setUserToFollow(userId?: number): void;
     getClientId(): number;
     /**
@@ -111,15 +122,18 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     }, group: IJGISLayerGroup): void;
     private _removeLayerTreeLayer;
     private _removeLayerTreeGroup;
+    private _removeLayerTreeItem;
     renameLayerGroup(groupName: string, newName: string): void;
     removeLayerGroup(groupName: string): void;
+    toggleIdentify(): void;
     private _getLayerTreeInfo;
     private _onClientStateChanged;
     readonly defaultKernelName: string;
     readonly defaultKernelLanguage: string;
+    readonly annotationModel?: IAnnotationModel;
     private _sharedModel;
     private _filePath;
-    private _drive?;
+    private _contentsManager?;
     private _dirty;
     private _readOnly;
     private _isDisposed;
@@ -130,6 +144,9 @@ export declare class JupyterGISModel implements IJupyterGISModel {
     private _stateChanged;
     private _themeChanged;
     private _clientStateChanged;
+    private _sharedMetadataChanged;
+    private _zoomToAnnotationSignal;
+    private _isIdentifying;
     static worker: Worker;
 }
 export declare namespace JupyterGISModel {
@@ -137,4 +154,7 @@ export declare namespace JupyterGISModel {
      * Function to get the ordered list of layers according to the tree.
      */
     function getOrderedLayerIds(model: IJupyterGISModel): string[];
+    interface IOptions extends DocumentRegistry.IModelOptions<IJupyterGISDoc> {
+        annotationModel?: IAnnotationModel;
+    }
 }

package/lib/model.js

@@ -12,15 +12,13 @@ export class JupyterGISModel {
                 this.dirty = true;
             }
         };
-        this.collaborative = true;
+        this.collaborative = document.querySelectorAll('[data-jupyter-lite-root]')[0] === undefined;
         this._onClientStateChanged = (changed) => {
             const clients = this.sharedModel.awareness.getStates();
             this._clientStateChanged.emit(clients);
-            this._sharedModel.awareness.on('change', (update) => {
-                if (update.added.length || update.removed.length) {
-                    this._userChanged.emit(this.users);
-                }
-            });
+            if (changed.added.length || changed.removed.length) {
+                this._userChanged.emit(this.users);
+            }
         };
         this.defaultKernelName = '';
         this.defaultKernelLanguage = '';
@@ -33,7 +31,10 @@ export class JupyterGISModel {
         this._stateChanged = new Signal(this);
         this._themeChanged = new Signal(this);
         this._clientStateChanged = new Signal(this);
-        const { sharedModel } = options;
+        this._sharedMetadataChanged = new Signal(this);
+        this._zoomToAnnotationSignal = new Signal(this);
+        this._isIdentifying = false;
+        const { annotationModel, sharedModel } = options;
         if (sharedModel) {
             this._sharedModel = sharedModel;
         }
@@ -42,6 +43,8 @@ export class JupyterGISModel {
             this._sharedModel.changed.connect(this._onSharedModelChanged);
         }
         this.sharedModel.awareness.on('change', this._onClientStateChanged);
+        this._sharedModel.metadataChanged.connect(this._metadataChangedHandler, this);
+        this.annotationModel = annotationModel;
     }
     get sharedModel() {
         return this._sharedModel;
@@ -109,6 +112,30 @@ export class JupyterGISModel {
     get disposed() {
         return this._disposed;
     }
+    get sharedMetadataChanged() {
+        return this._sharedMetadataChanged;
+    }
+    get zoomToAnnotationSignal() {
+        return this._zoomToAnnotationSignal;
+    }
+    set isIdentifying(isIdentifying) {
+        this._isIdentifying = isIdentifying;
+    }
+    get isIdentifying() {
+        return this._isIdentifying;
+    }
+    centerOnAnnotation(id) {
+        this._zoomToAnnotationSignal.emit(id);
+    }
+    _metadataChangedHandler(_, args) {
+        this._sharedMetadataChanged.emit(args);
+    }
+    addMetadata(key, value) {
+        this.sharedModel.setMetadata(key, value);
+    }
+    removeMetadata(key) {
+        this.sharedModel.removeMetadata(key);
+    }
     dispose() {
         if (this._isDisposed) {
             return;
@@ -127,14 +154,14 @@ export class JupyterGISModel {
         const validate = ajv.compile(jgisSchema);
         const valid = validate(jsonData);
         if (!valid) {
-            let errorMsg = 'File format errors:\n';
+            let errorMsg = 'JupyterGIS format errors:\n';
             for (const error of validate.errors || []) {
                 errorMsg = `${errorMsg}- ${error.instancePath} ${error.message}\n`;
             }
-            throw Error(errorMsg);
+            console.warn(errorMsg);
         }
         this.sharedModel.transact(() => {
-            var _a, _b, _c, _d;
+            var _a, _b, _c, _d, _e;
             this.sharedModel.sources = (_a = jsonData.sources) !== null && _a !== void 0 ? _a : {};
             this.sharedModel.layers = (_b = jsonData.layers) !== null && _b !== void 0 ? _b : {};
             this.sharedModel.layerTree = (_c = jsonData.layerTree) !== null && _c !== void 0 ? _c : [];
@@ -146,6 +173,7 @@ export class JupyterGISModel {
                 pitch: 0,
                 projection: 'EPSG:3857'
             };
+            this.sharedModel.metadata = (_e = jsonData.metadata) !== null && _e !== void 0 ? _e : {};
         });
         this.dirty = true;
     }
@@ -166,11 +194,12 @@ export class JupyterGISModel {
             sources: this.sharedModel.sources,
             layers: this.sharedModel.layers,
             layerTree: this.sharedModel.layerTree,
-            options: this.sharedModel.options
+            options: this.sharedModel.options,
+            metadata: this.sharedModel.metadata
         };
     }
-    setDrive(value, filePath) {
-        this._drive = value;
+    setContentsManager(value, filePath) {
+        this._contentsManager = value;
         this._filePath = filePath;
     }
     getLayers() {
@@ -186,7 +215,7 @@ export class JupyterGISModel {
         return this.sharedModel.getLayer(id);
     }
     getSource(id) {
-        return this.sharedModel.getSource(id);
+        return this.sharedModel.getLayerSource(id);
     }
     /**
      * Get a {[key: id]: name} dictionary of sources for a given source type
@@ -225,22 +254,17 @@ export class JupyterGISModel {
      * @returns a promise to the GeoJSON data.
      */
     async readGeoJSON(filepath) {
-        if (!this._drive) {
+        if (!this._contentsManager) {
             return;
         }
-        let dir = PathExt.dirname(this._filePath);
-        if (dir.includes(':')) {
-            dir = dir.split(':')[1];
-        }
-        const absolutePath = PathExt.join(dir, filepath);
-        return this._drive
-            .get(absolutePath)
-            .then(contentModel => {
-            return JSON.parse(contentModel.content);
-        })
-            .catch(e => {
-            throw e;
+        const absolutePath = PathExt.resolve(PathExt.dirname(this._filePath), filepath);
+        const file = await this._contentsManager.get(absolutePath, {
+            content: true
         });
+        if (typeof file.content === 'string') {
+            return JSON.parse(file.content);
+        }
+        return file.content;
     }
     /**
      * Add a layer group in the layer tree.
@@ -289,10 +313,28 @@ export class JupyterGISModel {
     getOptions() {
         return this._sharedModel.options;
     }
+    syncViewport(viewport, emitter) {
+        this.sharedModel.awareness.setLocalStateField('viewportState', {
+            value: viewport,
+            emitter
+        });
+    }
+    syncPointer(pointer, emitter) {
+        this.sharedModel.awareness.setLocalStateField('pointer', {
+            value: pointer,
+            emitter
+        });
+    }
     syncSelected(value, emitter) {
         this.sharedModel.awareness.setLocalStateField('selected', {
             value,
-            emitter: emitter
+            emitter
+        });
+    }
+    syncIdentifiedFeatures(features, emitter) {
+        this.sharedModel.awareness.setLocalStateField('identifiedFeatures', {
+            value: features,
+            emitter
         });
     }
     setUserToFollow(userId) {
@@ -385,29 +427,22 @@ export class JupyterGISModel {
         this._addLayerTreeItem(group);
     }
     _removeLayerTreeLayer(layerTree, layerIdToRemove) {
-        // Iterate over each item in the layerTree
-        for (let i = 0; i < layerTree.length; i++) {
-            const currentItem = layerTree[i];
-            // Check if the current item is a string and matches the target
-            if (typeof currentItem === 'string' && currentItem === layerIdToRemove) {
-                // Remove the item from the array
-                layerTree.splice(i, 1);
-                // Decrement i to ensure the next iteration processes the remaining items correctly
-                i--;
-            }
-            else if (typeof currentItem !== 'string' && 'layers' in currentItem) {
-                // If the current item is a group, recursively call the function on its layers
-                this._removeLayerTreeLayer(currentItem.layers, layerIdToRemove);
-            }
-        }
+        this._removeLayerTreeItem(layerTree, layerIdToRemove, true);
         this.sharedModel.layerTree = layerTree;
     }
     _removeLayerTreeGroup(layerTree, groupName) {
+        this._removeLayerTreeItem(layerTree, groupName, false);
+        this.sharedModel.layerTree = layerTree;
+    }
+    _removeLayerTreeItem(layerTree, target, isLayer) {
         // Iterate over each item in the layerTree
         for (let i = 0; i < layerTree.length; i++) {
             const currentItem = layerTree[i];
+            const matches = isLayer
+                ? typeof currentItem === 'string' && currentItem === target
+                : typeof currentItem !== 'string' && currentItem.name === target;
             // Check if the current item is a string and matches the target
-            if (typeof currentItem !== 'string' && currentItem.name === groupName) {
+            if (matches) {
                 // Remove the item from the array
                 layerTree.splice(i, 1);
                 // Decrement i to ensure the next iteration processes the remaining items correctly
@@ -415,10 +450,9 @@ export class JupyterGISModel {
             }
             else if (typeof currentItem !== 'string' && 'layers' in currentItem) {
                 // If the current item is a group, recursively call the function on its layers
-                this._removeLayerTreeGroup(currentItem.layers, groupName);
+                this._removeLayerTreeItem(currentItem.layers, target, isLayer);
             }
         }
-        this.sharedModel.layerTree = layerTree;
     }
     renameLayerGroup(groupName, newName) {
         const layerTreeInfo = this._getLayerTreeInfo(groupName);
@@ -451,6 +485,9 @@ export class JupyterGISModel {
             this._sharedModel.updateLayerTreeItem(layerTreeInfo.mainGroupIndex, updatedLayerTree[layerTreeInfo.mainGroupIndex]);
         }
     }
+    toggleIdentify() {
+        this._isIdentifying = !this._isIdentifying;
+    }
     _getLayerTreeInfo(groupName) {
         const layerTree = this.getLayerTree();
         const indexesPath = Private.findItemPath(layerTree, groupName);