@fails-components/jupyter-applet-view 0.0.1-alpha.10

package/lib/avtoolbarextension.d.ts

@@ -0,0 +1,36 @@
+import { ToolbarRegistry } from '@jupyterlab/apputils';
+import { DocumentRegistry } from '@jupyterlab/docregistry';
+import { IObservableList } from '@jupyterlab/observables';
+import { CommandRegistry } from '@lumino/commands';
+import { IDisposable } from '@lumino/disposable';
+import { Widget } from '@lumino/widgets';
+import { SplitViewNotebookPanel } from './splitviewnotebookpanel';
+import { IFailsLauncherInfo } from '@fails-components/jupyter-launcher';
+export declare const defaultToolbarItems: ToolbarRegistry.IWidget[];
+export declare class AppletViewToolbarExtension implements DocumentRegistry.WidgetExtension {
+    static readonly FACTORY_NAME = "AppletView";
+    constructor(commands: CommandRegistry, launcherInfo: IFailsLauncherInfo | null, toolbarFactory?: (widget: Widget) => IObservableList<ToolbarRegistry.IToolbarItem>);
+    protected get defaultToolbarFactory(): (widget: Widget) => IObservableList<ToolbarRegistry.IToolbarItem>;
+    createNew(panel: SplitViewNotebookPanel): IDisposable;
+    private _commands;
+    private _toolbarFactory;
+    private _launcherInfo;
+}
+export declare class AppletViewToolbarTracker implements IDisposable {
+    /**
+     * AppletViewToolbarTracker constructor
+     *
+     * @param view The Applet View area
+     * @param toolbarFactory The toolbar factory
+     */
+    constructor(notebookpanel: SplitViewNotebookPanel, toolbarFactory: (widget: Widget) => IObservableList<ToolbarRegistry.IToolbarItem>, launcherInfo: IFailsLauncherInfo | null);
+    dispose(): void;
+    get isDisposed(): boolean;
+    private _addToolbar;
+    _setHiddenToolbars(hidden: boolean): void;
+    private _isDisposed;
+    private _notebookpanel;
+    private _toolbars;
+    private _toolbarStore;
+    private _toolbarFactory;
+}

package/lib/avtoolbarextension.js

@@ -0,0 +1,213 @@
+import { createDefaultFactory, setToolbar } from '@jupyterlab/apputils';
+import { ObservableList } from '@jupyterlab/observables';
+import { Toolbar } from '@jupyterlab/ui-components';
+import { Signal } from '@lumino/signaling';
+// portions used from Jupyterlab:
+/* -----------------------------------------------------------------------------
+| Copyright (c) Jupyter Development Team.
+| Distributed under the terms of the Modified BSD License.
+|----------------------------------------------------------------------------*/
+// This code contains portions from or is inspired by Jupyter lab's notebook extension, especially the createOutputView part
+// Also a lot is taken from the cell toolbar related parts.
+export const defaultToolbarItems = [
+    {
+        command: 'fails-components-jupyter-applet-view:move_view_up',
+        name: 'move-view-up'
+    },
+    {
+        command: 'fails-components-jupyter-applet-view:move_view_down',
+        name: 'move-view-down'
+    },
+    {
+        command: 'fails-components-jupyter-applet-view:move_view_app_up',
+        name: 'move-view-app-up'
+    },
+    {
+        command: 'fails-components-jupyter-applet-view:move_view_app_down',
+        name: 'move-view-app-down'
+    },
+    {
+        command: 'fails-components-jupyter-applet-view:delete_view',
+        name: 'delete-view'
+    }
+];
+// a lot of code taken from Jupyter labs CellBarExtension
+class AppletViewToolbarExtension {
+    constructor(commands, launcherInfo, toolbarFactory) {
+        this._commands = commands;
+        this._launcherInfo = launcherInfo;
+        // # TODO we have to make sure, we get the default, how can we do this?
+        this._toolbarFactory = toolbarFactory !== null && toolbarFactory !== void 0 ? toolbarFactory : this.defaultToolbarFactory;
+    }
+    get defaultToolbarFactory() {
+        const itemFactory = createDefaultFactory(this._commands);
+        return (widget) => new ObservableList({
+            values: defaultToolbarItems.map(item => {
+                // console.log('widget? factory', widget);
+                const applet = widget.parent;
+                const parent = applet.parent;
+                const path = parent.path;
+                return {
+                    name: item.name,
+                    widget: itemFactory(AppletViewToolbarExtension.FACTORY_NAME, widget, {
+                        ...item,
+                        args: {
+                            // @ts-expect-error cellid is not part of Widget
+                            cellid: widget.cellid,
+                            notepadpath: path,
+                            // @ts-expect-error appid is not part of Widget
+                            widgetid: widget.widgetid
+                        }
+                    })
+                };
+            })
+        });
+    }
+    createNew(panel) {
+        return new AppletViewToolbarTracker(panel, this._toolbarFactory, this._launcherInfo);
+    }
+}
+AppletViewToolbarExtension.FACTORY_NAME = 'AppletView';
+export { AppletViewToolbarExtension };
+export class AppletViewToolbarTracker {
+    /**
+     * AppletViewToolbarTracker constructor
+     *
+     * @param view The Applet View area
+     * @param toolbarFactory The toolbar factory
+     */
+    constructor(notebookpanel, toolbarFactory, launcherInfo) {
+        this._isDisposed = false;
+        this._toolbars = new WeakMap();
+        this._toolbarStore = [];
+        this._notebookpanel = notebookpanel;
+        this._toolbarFactory = toolbarFactory !== null && toolbarFactory !== void 0 ? toolbarFactory : null;
+        // Only add the toolbar to the notebook's active cell (if any) once it has fully rendered and been revealed.
+        void notebookpanel.revealed.then(() => {
+            requestAnimationFrame(() => {
+                var _a;
+                (_a = this._notebookpanel) === null || _a === void 0 ? void 0 : _a.appletViewWidget.viewChanged.connect(this._addToolbar, this);
+                this._addToolbar();
+                if (launcherInfo === null || launcherInfo === void 0 ? void 0 : launcherInfo.inLecture) {
+                    this._setHiddenToolbars(launcherInfo === null || launcherInfo === void 0 ? void 0 : launcherInfo.inLecture);
+                }
+                if (launcherInfo) {
+                    let hasToolbar = !(launcherInfo === null || launcherInfo === void 0 ? void 0 : launcherInfo.inLecture);
+                    launcherInfo.inLectureChanged.connect((sender, newInLecture) => {
+                        if (hasToolbar !== !newInLecture) {
+                            this._setHiddenToolbars(newInLecture);
+                            hasToolbar = !newInLecture;
+                        }
+                    });
+                }
+            });
+        });
+    }
+    dispose() {
+        if (this.isDisposed) {
+            return;
+        }
+        this._isDisposed = true;
+        this._toolbarStore.forEach(tb => tb.dispose());
+        this._toolbarStore = [];
+        this._toolbars = new WeakMap();
+        this._notebookpanel = null;
+        Signal.clearData(this);
+    }
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    _addToolbar() {
+        var _a;
+        const notebookpanel = this._notebookpanel;
+        if (notebookpanel && !notebookpanel.isDisposed) {
+            const promises = [
+            /*notebookpanel.ready*/
+            ]; // remove area ready
+            const applets = (_a = notebookpanel.appletViewWidget) === null || _a === void 0 ? void 0 : _a.applets;
+            const doAddToolbar = (part) => {
+                const clone = part.clone;
+                if (clone) {
+                    // eslint-disable-next-line no-constant-condition
+                    const toolbarWidget = new Toolbar();
+                    this._toolbars.set(part, toolbarWidget);
+                    this._toolbarStore.push(toolbarWidget);
+                    // Note: CELL_MENU_CLASS is deprecated.
+                    toolbarWidget.addClass('fl-jp-AppletViewToolbar'); // implement MR
+                    if (this._toolbarFactory) {
+                        // ts-expect-error Widget has no toolbar
+                        // clone.toolbar = toolbarWidget;
+                        setToolbar(clone, this._toolbarFactory, toolbarWidget);
+                    }
+                }
+            };
+            for (const applet of applets) {
+                for (const part of applet.parts) {
+                    const clone = part.clone;
+                    if (!this._toolbars.has(part)) {
+                        if (clone) {
+                            // eslint-disable-next-line no-constant-condition
+                            doAddToolbar(part);
+                        }
+                        else {
+                            // we have to defer it
+                            const slot = () => {
+                                doAddToolbar(part);
+                                part.cloned.disconnect(slot);
+                            };
+                            part.cloned.connect(slot);
+                            this._toolbars.set(part, null);
+                        }
+                    }
+                    // FIXME toolbarWidget.update() - strangely this does not work
+                }
+            }
+            // promises.push(area.ready); // remove?
+            // Wait for all the buttons to be rendered before attaching the toolbar.
+            Promise.all(promises)
+                .then(() => {
+                for (const applet of applets) {
+                    for (const part of applet.parts) {
+                        const toolbarWidget = this._toolbars.get(part);
+                        if (!toolbarWidget) {
+                            continue;
+                        }
+                        if (!part.clone || part.clone.isDisposed) {
+                            continue;
+                        }
+                        const clone = part.clone;
+                        if (clone) {
+                            // (clone!.layout as PanelLayout).insertWidget(0, toolbarWidget);
+                            clone.layout.addWidget(toolbarWidget);
+                        }
+                    }
+                }
+                // For rendered markdown, watch for resize events.
+                // area.displayChanged.connect(this._resizeEventCallback, this); // remove?
+                // Watch for changes in the cell's contents.
+                // area.model.contentChanged.connect(this._changedEventCallback, this); ?
+                // Hide the cell toolbar if it overlaps with cell contents
+                // this._updateCellForToolbarOverlap(area); // remove?
+            })
+                .catch(e => {
+                console.error('Error rendering buttons of the cell toolbar: ', e);
+            });
+        }
+    }
+    _setHiddenToolbars(hidden) {
+        var _a;
+        const notebookpanel = this._notebookpanel;
+        if (notebookpanel && !notebookpanel.isDisposed) {
+            const applets = (_a = notebookpanel.appletViewWidget) === null || _a === void 0 ? void 0 : _a.applets;
+            for (const applet of applets) {
+                for (const part of applet.parts) {
+                    const toolbarWidget = this._toolbars.get(part);
+                    if (!toolbarWidget) {
+                        continue;
+                    }
+                    toolbarWidget.setHidden(hidden);
+                }
+            }
+        }
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,6 @@
+import { JupyterFrontEndPlugin } from '@jupyterlab/application';
+/**
+ * Initialization data for the @fails-components/jupyter-applet-view extension.
+ */
+declare const plugins: JupyterFrontEndPlugin<any>[];
+export default plugins;

package/lib/index.js

@@ -0,0 +1,35 @@
+import { ILayoutRestorer } from '@jupyterlab/application';
+import { IDocumentManager } from '@jupyterlab/docmanager';
+import { ITranslator } from '@jupyterlab/translation';
+import { INotebookTracker } from '@jupyterlab/notebook';
+import { AppletViewToolbarExtension } from './avtoolbarextension';
+import { activateAppletView } from './appletview';
+import { IFailsInterceptor } from '@fails-components/jupyter-interceptor';
+import { IFailsLauncherInfo } from '@fails-components/jupyter-launcher';
+const appletView = {
+    id: '@fails-components/jupyter-applet-view:plugin',
+    description: "An extension, that let's you select cell and switch to an applet mode, where only the selected cells are visible. This is used for fails-components to have jupyter applets in interactive teaching. ",
+    requires: [IDocumentManager, INotebookTracker, ITranslator],
+    optional: [ILayoutRestorer, IFailsLauncherInfo, IFailsInterceptor],
+    autoStart: true,
+    activate: activateAppletView
+};
+const appletViewToolbar = {
+    id: '@fails-components/jupyter-applet-view:toolbar',
+    description: 'Add the applet view toolbar during editing.',
+    autoStart: true,
+    activate: async (app, launcherInfo) => {
+        const toolbarItems = undefined;
+        app.docRegistry.addWidgetExtension('Notebook', new AppletViewToolbarExtension(app.commands, launcherInfo, toolbarItems));
+    },
+    optional: [IFailsLauncherInfo]
+};
+/**
+ * Initialization data for the @fails-components/jupyter-applet-view extension.
+ */
+const plugins = [
+    // all JupyterFrontEndPlugins
+    appletView,
+    appletViewToolbar
+];
+export default plugins;

package/lib/splitviewnotebookpanel.d.ts

@@ -0,0 +1,31 @@
+import { DocumentRegistry, DocumentWidget } from '@jupyterlab/docregistry';
+import { NotebookPanel, Notebook, INotebookModel, NotebookWidgetFactory } from '@jupyterlab/notebook';
+import { AppletViewOutputArea } from './avoutputarea';
+import { IFailsLauncherInfo, IAppletScreenshottaker, IScreenShotOpts } from '@fails-components/jupyter-launcher';
+import { IFailsInterceptor } from '@fails-components/jupyter-interceptor';
+interface IAppletResizeEvent {
+    appid: string;
+    width: number;
+    height: number;
+}
+export declare class SplitViewNotebookPanel extends NotebookPanel implements IAppletScreenshottaker {
+    constructor(options: DocumentWidget.IOptions<Notebook, INotebookModel>, failsLauncherInfo: IFailsLauncherInfo | undefined, failsInterceptor: IFailsInterceptor | undefined);
+    appletResizeinfo({ appid, width, height }: IAppletResizeEvent): void;
+    get appletViewWidget(): AppletViewOutputArea;
+    takeAppScreenshot(opts: IScreenShotOpts): Promise<Blob | undefined>;
+    private _appletviewWidget;
+    private _failsLauncherInfo;
+}
+declare namespace SplitViewNotebookWidgetFactory {
+    interface IOptions extends NotebookWidgetFactory.IOptions<NotebookPanel> {
+        failsLauncherInfo?: IFailsLauncherInfo;
+        failsInterceptor?: IFailsInterceptor;
+    }
+}
+export declare class SplitViewNotebookWidgetFactory extends NotebookWidgetFactory {
+    constructor(options: SplitViewNotebookWidgetFactory.IOptions);
+    protected createNewWidget(context: DocumentRegistry.IContext<INotebookModel>, source?: NotebookPanel): SplitViewNotebookPanel;
+    private _failsLauncherInfo;
+    private _failsInterceptor;
+}
+export {};

package/lib/splitviewnotebookpanel.js

@@ -0,0 +1,127 @@
+import { NotebookPanel, NotebookHistory, NotebookWidgetFactory } from '@jupyterlab/notebook';
+import { BoxLayout, SplitPanel } from '@lumino/widgets';
+import { AppletViewOutputArea } from './avoutputarea';
+export class SplitViewNotebookPanel extends NotebookPanel {
+    constructor(options, failsLauncherInfo, failsInterceptor) {
+        super(options);
+        this._failsLauncherInfo = failsLauncherInfo;
+        // now we have to do the following
+        // 1. remove this._content from the layout
+        const content = this['_content'];
+        const layout = this.layout;
+        layout.removeWidget(content);
+        // 2. add a BoxLayout instead
+        const splitPanel = new SplitPanel({
+            spacing: 1,
+            orientation: 'horizontal'
+        });
+        BoxLayout.setStretch(splitPanel, 1);
+        // 3. add content to the BoxLayout, as well as a applet view area
+        splitPanel.addWidget(content);
+        const widget = (this._appletviewWidget = new AppletViewOutputArea({
+            notebook: this,
+            applets: undefined,
+            translator: options.translator,
+            interceptor: failsInterceptor
+        }));
+        splitPanel.addWidget(widget);
+        layout.addWidget(splitPanel);
+        // move to separate handler
+        if (failsLauncherInfo === null || failsLauncherInfo === void 0 ? void 0 : failsLauncherInfo.inLecture) {
+            this.toolbar.hide();
+            this.addClass('fl-jl-notebook-inlecture');
+            this._appletviewWidget.inLecture = true;
+            content.hide();
+            splitPanel.setRelativeSizes([0, 1]); // change sizes
+        }
+        if (failsLauncherInfo) {
+            failsLauncherInfo.inLectureChanged.connect((sender, newInLecture) => {
+                if (newInLecture) {
+                    this.toolbar.hide();
+                    this.addClass('fl-jl-notebook-inlecture');
+                    this._appletviewWidget.inLecture = true;
+                    content.hide();
+                    splitPanel.setRelativeSizes([0, 1]); // change sizes
+                }
+                else {
+                    this.toolbar.show();
+                    this.removeClass('fl-jl-notebook-inlecture');
+                    this._appletviewWidget.inLecture = false;
+                    content.show();
+                    splitPanel.setRelativeSizes([1, 1]); // change sizes
+                    widget.unselectApplet();
+                }
+            });
+            if (failsLauncherInfo.inLecture &&
+                typeof failsLauncherInfo.selectedAppid !== 'undefined') {
+                widget.selectApplet(failsLauncherInfo.selectedAppid);
+            }
+            failsLauncherInfo.selectedAppidChanged.connect((sender, appid) => {
+                if (typeof appid !== 'undefined') {
+                    widget.selectApplet(appid);
+                }
+            });
+        }
+        widget.viewChanged.connect((sender) => {
+            const failsData = sender.saveData();
+            if (failsData) {
+                const model = this.context.model;
+                model.setMetadata('failsApp', failsData);
+            }
+        });
+        const metadataUpdater = () => {
+            const { failsApp, kernelspec } = this.context.model.metadata;
+            if (failsLauncherInfo === null || failsLauncherInfo === void 0 ? void 0 : failsLauncherInfo.reportMetadata) {
+                failsLauncherInfo.reportMetadata({ failsApp, kernelspec });
+            }
+        };
+        this.context.model.metadataChanged.connect(metadataUpdater);
+        metadataUpdater();
+    }
+    appletResizeinfo({ appid, width, height }) {
+        if (this._failsLauncherInfo) {
+            this._failsLauncherInfo.appletSizes[appid] = { appid, width, height };
+        }
+    }
+    get appletViewWidget() {
+        return this._appletviewWidget;
+    }
+    async takeAppScreenshot(opts) {
+        return await this._appletviewWidget.takeAppScreenshot(opts);
+    }
+}
+export class SplitViewNotebookWidgetFactory extends NotebookWidgetFactory {
+    constructor(options) {
+        super(options);
+        this._failsLauncherInfo = options.failsLauncherInfo;
+        this._failsInterceptor = options.failsInterceptor;
+    }
+    createNewWidget(context, source) {
+        // copied from basis object
+        const translator = context.translator;
+        const kernelHistory = new NotebookHistory({
+            sessionContext: context.sessionContext,
+            translator: translator
+        });
+        const nbOptions = {
+            rendermime: source
+                ? source.content.rendermime
+                : this.rendermime.clone({ resolver: context.urlResolver }),
+            contentFactory: this.contentFactory,
+            mimeTypeService: this.mimeTypeService,
+            editorConfig: source
+                ? source.content.editorConfig
+                : this['_editorConfig'],
+            notebookConfig: source
+                ? source.content.notebookConfig
+                : this['_notebookConfig'],
+            translator,
+            kernelHistory
+        };
+        const content = this.contentFactory.createNotebook(nbOptions);
+        return new SplitViewNotebookPanel({
+            context,
+            content
+        }, this._failsLauncherInfo, this._failsInterceptor);
+    }
+}

package/package.json

@@ -0,0 +1,226 @@
+{
+    "name": "@fails-components/jupyter-applet-view",
+    "version": "0.0.1-alpha.10",
+    "description": "A collection of extensions, that let's you select cell and switch to an applet mode, where only the selected cells are visible. This is used for fails-components to have jupyter applets in interactive teaching. ",
+    "keywords": [
+        "jupyter",
+        "jupyterlab",
+        "jupyterlab-extension"
+    ],
+    "homepage": "https://github.com/fails-components/jupyterfails",
+    "bugs": {
+        "url": "https://github.com/fails-components/jupyterfails/issues"
+    },
+    "license": "BSD-3-Clause",
+    "author": {
+        "name": "Marten Richter",
+        "email": "marten.richter@freenet.de"
+    },
+    "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}",
+        "schema/*.json",
+        "src/**/*.{ts,tsx}"
+    ],
+    "main": "lib/index.js",
+    "types": "lib/index.d.ts",
+    "style": "style/index.css",
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/fails-components/jupyterfails.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 fails_components_jupyter_applet_view/labextension fails_components_jupyter_applet_view/_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",
+        "prepublishOnly": "npm run build",
+        "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 --passWithNoTests",
+        "watch": "run-p watch:src watch:labextension",
+        "watch:src": "tsc -w --sourceMap",
+        "watch:labextension": "jupyter labextension watch ."
+    },
+    "dependencies": {
+        "@fails-components/jupyter-interceptor": "^0.0.1-alpha.10",
+        "@fails-components/jupyter-launcher": "^0.0.1-alpha.10",
+        "@jupyter-notebook/application": "^7.2.0",
+        "@jupyter-widgets/jupyterlab-manager": "^5.0.13",
+        "@jupyterlab/application": "^4.3.4",
+        "@jupyterlab/apputils": "^4.3.4",
+        "@jupyterlab/cells": "^4.3.4",
+        "@jupyterlab/docmanager": "^4.3.4",
+        "@jupyterlab/docregistry": "^4.3.4",
+        "@jupyterlab/notebook": "^4.3.4",
+        "@jupyterlab/observables": "^5.3.4",
+        "@jupyterlab/outputarea": "^4.3.4",
+        "@jupyterlab/statedb": "^4.3.4",
+        "@jupyterlab/translation": "^4.3.4",
+        "@jupyterlab/ui-components": "^4.3.4",
+        "@jupyterlite/application-extension": "^0.5.0",
+        "@jupyterlite/contents": "^0.5.0",
+        "@jupyterlite/server": "^0.5.0",
+        "@jupyterlite/settings": "^0.5.0",
+        "@lumino/algorithm": "^2.0.1",
+        "@lumino/commands": "^2.1.2",
+        "@lumino/coreutils": "^2.2.0",
+        "@lumino/disposable": "^2.1.3",
+        "@lumino/signaling": "^2.1.3",
+        "@lumino/widgets": "^2.5.0",
+        "json5": "^2.2.3",
+        "modern-screenshot": "^4.5.5"
+    },
+    "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",
+        "npm-run-all": "^4.1.5",
+        "prettier": "^3.0.0",
+        "rimraf": "^5.0.1",
+        "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.0.2",
+        "yjs": "^13.5.0"
+    },
+    "sideEffects": [
+        "style/*.css",
+        "style/index.js"
+    ],
+    "styleModule": "style/index.js",
+    "publishConfig": {
+        "access": "public"
+    },
+    "jupyterlab": {
+        "extension": true,
+        "outputDir": "fails_components_jupyter_applet_view/labextension",
+        "schemaDir": "schema"
+    },
+    "jupyterlite": {
+        "liteExtension": false
+    },
+    "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
+        }
+    }
+}