@jupytergis/jupytergis-qgis 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_qgis

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("@jupyterlab/application").JupyterFrontEndPlugin<void>[];
+export default _default;

package/lib/index.js

@@ -0,0 +1,2 @@
+import { qgisplugin } from './plugins';
+export default [qgisplugin];

package/lib/modelfactory.d.ts

@@ -0,0 +1,82 @@
+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 JupyterGISModelFactoryBase 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;
+}
+export declare class QGZModelFactory extends JupyterGISModelFactoryBase {
+    /**
+     * 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;
+}
+export declare class QGSModelFactory extends JupyterGISModelFactoryBase {
+    /**
+     * 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;
+}

package/lib/modelfactory.js

@@ -0,0 +1,108 @@
+import { JupyterGISModel } from '@jupytergis/schema';
+/**
+ * A Model factory to create new instances of JupyterGISModel.
+ */
+export class JupyterGISModelFactoryBase {
+    constructor() {
+        /**
+         * Whether the model is collaborative or not.
+         */
+        this.collaborative = true;
+        this._disposed = false;
+    }
+    /**
+     * The name of the model.
+     *
+     * @returns The name
+     */
+    get name() {
+        throw 'Not implemented';
+    }
+    /**
+     * The content type of the file.
+     *
+     * @returns The content type
+     */
+    get contentType() {
+        throw 'Not implemented';
+    }
+    /**
+     * The format of the file.
+     *
+     * @returns the file format
+     */
+    get fileFormat() {
+        return 'base64';
+    }
+    /**
+     * 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;
+    }
+}
+export class QGZModelFactory extends JupyterGISModelFactoryBase {
+    /**
+     * The name of the model.
+     *
+     * @returns The name
+     */
+    get name() {
+        return 'jupytergis-qgzmodel';
+    }
+    /**
+     * The content type of the file.
+     *
+     * @returns The content type
+     */
+    get contentType() {
+        return 'QGZ';
+    }
+}
+export class QGSModelFactory extends JupyterGISModelFactoryBase {
+    /**
+     * The name of the model.
+     *
+     * @returns The name
+     */
+    get name() {
+        return 'jupytergis-qgsmodel';
+    }
+    /**
+     * The content type of the file.
+     *
+     * @returns The content type
+     */
+    get contentType() {
+        return 'QGS';
+    }
+}

package/lib/plugins.d.ts

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

package/lib/plugins.js

@@ -0,0 +1,109 @@
+import { ICollaborativeDrive } from '@jupyter/docprovider';
+import { JupyterGISDoc, IJGISExternalCommandRegistryToken } from '@jupytergis/schema';
+import { IThemeManager, showErrorMessage } from '@jupyterlab/apputils';
+import { IEditorServices } from '@jupyterlab/codeeditor';
+import { ConsolePanel, IConsoleTracker } from '@jupyterlab/console';
+import { IRenderMimeRegistry } from '@jupyterlab/rendermime';
+import { JupyterGISWidgetFactory } from '@jupytergis/jupytergis-core';
+import { IJupyterGISDocTracker } from '@jupytergis/schema';
+import { requestAPI } from '@jupytergis/base';
+import { QGSModelFactory, QGZModelFactory } from './modelfactory';
+const activate = async (app, tracker, themeManager, drive, externalCommandRegistry, contentFactory, editorServices, rendermime, consoleTracker) => {
+    const fcCheck = await requestAPI('jupytergis_qgis/backend-check', {
+        method: 'POST',
+        body: JSON.stringify({})
+    });
+    const { installed } = fcCheck;
+    const backendCheck = () => {
+        if (!installed) {
+            showErrorMessage('QGIS is not installed', 'QGIS is required to open QGIS files');
+        }
+        return installed;
+    };
+    const QGSWidgetFactory = new JupyterGISWidgetFactory({
+        name: 'JupyterGIS QGS Factory',
+        modelName: 'jupytergis-qgsmodel',
+        fileTypes: ['QGS'],
+        defaultFor: ['QGS'],
+        tracker,
+        commands: app.commands,
+        externalCommandRegistry,
+        backendCheck,
+        manager: app.serviceManager,
+        contentFactory,
+        rendermime,
+        mimeTypeService: editorServices.mimeTypeService,
+        consoleTracker
+    });
+    const QGZWidgetFactory = new JupyterGISWidgetFactory({
+        name: 'JupyterGIS QGZ Factory',
+        modelName: 'jupytergis-qgzmodel',
+        fileTypes: ['QGZ'],
+        defaultFor: ['QGZ'],
+        tracker,
+        commands: app.commands,
+        externalCommandRegistry,
+        backendCheck,
+        manager: app.serviceManager,
+        contentFactory,
+        rendermime,
+        mimeTypeService: editorServices.mimeTypeService,
+        consoleTracker
+    });
+    // Registering the widget factory
+    app.docRegistry.addWidgetFactory(QGSWidgetFactory);
+    app.docRegistry.addWidgetFactory(QGZWidgetFactory);
+    // Creating and registering the model factory for our custom DocumentModel
+    app.docRegistry.addModelFactory(new QGSModelFactory());
+    app.docRegistry.addModelFactory(new QGZModelFactory());
+    // register the filetype
+    app.docRegistry.addFileType({
+        name: 'QGS',
+        displayName: 'QGS',
+        mimeTypes: ['application/octet-stream'],
+        extensions: ['.qgs', '.QGS'],
+        fileFormat: 'base64',
+        contentType: 'QGS'
+    });
+    app.docRegistry.addFileType({
+        name: 'QGZ',
+        displayName: 'QGZ',
+        mimeTypes: ['application/octet-stream'],
+        extensions: ['.qgz', '.QGZ'],
+        fileFormat: 'base64',
+        contentType: 'QGZ'
+    });
+    const QGISSharedModelFactory = () => {
+        return new JupyterGISDoc();
+    };
+    drive.sharedModelFactory.registerDocumentFactory('QGS', QGISSharedModelFactory);
+    drive.sharedModelFactory.registerDocumentFactory('QGZ', QGISSharedModelFactory);
+    const widgetCreatedCallback = (sender, widget) => {
+        // Notify the instance tracker if restore data needs to update.
+        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');
+    };
+    QGSWidgetFactory.widgetCreated.connect(widgetCreatedCallback);
+    QGZWidgetFactory.widgetCreated.connect(widgetCreatedCallback);
+    console.log('jupytergis:qgisplugin is activated!');
+};
+export const qgisplugin = {
+    id: 'jupytergis:qgisplugin',
+    requires: [
+        IJupyterGISDocTracker,
+        IThemeManager,
+        ICollaborativeDrive,
+        IJGISExternalCommandRegistryToken,
+        ConsolePanel.IContentFactory,
+        IEditorServices,
+        IRenderMimeRegistry,
+        IConsoleTracker
+    ],
+    autoStart: true,
+    activate
+};

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "@jupytergis/jupytergis-qgis",
+  "version": "0.1.1",
+  "description": "JupyterGIS QGIS 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_qgis/labextension jupytergis_qgis/_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/jupytergis-core": "^0.1.1",
+    "@jupytergis/schema": "^0.1.1",
+    "@jupyterlab/application": "^4.0.0",
+    "@jupyterlab/apputils": "^4.0.0",
+    "@jupyterlab/coreutils": "^6.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/messaging": "^2.0.0",
+    "@lumino/widgets": "^2.0.0",
+    "react": "^18.0.1"
+  },
+  "devDependencies": {
+    "@jupyterlab/builder": "^4.0.0",
+    "css-loader": "^6.7.1",
+    "mkdirp": "^1.0.3",
+    "npm-run-all": "^4.1.5",
+    "rimraf": "^3.0.2",
+    "typescript": "^5",
+    "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_qgis"
+        }
+      }
+    },
+    "extension": true,
+    "outputDir": "jupytergis_qgis/labextension",
+    "sharedPackages": {
+      "@jupytergis/base": {
+        "singleton": true,
+        "bundled": false
+      },
+      "@jupytergis/schema": {
+        "singleton": true,
+        "bundled": false
+      },
+      "@jupytergis/jupytergis-core": {
+        "singleton": true,
+        "bundled": false
+      },
+      "@jupyter/docprovider": {
+        "singleton": true,
+        "bundled": false
+      }
+    }
+  }
+}

package/style/index.css

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

package/style/index.js

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