@jupytergis/jupytergis-core 0.1.1

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2023, JupyterGIS contributors
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1 @@
+# JupyterGIS Core package

package/lib/externalcommand.d.ts

@@ -0,0 +1,7 @@
+import { IJGISExternalCommand, IJGISExternalCommandRegistry } from '@jupytergis/schema';
+export declare class JupyterGISExternalCommandRegistry implements IJGISExternalCommandRegistry {
+    constructor();
+    registerCommand(cmd: IJGISExternalCommand): void;
+    getCommands(): IJGISExternalCommand[];
+    private _registry;
+}

package/lib/externalcommand.js

@@ -0,0 +1,11 @@
+export class JupyterGISExternalCommandRegistry {
+    constructor() {
+        this._registry = new Set();
+    }
+    registerCommand(cmd) {
+        this._registry.add(cmd);
+    }
+    getCommands() {
+        return [...this._registry];
+    }
+}

package/lib/factory.d.ts

@@ -0,0 +1,37 @@
+import { ConsolePanel, IConsoleTracker } from '@jupyterlab/console';
+import { ICollaborativeDrive } from '@jupyter/docprovider';
+import { JupyterGISModel, IJupyterGISTracker, IJGISExternalCommandRegistry } from '@jupytergis/schema';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { IEditorMimeTypeService } from '@jupyterlab/codeeditor';
+import { ABCWidgetFactory, DocumentRegistry } from '@jupyterlab/docregistry';
+import { CommandRegistry } from '@lumino/commands';
+import { JupyterGISWidget } from '@jupytergis/base';
+import { ServiceManager } from '@jupyterlab/services';
+interface IOptions extends DocumentRegistry.IWidgetFactoryOptions {
+    tracker: IJupyterGISTracker;
+    commands: CommandRegistry;
+    externalCommandRegistry: IJGISExternalCommandRegistry;
+    manager?: ServiceManager.IManager;
+    contentFactory?: ConsolePanel.IContentFactory;
+    mimeTypeService?: IEditorMimeTypeService;
+    rendermime?: IRenderMimeRegistry;
+    consoleTracker?: IConsoleTracker;
+    backendCheck?: () => boolean;
+    drive?: ICollaborativeDrive | null;
+}
+export declare class JupyterGISWidgetFactory extends ABCWidgetFactory<JupyterGISWidget, JupyterGISModel> {
+    private options;
+    constructor(options: IOptions);
+    /**
+     * Create a new widget given a context.
+     *
+     * @param context Contains the information of the file
+     * @returns The widget
+     */
+    protected createNewWidget(context: DocumentRegistry.IContext<JupyterGISModel>): JupyterGISWidget;
+    private _commands;
+    private _externalCommandRegistry;
+    private _backendCheck?;
+    private _drive?;
+}
+export {};

package/lib/factory.js

@@ -0,0 +1,57 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { ABCWidgetFactory } from '@jupyterlab/docregistry';
+import { JupyterGISPanel, JupyterGISWidget, ToolbarWidget } from '@jupytergis/base';
+export class JupyterGISWidgetFactory extends ABCWidgetFactory {
+    constructor(options) {
+        const { backendCheck, externalCommandRegistry } = options, rest = __rest(options, ["backendCheck", "externalCommandRegistry"]);
+        super(rest);
+        this.options = options;
+        this._backendCheck = backendCheck;
+        this._commands = options.commands;
+        this._externalCommandRegistry = externalCommandRegistry;
+        this._drive = options.drive;
+    }
+    /**
+     * Create a new widget given a context.
+     *
+     * @param context Contains the information of the file
+     * @returns The widget
+     */
+    createNewWidget(context) {
+        if (this._backendCheck) {
+            const checked = this._backendCheck();
+            if (!checked) {
+                throw new Error('Requested backend is not installed');
+            }
+        }
+        const { model } = context;
+        if (this._drive) {
+            model.setDrive(this._drive, context.path);
+        }
+        const content = new JupyterGISPanel({
+            model,
+            manager: this.options.manager,
+            contentFactory: this.options.contentFactory,
+            mimeTypeService: this.options.mimeTypeService,
+            rendermime: this.options.rendermime,
+            consoleTracker: this.options.consoleTracker,
+            commandRegistry: this.options.commands
+        });
+        const toolbar = new ToolbarWidget({
+            commands: this._commands,
+            model,
+            externalCommands: this._externalCommandRegistry.getCommands()
+        });
+        return new JupyterGISWidget({ context, content, toolbar });
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,3 @@
+export * from './factory';
+declare const _default: (import("@jupyterlab/application").JupyterFrontEndPlugin<void> | import("@jupyterlab/application").JupyterFrontEndPlugin<import("@jupytergis/schema").IJupyterGISTracker> | import("@jupyterlab/application").JupyterFrontEndPlugin<import("@jupytergis/schema").IJGISFormSchemaRegistry> | import("@jupyterlab/application").JupyterFrontEndPlugin<import("@jupytergis/schema").IJGISExternalCommandRegistry> | import("@jupyterlab/application").JupyterFrontEndPlugin<import("@jupytergis/schema").IJGISLayerBrowserRegistry>)[];
+export default _default;

package/lib/index.js

@@ -0,0 +1,10 @@
+import jgisPlugin from './jgisplugin/plugins';
+import { externalCommandRegistryPlugin, formSchemaRegistryPlugin, layerBrowserRegistryPlugin, trackerPlugin } from './plugin';
+export * from './factory';
+export default [
+    trackerPlugin,
+    jgisPlugin,
+    formSchemaRegistryPlugin,
+    externalCommandRegistryPlugin,
+    layerBrowserRegistryPlugin
+];

package/lib/jgisplugin/modelfactory.d.ts

@@ -0,0 +1,54 @@
+import { IJupyterGISDoc, JupyterGISModel } from '@jupytergis/schema';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { Contents } from '@jupyterlab/services';
+/**
+ * A Model factory to create new instances of JupyterGISModel.
+ */
+export declare class JupyterGISModelFactory implements DocumentRegistry.IModelFactory<JupyterGISModel> {
+    /**
+     * Whether the model is collaborative or not.
+     */
+    readonly collaborative = true;
+    /**
+     * The name of the model.
+     *
+     * @returns The name
+     */
+    get name(): string;
+    /**
+     * The content type of the file.
+     *
+     * @returns The content type
+     */
+    get contentType(): Contents.ContentType;
+    /**
+     * The format of the file.
+     *
+     * @returns the file format
+     */
+    get fileFormat(): Contents.FileFormat;
+    /**
+     * Get whether the model factory has been disposed.
+     *
+     * @returns disposed status
+     */
+    get isDisposed(): boolean;
+    /**
+     * Dispose the model factory.
+     */
+    dispose(): void;
+    /**
+     * Get the preferred language given the path on the file.
+     *
+     * @param path path of the file represented by this document model
+     * @returns The preferred language
+     */
+    preferredLanguage(path: string): string;
+    /**
+     * Create a new instance of JupyterGISModel.
+     *
+     * @returns The model
+     */
+    createNew(options: DocumentRegistry.IModelOptions<IJupyterGISDoc>): JupyterGISModel;
+    private _disposed;
+}

package/lib/jgisplugin/modelfactory.js

@@ -0,0 +1,72 @@
+import { JupyterGISModel } from '@jupytergis/schema';
+/**
+ * A Model factory to create new instances of JupyterGISModel.
+ */
+export class JupyterGISModelFactory {
+    constructor() {
+        /**
+         * Whether the model is collaborative or not.
+         */
+        this.collaborative = true;
+        this._disposed = false;
+    }
+    /**
+     * The name of the model.
+     *
+     * @returns The name
+     */
+    get name() {
+        return 'jupytergis-jgismodel';
+    }
+    /**
+     * The content type of the file.
+     *
+     * @returns The content type
+     */
+    get contentType() {
+        return 'jgis';
+    }
+    /**
+     * The format of the file.
+     *
+     * @returns the file format
+     */
+    get fileFormat() {
+        return 'text';
+    }
+    /**
+     * Get whether the model factory has been disposed.
+     *
+     * @returns disposed status
+     */
+    get isDisposed() {
+        return this._disposed;
+    }
+    /**
+     * Dispose the model factory.
+     */
+    dispose() {
+        this._disposed = true;
+    }
+    /**
+     * Get the preferred language given the path on the file.
+     *
+     * @param path path of the file represented by this document model
+     * @returns The preferred language
+     */
+    preferredLanguage(path) {
+        return '';
+    }
+    /**
+     * Create a new instance of JupyterGISModel.
+     *
+     * @returns The model
+     */
+    createNew(options) {
+        const model = new JupyterGISModel({
+            sharedModel: options.sharedModel,
+            languagePreference: options.languagePreference
+        });
+        return model;
+    }
+}

package/lib/jgisplugin/plugins.d.ts

@@ -0,0 +1,3 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+declare const jGISPlugin: JupyterFrontEndPlugin<void>;
+export default jGISPlugin;

package/lib/jgisplugin/plugins.js

@@ -0,0 +1,183 @@
+import { ICollaborativeDrive } from '@jupyter/docprovider';
+import { IJGISExternalCommandRegistryToken, IJupyterGISDocTracker, JupyterGISDoc } from '@jupytergis/schema';
+import { ICommandPalette, IThemeManager } from '@jupyterlab/apputils';
+import { IEditorServices } from '@jupyterlab/codeeditor';
+import { ConsolePanel, IConsoleTracker } from '@jupyterlab/console';
+import { IFileBrowserFactory } from '@jupyterlab/filebrowser';
+import { ILauncher } from '@jupyterlab/launcher';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { fileIcon } from '@jupyterlab/ui-components';
+import { CommandIDs } from '@jupytergis/base';
+import { JupyterGISWidgetFactory } from '../factory';
+import { JupyterGISModelFactory } from './modelfactory';
+const FACTORY = 'JupyterGIS .jgis Viewer';
+const PALETTE_CATEGORY = 'JupyterGIS';
+const activate = (app, tracker, themeManager, browserFactory, externalCommandRegistry, contentFactory, editorServices, rendermime, consoleTracker, launcher, palette, drive) => {
+    const widgetFactory = new JupyterGISWidgetFactory({
+        name: FACTORY,
+        modelName: 'jupytergis-jgismodel',
+        fileTypes: ['jgis'],
+        defaultFor: ['jgis'],
+        tracker,
+        commands: app.commands,
+        externalCommandRegistry,
+        drive,
+        manager: app.serviceManager,
+        contentFactory,
+        rendermime,
+        mimeTypeService: editorServices.mimeTypeService,
+        consoleTracker
+    });
+    // Registering the widget factory
+    app.docRegistry.addWidgetFactory(widgetFactory);
+    // Creating and registering the model factory for our custom DocumentModel
+    const modelFactory = new JupyterGISModelFactory();
+    app.docRegistry.addModelFactory(modelFactory);
+    // register the filetype
+    app.docRegistry.addFileType({
+        name: 'jgis',
+        displayName: 'JGIS',
+        mimeTypes: ['text/json'],
+        extensions: ['.jgis', '.JGIS'],
+        fileFormat: 'text',
+        contentType: 'jgis'
+    });
+    const jGISSharedModelFactory = () => {
+        return new JupyterGISDoc();
+    };
+    if (drive) {
+        drive.sharedModelFactory.registerDocumentFactory('jgis', jGISSharedModelFactory);
+    }
+    widgetFactory.widgetCreated.connect((sender, widget) => {
+        widget.context.pathChanged.connect(() => {
+            tracker.save(widget);
+        });
+        themeManager.themeChanged.connect((_, changes) => widget.context.model.themeChanged.emit(changes));
+        tracker.add(widget);
+        app.shell.activateById('jupytergis::leftControlPanel');
+        app.shell.activateById('jupytergis::rightControlPanel');
+    });
+    app.commands.addCommand(CommandIDs.createNew, {
+        label: args => 'New JGIS File',
+        caption: 'Create a new JGIS Editor',
+        icon: args => (args['isPalette'] ? undefined : fileIcon),
+        execute: async (args) => {
+            var _a;
+            // Get the directory in which the JGIS file must be created;
+            // otherwise take the current filebrowser directory
+            const cwd = (args['cwd'] ||
+                ((_a = browserFactory.tracker.currentWidget) === null || _a === void 0 ? void 0 : _a.model.path));
+            // Create a new untitled GIS file
+            let model = await app.serviceManager.contents.newUntitled({
+                path: cwd,
+                type: 'file',
+                ext: '.jGIS'
+            });
+            model = await app.serviceManager.contents.save(model.path, Object.assign(Object.assign({}, model), { format: 'text', size: undefined, content: '{\n\t"layers": {},\n\t"sources": {},\n\t"options": {"latitude": 0, "longitude": 0, "zoom": 0, "bearing": 0, "pitch": 0, "projection": "EPSG:3857"},\n\t"layerTree": [],\n\t"terrain": {"source": "", "exaggeration": 0}\n}' }));
+            // Open the newly created file with the 'Editor'
+            return app.commands.execute('docmanager:open', {
+                path: model.path,
+                factory: FACTORY
+            });
+        }
+    });
+    // Add the command to the launcher
+    if (launcher) {
+        launcher.add({
+            command: CommandIDs.createNew,
+            category: 'Other',
+            rank: 1
+        });
+    }
+    // Add the command to the palette
+    if (palette) {
+        palette.addItem({
+            command: CommandIDs.createNew,
+            args: { isPalette: true },
+            category: PALETTE_CATEGORY
+        });
+        palette.addItem({
+            command: CommandIDs.openLayerBrowser,
+            category: 'JupyterGIS'
+        });
+        // Layers and Sources
+        palette.addItem({
+            command: CommandIDs.newRasterEntry,
+            category: 'JupyterGIS'
+        });
+        palette.addItem({
+            command: CommandIDs.newVectorTileEntry,
+            category: 'JupyterGIS'
+        });
+        palette.addItem({
+            command: CommandIDs.newGeoJSONEntry,
+            category: 'JupyterGIS'
+        });
+        palette.addItem({
+            command: CommandIDs.newHillshadeEntry,
+            category: 'JupyterGIS'
+        });
+        // Source only
+        palette.addItem({
+            command: CommandIDs.newRasterSource,
+            category: 'JupyterGIS'
+        });
+        palette.addItem({
+            command: CommandIDs.newRasterDemSource,
+            category: 'JupyterGIS'
+        });
+        palette.addItem({
+            command: CommandIDs.newVectorSource,
+            category: 'JupyterGIS'
+        });
+        palette.addItem({
+            command: CommandIDs.newGeoJSONSource,
+            category: 'JupyterGIS'
+        });
+        // Layers only
+        palette.addItem({
+            command: CommandIDs.newRasterLayer,
+            category: 'JupyterGIS'
+        });
+        palette.addItem({
+            command: CommandIDs.newVectorLayer,
+            category: 'JupyterGIS'
+        });
+        palette.addItem({
+            command: CommandIDs.newHillshadeLayer,
+            category: 'JupyterGIS'
+        });
+        // Layer and group actions
+        palette.addItem({
+            command: CommandIDs.moveLayerToNewGroup,
+            category: 'JupyterGIS'
+        });
+        // Source actions
+        // Terrain
+        palette.addItem({
+            command: CommandIDs.newTerrain,
+            category: 'JupyterGIS'
+        });
+        palette.addItem({
+            command: CommandIDs.removeTerrain,
+            category: 'JupyterGIS'
+        });
+    }
+};
+const jGISPlugin = {
+    id: 'jupyterGIS:jGISplugin',
+    requires: [
+        IJupyterGISDocTracker,
+        IThemeManager,
+        IFileBrowserFactory,
+        IJGISExternalCommandRegistryToken,
+        ConsolePanel.IContentFactory,
+        IEditorServices,
+        IRenderMimeRegistry,
+        IConsoleTracker
+    ],
+    optional: [ILauncher, ICommandPalette, ICollaborativeDrive],
+    autoStart: true,
+    activate
+};
+export default jGISPlugin;

package/lib/layerBrowserRegistry.d.ts

@@ -0,0 +1,32 @@
+import { IJGISLayerBrowserRegistry, IRasterLayerGalleryEntry } from '@jupytergis/schema';
+/**
+ * Manages a registry of raster layer gallery entries for a Jupyter GIS Layer Browser.
+ * Implements the {@link IJGISLayerBrowserRegistry} interface, allowing for the addition, removal, and retrieval of raster layer entries.
+ *
+ * @class JupyterGISLayerBrowserRegistry
+ * @implements IJGISLayerBrowserRegistry
+ */
+export declare class JupyterGISLayerBrowserRegistry implements IJGISLayerBrowserRegistry {
+    private _registry;
+    constructor();
+    /**
+     * Retrieves the current state of the registry layers.
+     * Returns a copy of the internal registry array to prevent external modifications.
+     * @returns The current state of the registry layers.
+     */
+    getRegistryLayers(): IRasterLayerGalleryEntry[];
+    /**
+     * Adds a new raster layer gallery entry to the registry.
+     * @param data - The raster layer gallery entry to add.
+     */
+    addRegistryLayer(data: IRasterLayerGalleryEntry): void;
+    /**
+     * Removes a raster layer gallery entry from the registry by its name.
+     * @param name - The name of the raster layer gallery entry to remove.
+     */
+    removeRegistryLayer(name: string): void;
+    /**
+     * Clears the entire registry of raster layer gallery entries.
+     */
+    clearRegistry(): void;
+}

package/lib/layerBrowserRegistry.js

@@ -0,0 +1,40 @@
+/**
+ * Manages a registry of raster layer gallery entries for a Jupyter GIS Layer Browser.
+ * Implements the {@link IJGISLayerBrowserRegistry} interface, allowing for the addition, removal, and retrieval of raster layer entries.
+ *
+ * @class JupyterGISLayerBrowserRegistry
+ * @implements IJGISLayerBrowserRegistry
+ */
+export class JupyterGISLayerBrowserRegistry {
+    constructor() {
+        this._registry = [];
+    }
+    /**
+     * Retrieves the current state of the registry layers.
+     * Returns a copy of the internal registry array to prevent external modifications.
+     * @returns The current state of the registry layers.
+     */
+    getRegistryLayers() {
+        return [...this._registry];
+    }
+    /**
+     * Adds a new raster layer gallery entry to the registry.
+     * @param data - The raster layer gallery entry to add.
+     */
+    addRegistryLayer(data) {
+        this._registry.push(data);
+    }
+    /**
+     * Removes a raster layer gallery entry from the registry by its name.
+     * @param name - The name of the raster layer gallery entry to remove.
+     */
+    removeRegistryLayer(name) {
+        this._registry = this._registry.filter(item => item.name !== name);
+    }
+    /**
+     * Clears the entire registry of raster layer gallery entries.
+     */
+    clearRegistry() {
+        this._registry = [];
+    }
+}

package/lib/plugin.d.ts

@@ -0,0 +1,6 @@
+import { IJGISExternalCommandRegistry, IJGISFormSchemaRegistry, IJGISLayerBrowserRegistry, IJupyterGISTracker } from '@jupytergis/schema';
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+export declare const trackerPlugin: JupyterFrontEndPlugin<IJupyterGISTracker>;
+export declare const formSchemaRegistryPlugin: JupyterFrontEndPlugin<IJGISFormSchemaRegistry>;
+export declare const externalCommandRegistryPlugin: JupyterFrontEndPlugin<IJGISExternalCommandRegistry>;
+export declare const layerBrowserRegistryPlugin: JupyterFrontEndPlugin<IJGISLayerBrowserRegistry>;

package/lib/plugin.js

@@ -0,0 +1,53 @@
+import { IJGISExternalCommandRegistryToken, IJGISFormSchemaRegistryToken, IJGISLayerBrowserRegistryToken, IJupyterGISDocTracker } from '@jupytergis/schema';
+import { WidgetTracker } from '@jupyterlab/apputils';
+import { IMainMenu } from '@jupyterlab/mainmenu';
+import { ITranslator } from '@jupyterlab/translation';
+import { JupyterGISExternalCommandRegistry } from './externalcommand';
+import { JupyterGISLayerBrowserRegistry } from './layerBrowserRegistry';
+import { JupyterGISFormSchemaRegistry } from './schemaregistry';
+const NAME_SPACE = 'jupytergis';
+export const trackerPlugin = {
+    id: 'jupytergis:core:tracker',
+    autoStart: true,
+    requires: [ITranslator],
+    optional: [IMainMenu],
+    provides: IJupyterGISDocTracker,
+    activate: (app, translator, mainMenu) => {
+        const tracker = new WidgetTracker({
+            namespace: NAME_SPACE
+        });
+        console.log('jupytergis:core:tracker is activated!');
+        return tracker;
+    }
+};
+export const formSchemaRegistryPlugin = {
+    id: 'jupytergis:core:form-schema-registry',
+    autoStart: true,
+    requires: [],
+    provides: IJGISFormSchemaRegistryToken,
+    activate: (app) => {
+        const registry = new JupyterGISFormSchemaRegistry();
+        return registry;
+    }
+};
+export const externalCommandRegistryPlugin = {
+    id: 'jupytergis:core:external-command-registry',
+    autoStart: true,
+    requires: [],
+    provides: IJGISExternalCommandRegistryToken,
+    activate: (app) => {
+        const registry = new JupyterGISExternalCommandRegistry();
+        return registry;
+    }
+};
+export const layerBrowserRegistryPlugin = {
+    id: 'jupytergis:core:layer-browser-registry',
+    autoStart: true,
+    requires: [],
+    provides: IJGISLayerBrowserRegistryToken,
+    activate: (app) => {
+        console.log('jupytergis:core:layer-browser-registry is activated');
+        const registry = new JupyterGISLayerBrowserRegistry();
+        return registry;
+    }
+};

package/lib/schemaregistry.d.ts

@@ -0,0 +1,8 @@
+import { IDict, IJGISFormSchemaRegistry } from '@jupytergis/schema';
+export declare class JupyterGISFormSchemaRegistry implements IJGISFormSchemaRegistry {
+    constructor();
+    registerSchema(name: string, schema: IDict): void;
+    has(name: string): boolean;
+    getSchemas(): Map<string, IDict>;
+    private _registry;
+}

package/lib/schemaregistry.js

@@ -0,0 +1,20 @@
+import formSchema from '@jupytergis/schema/lib/_interface/forms.json';
+export class JupyterGISFormSchemaRegistry {
+    constructor() {
+        this._registry = new Map(Object.entries(formSchema));
+    }
+    registerSchema(name, schema) {
+        if (!this._registry.has(name)) {
+            this._registry.set(name, schema);
+        }
+        else {
+            console.error('Worker is already registered!');
+        }
+    }
+    has(name) {
+        return this._registry.has(name);
+    }
+    getSchemas() {
+        return this._registry;
+    }
+}

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "@jupytergis/jupytergis-core",
+  "version": "0.1.1",
+  "description": "JupyterGIS core extension",
+  "keywords": [
+    "jupyter",
+    "jupyterlab",
+    "jupyterlab-extension"
+  ],
+  "homepage": "https://github.com/geojupyter/jupytergis",
+  "bugs": {
+    "url": "https://github.com/geojupyter/jupytergis/issues"
+  },
+  "license": "BSD-3-Clause",
+  "author": "JupyterGIS contributors",
+  "files": [
+    "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}",
+    "style/**/*.{css,js,eot,gif,html,jpg,json,png,svg,woff2,ttf}"
+  ],
+  "main": "lib/index.js",
+  "types": "lib/index.d.ts",
+  "style": "style/index.css",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/geojupyter/jupytergis.git"
+  },
+  "scripts": {
+    "build": "jlpm build:lib && jlpm build:labextension:dev",
+    "build:prod": "jlpm clean && jlpm build:lib:prod && jlpm build:labextension",
+    "build:labextension": "jupyter labextension build .",
+    "build:labextension:dev": "jupyter labextension build --development True .",
+    "build:lib": "tsc --sourceMap",
+    "build:lib:prod": "tsc",
+    "build:dev": "jlpm run build",
+    "clean": "jlpm clean:lib",
+    "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
+    "clean:lintcache": "rimraf .eslintcache .stylelintcache",
+    "clean:labextension": "rimraf jupytergis_core/labextension jupytergis_core/_version.py",
+    "clean:all": "jlpm clean:lib && jlpm clean:labextension && jlpm clean:lintcache",
+    "eslint": "jlpm eslint:check --fix",
+    "eslint:check": "eslint . --cache --ext .ts,.tsx",
+    "install:extension": "jlpm build",
+    "lint": "jlpm stylelint && jlpm prettier && jlpm eslint",
+    "lint:check": "jlpm stylelint:check && jlpm prettier:check && jlpm eslint:check",
+    "prettier": "jlpm prettier:base --write",
+    "prettier:base": "prettier \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md}\"",
+    "prettier:check": "jlpm prettier:base --check",
+    "stylelint": "jlpm stylelint:check --fix",
+    "stylelint:check": "stylelint --cache \"style/**/*.css\"",
+    "watch": "run-p watch:src watch:labextension",
+    "watch:src": "tsc -w --sourceMap",
+    "watch:labextension": "jupyter labextension watch ."
+  },
+  "dependencies": {
+    "@jupyter/docprovider": "^2.0.0",
+    "@jupytergis/base": "^0.1.1",
+    "@jupytergis/schema": "^0.1.1",
+    "@jupyterlab/application": "^4.0.0",
+    "@jupyterlab/apputils": "^4.0.0",
+    "@jupyterlab/docregistry": "^4.0.0",
+    "@jupyterlab/filebrowser": "^4.0.0",
+    "@jupyterlab/launcher": "^4.0.0",
+    "@jupyterlab/mainmenu": "^4.0.0",
+    "@jupyterlab/services": "^7.0.0",
+    "@jupyterlab/translation": "^4.0.0",
+    "@jupyterlab/ui-components": "^4.0.0",
+    "@lumino/commands": "^2.0.0",
+    "util": "^0.12.5"
+  },
+  "devDependencies": {
+    "@jupyterlab/builder": "^4.0.0",
+    "@types/json-schema": "^7.0.11",
+    "@types/react": "^18.0.26",
+    "@types/react-addons-linked-state-mixin": "^0.14.22",
+    "copy-webpack-plugin": "^10.0.0",
+    "css-loader": "^6.7.1",
+    "mkdirp": "^1.0.3",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^3.0.2",
+    "style-loader": "^3.3.1",
+    "typescript": "^5",
+    "webpack": "^5.76.3",
+    "yjs": "^13.5.0"
+  },
+  "sideEffects": [
+    "style/*.css",
+    "style/index.js"
+  ],
+  "styleModule": "style/index.js",
+  "publishConfig": {
+    "access": "public"
+  },
+  "jupyterlab": {
+    "discovery": {
+      "server": {
+        "managers": [
+          "pip"
+        ],
+        "base": {
+          "name": "jupytergis_core"
+        }
+      }
+    },
+    "extension": true,
+    "outputDir": "jupytergis_core/labextension",
+    "webpackConfig": "./extension.webpack.config.js",
+    "sharedPackages": {
+      "@jupytergis/base": {
+        "singleton": true,
+        "bundled": true
+      },
+      "@jupytergis/schema": {
+        "singleton": true,
+        "bundled": true
+      },
+      "@jupyter/docprovider": {
+        "singleton": true,
+        "bundled": false
+      }
+    }
+  }
+}

package/style/base.css

@@ -0,0 +1,5 @@
+/*
+    See the JupyterLab Developer Guide for useful CSS Patterns:
+
+    https://jupyterlab.readthedocs.io/en/stable/developer/css.html
+*/

package/style/index.css

@@ -0,0 +1 @@
+@import url('base.css');

package/style/index.js

@@ -0,0 +1 @@
+import "./base.css";