@jupytergis/schema 0.1.1

package/lib/interfaces.d.ts

@@ -0,0 +1,189 @@
+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 { 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, IJGISTerrain, SourceType } from './_interface/jgis';
+import { IRasterSource } from './_interface/rastersource';
+export { IGeoJSONSource } from './_interface/geojsonsource';
+export interface IDict<T = any> {
+    [key: string]: T;
+}
+export interface IJGISLayerDocChange {
+    layerChange?: Array<{
+        id: string;
+        newValue: IJGISLayer | undefined;
+    }>;
+}
+export interface IJGISLayerTreeDocChange {
+    layerTreeChange?: Delta<IJGISLayerItem[]>;
+}
+export interface IJGISSourceDocChange {
+    sourceChange?: Array<{
+        id: string;
+        newValue: IJGISSource | undefined;
+    }>;
+}
+export type SelectionType = 'layer' | 'source' | 'group';
+export interface ISelection {
+    type: SelectionType;
+    parent?: string;
+    selectedNodeId?: string;
+}
+export interface IJupyterGISClientState {
+    selected: {
+        value?: {
+            [key: string]: ISelection;
+        };
+        emitter?: string | null;
+    };
+    user: User.IIdentity;
+    remoteUser?: number;
+    toolbarForm?: IDict;
+}
+export interface IJupyterGISDoc extends YDocument<IJupyterGISDocChange> {
+    options: IJGISOptions;
+    layers: IJGISLayers;
+    sources: IJGISSources;
+    layerTree: IJGISLayerTree;
+    terrain: IJGISTerrain;
+    readonly editable: boolean;
+    readonly toJGISEndpoint?: string;
+    layerExists(id: string): boolean;
+    getLayer(id: string): IJGISLayer | undefined;
+    removeLayer(id: string): void;
+    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;
+    removeSource(id: string): void;
+    addSource(id: string, value: IJGISSource): void;
+    updateSource(id: string, value: IJGISSource): void;
+    addLayerTreeItem(index: number, item: IJGISLayerItem): void;
+    updateLayerTreeItem(index: number, item: IJGISLayerItem): void;
+    updateObjectParameters(id: string, value: IJGISLayer['parameters'] | IJGISSource['parameters']): void;
+    getObject(id: string): IJGISLayer | IJGISSource | undefined;
+    getOption(key: keyof IJGISOptions): IDict | undefined;
+    setOption(key: keyof IJGISOptions, value: IDict): void;
+    optionsChanged: ISignal<IJupyterGISDoc, MapChange>;
+    layersChanged: ISignal<IJupyterGISDoc, IJGISLayerDocChange>;
+    sourcesChanged: ISignal<IJupyterGISDoc, IJGISSourceDocChange>;
+    layerTreeChanged: ISignal<IJupyterGISDoc, IJGISLayerTreeDocChange>;
+    terrainChanged: ISignal<IJupyterGISDoc, IJGISTerrain>;
+}
+export interface IJupyterGISDocChange extends DocumentChange {
+    contextChange?: MapChange;
+    contentChange?: MapChange;
+    layerChange?: Array<{
+        name: string;
+        key: string;
+        newValue: IJGISLayer | undefined;
+    }>;
+    layerTreeChange?: Delta<IJGISLayerItem[]>;
+    optionChange?: MapChange;
+    stateChange?: StateChange<any>[];
+}
+export interface IJupyterGISModel extends DocumentRegistry.IModel {
+    isDisposed: boolean;
+    sharedModel: IJupyterGISDoc;
+    localState: IJupyterGISClientState | null;
+    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>;
+    terrainChanged: ISignal<IJupyterGISDoc, IJGISTerrain>;
+    setDrive(value: ICollaborativeDrive, filePath: string): void;
+    getContent(): IJGISContent;
+    getLayers(): IJGISLayers;
+    getLayer(id: string): IJGISLayer | undefined;
+    getSources(): IJGISSources;
+    getSource(id: string): IJGISSource | undefined;
+    getSourcesByType(type: SourceType): {
+        [key: string]: string;
+    };
+    getLayersBySource(id: string): string[];
+    getLayerTree(): IJGISLayerTree;
+    addLayer(id: string, layer: IJGISLayer, groupName?: string, position?: number): void;
+    removeLayer(id: string): void;
+    getOptions(): IJGISOptions;
+    setOptions(value: IJGISOptions): void;
+    readGeoJSON(filepath: string): Promise<GeoJSON | undefined>;
+    setTerrain(terrain: IJGISTerrain): void;
+    removeLayerGroup(groupName: string): void;
+    renameLayerGroup(groupName: string, newName: string): void;
+    moveItemsToGroup(items: string[], groupName: string, index?: number): void;
+    moveItemRelatedTo(item: string, relativeItem: string, after: boolean): void;
+    addNewLayerGroup(selected: {
+        [key: string]: ISelection;
+    }, group: IJGISLayerGroup): void;
+    syncSelected(value: {
+        [key: string]: ISelection;
+    }, emitter?: string): void;
+    setUserToFollow(userId?: number): void;
+    getClientId(): number;
+    disposed: ISignal<any, void>;
+}
+export interface IUserData {
+    userId: number;
+    userData: User.IIdentity;
+}
+export type IJupyterGISWidget = IDocumentWidget<SplitPanel, IJupyterGISModel>;
+export type IJupyterGISTracker = IWidgetTracker<IJupyterGISWidget>;
+export interface IJGISFormSchemaRegistry {
+    /**
+     *
+     *
+     * @return {*}  {IDict}
+     * @memberof IJGISFormSchemaRegistry
+     */
+    getSchemas(): Map<string, IDict>;
+    /**
+     *
+     *
+     * @param {string} name
+     * @param {IDict} schema
+     * @memberof IJGISFormSchemaRegistry
+     */
+    registerSchema(name: string, schema: IDict): void;
+    /**
+     *
+     *
+     * @param {string} name
+     * @return {*}  {boolean}
+     * @memberof IJGISFormSchemaRegistry
+     */
+    has(name: string): boolean;
+}
+export interface IJGISExternalCommand {
+    name: string;
+    id: string;
+    label?: string;
+}
+export interface IJGISExternalCommandRegistry {
+    getCommands(): IJGISExternalCommand[];
+    registerCommand(command: IJGISExternalCommand): void;
+}
+/**
+ * Defines the structure for entries in a raster layer gallery.
+ * Each entry consists of a name, a thumbnail URL, and source information.
+ * The source information is expected to conform to the IRasterSource interface.
+ *
+ * @interface IRasterLayerGalleryEntry
+ */
+export interface IRasterLayerGalleryEntry {
+    name: string;
+    thumbnail: string;
+    source: IRasterSource;
+}
+export interface IJGISLayerBrowserRegistry {
+    getRegistryLayers(): IRasterLayerGalleryEntry[];
+    addRegistryLayer(data: IRasterLayerGalleryEntry): void;
+    removeRegistryLayer(name: string): void;
+    clearRegistry(): void;
+}

package/lib/interfaces.js

@@ -0,0 +1 @@
+export {};

package/lib/model.d.ts

@@ -0,0 +1,142 @@
+import { ICollaborativeDrive } from '@jupyter/docprovider';
+import { MapChange } from '@jupyter/ydoc';
+import { IChangedArgs } from '@jupyterlab/coreutils';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+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, IJGISTerrain } from './_interface/jgis';
+import { IJGISLayerDocChange, IJGISLayerTreeDocChange, IJGISSourceDocChange, IJupyterGISClientState, IJupyterGISDoc, IJupyterGISModel, ISelection, IUserData } from './interfaces';
+export declare class JupyterGISModel implements IJupyterGISModel {
+    constructor(options: DocumentRegistry.IModelOptions<IJupyterGISDoc>);
+    private _onSharedModelChanged;
+    readonly collaborative = true;
+    get sharedModel(): IJupyterGISDoc;
+    get isDisposed(): boolean;
+    get contentChanged(): ISignal<this, void>;
+    get stateChanged(): ISignal<this, IChangedArgs<any, any, string>>;
+    get themeChanged(): Signal<this, IChangedArgs<string, string | null, string>>;
+    get currentUserId(): number | undefined;
+    get users(): IUserData[];
+    get userChanged(): ISignal<this, IUserData[]>;
+    get dirty(): boolean;
+    set dirty(value: boolean);
+    get readOnly(): boolean;
+    set readOnly(value: boolean);
+    get localState(): IJupyterGISClientState | null;
+    get clientStateChanged(): ISignal<this, Map<number, IJupyterGISClientState>>;
+    get sharedOptionsChanged(): ISignal<IJupyterGISDoc, MapChange>;
+    get sharedLayersChanged(): ISignal<IJupyterGISDoc, IJGISLayerDocChange>;
+    get sharedLayerTreeChanged(): ISignal<IJupyterGISDoc, IJGISLayerTreeDocChange>;
+    get sharedSourcesChanged(): ISignal<IJupyterGISDoc, IJGISSourceDocChange>;
+    get terrainChanged(): ISignal<IJupyterGISDoc, IJGISTerrain>;
+    get disposed(): ISignal<JupyterGISModel, void>;
+    dispose(): void;
+    toString(): string;
+    fromString(data: string): void;
+    toJSON(): PartialJSONObject;
+    fromJSON(data: PartialJSONObject): void;
+    initialize(): void;
+    getWorker(): Worker;
+    getContent(): IJGISContent;
+    setDrive(value: ICollaborativeDrive, filePath: string): void;
+    getLayers(): IJGISLayers;
+    getSources(): IJGISSources;
+    getLayerTree(): IJGISLayerTree;
+    getLayer(id: string): IJGISLayer | undefined;
+    getSource(id: string): IJGISSource | undefined;
+    /**
+     * Get a {[key: id]: name} dictionary of sources for a given source type
+     * @param type The required source type
+     */
+    getSourcesByType(type: string): {
+        [key: string]: string;
+    };
+    /**
+     * 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: string): string[];
+    /**
+     * Read a GeoJSON file.
+     *
+     * @param filepath - the path of the GeoJSON file.
+     * @returns a promise to the GeoJSON data.
+     */
+    readGeoJSON(filepath: string): Promise<GeoJSON | undefined>;
+    /**
+     * 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: string, groupName?: string, position?: number): void;
+    /**
+     * 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: string, layer: IJGISLayer, groupName?: string, position?: number): void;
+    removeLayer(layer_id: string): void;
+    setTerrain(terrain: IJGISTerrain): void;
+    setOptions(value: IJGISOptions): void;
+    getOptions(): IJGISOptions;
+    syncSelected(value: {
+        [key: string]: ISelection;
+    }, emitter?: string): void;
+    setUserToFollow(userId?: number): void;
+    getClientId(): number;
+    /**
+     * 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.
+     */
+    private _addLayerTreeItem;
+    moveItemsToGroup(items: string[], groupName: string, index?: number): void;
+    moveItemRelatedTo(item: string, relativeItem: string, after: boolean): void;
+    addNewLayerGroup(selected: {
+        [key: string]: ISelection;
+    }, group: IJGISLayerGroup): void;
+    private _removeLayerTreeLayer;
+    private _removeLayerTreeGroup;
+    renameLayerGroup(groupName: string, newName: string): void;
+    removeLayerGroup(groupName: string): void;
+    private _getLayerTreeInfo;
+    private _onClientStateChanged;
+    readonly defaultKernelName: string;
+    readonly defaultKernelLanguage: string;
+    private _sharedModel;
+    private _filePath;
+    private _drive?;
+    private _dirty;
+    private _readOnly;
+    private _isDisposed;
+    private _userChanged;
+    private _usersMap?;
+    private _disposed;
+    private _contentChanged;
+    private _stateChanged;
+    private _themeChanged;
+    private _clientStateChanged;
+    static worker: Worker;
+}
+export declare namespace JupyterGISModel {
+    /**
+     * Function to get the ordered list of layers according to the tree.
+     */
+    function getOrderedLayerIds(model: IJupyterGISModel): string[];
+}