@jupytergis/schema 0.1.1

package/lib/model.js

@@ -0,0 +1,554 @@
+import { PathExt } from '@jupyterlab/coreutils';
+import { Signal } from '@lumino/signaling';
+import Ajv from 'ajv';
+import { JupyterGISDoc } from './doc';
+import jgisSchema from './schema/jgis.json';
+export class JupyterGISModel {
+    constructor(options) {
+        this._onSharedModelChanged = (sender, changes) => {
+            var _a;
+            if (changes && ((_a = changes === null || changes === void 0 ? void 0 : changes.objectChange) === null || _a === void 0 ? void 0 : _a.length)) {
+                this._contentChanged.emit(void 0);
+                this.dirty = true;
+            }
+        };
+        this.collaborative = true;
+        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);
+                }
+            });
+        };
+        this.defaultKernelName = '';
+        this.defaultKernelLanguage = '';
+        this._dirty = false;
+        this._readOnly = false;
+        this._isDisposed = false;
+        this._userChanged = new Signal(this);
+        this._disposed = new Signal(this);
+        this._contentChanged = new Signal(this);
+        this._stateChanged = new Signal(this);
+        this._themeChanged = new Signal(this);
+        this._clientStateChanged = new Signal(this);
+        const { sharedModel } = options;
+        if (sharedModel) {
+            this._sharedModel = sharedModel;
+        }
+        else {
+            this._sharedModel = JupyterGISDoc.create();
+            this._sharedModel.changed.connect(this._onSharedModelChanged);
+        }
+        this.sharedModel.awareness.on('change', this._onClientStateChanged);
+    }
+    get sharedModel() {
+        return this._sharedModel;
+    }
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    get contentChanged() {
+        return this._contentChanged;
+    }
+    get stateChanged() {
+        return this._stateChanged;
+    }
+    get themeChanged() {
+        return this._themeChanged;
+    }
+    get currentUserId() {
+        var _a;
+        return (_a = this.sharedModel) === null || _a === void 0 ? void 0 : _a.awareness.clientID;
+    }
+    get users() {
+        var _a;
+        this._usersMap = (_a = this._sharedModel) === null || _a === void 0 ? void 0 : _a.awareness.getStates();
+        const users = [];
+        if (this._usersMap) {
+            this._usersMap.forEach((val, key) => {
+                users.push({ userId: key, userData: val.user });
+            });
+        }
+        return users;
+    }
+    get userChanged() {
+        return this._userChanged;
+    }
+    get dirty() {
+        return this._dirty;
+    }
+    set dirty(value) {
+        this._dirty = value;
+    }
+    get readOnly() {
+        return this._readOnly;
+    }
+    set readOnly(value) {
+        this._readOnly = value;
+    }
+    get localState() {
+        return this.sharedModel.awareness.getLocalState();
+    }
+    get clientStateChanged() {
+        return this._clientStateChanged;
+    }
+    get sharedOptionsChanged() {
+        return this.sharedModel.optionsChanged;
+    }
+    get sharedLayersChanged() {
+        return this.sharedModel.layersChanged;
+    }
+    get sharedLayerTreeChanged() {
+        return this.sharedModel.layerTreeChanged;
+    }
+    get sharedSourcesChanged() {
+        return this.sharedModel.sourcesChanged;
+    }
+    get terrainChanged() {
+        return this.sharedModel.terrainChanged;
+    }
+    get disposed() {
+        return this._disposed;
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this._sharedModel.dispose();
+        this._disposed.emit();
+        Signal.clearData(this);
+    }
+    toString() {
+        return JSON.stringify(this.getContent(), null, 2);
+    }
+    fromString(data) {
+        const jsonData = JSON.parse(data);
+        const ajv = new Ajv();
+        const validate = ajv.compile(jgisSchema);
+        const valid = validate(jsonData);
+        if (!valid) {
+            let errorMsg = 'File format errors:\n';
+            for (const error of validate.errors || []) {
+                errorMsg = `${errorMsg}- ${error.instancePath} ${error.message}\n`;
+            }
+            throw Error(errorMsg);
+        }
+        this.sharedModel.transact(() => {
+            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 : [];
+            this.sharedModel.terrain = (_d = jsonData.terrain) !== null && _d !== void 0 ? _d : {
+                source: '',
+                exaggeration: 0
+            };
+            this.sharedModel.options = (_e = jsonData.options) !== null && _e !== void 0 ? _e : {
+                latitude: 0,
+                longitude: 0,
+                zoom: 0,
+                bearing: 0,
+                pitch: 0,
+                projection: 'EPSG:3857'
+            };
+        });
+        this.dirty = true;
+    }
+    toJSON() {
+        return JSON.parse(this.toString());
+    }
+    fromJSON(data) {
+        // nothing to do
+    }
+    initialize() {
+        //
+    }
+    getWorker() {
+        return JupyterGISModel.worker;
+    }
+    getContent() {
+        return {
+            sources: this.sharedModel.sources,
+            layers: this.sharedModel.layers,
+            layerTree: this.sharedModel.layerTree,
+            options: this.sharedModel.options,
+            terrain: this.sharedModel.terrain
+        };
+    }
+    setDrive(value, filePath) {
+        this._drive = value;
+        this._filePath = filePath;
+    }
+    getLayers() {
+        return this.sharedModel.layers;
+    }
+    getSources() {
+        return this.sharedModel.sources;
+    }
+    getLayerTree() {
+        return this.sharedModel.layerTree;
+    }
+    getLayer(id) {
+        return this.sharedModel.getLayer(id);
+    }
+    getSource(id) {
+        return this.sharedModel.getSource(id);
+    }
+    /**
+     * Get a {[key: id]: name} dictionary of sources for a given source type
+     * @param type The required source type
+     */
+    getSourcesByType(type) {
+        const sources = {};
+        for (const sourceId of Object.keys(this.getSources() || {})) {
+            const source = this.getSource(sourceId);
+            if ((source === null || source === void 0 ? void 0 : source.type) === type) {
+                sources[sourceId] = source.name;
+            }
+        }
+        return sources;
+    }
+    /**
+     * Get the list of layers using a source.
+     *
+     * @param id - the source id.
+     * @returns a list of layer ids that use the source.
+     */
+    getLayersBySource(id) {
+        const usingLayers = [];
+        Object.entries(this.getLayers() || {}).forEach(([layerId, layer]) => {
+            var _a;
+            if (((_a = layer.parameters) === null || _a === void 0 ? void 0 : _a.source) === id) {
+                usingLayers.push(layerId);
+            }
+        });
+        return usingLayers;
+    }
+    /**
+     * Read a GeoJSON file.
+     *
+     * @param filepath - the path of the GeoJSON file.
+     * @returns a promise to the GeoJSON data.
+     */
+    async readGeoJSON(filepath) {
+        if (!this._drive) {
+            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;
+        });
+    }
+    /**
+     * Add a layer group in the layer tree.
+     *
+     * @param name - the name of the group.
+     * @param groupName - (optional) the name of the parent group in which to include the
+     *   new group.
+     * @param position - (optional) the index of the new group in its parent group or
+     *   from root of layer tree.
+     */
+    addGroup(name, groupName, position) {
+        const indexesPath = Private.findItemPath(this.getLayerTree(), name);
+        if (indexesPath.length) {
+            console.warn(`The group "${groupName}" already exist in the layer tree`);
+            return;
+        }
+        const item = {
+            name,
+            layers: []
+        };
+        this._addLayerTreeItem(item, groupName, position);
+    }
+    /**
+     * Add a layer in the layer tree and the layers list.
+     *
+     * @param id - the ID of the layer.
+     * @param layer - the layer object.
+     * @param groupName - (optional) the name of the group in which to include the new
+     *   layer.
+     * @param position - (optional) the index of the new layer in its parent group or
+     *   from root of layer tree.
+     */
+    addLayer(id, layer, groupName, position) {
+        if (!this.getLayer(id)) {
+            this.sharedModel.addLayer(id, layer);
+        }
+        this._addLayerTreeItem(id, groupName, position);
+    }
+    removeLayer(layer_id) {
+        this._removeLayerTreeLayer(this.getLayerTree(), layer_id);
+        this.sharedModel.removeLayer(layer_id);
+    }
+    setTerrain(terrain) {
+        this._sharedModel.terrain = terrain;
+    }
+    setOptions(value) {
+        this._sharedModel.options = value;
+    }
+    getOptions() {
+        return this._sharedModel.options;
+    }
+    syncSelected(value, emitter) {
+        this.sharedModel.awareness.setLocalStateField('selected', {
+            value,
+            emitter: emitter
+        });
+    }
+    setUserToFollow(userId) {
+        if (this._sharedModel) {
+            this._sharedModel.awareness.setLocalStateField('remoteUser', userId);
+        }
+    }
+    getClientId() {
+        return this.sharedModel.awareness.clientID;
+    }
+    /**
+     * Add an item in the layer tree.
+     *
+     * @param item - the item to add.
+     * @param groupName - (optional) the name of the parent group in which to include the
+     *   new item.
+     * @param index - (optional) the index of the new item in its parent group or
+     *   from root of layer tree.
+     */
+    _addLayerTreeItem(item, groupName, index) {
+        if (groupName) {
+            const layerTreeInfo = this._getLayerTreeInfo(groupName);
+            if (layerTreeInfo) {
+                layerTreeInfo.workingGroup.layers.splice(index !== null && index !== void 0 ? index : layerTreeInfo.workingGroup.layers.length, 0, item);
+                this._sharedModel.updateLayerTreeItem(layerTreeInfo.mainGroupIndex, layerTreeInfo.mainGroup);
+            }
+        }
+        else {
+            this.sharedModel.addLayerTreeItem(index !== null && index !== void 0 ? index : this.getLayerTree().length, item);
+        }
+    }
+    moveItemsToGroup(items, groupName, index) {
+        const layerTree = this.getLayerTree();
+        for (const item of items) {
+            if (this.getLayer(item)) {
+                // the item is a layer, remove and add it at the correct position.
+                this._removeLayerTreeLayer(layerTree, item);
+                this._addLayerTreeItem(item, groupName, index);
+            }
+            else {
+                // the item is a group, let's copy it before removing it.
+                const treeInfo = this._getLayerTreeInfo(item);
+                if (treeInfo === undefined) {
+                    continue;
+                }
+                const group = Object.assign({}, treeInfo.workingGroup);
+                this._removeLayerTreeGroup(layerTree, item);
+                this._addLayerTreeItem(group, groupName, index);
+            }
+        }
+    }
+    moveItemRelatedTo(item, relativeItem, after) {
+        var _a;
+        const layerTree = this.getLayerTree();
+        let insertedItem;
+        if (this.getLayer(item)) {
+            this._removeLayerTreeLayer(layerTree, item);
+            insertedItem = item;
+        }
+        else {
+            const treeInfo = this._getLayerTreeInfo(item);
+            if (treeInfo === undefined) {
+                return;
+            }
+            insertedItem = Object.assign({}, treeInfo.workingGroup);
+            this._removeLayerTreeGroup(layerTree, item);
+        }
+        const indexesPath = Private.findItemPath(layerTree, relativeItem);
+        const insertedIndex = ((_a = indexesPath.pop()) !== null && _a !== void 0 ? _a : 0) + (after ? 1 : 0);
+        let parentGroupName = '';
+        let workingGroupId = indexesPath.shift();
+        if (workingGroupId !== undefined) {
+            let workingGroup = layerTree[workingGroupId];
+            while (indexesPath.length) {
+                workingGroupId = indexesPath.shift();
+                if (workingGroupId === undefined) {
+                    break;
+                }
+                workingGroup = workingGroup.layers[workingGroupId];
+            }
+            parentGroupName = workingGroup.name;
+        }
+        this._addLayerTreeItem(insertedItem, parentGroupName, insertedIndex);
+    }
+    addNewLayerGroup(selected, group) {
+        const layerTree = this.getLayerTree();
+        for (const item in selected) {
+            this._removeLayerTreeLayer(layerTree, item);
+        }
+        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.sharedModel.layerTree = layerTree;
+    }
+    _removeLayerTreeGroup(layerTree, groupName) {
+        // 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.name === groupName) {
+                // 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._removeLayerTreeGroup(currentItem.layers, groupName);
+            }
+        }
+        this.sharedModel.layerTree = layerTree;
+    }
+    renameLayerGroup(groupName, newName) {
+        const layerTreeInfo = this._getLayerTreeInfo(groupName);
+        if (layerTreeInfo) {
+            layerTreeInfo.workingGroup.name = newName;
+            this._sharedModel.updateLayerTreeItem(layerTreeInfo.mainGroupIndex, layerTreeInfo.mainGroup);
+        }
+        else {
+            console.log('Something went wrong when renaming layer');
+        }
+    }
+    removeLayerGroup(groupName) {
+        const layerTree = this.getLayerTree();
+        const layerTreeInfo = this._getLayerTreeInfo(groupName);
+        const updatedLayerTree = removeLayerGroupEntry(layerTree, groupName);
+        function removeLayerGroupEntry(layerTree, groupName) {
+            const result = [];
+            for (const item of layerTree) {
+                if (typeof item === 'string') {
+                    result.push(item); // Push layer IDs directly
+                }
+                else if (item.name !== groupName) {
+                    const filteredLayers = removeLayerGroupEntry(item.layers, groupName);
+                    result.push(Object.assign(Object.assign({}, item), { layers: filteredLayers })); // Update layers with filtered list
+                }
+            }
+            return result;
+        }
+        if (layerTreeInfo) {
+            this._sharedModel.updateLayerTreeItem(layerTreeInfo.mainGroupIndex, updatedLayerTree[layerTreeInfo.mainGroupIndex]);
+        }
+    }
+    _getLayerTreeInfo(groupName) {
+        const layerTree = this.getLayerTree();
+        const indexesPath = Private.findItemPath(layerTree, groupName);
+        if (!indexesPath.length) {
+            console.warn(`The group "${groupName}" does not exist in the layer tree`);
+            return;
+        }
+        const mainGroupIndex = indexesPath.shift();
+        if (mainGroupIndex === undefined) {
+            return;
+        }
+        const mainGroup = layerTree[mainGroupIndex];
+        let workingGroup = mainGroup;
+        while (indexesPath.length) {
+            const groupIndex = indexesPath.shift();
+            if (groupIndex === undefined) {
+                break;
+            }
+            workingGroup = workingGroup.layers[groupIndex];
+        }
+        return {
+            mainGroup,
+            workingGroup,
+            mainGroupIndex
+        };
+    }
+}
+(function (JupyterGISModel) {
+    /**
+     * Function to get the ordered list of layers according to the tree.
+     */
+    function getOrderedLayerIds(model) {
+        return Private.layerTreeRecursion(model.sharedModel.layerTree);
+    }
+    JupyterGISModel.getOrderedLayerIds = getOrderedLayerIds;
+})(JupyterGISModel || (JupyterGISModel = {}));
+var Private;
+(function (Private) {
+    /**
+     * Recursive function through the layer tree to retrieve the flattened layers order.
+     *
+     * @param items - the items list being scanned.
+     * @param current - the current flattened layers.
+     */
+    function layerTreeRecursion(items, current = []) {
+        for (const layer of items) {
+            if (typeof layer === 'string') {
+                current.push(layer);
+            }
+            else {
+                current.push(...layerTreeRecursion(layer.layers));
+            }
+        }
+        return current;
+    }
+    Private.layerTreeRecursion = layerTreeRecursion;
+    /**
+     * Recursive function through the layer tree to retrieve the indexes path to a group
+     * or a layer.
+     *
+     * @param items - the items list being scanned.
+     * @param itemId - the target group name or layer ID.
+     * @param indexes - the current indexes path to the group
+     */
+    function findItemPath(items, itemId, indexes = []) {
+        for (let index = 0; index < items.length; index++) {
+            const item = items[index];
+            if (typeof item === 'string') {
+                if (item === itemId) {
+                    const workingIndexes = [...indexes];
+                    workingIndexes.push(index);
+                    return workingIndexes;
+                }
+            }
+            else {
+                const workingIndexes = [...indexes];
+                workingIndexes.push(index);
+                if (item.name === itemId) {
+                    return workingIndexes;
+                }
+                const foundIndexes = findItemPath(item.layers, itemId, workingIndexes);
+                if (foundIndexes.length > workingIndexes.length) {
+                    return foundIndexes;
+                }
+            }
+        }
+        return indexes;
+    }
+    Private.findItemPath = findItemPath;
+})(Private || (Private = {}));

package/lib/schema/geoTiffSource.json

@@ -0,0 +1,37 @@
+{
+    "type": "object",
+    "description": "GeoTiffSource",
+    "title": "IGeoTiffSource",
+    "required": ["urls"],
+    "additionalProperties": false,
+    "properties": {
+        "urls": {
+            "type": "array",
+            "items": {
+                "type": "object",
+                "properties": {
+                    "url": {
+                        "type": "string"
+                    },
+                    "min": {
+                        "type": "number"
+                    },
+                    "max": {
+                        "type": "number"
+                    }
+                }
+            },
+            "minItems": 1,
+            "default": [],
+            "description": "URLs"
+        },
+        "normalize": {
+            "type": "boolean",
+            "default": true
+        },
+        "wrapX": {
+            "type": "boolean",
+            "default": false
+        }
+    }
+}

package/lib/schema/geojsonsource.json

@@ -0,0 +1,23 @@
+{
+    "type": "object",
+    "description": "GeoJSONSource",
+    "title": "IGeoJSONSource",
+    "required": [],
+    "additionalProperties": false,
+    "properties": {
+        "path": {
+            "type": "string",
+            "description": "The local path to a GeoJSON file"
+        },
+        "data": {
+            "type": "object",
+            "description": "The GeoJSON data",
+            "$ref": "https://geojson.org/schema/GeoJSON.json"
+        },
+        "valid": {
+            "type": "boolean",
+            "description": "Whether the data are valid or not",
+            "readOnly": true
+        }
+    }
+}

package/lib/schema/hillshadeLayer.json

@@ -0,0 +1,18 @@
+{
+    "type": "object",
+    "description": "HillshadeLayer",
+    "title": "IHillshadeLayer",
+    "required": ["source"],
+    "additionalProperties": false,
+    "properties": {
+        "source": {
+            "type": "string",
+            "description": "The id of the source"
+        },
+        "shadowColor": {
+            "type": "string",
+            "description": "The color of the the shadows",
+            "default": "#473B24"
+        }
+    }
+}

package/lib/schema/imageLayer.json

@@ -0,0 +1,21 @@
+{
+    "type": "object",
+    "description": "ImageLayer",
+    "title": "IImageLayer",
+    "required": ["source"],
+    "additionalProperties": false,
+    "properties": {
+        "source": {
+            "type": "string",
+            "description": "The id of the source"
+        },
+        "opacity": {
+            "type": "number",
+            "description": "The opacity of the source",
+            "default": 1,
+            "multipleOf": 0.1,
+            "minimum": 0,
+            "maximum": 1
+        }
+    }
+}

package/lib/schema/imageSource.json

@@ -0,0 +1,30 @@
+{
+    "type": "object",
+    "description": "ImageSource",
+    "title": "IImageSource",
+    "required": ["url", "coordinates"],
+    "additionalProperties": false,
+    "properties": {
+        "url": {
+            "type": "string",
+            "readOnly": true,
+            "description": "URL that points to an image"
+        },
+        "coordinates": {
+            "type": "array",
+            "readOnly": true,
+            "items": {
+                "type": "array",
+                "items": {
+                    "type": "number"
+                },
+                "minItems": 2,
+                "maxItems": 2
+            },
+            "minItems": 4,
+            "maxItems": 4,
+            "default": [],
+            "description": "Corners of image specified in longitude, latitude pairs"
+        }
+    }
+}