jupyterlab_notifications_extension 1.0.18

package/LICENSE

@@ -0,0 +1,29 @@
+BSD 3-Clause License
+
+Copyright (c) 2025, Stellars Henson
+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,204 @@
+# jupyterlab_notifications_extension
+
+[![GitHub Actions](https://github.com/stellarshenson/jupyterlab_notifications_extension/actions/workflows/build.yml/badge.svg)](https://github.com/stellarshenson/jupyterlab_notifications_extension/actions/workflows/build.yml)
+[![npm version](https://img.shields.io/npm/v/jupyterlab_notifications_extension.svg)](https://www.npmjs.com/package/jupyterlab_notifications_extension)
+[![PyPI version](https://img.shields.io/pypi/v/jupyterlab-notifications-extension.svg)](https://pypi.org/project/jupyterlab-notifications-extension/)
+[![Total PyPI downloads](https://static.pepy.tech/badge/jupyterlab-notifications-extension)](https://pepy.tech/project/jupyterlab-notifications-extension)
+[![JupyterLab 4](https://img.shields.io/badge/JupyterLab-4-orange.svg)](https://jupyterlab.readthedocs.io/en/stable/)
+
+JupyterLab extension enabling external systems to send notifications that appear in JupyterLab's notification center. Administrators, monitoring systems, and CI/CD pipelines broadcast alerts and status updates to users via a simple REST API.
+
+The extension provides a POST endpoint for notification ingestion and polls every 30 seconds to display new notifications using JupyterLab's native notification system. Supports multiple notification types, configurable auto-close behavior, and optional action buttons.
+
+## Installation
+
+```bash
+pip install jupyterlab_notifications_extension
+```
+
+**Requirements**: JupyterLab >= 4.0.0
+
+## API Reference
+
+### POST /jupyterlab-notifications-extension/ingest
+
+Send notifications to JupyterLab users. Requires authentication via `Authorization: token <TOKEN>` header or `?token=<TOKEN>` query parameter.
+
+**Endpoint**: `POST /jupyterlab-notifications-extension/ingest`
+
+**Request Body** (application/json):
+
+```json
+{
+  "message": "Your notification message",
+  "type": "info",
+  "autoClose": 5000,
+  "actions": [
+    {
+      "label": "Click here",
+      "caption": "Additional info",
+      "displayType": "accent"
+    }
+  ]
+}
+```
+
+**Request Parameters**:
+
+| Field       | Type           | Required | Default  | Description                                                                                                             |
+| ----------- | -------------- | -------- | -------- | ----------------------------------------------------------------------------------------------------------------------- |
+| `message`   | string         | Yes      | -        | Notification text displayed to users                                                                                    |
+| `type`      | string         | No       | `"info"` | Visual style: `default`, `info`, `success`, `warning`, `error`, `in-progress`                                           |
+| `autoClose` | number/boolean | No       | `5000`   | Milliseconds before auto-dismiss. `false` = manual dismiss only. `0` = silent mode (notification center only, no toast) |
+| `actions`   | array          | No       | `[]`     | Action buttons (see below)                                                                                              |
+
+**Action Button Schema**:
+
+| Field         | Type   | Required | Default     | Description                                       |
+| ------------- | ------ | -------- | ----------- | ------------------------------------------------- |
+| `label`       | string | Yes      | -           | Button text                                       |
+| `caption`     | string | No       | `""`        | Tooltip text                                      |
+| `displayType` | string | No       | `"default"` | Visual style: `default`, `accent`, `warn`, `link` |
+
+**Response** (200 OK):
+
+```json
+{
+  "success": true,
+  "notification_id": "notif_1762549476180_0"
+}
+```
+
+**Error Responses**:
+
+- `400 Bad Request` - Missing `message` field or invalid JSON
+- `401 Unauthorized` - Missing or invalid authentication token
+- `500 Internal Server Error` - Server-side processing error
+
+## Usage Examples
+
+### Python Script
+
+The included script auto-detects tokens from `JUPYTERHUB_API_TOKEN`, `JPY_API_TOKEN`, or `JUPYTER_TOKEN` environment variables:
+
+```bash
+# Basic notification
+./scripts/send_notification.py --message "Deployment complete" --type success
+
+# Persistent warning (no auto-close)
+./scripts/send_notification.py --message "System maintenance in 1 hour" --type warning --no-auto-close
+
+# Silent mode (notification center only)
+./scripts/send_notification.py --message "Background task finished" --auto-close 0
+```
+
+### cURL
+
+```bash
+# Basic info notification
+curl -X POST http://localhost:8888/jupyterlab-notifications-extension/ingest \
+  -H "Content-Type: application/json" \
+  -H "Authorization: token YOUR_TOKEN" \
+  -d '{"message": "Build completed", "type": "info"}'
+
+# Error notification with action button
+curl -X POST http://localhost:8888/jupyterlab-notifications-extension/ingest \
+  -H "Content-Type: application/json" \
+  -H "Authorization: token YOUR_TOKEN" \
+  -d '{
+    "message": "Build failed on main branch",
+    "type": "error",
+    "autoClose": false,
+    "actions": [{
+      "label": "View Logs",
+      "caption": "Open build logs",
+      "displayType": "accent"
+    }]
+  }'
+```
+
+## Architecture
+
+Broadcast-only model - all notifications delivered to all users.
+
+**Flow**: External system POSTs to `/jupyterlab-notifications-extension/ingest` -> Server queues in memory -> Frontend polls `/jupyterlab-notifications-extension/notifications` every 30 seconds -> Displays via JupyterLab notification manager -> Clears queue after fetch.
+
+## Troubleshooting
+
+**Frontend installed but not working**:
+
+```bash
+jupyter server extension list  # Verify server extension enabled
+```
+
+**Server extension enabled but frontend missing**:
+
+```bash
+jupyter labextension list  # Verify frontend extension installed
+```
+
+**Notifications not appearing**: Check browser console for polling errors or verify JupyterLab was restarted after installation.
+
+## Uninstall
+
+```bash
+pip uninstall jupyterlab_notifications_extension
+```
+
+## Development
+
+### Setup
+
+Requires NodeJS to build the extension. Uses `jlpm` (JupyterLab's pinned yarn) for package management.
+
+```bash
+# Install in development mode
+python -m venv .venv
+source .venv/bin/activate
+pip install --editable ".[dev,test]"
+
+# Link extension with JupyterLab
+jupyter labextension develop . --overwrite
+jupyter server extension enable jupyterlab_notifications_extension
+
+# Build TypeScript
+jlpm build
+```
+
+### Development workflow
+
+Run `jlpm watch` in one terminal to auto-rebuild on changes, and `jupyter lab` in another. Refresh browser after rebuilds to load changes.
+
+```bash
+jlpm watch           # Auto-rebuild on file changes
+jupyter lab          # Run JupyterLab
+```
+
+### Cleanup
+
+```bash
+jupyter server extension disable jupyterlab_notifications_extension
+pip uninstall jupyterlab_notifications_extension
+# Remove symlink: find via `jupyter labextension list`
+```
+
+### Testing
+
+**Python tests** (Pytest):
+
+```bash
+pip install -e ".[test]"
+pytest -vv -r ap --cov jupyterlab_notifications_extension
+```
+
+**Frontend tests** (Jest):
+
+```bash
+jlpm test
+```
+
+**Integration tests** (Playwright/Galata): See [ui-tests/README.md](ui-tests/README.md)
+
+### Packaging
+
+See [RELEASE.md](RELEASE.md) for release procedures.

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+/**
+ * Initialization data for the jupyterlab_notifications_extension extension.
+ */
+declare const plugin: JupyterFrontEndPlugin<void>;
+export default plugin;

package/lib/index.js

@@ -0,0 +1,65 @@
+import { requestAPI } from './request';
+/**
+ * Poll interval in milliseconds (30 seconds)
+ */
+const POLL_INTERVAL = 30000;
+/**
+ * Fetch and display notifications from the server
+ */
+async function fetchAndDisplayNotifications(app) {
+    try {
+        const response = await requestAPI('notifications');
+        if (response.notifications && response.notifications.length > 0) {
+            console.log(`Received ${response.notifications.length} notification(s) from server`);
+            response.notifications.forEach(notif => {
+                // Build options object
+                const options = {
+                    autoClose: notif.autoClose
+                };
+                // Build actions array if present (actions are passed as part of options)
+                if (notif.actions && notif.actions.length > 0) {
+                    options.actions = notif.actions.map(action => ({
+                        label: action.label,
+                        caption: action.caption || '',
+                        displayType: action.displayType || 'default',
+                        callback: () => {
+                            console.log(`Action clicked: ${action.label}`);
+                        }
+                    }));
+                }
+                // Display notification using JupyterLab's command
+                app.commands
+                    .execute('apputils:notify', {
+                    message: notif.message,
+                    type: notif.type,
+                    options: options
+                })
+                    .catch(err => {
+                    console.error('Failed to display notification:', err);
+                });
+            });
+        }
+    }
+    catch (reason) {
+        console.error('Failed to fetch notifications from server:', reason);
+    }
+}
+/**
+ * Initialization data for the jupyterlab_notifications_extension extension.
+ */
+const plugin = {
+    id: 'jupyterlab_notifications_extension:plugin',
+    description: 'Jupyterlab extension to receive and display notifications in the main panel. Those can be from the jupyterjub administrator or from other places.',
+    autoStart: true,
+    activate: (app) => {
+        console.log('JupyterLab extension jupyterlab_notifications_extension is activated!');
+        // Fetch notifications immediately on startup
+        fetchAndDisplayNotifications(app);
+        // Set up periodic polling for new notifications
+        setInterval(() => {
+            fetchAndDisplayNotifications(app);
+        }, POLL_INTERVAL);
+        console.log(`Notification polling started (interval: ${POLL_INTERVAL / 1000}s)`);
+    }
+};
+export default plugin;

package/lib/request.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Call the server extension
+ *
+ * @param endPoint API REST end point for the extension
+ * @param init Initial values for the request
+ * @returns The response body interpreted as JSON
+ */
+export declare function requestAPI<T>(endPoint?: string, init?: RequestInit): Promise<T>;

package/lib/request.js

@@ -0,0 +1,35 @@
+import { URLExt } from '@jupyterlab/coreutils';
+import { ServerConnection } from '@jupyterlab/services';
+/**
+ * Call the server extension
+ *
+ * @param endPoint API REST end point for the extension
+ * @param init Initial values for the request
+ * @returns The response body interpreted as JSON
+ */
+export async function requestAPI(endPoint = '', init = {}) {
+    // Make request to Jupyter API
+    const settings = ServerConnection.makeSettings();
+    const requestUrl = URLExt.join(settings.baseUrl, 'jupyterlab-notifications-extension', // our server extension's API namespace
+    endPoint);
+    let response;
+    try {
+        response = await ServerConnection.makeRequest(requestUrl, init, settings);
+    }
+    catch (error) {
+        throw new ServerConnection.NetworkError(error);
+    }
+    let data = await response.text();
+    if (data.length > 0) {
+        try {
+            data = JSON.parse(data);
+        }
+        catch (error) {
+            console.log('Not a JSON response body.', response);
+        }
+    }
+    if (!response.ok) {
+        throw new ServerConnection.ResponseError(response, data.message || data);
+    }
+    return data;
+}

package/package.json

@@ -0,0 +1,207 @@
+{
+    "name": "jupyterlab_notifications_extension",
+    "version": "1.0.18",
+    "description": "Jupyterlab extension to receive and display notifications in the main panel. Those can be from the jupyterjub administrator or from other places.",
+    "keywords": [
+        "jupyter",
+        "jupyterlab",
+        "jupyterlab-extension"
+    ],
+    "homepage": "https://github.com/stellarshenson/jupyterlab_notifications_extension",
+    "bugs": {
+        "url": "https://github.com/stellarshenson/jupyterlab_notifications_extension/issues"
+    },
+    "license": "BSD-3-Clause",
+    "author": {
+        "name": "Stellars Henson",
+        "email": "konrad.jelen@gmail.com"
+    },
+    "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}",
+        "src/**/*.{ts,tsx}"
+    ],
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "style": "style/index.css",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/stellarshenson/jupyterlab_notifications_extension.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",
+        "clean": "jlpm clean:lib",
+        "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
+        "clean:lintcache": "rimraf .eslintcache .stylelintcache",
+        "clean:labextension": "rimraf jupyterlab_notifications_extension/labextension jupyterlab_notifications_extension/_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 --list-different",
+        "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\"",
+        "test": "jest --coverage",
+        "watch": "run-p watch:src watch:labextension",
+        "watch:src": "tsc -w --sourceMap",
+        "watch:labextension": "jupyter labextension watch ."
+    },
+    "dependencies": {
+        "@jupyterlab/application": "^4.0.0",
+        "@jupyterlab/coreutils": "^6.0.0",
+        "@jupyterlab/services": "^7.0.0"
+    },
+    "devDependencies": {
+        "@jupyterlab/builder": "^4.0.0",
+        "@jupyterlab/testutils": "^4.0.0",
+        "@types/jest": "^29.2.0",
+        "@types/json-schema": "^7.0.11",
+        "@types/react": "^18.0.26",
+        "@types/react-addons-linked-state-mixin": "^0.14.22",
+        "@typescript-eslint/eslint-plugin": "^6.1.0",
+        "@typescript-eslint/parser": "^6.1.0",
+        "css-loader": "^6.7.1",
+        "eslint": "^8.36.0",
+        "eslint-config-prettier": "^8.8.0",
+        "eslint-plugin-prettier": "^5.0.0",
+        "jest": "^29.2.0",
+        "mkdirp": "^1.0.3",
+        "npm-run-all2": "^7.0.1",
+        "prettier": "^3.0.0",
+        "rimraf": "^5.0.10",
+        "source-map-loader": "^1.0.2",
+        "style-loader": "^3.3.1",
+        "stylelint": "^15.10.1",
+        "stylelint-config-recommended": "^13.0.0",
+        "stylelint-config-standard": "^34.0.0",
+        "stylelint-csstree-validator": "^3.0.0",
+        "stylelint-prettier": "^4.0.0",
+        "typescript": "~5.8.0",
+        "yjs": "^13.5.0"
+    },
+    "sideEffects": [
+        "style/*.css",
+        "style/index.js"
+    ],
+    "styleModule": "style/index.js",
+    "publishConfig": {
+        "access": "public"
+    },
+    "jupyterlab": {
+        "discovery": {
+            "server": {
+                "managers": [
+                    "pip"
+                ],
+                "base": {
+                    "name": "jupyterlab_notifications_extension"
+                }
+            }
+        },
+        "extension": true,
+        "outputDir": "jupyterlab_notifications_extension/labextension"
+    },
+    "eslintIgnore": [
+        "node_modules",
+        "dist",
+        "coverage",
+        "**/*.d.ts",
+        "tests",
+        "**/__tests__",
+        "ui-tests"
+    ],
+    "eslintConfig": {
+        "extends": [
+            "eslint:recommended",
+            "plugin:@typescript-eslint/eslint-recommended",
+            "plugin:@typescript-eslint/recommended",
+            "plugin:prettier/recommended"
+        ],
+        "parser": "@typescript-eslint/parser",
+        "parserOptions": {
+            "project": "tsconfig.json",
+            "sourceType": "module"
+        },
+        "plugins": [
+            "@typescript-eslint"
+        ],
+        "rules": {
+            "@typescript-eslint/naming-convention": [
+                "error",
+                {
+                    "selector": "interface",
+                    "format": [
+                        "PascalCase"
+                    ],
+                    "custom": {
+                        "regex": "^I[A-Z]",
+                        "match": true
+                    }
+                }
+            ],
+            "@typescript-eslint/no-unused-vars": [
+                "warn",
+                {
+                    "args": "none"
+                }
+            ],
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-namespace": "off",
+            "@typescript-eslint/no-use-before-define": "off",
+            "@typescript-eslint/quotes": [
+                "error",
+                "single",
+                {
+                    "avoidEscape": true,
+                    "allowTemplateLiterals": false
+                }
+            ],
+            "curly": [
+                "error",
+                "all"
+            ],
+            "eqeqeq": "error",
+            "prefer-arrow-callback": "error"
+        }
+    },
+    "prettier": {
+        "singleQuote": true,
+        "trailingComma": "none",
+        "arrowParens": "avoid",
+        "endOfLine": "auto",
+        "overrides": [
+            {
+                "files": "package.json",
+                "options": {
+                    "tabWidth": 4
+                }
+            }
+        ]
+    },
+    "stylelint": {
+        "extends": [
+            "stylelint-config-recommended",
+            "stylelint-config-standard",
+            "stylelint-prettier/recommended"
+        ],
+        "plugins": [
+            "stylelint-csstree-validator"
+        ],
+        "rules": {
+            "csstree/validator": true,
+            "property-no-vendor-prefix": null,
+            "selector-class-pattern": "^([a-z][A-z\\d]*)(-[A-z\\d]+)*$",
+            "selector-no-vendor-prefix": null,
+            "value-no-vendor-prefix": null
+        }
+    }
+}

package/src/__tests__/jupyterlab_notifications_extension.spec.ts

@@ -0,0 +1,9 @@
+/**
+ * Example of [Jest](https://jestjs.io/docs/getting-started) unit tests
+ */
+
+describe('jupyterlab_notifications_extension', () => {
+  it('should be tested', () => {
+    expect(1 + 1).toEqual(2);
+  });
+});

package/src/index.ts

@@ -0,0 +1,107 @@
+import {
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+
+import { requestAPI } from './request';
+
+/**
+ * Notification interface matching backend payload
+ */
+interface INotificationData {
+  id: string;
+  message: string;
+  type: 'default' | 'info' | 'success' | 'warning' | 'error' | 'in-progress';
+  autoClose: number | false;
+  createdAt: number;
+  actions?: Array<{
+    label: string;
+    caption?: string;
+    displayType?: 'default' | 'accent' | 'warn' | 'link';
+  }>;
+}
+
+/**
+ * Poll interval in milliseconds (30 seconds)
+ */
+const POLL_INTERVAL = 30000;
+
+/**
+ * Fetch and display notifications from the server
+ */
+async function fetchAndDisplayNotifications(
+  app: JupyterFrontEnd
+): Promise<void> {
+  try {
+    const response = await requestAPI<{ notifications: INotificationData[] }>(
+      'notifications'
+    );
+
+    if (response.notifications && response.notifications.length > 0) {
+      console.log(
+        `Received ${response.notifications.length} notification(s) from server`
+      );
+
+      response.notifications.forEach(notif => {
+        // Build options object
+        const options: any = {
+          autoClose: notif.autoClose
+        };
+
+        // Build actions array if present (actions are passed as part of options)
+        if (notif.actions && notif.actions.length > 0) {
+          options.actions = notif.actions.map(action => ({
+            label: action.label,
+            caption: action.caption || '',
+            displayType: action.displayType || 'default',
+            callback: () => {
+              console.log(`Action clicked: ${action.label}`);
+            }
+          }));
+        }
+
+        // Display notification using JupyterLab's command
+        app.commands
+          .execute('apputils:notify', {
+            message: notif.message,
+            type: notif.type,
+            options: options
+          })
+          .catch(err => {
+            console.error('Failed to display notification:', err);
+          });
+      });
+    }
+  } catch (reason) {
+    console.error('Failed to fetch notifications from server:', reason);
+  }
+}
+
+/**
+ * Initialization data for the jupyterlab_notifications_extension extension.
+ */
+const plugin: JupyterFrontEndPlugin<void> = {
+  id: 'jupyterlab_notifications_extension:plugin',
+  description:
+    'Jupyterlab extension to receive and display notifications in the main panel. Those can be from the jupyterjub administrator or from other places.',
+  autoStart: true,
+  activate: (app: JupyterFrontEnd) => {
+    console.log(
+      'JupyterLab extension jupyterlab_notifications_extension is activated!'
+    );
+
+    // Fetch notifications immediately on startup
+    fetchAndDisplayNotifications(app);
+
+    // Set up periodic polling for new notifications
+    setInterval(() => {
+      fetchAndDisplayNotifications(app);
+    }, POLL_INTERVAL);
+
+    console.log(
+      `Notification polling started (interval: ${POLL_INTERVAL / 1000}s)`
+    );
+  }
+};
+
+export default plugin;

package/src/request.ts

@@ -0,0 +1,46 @@
+import { URLExt } from '@jupyterlab/coreutils';
+
+import { ServerConnection } from '@jupyterlab/services';
+
+/**
+ * Call the server extension
+ *
+ * @param endPoint API REST end point for the extension
+ * @param init Initial values for the request
+ * @returns The response body interpreted as JSON
+ */
+export async function requestAPI<T>(
+  endPoint = '',
+  init: RequestInit = {}
+): Promise<T> {
+  // Make request to Jupyter API
+  const settings = ServerConnection.makeSettings();
+  const requestUrl = URLExt.join(
+    settings.baseUrl,
+    'jupyterlab-notifications-extension', // our server extension's API namespace
+    endPoint
+  );
+
+  let response: Response;
+  try {
+    response = await ServerConnection.makeRequest(requestUrl, init, settings);
+  } catch (error) {
+    throw new ServerConnection.NetworkError(error as any);
+  }
+
+  let data: any = await response.text();
+
+  if (data.length > 0) {
+    try {
+      data = JSON.parse(data);
+    } catch (error) {
+      console.log('Not a JSON response body.', response);
+    }
+  }
+
+  if (!response.ok) {
+    throw new ServerConnection.ResponseError(response, data.message || data);
+  }
+
+  return data;
+}

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';