diff --git a/.bumpversion.cfg b/.bumpversion.cfg index fdd23739..8cd93b48 100644 --- a/.bumpversion.cfg +++ b/.bumpversion.cfg @@ -3,12 +3,12 @@ current_version = 0, 1, 10, 'final', 0 commit = False tag = False parse = (?P\d+)\,\ (?P\d+)\,\ (?P\d+)\,\ \'(?P\S+)\'\,\ (?P\d+) -serialize = +serialize = {major}, {minor}, {patch}, '{release}', {build} [bumpversion:part:release] optional_value = final -values = +values = alpha beta candidate @@ -16,4 +16,4 @@ values = [bumpversion:part:build] -[bumpversion:file:jupyterlab_classic/_version.py] +[bumpversion:file:retrolab/_version.py] diff --git a/.github/workflows/binder.yml b/.github/workflows/binder.yml index b6394534..de178421 100644 --- a/.github/workflows/binder.yml +++ b/.github/workflows/binder.yml @@ -19,7 +19,7 @@ jobs: issue_number: context.issue.number, owner: context.repo.owner, repo: context.repo.repo, - body: `[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/${PR_HEAD_USERREPO}/${PR_HEAD_REF}?urlpath=classic/tree) :point_left: Launch JupyterLab Classic on Binder` + body: `[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gh/${PR_HEAD_USERREPO}/${PR_HEAD_REF}?urlpath=retro/tree) :point_left: Launch RetroLab on Binder` }) env: PR_HEAD_REF: ${{ github.event.pull_request.head.ref }} diff --git a/.github/workflows/build.yml b/.github/workflows/build.yml index 4efd5c32..5b2bd0a7 100644 --- a/.github/workflows/build.yml +++ b/.github/workflows/build.yml @@ -47,8 +47,8 @@ jobs: - name: Install the package run: | python -m pip install . - jupyter labextension list 2>&1 | grep -ie "@jupyterlab-classic/lab-extension.*enabled.*ok" - - jupyter server extension list 2>&1 | grep -ie "jupyterlab_classic.*enabled" - + jupyter labextension list 2>&1 | grep -ie "@retrolab/lab-extension.*enabled.*ok" - + jupyter server extension list 2>&1 | grep -ie "retrolab.*enabled" - python -m jupyterlab.browser_check - name: Lint run: | @@ -114,9 +114,9 @@ jobs: python: ['3.6', '3.9'] include: - python: '3.6' - dist: 'jupyterlab-classic*.tar.gz' + dist: 'retrolab*.tar.gz' - python: '3.9' - dist: 'jupyterlab_classic*.whl' + dist: 'retrolab*.whl' - os: windows py_cmd: python - os: macos @@ -147,11 +147,11 @@ jobs: - name: Validate the install run: | jupyter labextension list - jupyter labextension list 2>&1 | grep -ie "@jupyterlab-classic/lab-extension.*enabled.*ok" - + jupyter labextension list 2>&1 | grep -ie "@retrolab/lab-extension.*enabled.*ok" - jupyter server extension list - jupyter server extension list 2>&1 | grep -ie "jupyterlab_classic.*enabled" - - jupyter classic --version - jupyter classic --help + jupyter server extension list 2>&1 | grep -ie "retrolab.*enabled" - + jupyter retro --version + jupyter retro --help end2end: needs: [build] @@ -178,7 +178,7 @@ jobs: - name: Install the package run: | cd dist - python -m pip install -vv jupyterlab_classic*.whl + python -m pip install -vv retrolab*.whl - uses: microsoft/playwright-github-action@v1 - name: Test run: | diff --git a/.github/workflows/buildutils.yml b/.github/workflows/buildutils.yml index 073ea60b..4b1afed2 100644 --- a/.github/workflows/buildutils.yml +++ b/.github/workflows/buildutils.yml @@ -38,7 +38,7 @@ jobs: run: | # TODO: improve this with a mock package? # This step is to ensure the workflow always starts with a final version - sed -i -E "s/VersionInfo\(.*\)/VersionInfo\(9, 8, 7, 'final', 0\)/" jupyterlab_classic/_version.py + sed -i -E "s/VersionInfo\(.*\)/VersionInfo\(9, 8, 7, 'final', 0\)/" retrolab/_version.py sed -i -E "s/current_version = .*/current_version = 9, 8, 7, 'final', 0/" .bumpversion.cfg jlpm run lerna version 9.8.7 --no-push --force-publish --no-git-tag-version --yes git commit -am "Release 9.8.7" diff --git a/.github/workflows/release.yml b/.github/workflows/release.yml index 38e8af42..eb4226fb 100644 --- a/.github/workflows/release.yml +++ b/.github/workflows/release.yml @@ -47,8 +47,8 @@ jobs: - name: Install the package run: | python -m pip install . - jupyter labextension list 2>&1 | grep -ie "@jupyterlab-classic/lab-extension.*enabled.*ok" - - jupyter server extension list 2>&1 | grep -ie "jupyterlab_classic.*enabled" - + jupyter labextension list 2>&1 | grep -ie "@retrolab/lab-extension.*enabled.*ok" - + jupyter server extension list 2>&1 | grep -ie "retrolab.*enabled" - python -m jupyterlab.browser_check - name: Lint run: | @@ -114,9 +114,9 @@ jobs: python: ['3.6', '3.9'] include: - python: '3.6' - dist: 'jupyterlab-classic*.tar.gz' + dist: 'retrolab*.tar.gz' - python: '3.9' - dist: 'jupyterlab_classic*.whl' + dist: 'retrolab*.whl' - os: windows py_cmd: python - os: macos @@ -147,11 +147,11 @@ jobs: - name: Validate the install run: | jupyter labextension list - jupyter labextension list 2>&1 | grep -ie "@jupyterlab-classic/lab-extension.*enabled.*ok" - + jupyter labextension list 2>&1 | grep -ie "@retrolab/lab-extension.*enabled.*ok" - jupyter server extension list - jupyter server extension list 2>&1 | grep -ie "jupyterlab_classic.*enabled" - - jupyter classic --version - jupyter classic --help + jupyter server extension list 2>&1 | grep -ie "retrolab.*enabled" - + jupyter retro --version + jupyter retro --help release: if: startsWith(github.ref, 'refs/tags/') @@ -217,7 +217,7 @@ jobs: docker run --rm -v "$(pwd)":/usr/local/src/your-app \ -e CHANGELOG_GITHUB_TOKEN=${CHANGELOG_GITHUB_TOKEN} \ ferrarimarco/github-changelog-generator \ - github_changelog_generator -u jtpio -p jupyterlab-classic --usernames-as-github-logins --no-issues --no-unreleased \ + github_changelog_generator -u jtpio -p retrolab --usernames-as-github-logins --no-issues --no-unreleased \ --since-tag ${{ steps.previous_tag.outputs.tag }} --header "" --pr-label "## Changes" head -n -1 CHANGELOG.md > CHANGELOG - name: Create Release diff --git a/.gitignore b/.gitignore index 16dd79b4..ab35bd76 100644 --- a/.gitignore +++ b/.gitignore @@ -113,8 +113,8 @@ dmypy.json _temp_extension junit.xml [uU]ntitled* -jupyterlab_classic/static -jupyterlab_classic/labextension +retrolab/static +retrolab/labextension # playwright app/artifacts/videos diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 7014ea3c..b7a35225 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -1,6 +1,6 @@ -# Contributing to JupyterLab Classic +# Contributing to RetroLab -Thanks for contributing to JupyterLab Classic! +Thanks for contributing to RetroLab! Make sure to follow [Project Jupyter's Code of Conduct](https://github.com/jupyter/governance/blob/master/conduct/code_of_conduct.md) for a friendly and welcoming collaborative environment. @@ -16,16 +16,16 @@ The `jlpm` command is JupyterLab's pinned version of [yarn](https://yarnpkg.com/ ```bash # create a new environment -mamba create -n jupyterlab-classic -c conda-forge python nodejs -y +mamba create -n retrolab -c conda-forge python nodejs -y # activate the environment -conda activate jupyterlab-classic +conda activate retrolab # Install package in development mode pip install -e . ``` -`jupyterlab-classic` follows a monorepo structure. To build all the packages at once: +`retrolab` follows a monorepo structure. To build all the packages at once: ```bash jlpm build @@ -37,19 +37,19 @@ There is also a `watch` script to watch for changes and rebuild the app automati jlpm watch ``` -To make sure the `jupyterlab_classic` server extension is installed: +To make sure the `retrolab` server extension is installed: ```bash $ jupyter server extension list Config dir: /home/username/.jupyter -Config dir: /home/username/miniforge3/envs/jupyterlab-classic/etc/jupyter +Config dir: /home/username/miniforge3/envs/retrolab/etc/jupyter jupyterlab enabled - Validating jupyterlab... jupyterlab 3.0.0 OK - jupyterlab_classic enabled - - Validating jupyterlab_classic... - jupyterlab_classic 0.1.0rc2 OK + retrolab enabled + - Validating retrolab... + retrolab 0.1.0rc2 OK nbclassic enabled - Validating nbclassic... nbclassic OK @@ -57,10 +57,10 @@ Config dir: /home/username/miniforge3/envs/jupyterlab-classic/etc/jupyter Config dir: /usr/local/etc/jupyter ``` -Then start JupyterLab Classic with: +Then start RetroLab with: ```bash -jupyter classic +jupyter retro ``` ## Running Tests diff --git a/LICENSE b/LICENSE index d7662c62..c7ff1013 100644 --- a/LICENSE +++ b/LICENSE @@ -1,6 +1,6 @@ BSD 3-Clause License -Copyright (c) 2020, JupyterLab Classic Contributors +Copyright (c) 2020, RetroLab Contributors All rights reserved. Redistribution and use in source and binary forms, with or without diff --git a/MANIFEST.in b/MANIFEST.in index 3f216b26..b8c01730 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -1,15 +1,15 @@ include LICENSE include README.md include pyproject.toml -include jupyter-config/jupyterlab-classic.json +include jupyter-config/retrolab.json include package.json include install.json include ts*.json -graft jupyterlab_classic/labextension -graft jupyterlab_classic/static -graft jupyterlab_classic/templates +graft retrolab/labextension +graft retrolab/static +graft retrolab/templates # Javascript files graft src diff --git a/README.md b/README.md index 8915533f..75799502 100644 --- a/README.md +++ b/README.md @@ -1,41 +1,41 @@ -![jupyterlab-classic-logo](./jupyterlab-classic.png) +![retrolab-logo](./retrolab.png) -![Github Actions Status](https://github.com/jtpio/jupyterlab-classic/workflows/Build/badge.svg) -[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gist/jtpio/795608163800b4a7d34d60a015c3d27c/master?urlpath=/classic/notebooks/tour.ipynb) -[![Binder main](https://img.shields.io/badge/launch-main-E66581.svg?logo=data:image/png;base64,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)](https://mybinder.org/v2/gh/jtpio/jupyterlab-classic/main?urlpath=classic/tree) -[![PyPI](https://img.shields.io/pypi/v/jupyterlab-classic.svg)](https://pypi.org/project/jupyterlab-classic) -[![conda-forge](https://img.shields.io/conda/vn/conda-forge/jupyterlab-classic.svg)](https://anaconda.org/conda-forge/jupyterlab-classic) +![Github Actions Status](https://github.com/jtpio/retrolab/workflows/Build/badge.svg) +[![Binder](https://mybinder.org/badge_logo.svg)](https://mybinder.org/v2/gist/jtpio/795608163800b4a7d34d60a015c3d27c/master?urlpath=/retro/notebooks/tour.ipynb) +[![Binder main](https://img.shields.io/badge/launch-main-E66581.svg?logo=data:image/png;base64,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)](https://mybinder.org/v2/gh/jtpio/retrolab/main?urlpath=retro/tree) +[![PyPI](https://img.shields.io/pypi/v/retrolab.svg)](https://pypi.org/project/retrolab) +[![conda-forge](https://img.shields.io/conda/vn/conda-forge/retrolab.svg)](https://anaconda.org/conda-forge/retrolab) -The next gen old-school Notebook UI. +`RetroLab` (also known as _JupyterLab Retro_, previously called _JupyterLab Classic_) is an _unofficial_ [JupyterLab](https://github.com/jupyterlab/jupyterlab) distribution with a retro look and feel. -![image](https://user-images.githubusercontent.com/591645/101378325-400fa280-38b3-11eb-81a5-4c7a1aca780e.png) +![image](https://user-images.githubusercontent.com/591645/118792690-2f1e8080-b898-11eb-98fb-1b8a22b8a07d.png) ## Install -`jupyterlab-classic` can be installed with `pip`: +`retrolab` can be installed with `pip`: ```bash -pip install jupyterlab-classic +pip install retrolab ``` With `mamba`: ```bash -mamba install -c conda-forge jupyterlab-classic +mamba install -c conda-forge retrolab ``` With `conda`: ```bash -conda install -c conda-forge jupyterlab-classic +conda install -c conda-forge retrolab ``` ## Usage -`jupyterlab-classic` can be started as a standalone app with: +`retrolab` can be started as a standalone app with: ```bash -jupyter classic +jupyter retro ``` Existing federated JupyterLab extensions listed via: @@ -44,7 +44,7 @@ Existing federated JupyterLab extensions listed via: jupyter labextension list ``` -Should also be available when starting `jupyterlab-classic`. +Should also be available when starting `retrolab`. ### Files 📂 and Running Sessions 🏃‍♀️ @@ -56,7 +56,7 @@ Should also be available when starting `jupyterlab-classic`. ### Open in a new Browser Tab by default -![new-browser-tab](https://user-images.githubusercontent.com/591645/101954309-21374600-3bfc-11eb-80fc-447dce4e6ac6.gif) +![new-browser-tab](https://user-images.githubusercontent.com/591645/118811914-d9ed6980-b8ad-11eb-8362-f38627199f71.gif) ### Command Palette 🎨 @@ -74,7 +74,7 @@ Support for existing JupyterLab themes! ### Terminals 🖥️ -![terminals](https://user-images.githubusercontent.com/591645/101954217-fc42d300-3bfb-11eb-84c3-fbf84896b829.gif) +![terminals](https://user-images.githubusercontent.com/591645/118793525-fc28bc80-b898-11eb-9e02-d5a80ad8ddb8.gif) ### File Editor 🖊️ @@ -88,11 +88,11 @@ Support for existing JupyterLab themes! Install new extensions easily! -![federated-extensions](https://user-images.githubusercontent.com/591645/101954127-dd444100-3bfb-11eb-96be-fee87db5171d.gif) +![federated-extensions](https://user-images.githubusercontent.com/591645/118813222-38671780-b8af-11eb-835b-f2865bab5c62.gif) -### Switch between JupyterLab and JupyterLab Classic easily ↔️ +### Switch between JupyterLab and RetroLab easily ↔️ -![jupyterlab-switch](https://user-images.githubusercontent.com/591645/101954746-ec77be80-3bfc-11eb-85ed-7ac0922e365c.gif) +![jupyterlab-switch](https://user-images.githubusercontent.com/591645/118816963-05bf1e00-b8b3-11eb-92a2-899288471011.gif) ## Contributing @@ -106,18 +106,18 @@ However in some cases, having a leaner, simpler, and more focused interface to w The single document mode as currently implemented in JupyterLab helps address this issue, but still displays a couple of visual cues that can be distracting to some users. -The goal of the `jupyterlab-classic` project is to provide an alternative JupyterLab distribution with the look and feed of the classic notebook UI, while leveraging the efforts put in the development of JupyterLab itself and its extension system. +The goal of the `retrolab` project is to provide an alternative JupyterLab distribution with the look and feed of the classic notebook UI, while leveraging the efforts put in the development of JupyterLab itself and its extension system. -Technically speaking, `jupyterlab-classic` reuses **many** of the existing plugins for JupyterLab (notebook, toolbar), and also supports prebuilt (federated) third-party extensions using the new distribution system added in 3.0. That way, extensions built for JupyterLab should also be compatible with `jupyterlab-classic`, as long as they can be added to the application shell provided by JupyterLab Classic. +Technically speaking, `retrolab` reuses **many** of the existing plugins for JupyterLab (notebook, toolbar), and also supports prebuilt (federated) third-party extensions using the new distribution system added in 3.0. That way, extensions built for JupyterLab should also be compatible with `retrolab`, as long as they can be added to the application shell provided by RetroLab. ## Relation to other Jupyter frontends -Jupyterlab Classic is an alternative frontend built using the latest JupyterLab components, with the look and feel of the Classic Jupyter Notebook UI. Below is a short comparison to know where it stands when compared to other Jupyter UI projects: +RetroLab is an alternative frontend built using the latest JupyterLab components, with the look and feel of the Classic Jupyter Notebook UI. Below is a short comparison to know where it stands when compared to other Jupyter UI projects: - Classic Jupyter Notebook - Classic frontend, classic notebook server. - NBClassic - Classic frontend, new Jupyter Server. - JupyterLab - Jupyterlab frontend, new Jupyter Server (or Classic Notebook Server). Extensions are not compatible with the Classic Jupyter Notebook since it is built with different components. With version 3.0 onwards, it uses the new Jupyter Server and supports federated extensions that don't need to be rebuilt on the end-user machine. -- Jupyterlab Classic - JupyterLab frontend built with JupyterLab components, with the look and feel of the Classic Notebook. Consistent with the latest version of Jupyterlab. Extensions built for Jupyterlab should work as long as the components they depend on are part of this classic interface (for install JupyterLab Classic doesn't have the `left`, `right` and `bottom` areas). +- RetroLab - JupyterLab frontend built with JupyterLab components, with the look and feel of the Classic Notebook. Consistent with the latest version of Jupyterlab. Extensions built for Jupyterlab should work as long as the components they depend on are part of this classic interface (for install RetroLab doesn't have the `left`, `right` and `bottom` areas). ## Prior art @@ -128,9 +128,10 @@ This project is mostly a reboot of the two previous attempts at making something These projects really expressed the need for a stripped down, minimal version of the Jupyter Notebook UI. -`jupyterlab-classic` contributes to that space with the added features: +`retrolab` contributes to that space with the added features: - Support for existing federated (prebuilt) JupyterLab extensions - Zen Mode - Repo structure, similar to JupyterLab - Reusing as much as possible from upstream JupyterLab +- Serve as a template and reference implementation for other alternative JupyterLab distributions diff --git a/RELEASE.md b/RELEASE.md index 1a3cd4c6..cfc3d2d2 100644 --- a/RELEASE.md +++ b/RELEASE.md @@ -1,4 +1,4 @@ -# Releasing JupyterLab Classic +# Releasing RetroLab ## Automated releases @@ -29,7 +29,7 @@ The release workflow also creates a GitHub release with the new changes generate If you would still like to do the release manually instead, read below. -## Making a nanual new release of JupyterLab Classic +## Making a nanual new release of RetroLab This process is still a bit manual and consists in running a couple of commands. @@ -38,8 +38,8 @@ This process is still a bit manual and consists in running a couple of commands. Creating a new environment can help avoid pushing local changes and any extra tag. ```bash -mamba create -q -y -n jupyterlab-classic-release -c conda-forge twine nodejs jupyter-packaging jupyterlab -y -conda activate jupyterlab-classic-release +mamba create -q -y -n retrolab-release -c conda-forge twine nodejs jupyter-packaging jupyterlab -y +conda activate retrolab-release ``` Alternatively, the local repository can be cleaned with: @@ -52,10 +52,10 @@ git clean -fdx Make sure the `dist/` folder is empty. -1. Update [jupyterlab_classic/\_version.py](./jupyterlab_classic/_version.py) with the new version number +1. Update [retrolab/\_version.py](./retrolab/_version.py) with the new version number 2. Commit the changes -- `git add jupyterlab_classic/_version.py` +- `git add retrolab/_version.py` - `git commit -m "Release x.y.z"` 3. Bump the frontend packages: @@ -65,7 +65,7 @@ Make sure the `dist/` folder is empty. 4. Run: `python setup.py sdist bdist_wheel` 5. Double check the size of the bundles in the `dist/` folder -6. Test the release by installing the wheel or sdist: `python -m pip install ./dist/jupyterlab_classic-x.y.z-py3-none-any.whl +6. Test the release by installing the wheel or sdist: `python -m pip install ./dist/retrolab-x.y.z-py3-none-any.whl 7. `export TWINE_USERNAME=mypypi_username` 8. `twine upload dist/*` @@ -75,7 +75,7 @@ The simplest is to wait for the bot to automatically open the PR. Alternatively, to do the update manually: -1. Open a new PR on https://github.com/conda-forge/jupyterlab-classic-feedstock to update the `version` and the `sha256` hash +1. Open a new PR on https://github.com/conda-forge/retrolab-feedstock to update the `version` and the `sha256` hash 2. Wait for the tests 3. Merge the PR diff --git a/app/index.js b/app/index.js index 80d20cec..cb54dae7 100644 --- a/app/index.js +++ b/app/index.js @@ -76,19 +76,19 @@ async function main() { require('@jupyterlab/vega5-extension') ]; - const App = require('@jupyterlab-classic/application').App; + const App = require('@retrolab/application').App; const app = new App({ mimeExtensions }); const disabled = []; // TODO: formalize the way the set of initial extensions and plugins are specified let mods = [ - // @jupyterlab-classic plugins - require('@jupyterlab-classic/application-extension'), - require('@jupyterlab-classic/docmanager-extension'), - require('@jupyterlab-classic/help-extension'), - require('@jupyterlab-classic/notebook-extension'), + // @retrolab plugins + require('@retrolab/application-extension'), + require('@retrolab/docmanager-extension'), + require('@retrolab/help-extension'), + require('@retrolab/notebook-extension'), // to handle opening new tabs after creating a new terminal - require('@jupyterlab-classic/terminal-extension'), + require('@retrolab/terminal-extension'), // @jupyterlab plugins require('@jupyterlab/apputils-extension').default.filter(({ id }) => @@ -130,11 +130,11 @@ async function main() { // The motivation here is to only load a specific set of plugins dependending on // the current page - const page = PageConfig.getOption('classicPage'); + const page = PageConfig.getOption('retroPage'); switch (page) { case 'tree': { mods = mods.concat([ - require('@jupyterlab-classic/tree-extension'), + require('@retrolab/tree-extension'), require('@jupyterlab/running-extension') ]); break; @@ -161,8 +161,8 @@ async function main() { require('@jupyterlab/fileeditor-extension').default.filter(({ id }) => ['@jupyterlab/fileeditor-extension:plugin'].includes(id) ), - require('@jupyterlab-classic/tree-extension').default.filter(({ id }) => - ['@jupyterlab-classic/tree-extension:factory'].includes(id) + require('@retrolab/tree-extension').default.filter(({ id }) => + ['@retrolab/tree-extension:factory'].includes(id) ) ]); break; diff --git a/app/package.json b/app/package.json index bc91de84..c7d931d0 100644 --- a/app/package.json +++ b/app/package.json @@ -1,5 +1,5 @@ { - "name": "@jupyterlab-classic/app", + "name": "@retrolab/app", "version": "0.1.10", "private": true, "scripts": { @@ -8,7 +8,7 @@ "build:test": "tsc --build tsconfig.test.json", "clean": "rimraf build && jlpm run clean:static", "clean:artifacts": "rimraf artifacts", - "clean:static": "rimraf ../jupyterlab_classic/static", + "clean:static": "rimraf ../retrolab/static", "prepublishOnly": "yarn run build", "test:cov": "jest --collect-coverage", "test:debug": "node --inspect-brk node_modules/.bin/jest --runInBand", @@ -18,14 +18,14 @@ "watch": "webpack --config ./webpack.config.watch.js" }, "resolutions": { - "@jupyterlab-classic/application": "~0.1.10", - "@jupyterlab-classic/application-extension": "~0.1.10", - "@jupyterlab-classic/docmanager-extension": "~0.1.10", - "@jupyterlab-classic/help-extension": "~0.1.10", - "@jupyterlab-classic/notebook-extension": "~0.1.10", - "@jupyterlab-classic/terminal-extension": "~0.1.10", - "@jupyterlab-classic/tree-extension": "~0.1.10", - "@jupyterlab-classic/ui-components": "~0.1.10", + "@retrolab/application": "~0.1.10", + "@retrolab/application-extension": "~0.1.10", + "@retrolab/docmanager-extension": "~0.1.10", + "@retrolab/help-extension": "~0.1.10", + "@retrolab/notebook-extension": "~0.1.10", + "@retrolab/terminal-extension": "~0.1.10", + "@retrolab/tree-extension": "~0.1.10", + "@retrolab/ui-components": "~0.1.10", "@jupyterlab/application": "~3.0.7", "@jupyterlab/apputils": "~3.0.5", "@jupyterlab/apputils-extension": "~3.0.7", @@ -84,14 +84,14 @@ "react-dom": "~17.0.2" }, "dependencies": { - "@jupyterlab-classic/application": "^0.1.10", - "@jupyterlab-classic/application-extension": "^0.1.10", - "@jupyterlab-classic/docmanager-extension": "^0.1.10", - "@jupyterlab-classic/help-extension": "^0.1.10", - "@jupyterlab-classic/notebook-extension": "^0.1.10", - "@jupyterlab-classic/terminal-extension": "^0.1.10", - "@jupyterlab-classic/tree-extension": "^0.1.10", - "@jupyterlab-classic/ui-components": "^0.1.10", + "@retrolab/application": "^0.1.10", + "@retrolab/application-extension": "^0.1.10", + "@retrolab/docmanager-extension": "^0.1.10", + "@retrolab/help-extension": "^0.1.10", + "@retrolab/notebook-extension": "^0.1.10", + "@retrolab/terminal-extension": "^0.1.10", + "@retrolab/tree-extension": "^0.1.10", + "@retrolab/ui-components": "^0.1.10", "@jupyterlab/apputils-extension": "^3.0.0", "@jupyterlab/celltags": "^3.0.0", "@jupyterlab/codemirror-extension": "^3.0.0", @@ -142,14 +142,14 @@ "whatwg-fetch": "^3.0.0" }, "jupyterlab": { - "name": "JupyterLab Classic", + "name": "RetroLab", "extensions": [ - "@jupyterlab-classic/application-extension", - "@jupyterlab-classic/docmanager-extension", - "@jupyterlab-classic/help-extension", - "@jupyterlab-classic/notebook-extension", - "@jupyterlab-classic/terminal-extension", - "@jupyterlab-classic/tree-extension", + "@retrolab/application-extension", + "@retrolab/docmanager-extension", + "@retrolab/help-extension", + "@retrolab/notebook-extension", + "@retrolab/terminal-extension", + "@retrolab/tree-extension", "@jupyterlab/apputils-extension", "@jupyterlab/codemirror-extension", "@jupyterlab/completer-extension", diff --git a/app/test/notebook.spec.ts b/app/test/notebook.spec.ts index 3d0b133a..42078a9f 100644 --- a/app/test/notebook.spec.ts +++ b/app/test/notebook.spec.ts @@ -6,7 +6,7 @@ import { chromium, firefox, Browser } from 'playwright'; import { BrowserName, BASE_URL } from './utils'; const NOTEBOOK_PATH = 'app/test/data/example.ipynb'; -const NOTEBOOK_URL = `${BASE_URL}classic/notebooks/${NOTEBOOK_PATH}`; +const NOTEBOOK_URL = `${BASE_URL}retro/notebooks/${NOTEBOOK_PATH}`; describe('Notebook', () => { let browser: Browser; @@ -26,9 +26,9 @@ describe('Notebook', () => { await page.goto(NOTEBOOK_URL); await page.waitForTimeout(2000); const href = await page.evaluate(() => { - return document.querySelector('#jp-ClassicLogo')?.getAttribute('href'); + return document.querySelector('#jp-RetroLogo')?.getAttribute('href'); }); - expect(href).toContain('/classic/tree'); + expect(href).toContain('/retro/tree'); }); }); diff --git a/app/test/smoke.spec.ts b/app/test/smoke.spec.ts index 8fe89dc9..449c6b37 100644 --- a/app/test/smoke.spec.ts +++ b/app/test/smoke.spec.ts @@ -25,7 +25,7 @@ describe('Smoke', () => { const tree = await context.newPage(); // Open the tree page - await tree.goto(`${BASE_URL}classic/tree`); + await tree.goto(`${BASE_URL}retro/tree`); await tree.click('text="Running"'); await tree.click('text="Files"'); diff --git a/app/test/tree.spec.ts b/app/test/tree.spec.ts index 36c1f8ab..cc773526 100644 --- a/app/test/tree.spec.ts +++ b/app/test/tree.spec.ts @@ -18,7 +18,7 @@ describe('Tree', () => { describe('File Browser', () => { it('should render a New Notebook button', async () => { const page = await browser.newPage(); - await page.goto(`${BASE_URL}classic/tree`); + await page.goto(`${BASE_URL}retro/tree`); const button = await page.$('text="New Notebook"'); expect(button).toBeDefined(); diff --git a/app/webpack.config.js b/app/webpack.config.js index 6e2fbbf1..0ee849f2 100644 --- a/app/webpack.config.js +++ b/app/webpack.config.js @@ -158,7 +158,7 @@ module.exports = [ mode: 'development', entry: ['./publicpath.js', './' + path.relative(__dirname, entryPoint)], output: { - path: path.resolve(__dirname, '..', 'jupyterlab_classic/static/'), + path: path.resolve(__dirname, '..', 'retrolab/static/'), library: { type: 'var', name: ['_JUPYTERLAB', 'CORE_OUTPUT'] diff --git a/binder/environment.yml b/binder/environment.yml index fd6ed067..ceda79c0 100644 --- a/binder/environment.yml +++ b/binder/environment.yml @@ -1,4 +1,4 @@ -name: jupyterlab-classic +name: retrolab channels: - conda-forge dependencies: diff --git a/binder/example.ipynb b/binder/example.ipynb index 8cf6f32f..01f57f30 100644 --- a/binder/example.ipynb +++ b/binder/example.ipynb @@ -4,24 +4,21 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Welcome to JupyterLab Classic! 👋\n", + "# Welcome to RetroLab! 👋\n", "\n", - "**JupyterLab Classic is an alternative distribution of JupyterLab**. It is built using the same components as in JupyterLab, and reuse a lot of the work from the JupyterLab community by leveraging the new federated (prebuilt) extension system.\n", + "**RetroLab is an alternative distribution of JupyterLab**. It is built using the same components as in JupyterLab, and reuse a lot of the work from the JupyterLab community by leveraging the new federated (prebuilt) extension system.\n", "\n", - "The goal of JupyterLab Classic is to provide an interface focused on the notebook for users that would like a leaner and simpler interface with a **modern look and old school touch to it**.\n", + "The goal of RetroLab is to provide an interface focused on the notebook for users that would like a leaner and simpler interface with a **modern look and old school touch to it**.\n", "\n", "It is supposed to complement JupyterLab and its single document mode, not to replace it! All these different interfaces can perfectly be installed together in the same environment:\n", "\n", "- JupyterLab (`jupyterlab` package)\n", "- NBClassic (`nbclassic` package): provides the Classic Notebook interface formely developed in https://github.com/jupyter/notebook\n", - "- JupyterLab Classic (`jupyterlab-classic` package): the interface you are probably currently using if looking at this notebook :)" + "- RetroLab (`retrolab` package): the interface you are probably currently using if looking at this notebook :)" ] }, { "attachments": { - "26030dba-e0bf-4be4-a446-2716125ebde2.png": { - "image/png": "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" - }, "2d33971b-509e-433b-809e-2f0861a13105.png": { "image/png": "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" }, @@ -30,6 +27,9 @@ }, "c448a783-da5a-499b-a52d-62be28a72438.png": { "image/png": "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" + }, + "d183cf17-977b-4c28-b892-123bde959d5b.png": { + "image/png": "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" } }, "cell_type": "markdown", @@ -37,11 +37,11 @@ "source": [ "## Files 📂 and Running Sessions 🏃‍♀️\n", "\n", - "Just like in the classic notebook, JupyterLab Classic lets you navigate the files in a separate browser tab. \n", + "Just like in the classic notebook, RetroLab lets you navigate the files in a separate browser tab. \n", "\n", "Go ahead and click on the Jupyter icon in the top left corner!\n", "\n", - "![image.png](attachment:26030dba-e0bf-4be4-a446-2716125ebde2.png)\n", + "![image.png](attachment:d183cf17-977b-4c28-b892-123bde959d5b.png)\n", "\n", "It will open a new browser tab with the listing of the files on the server:\n", "\n", @@ -70,7 +70,7 @@ "source": [ "## Editing Files 🖊️\n", "\n", - "JupyterLab Classic also has support for editing files. Double-click on a file (or `Right Click > Open`) to open the editor:\n", + "RetroLab also has support for editing files. Double-click on a file (or `Right Click > Open`) to open the editor:\n", "\n", "![image.png](attachment:72f98bea-d61c-40cd-8f56-29df50ae5f8d.png)\n", "\n", @@ -79,11 +79,11 @@ }, { "attachments": { + "23b23672-e7ae-44f0-9588-63208bcf0caf.png": { + "image/png": "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" + }, "9016e117-00db-490f-80c4-fa3ed6766d0f.png": { "image/png": "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" - }, - "ea6b6c9b-72e2-4377-bf11-3afbed489890.png": { - "image/png": "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" } }, "cell_type": "markdown", @@ -97,7 +97,7 @@ "\n", "The terminal opens in a new browser tab:\n", "\n", - "![image.png](attachment:ea6b6c9b-72e2-4377-bf11-3afbed489890.png)" + "![image.png](attachment:23b23672-e7ae-44f0-9588-63208bcf0caf.png)" ] }, { @@ -111,7 +111,7 @@ "source": [ "## Command Palette 🎨\n", "\n", - "JupyterLab Classic includes a command palette, just like in JupyterLab.\n", + "RetroLab includes a command palette, just like in JupyterLab.\n", "\n", "Hit `Ctrl-Shift-C` or `Accel-Shift-C` to activate it. Or via the menu with `View > Activate Command Palette`:\n", "\n", @@ -131,14 +131,14 @@ "source": [ "## Themes 🌈\n", "\n", - "Since JupyterLab Classic is heavily built on top of JupyterLab, it also has support for a Dark Mode! 🕶️\n", + "Since RetroLab is heavily built on top of JupyterLab, it also has support for a Dark Mode! 🕶️\n", "\n", "Go to `Settings > JupyterLab Theme > JupyterLab Dark` to select the theme:\n", "\n", "![image.png](attachment:52cfe8f1-5d7f-4e99-8f43-95a16a8601bb.png)\n", "\n", "\n", - "New themes can be installed using the federated extension system. These themes will be compatible with both JupyterLab and JupyterLab Classic." + "New themes can be installed using the federated extension system. These themes will be compatible with both JupyterLab and RetroLab." ] }, { @@ -152,7 +152,7 @@ "source": [ "## Zen Mode 😌\n", "\n", - "This is an exclusivity in JupyterLab Classic 😎\n", + "This is an exclusivity in RetroLab 😎\n", "\n", "Activate the palette and choose `Toggle Zen Mode`. The interface will focus on the notebook and the notebook only!\n", "\n", @@ -167,9 +167,9 @@ "source": [ "## Third Party Extensions 🧩\n", "\n", - "JupyterLab Classic supports third-party extensions developed for JupyterLab 3.0+, using the new distribution system. These extensions can be installed via `pip`.\n", + "RetroLab supports third-party extensions developed for JupyterLab 3.0+, using the new distribution system. These extensions can be installed via `pip`.\n", "\n", - "For example the extension to enable Jupyter Widgets rendering in both JupyterLab and JupyterLab Classic can be installed using the following command (run the cell): " + "For example the extension to enable Jupyter Widgets rendering in both JupyterLab and RetroLab can be installed using the following command (run the cell): " ] }, { @@ -178,7 +178,7 @@ "metadata": {}, "outputs": [], "source": [ - "!pip install --pre jupyterlab_widgets" + "!pip install ipywidgets" ] }, { @@ -227,7 +227,7 @@ "source": [ "## Rich Display\n", "\n", - "Just like in many Jupyter Frontends, JupyterLab Classic supports rich display rendering. For example:" + "Just like in many Jupyter Frontends, RetroLab supports rich display rendering. For example:" ] }, { @@ -311,7 +311,7 @@ "\n", "Hope you enjoyed the tour. If you have more question or any other issues, don't hesitate to go to the repository on GitHub!\n", "\n", - "https://github.com/jtpio/jupyterlab-classic" + "https://github.com/jtpio/retrolab" ] } ], @@ -331,7 +331,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.9.0" + "version": "3.9.4" } }, "nbformat": 4, diff --git a/buildutils/package.json b/buildutils/package.json index 0f6b2f2c..3e707272 100644 --- a/buildutils/package.json +++ b/buildutils/package.json @@ -1,15 +1,15 @@ { - "name": "@jupyterlab-classic/buildutils", + "name": "@retrolab/buildutils", "version": "0.1.10", "private": true, - "description": "JupyterLab Classic - Build Utilities", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - Build Utilities", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", "author": "Project Jupyter", diff --git a/jupyter-config/jupyter_notebook_config.d/jupyterlab_classic.json b/jupyter-config/jupyter_notebook_config.d/retrolab.json similarity index 65% rename from jupyter-config/jupyter_notebook_config.d/jupyterlab_classic.json rename to jupyter-config/jupyter_notebook_config.d/retrolab.json index 678cf555..9fab9de6 100644 --- a/jupyter-config/jupyter_notebook_config.d/jupyterlab_classic.json +++ b/jupyter-config/jupyter_notebook_config.d/retrolab.json @@ -1,7 +1,7 @@ { "NotebookApp": { "nbserver_extensions": { - "jupyterlab_classic": true + "retrolab": true } } } diff --git a/jupyter-config/jupyter_server_config.d/jupyterlab_classic.json b/jupyter-config/jupyter_server_config.d/retrolab.json similarity index 64% rename from jupyter-config/jupyter_server_config.d/jupyterlab_classic.json rename to jupyter-config/jupyter_server_config.d/retrolab.json index 14965e96..3d88245f 100644 --- a/jupyter-config/jupyter_server_config.d/jupyterlab_classic.json +++ b/jupyter-config/jupyter_server_config.d/retrolab.json @@ -1,7 +1,7 @@ { "ServerApp": { "jpserver_extensions": { - "jupyterlab_classic": true + "retrolab": true } } } diff --git a/jupyterlab-classic.png b/jupyterlab-classic.png deleted file mode 100644 index ce7a0488..00000000 Binary files a/jupyterlab-classic.png and /dev/null differ diff --git a/jupyterlab_classic/__main__.py b/jupyterlab_classic/__main__.py deleted file mode 100644 index 42f84144..00000000 --- a/jupyterlab_classic/__main__.py +++ /dev/null @@ -1,5 +0,0 @@ -import sys - -from jupyterlab_classic.app import main - -sys.exit(main()) diff --git a/package.json b/package.json index 0accd6b7..5a4e8801 100644 --- a/package.json +++ b/package.json @@ -1,15 +1,15 @@ { "private": true, - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic" + "url": "https://github.com/jtpio/retrolab" }, "license": "BSD-3-Clause", - "author": "JupyterLab Classic Contributors", + "author": "RetroLab Contributors", "workspaces": { "packages": [ "app", @@ -32,14 +32,14 @@ "release:bump": "node ./buildutils/lib/release-bump.js", "release:npm": "node ./buildutils/lib/release-npm.js", "release:patch": "node ./buildutils/lib/release-patch.js", - "start": "jupyter classic --config ./app/test/jupyter_server_config.py --no-browser", + "start": "jupyter retro --config ./app/test/jupyter_server_config.py --no-browser", "test": "lerna run test", "test:e2e": "lerna run test:e2e --stream", "test:ci": "(jlpm run start&) && jlpm run test:e2e", "update:dependency": "node ./node_modules/@jupyterlab/buildutils/lib/update-dependency.js --lerna", "watch": "run-p watch:lib watch:app", - "watch:lib": "lerna exec --stream --scope @jupyterlab-classic/metapackage jlpm watch", - "watch:app": "lerna exec --stream --scope \"@jupyterlab-classic/app\" jlpm watch" + "watch:lib": "lerna exec --stream --scope @retrolab/metapackage jlpm watch", + "watch:app": "lerna exec --stream --scope \"@retrolab/app\" jlpm watch" }, "husky": { "hooks": { diff --git a/packages/_metapackage/package.json b/packages/_metapackage/package.json index 7b73cd56..9e9188f6 100644 --- a/packages/_metapackage/package.json +++ b/packages/_metapackage/package.json @@ -1,18 +1,18 @@ { - "name": "@jupyterlab-classic/metapackage", + "name": "@retrolab/metapackage", "private": true, "version": "0.1.0", - "description": "JupyterLab Classic - Metapackage", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - Metapackage", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", - "author": "JupyterLab Classic Contributors", + "author": "RetroLab Contributors", "main": "lib/index.js", "types": "lib/index.d.ts", "scripts": { @@ -20,15 +20,15 @@ "watch": "tsc -b -w --preserveWatchOutput" }, "dependencies": { - "@jupyterlab-classic/application": "file:../application", - "@jupyterlab-classic/application-extension": "file:../application-extension", - "@jupyterlab-classic/docmanager-extension": "file:../docmanager-extension", - "@jupyterlab-classic/help-extension": "file:../help-extension", - "@jupyterlab-classic/lab-extension": "file:../lab-extension", - "@jupyterlab-classic/notebook-extension": "file:../notebook-extension", - "@jupyterlab-classic/terminal-extension": "file:../terminal-extension", - "@jupyterlab-classic/tree-extension": "file:../tree-extension", - "@jupyterlab-classic/ui-components": "file:../ui-components" + "@retrolab/application": "file:../application", + "@retrolab/application-extension": "file:../application-extension", + "@retrolab/docmanager-extension": "file:../docmanager-extension", + "@retrolab/help-extension": "file:../help-extension", + "@retrolab/lab-extension": "file:../lab-extension", + "@retrolab/notebook-extension": "file:../notebook-extension", + "@retrolab/terminal-extension": "file:../terminal-extension", + "@retrolab/tree-extension": "file:../tree-extension", + "@retrolab/ui-components": "file:../ui-components" }, "devDependencies": { "typescript": "~4.1.3" diff --git a/packages/_metapackage/src/index.ts b/packages/_metapackage/src/index.ts index 6f0050b2..3045198f 100644 --- a/packages/_metapackage/src/index.ts +++ b/packages/_metapackage/src/index.ts @@ -1,9 +1,9 @@ -import '@jupyterlab-classic/application'; -import '@jupyterlab-classic/application-extension'; -import '@jupyterlab-classic/docmanager-extension'; -import '@jupyterlab-classic/help-extension'; -import '@jupyterlab-classic/lab-extension'; -import '@jupyterlab-classic/notebook-extension'; -import '@jupyterlab-classic/terminal-extension'; -import '@jupyterlab-classic/tree-extension'; -import '@jupyterlab-classic/ui-components'; +import '@retrolab/application'; +import '@retrolab/application-extension'; +import '@retrolab/docmanager-extension'; +import '@retrolab/help-extension'; +import '@retrolab/lab-extension'; +import '@retrolab/notebook-extension'; +import '@retrolab/terminal-extension'; +import '@retrolab/tree-extension'; +import '@retrolab/ui-components'; diff --git a/packages/application-extension/package.json b/packages/application-extension/package.json index 09366673..31739141 100644 --- a/packages/application-extension/package.json +++ b/packages/application-extension/package.json @@ -1,14 +1,14 @@ { - "name": "@jupyterlab-classic/application-extension", + "name": "@retrolab/application-extension", "version": "0.1.10", - "description": "JupyterLab Classic - Application Extension", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - Application Extension", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", "author": "Project Jupyter", @@ -39,8 +39,8 @@ "watch": "tsc -b --watch" }, "dependencies": { - "@jupyterlab-classic/application": "^0.1.10", - "@jupyterlab-classic/ui-components": "^0.1.10", + "@retrolab/application": "^0.1.10", + "@retrolab/ui-components": "^0.1.10", "@jupyterlab/application": "^3.0.0", "@jupyterlab/apputils": "^3.0.0", "@jupyterlab/celltags": "^3.0.0", diff --git a/packages/application-extension/src/index.ts b/packages/application-extension/src/index.ts index b8e02841..62339cc0 100644 --- a/packages/application-extension/src/index.ts +++ b/packages/application-extension/src/index.ts @@ -25,13 +25,9 @@ import { IMainMenu } from '@jupyterlab/mainmenu'; import { ITranslator, TranslationManager } from '@jupyterlab/translation'; -import { - App, - ClassicShell, - IClassicShell -} from '@jupyterlab-classic/application'; +import { App, RetroShell, IRetroShell } from '@retrolab/application'; -import { jupyterIcon } from '@jupyterlab-classic/ui-components'; +import { jupyterIcon } from '@retrolab/ui-components'; import { Widget } from '@lumino/widgets'; @@ -79,12 +75,12 @@ namespace CommandIDs { * The logo plugin. */ const logo: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:logo', + id: '@retrolab/application-extension:logo', autoStart: true, activate: (app: JupyterFrontEnd) => { const baseUrl = PageConfig.getBaseUrl(); const node = document.createElement('a'); - node.href = `${baseUrl}classic/tree`; + node.href = `${baseUrl}retro/tree`; node.target = '_blank'; node.rel = 'noopener noreferrer'; const logo = new Widget({ node }); @@ -95,7 +91,7 @@ const logo: JupyterFrontEndPlugin = { height: '28px', width: 'auto' }); - logo.id = 'jp-ClassicLogo'; + logo.id = 'jp-RetroLogo'; app.shell.add(logo, 'top', { rank: 0 }); } }; @@ -104,7 +100,7 @@ const logo: JupyterFrontEndPlugin = { * A plugin to open documents in the main area. */ const opener: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:opener', + id: '@retrolab/application-extension:opener', autoStart: true, requires: [IRouter, IDocumentManager], activate: ( @@ -149,7 +145,7 @@ const opener: JupyterFrontEndPlugin = { * A plugin to dispose the Tabs menu */ const noTabsMenu: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:no-tabs-menu', + id: '@retrolab/application-extension:no-tabs-menu', requires: [IMainMenu], autoStart: true, activate: (app: JupyterFrontEnd, menu: IMainMenu) => { @@ -161,7 +157,7 @@ const noTabsMenu: JupyterFrontEndPlugin = { * Add commands to open the tree and running pages. */ const pages: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:pages', + id: '@retrolab/application-extension:pages', autoStart: true, optional: [ICommandPalette, IMainMenu], activate: ( @@ -181,7 +177,7 @@ const pages: JupyterFrontEndPlugin = { app.commands.addCommand(CommandIDs.openTree, { label: 'Open Files', execute: () => { - window.open(`${baseUrl}classic/tree`); + window.open(`${baseUrl}retro/tree`); } }); @@ -201,15 +197,15 @@ const pages: JupyterFrontEndPlugin = { }; /** - * The default paths for a JupyterLab Classic app. + * The default paths for a RetroLab app. */ const paths: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:paths', + id: '@retrolab/application-extension:paths', autoStart: true, provides: JupyterFrontEnd.IPaths, activate: (app: JupyterFrontEnd): JupyterFrontEnd.IPaths => { if (!(app instanceof App)) { - throw new Error(`${paths.id} must be activated in JupyterLab Classic.`); + throw new Error(`${paths.id} must be activated in RetroLab.`); } return app.paths; } @@ -219,7 +215,7 @@ const paths: JupyterFrontEndPlugin = { * The default URL router provider. */ const router: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:router', + id: '@retrolab/application-extension:router', autoStart: true, provides: IRouter, requires: [JupyterFrontEnd.IPaths], @@ -244,42 +240,42 @@ const router: JupyterFrontEndPlugin = { * The default session dialogs plugin */ const sessionDialogs: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:session-dialogs', + id: '@retrolab/application-extension:session-dialogs', provides: ISessionContextDialogs, autoStart: true, activate: () => sessionContextDialogs }; /** - * The default JupyterLab Classic application shell. + * The default RetroLab application shell. */ -const shell: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:shell', +const shell: JupyterFrontEndPlugin = { + id: '@retrolab/application-extension:shell', activate: (app: JupyterFrontEnd) => { - if (!(app.shell instanceof ClassicShell)) { - throw new Error(`${shell.id} did not find a ClassicShell instance.`); + if (!(app.shell instanceof RetroShell)) { + throw new Error(`${shell.id} did not find a RetroShell instance.`); } return app.shell; }, autoStart: true, - provides: IClassicShell + provides: IRetroShell }; /** * A plugin to provide a spacer at rank 10000 for flex panels */ const spacer: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:spacer', + id: '@retrolab/application-extension:spacer', autoStart: true, activate: (app: JupyterFrontEnd) => { const top = new Widget(); top.id = DOMUtils.createDomID(); - top.addClass('jp-ClassicSpacer'); + top.addClass('jp-RetroSpacer'); app.shell.add(top, 'top', { rank: 10000 }); const menu = new Widget(); menu.id = DOMUtils.createDomID(); - menu.addClass('jp-ClassicSpacer'); + menu.addClass('jp-RetroSpacer'); app.shell.add(menu, 'menu', { rank: 10000 }); } }; @@ -288,10 +284,10 @@ const spacer: JupyterFrontEndPlugin = { * A plugin to display the document title in the browser tab title */ const tabTitle: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:tab-title', + id: '@retrolab/application-extension:tab-title', autoStart: true, - requires: [IClassicShell], - activate: (app: JupyterFrontEnd, shell: IClassicShell) => { + requires: [IRetroShell], + activate: (app: JupyterFrontEnd, shell: IRetroShell) => { const setTabTitle = () => { const current = shell.currentWidget; if (!(current instanceof DocumentWidget)) { @@ -314,13 +310,13 @@ const tabTitle: JupyterFrontEndPlugin = { * A plugin to display and rename the title of a file */ const title: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:title', + id: '@retrolab/application-extension:title', autoStart: true, - requires: [IClassicShell], + requires: [IRetroShell], optional: [IDocumentManager, IRouter], activate: ( app: JupyterFrontEnd, - shell: IClassicShell, + shell: IRetroShell, docManager: IDocumentManager | null, router: IRouter | null ) => { @@ -366,7 +362,7 @@ const title: JupyterFrontEndPlugin = { return; } const encoded = encodeURIComponent(result.path); - router.navigate(`/classic/${route}/${encoded}`, { + router.navigate(`/retro/${route}/${encoded}`, { skipRouting: true }); }; @@ -381,15 +377,15 @@ const title: JupyterFrontEndPlugin = { * Plugin to toggle the top header visibility. */ const topVisibility: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:top', - requires: [IClassicShell], + id: '@retrolab/application-extension:top', + requires: [IRetroShell], optional: [IMainMenu], activate: ( app: JupyterFrontEnd, - classicShell: IClassicShell, + retroShell: IRetroShell, menu: IMainMenu | null ) => { - const top = classicShell.top; + const top = retroShell.top; app.commands.addCommand(CommandIDs.toggleTop, { label: 'Show Header', @@ -405,9 +401,9 @@ const topVisibility: JupyterFrontEndPlugin = { const onChanged = (): void => { if (app.format === 'desktop') { - classicShell.expandTop(); + retroShell.expandTop(); } else { - classicShell.collapseTop(); + retroShell.collapseTop(); } }; @@ -422,7 +418,7 @@ const topVisibility: JupyterFrontEndPlugin = { * A simplified Translator */ const translator: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:translator', + id: '@retrolab/application-extension:translator', activate: (app: JupyterFrontEnd): ITranslator => { const translationManager = new TranslationManager(); return translationManager; @@ -435,27 +431,27 @@ const translator: JupyterFrontEndPlugin = { * Zen mode plugin */ const zen: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:zen', + id: '@retrolab/application-extension:zen', autoStart: true, - optional: [ICommandPalette, IClassicShell, IMainMenu], + optional: [ICommandPalette, IRetroShell, IMainMenu], activate: ( app: JupyterFrontEnd, palette: ICommandPalette | null, - classicShell: IClassicShell | null, + retroShell: IRetroShell | null, menu: IMainMenu | null ): void => { const { commands } = app; const elem = document.documentElement; const toggleOn = () => { - classicShell?.collapseTop(); - classicShell?.menu.setHidden(true); + retroShell?.collapseTop(); + retroShell?.menu.setHidden(true); zenModeEnabled = true; }; const toggleOff = () => { - classicShell?.expandTop(); - classicShell?.menu.setHidden(false); + retroShell?.expandTop(); + retroShell?.menu.setHidden(false); zenModeEnabled = false; }; diff --git a/packages/application-extension/style/base.css b/packages/application-extension/style/base.css index 20233875..5849875f 100644 --- a/packages/application-extension/style/base.css +++ b/packages/application-extension/style/base.css @@ -4,7 +4,7 @@ | Distributed under the terms of the Modified BSD License. |----------------------------------------------------------------------------*/ -.jp-ClassicSpacer { +.jp-RetroSpacer { flex-grow: 1; flex-shrink: 1; } diff --git a/packages/application-extension/style/index.css b/packages/application-extension/style/index.css index 1546d95c..4b235515 100644 --- a/packages/application-extension/style/index.css +++ b/packages/application-extension/style/index.css @@ -1,4 +1,4 @@ -@import url('~@jupyterlab-classic/application/style/index.css'); +@import url('~@retrolab/application/style/index.css'); @import url('~@lumino/widgets/style/index.css'); @import url('./base.css'); diff --git a/packages/application-extension/style/index.js b/packages/application-extension/style/index.js index b3952b85..9b6c4e7d 100644 --- a/packages/application-extension/style/index.js +++ b/packages/application-extension/style/index.js @@ -1,4 +1,4 @@ -import '@jupyterlab-classic/application/style/index.js'; +import '@retrolab/application/style/index.js'; import '@lumino/widgets/style/index.js'; import './base.css'; diff --git a/packages/application/package.json b/packages/application/package.json index bba6e0b6..b19fc6d1 100644 --- a/packages/application/package.json +++ b/packages/application/package.json @@ -1,14 +1,14 @@ { - "name": "@jupyterlab-classic/application", + "name": "@retrolab/application", "version": "0.1.10", - "description": "JupyterLab Classic - Application", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - Application", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", "author": "Project Jupyter", diff --git a/packages/application/src/app.ts b/packages/application/src/app.ts index f80f6586..f25949d9 100644 --- a/packages/application/src/app.ts +++ b/packages/application/src/app.ts @@ -14,21 +14,21 @@ import { IRenderMime } from '@jupyterlab/rendermime-interfaces'; import { Throttler } from '@lumino/polling'; -import { IClassicShell, ClassicShell } from './shell'; +import { IRetroShell, RetroShell } from './shell'; /** * App is the main application class. It is instantiated once and shared. */ -export class App extends JupyterFrontEnd { +export class App extends JupyterFrontEnd { /** * Construct a new App object. * * @param options The instantiation options for an application. */ - constructor(options: App.IOptions = { shell: new ClassicShell() }) { + constructor(options: App.IOptions = { shell: new RetroShell() }) { super({ ...options, - shell: options.shell ?? new ClassicShell() + shell: options.shell ?? new RetroShell() }); if (options.mimeExtensions) { for (const plugin of createRendermimePlugins(options.mimeExtensions)) { @@ -41,7 +41,7 @@ export class App extends JupyterFrontEnd { /** * The name of the application. */ - readonly name = 'JupyterLab Classic'; + readonly name = 'RetroLab'; /** * A namespace/prefix plugins may use to denote their provenance. @@ -145,11 +145,11 @@ export namespace App { * The instantiation options for an App application. */ export interface IOptions - extends JupyterFrontEnd.IOptions, + extends JupyterFrontEnd.IOptions, Partial {} /** - * The information about a JupyterLab Classic application. + * The information about a RetroLab application. */ export interface IInfo { /** diff --git a/packages/application/src/shell.ts b/packages/application/src/shell.ts index a7b7adba..4910378a 100644 --- a/packages/application/src/shell.ts +++ b/packages/application/src/shell.ts @@ -16,16 +16,16 @@ import { ISignal, Signal } from '@lumino/signaling'; import { Panel, Widget, BoxLayout } from '@lumino/widgets'; /** - * The JupyterLab Classic application shell token. + * The RetroLab application shell token. */ -export const IClassicShell = new Token( - '@jupyterlab-classic/application:IClassicShell' +export const IRetroShell = new Token( + '@retrolab/application:IRetroShell' ); /** - * The JupyterLab Classic application shell interface. + * The RetroLab application shell interface. */ -export interface IClassicShell extends ClassicShell {} +export interface IRetroShell extends RetroShell {} /** * The default rank for ranked panels. @@ -35,7 +35,7 @@ const DEFAULT_RANK = 900; /** * The application shell. */ -export class ClassicShell extends Widget implements JupyterFrontEnd.IShell { +export class RetroShell extends Widget implements JupyterFrontEnd.IShell { constructor() { super(); this.id = 'main'; @@ -78,7 +78,7 @@ export class ClassicShell extends Widget implements JupyterFrontEnd.IShell { /** * A signal emitted when the current widget changes. */ - get currentChanged(): ISignal { + get currentChanged(): ISignal { return this._currentChanged; } diff --git a/packages/application/test/shell.spec.ts b/packages/application/test/shell.spec.ts index 53ceaab7..a1296ef0 100644 --- a/packages/application/test/shell.spec.ts +++ b/packages/application/test/shell.spec.ts @@ -1,7 +1,7 @@ // Copyright (c) Jupyter Development Team. // Distributed under the terms of the Modified BSD License. -import { ClassicShell, IClassicShell } from '@jupyterlab-classic/application'; +import { RetroShell, IRetroShell } from '@retrolab/application'; import { JupyterFrontEnd } from '@jupyterlab/application'; @@ -10,10 +10,10 @@ import { toArray } from '@lumino/algorithm'; import { Widget } from '@lumino/widgets'; describe('Shell', () => { - let shell: IClassicShell; + let shell: IRetroShell; beforeEach(() => { - shell = new ClassicShell(); + shell = new RetroShell(); Widget.attach(shell, document.body); }); @@ -23,7 +23,7 @@ describe('Shell', () => { describe('#constructor()', () => { it('should create a LabShell instance', () => { - expect(shell).toBeInstanceOf(ClassicShell); + expect(shell).toBeInstanceOf(RetroShell); }); }); diff --git a/packages/docmanager-extension/package.json b/packages/docmanager-extension/package.json index 13df74be..4d9b6dea 100644 --- a/packages/docmanager-extension/package.json +++ b/packages/docmanager-extension/package.json @@ -1,14 +1,14 @@ { - "name": "@jupyterlab-classic/docmanager-extension", + "name": "@retrolab/docmanager-extension", "version": "0.1.10", - "description": "JupyterLab Classic - Document Manager Extension", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - Document Manager Extension", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", "author": "Project Jupyter", diff --git a/packages/docmanager-extension/src/index.ts b/packages/docmanager-extension/src/index.ts index 44d1967d..a1318663 100644 --- a/packages/docmanager-extension/src/index.ts +++ b/packages/docmanager-extension/src/index.ts @@ -20,7 +20,7 @@ import { Kernel } from '@jupyterlab/services'; * TODO: remove and use a custom doc manager? */ const opener: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/docmanager-extension:opener', + id: '@retrolab/docmanager-extension:opener', requires: [IDocumentManager], autoStart: true, activate: (app: JupyterFrontEnd, docManager: IDocumentManager) => { @@ -41,7 +41,7 @@ const opener: JupyterFrontEndPlugin = { } const ext = PathExt.extname(path); const route = ext === '.ipynb' ? 'notebooks' : 'edit'; - window.open(`${baseUrl}classic/${route}/${path}`); + window.open(`${baseUrl}retro/${route}/${path}`); return undefined; }; } diff --git a/packages/help-extension/package.json b/packages/help-extension/package.json index 7a6f62e3..f76c0981 100644 --- a/packages/help-extension/package.json +++ b/packages/help-extension/package.json @@ -1,14 +1,14 @@ { - "name": "@jupyterlab-classic/help-extension", + "name": "@retrolab/help-extension", "version": "0.1.10", - "description": "JupyterLab Classic - Help Extension", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - Help Extension", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", "author": "Project Jupyter", @@ -39,7 +39,7 @@ "watch": "tsc -b --watch" }, "dependencies": { - "@jupyterlab-classic/ui-components": "^0.1.10", + "@retrolab/ui-components": "^0.1.10", "@jupyterlab/application": "^3.0.0", "@jupyterlab/apputils": "^3.0.0", "@jupyterlab/mainmenu": "^3.0.0" diff --git a/packages/help-extension/src/index.tsx b/packages/help-extension/src/index.tsx index 45fd0503..986c25fc 100644 --- a/packages/help-extension/src/index.tsx +++ b/packages/help-extension/src/index.tsx @@ -10,7 +10,7 @@ import { showDialog, Dialog } from '@jupyterlab/apputils'; import { IMainMenu } from '@jupyterlab/mainmenu'; -import { jupyterlabClassicIcon } from '@jupyterlab-classic/ui-components'; +import { retroIcon } from '@retrolab/ui-components'; import * as React from 'react'; @@ -43,7 +43,7 @@ namespace CommandIDs { * The help plugin. */ const plugin: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/help-extension:plugin', + id: '@retrolab/help-extension:plugin', autoStart: true, optional: [IMainMenu], activate: (app: JupyterFrontEnd, menu: IMainMenu): void => { @@ -61,15 +61,15 @@ const plugin: JupyterFrontEndPlugin = { label: 'Keyboard Shortcuts', execute: () => { const title = ( - -
+ +
Keyboard Shortcuts
); const body = ( - +
@@ -98,7 +98,7 @@ const plugin: JupyterFrontEndPlugin = { Dialog.createButton({ label: 'Dismiss', className: - 'jp-AboutClassic-about-button jp-mod-reject jp-mod-styled' + 'jp-AboutRetro-about-button jp-mod-reject jp-mod-styled' }) ] }); @@ -110,29 +110,28 @@ const plugin: JupyterFrontEndPlugin = { execute: () => { const title = ( <> - - + + ); - const classicNotebookURL = - 'https://github.com/jtpio/jupyterlab-classic'; + const retroNotebookURL = 'https://github.com/jtpio/retrolab'; const externalLinks = ( - JUPYTERLAB CLASSIC ON GITHUB + RETROLAB ON GITHUB ); const body = ( <> - Version: {app.version} + Version: {app.version}
{externalLinks}
); @@ -144,7 +143,7 @@ const plugin: JupyterFrontEndPlugin = { Dialog.createButton({ label: 'Dismiss', className: - 'jp-AboutClassic-about-button jp-mod-reject jp-mod-styled' + 'jp-AboutRetro-about-button jp-mod-reject jp-mod-styled' }) ] }); diff --git a/packages/help-extension/style/base.css b/packages/help-extension/style/base.css index 0cf49e6c..0a354f4b 100644 --- a/packages/help-extension/style/base.css +++ b/packages/help-extension/style/base.css @@ -1,15 +1,15 @@ -.jp-AboutClassic-header { +.jp-AboutRetro-header { display: flex; flex-direction: row; align-items: center; padding: var(--jp-flat-button-padding); } -.jp-AboutClassic-header-text { +.jp-AboutRetro-header-text { margin-left: 16px; } -.jp-AboutClassic-body { +.jp-AboutRetro-body { display: flex; font-size: var(--jp-ui-font-size2); padding: var(--jp-flat-button-padding); @@ -20,11 +20,11 @@ overflow: hidden; } -.jp-AboutClassic-about-body pre { +.jp-AboutRetro-about-body pre { white-space: pre-wrap; } -.jp-AboutClassic-about-externalLinks { +.jp-AboutRetro-about-externalLinks { display: flex; flex-direction: column; justify-content: flex-start; @@ -33,11 +33,11 @@ color: var(--jp-warn-color0); } -.jp-AboutClassic-shortcuts { +.jp-AboutRetro-shortcuts { padding: 10px; } -.jp-AboutClassic-shortcuts pre { +.jp-AboutRetro-shortcuts pre { padding: 5px; margin: 0 0 10px; background: var(--jp-layout-color2); diff --git a/packages/lab-extension/package.json b/packages/lab-extension/package.json index 6fab848e..3de4b50a 100644 --- a/packages/lab-extension/package.json +++ b/packages/lab-extension/package.json @@ -1,14 +1,14 @@ { - "name": "@jupyterlab-classic/lab-extension", + "name": "@retrolab/lab-extension", "version": "0.1.10", - "description": "JupyterLab Classic - Lab Extension", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - Lab Extension", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", "author": "Project Jupyter", @@ -38,7 +38,7 @@ "build:prod": "jlpm run build:lib && jlpm run build:labextension", "clean": "jlpm run clean:lib", "clean:all": "jlpm run clean:lib && jlpm run clean:labextension", - "clean:labextension": "rimraf ../../jupyterlab_classic/labextension", + "clean:labextension": "rimraf ../../retrolab/labextension", "clean:lib": "rimraf lib tsconfig.tsbuildinfo", "prepare": "jlpm run clean && jlpm run build:prod", "watch": "run-p watch:src watch:labextension", @@ -46,7 +46,7 @@ "watch:src": "tsc -w" }, "dependencies": { - "@jupyterlab-classic/ui-components": "^0.1.10", + "@retrolab/ui-components": "^0.1.10", "@jupyterlab/application": "^3.0.0", "@jupyterlab/apputils": "^3.0.0", "@jupyterlab/coreutils": "^5.0.0", @@ -66,6 +66,6 @@ }, "jupyterlab": { "extension": true, - "outputDir": "../../jupyterlab_classic/labextension" + "outputDir": "../../retrolab/labextension" } } diff --git a/packages/lab-extension/src/index.ts b/packages/lab-extension/src/index.ts index d358561f..816d9c44 100644 --- a/packages/lab-extension/src/index.ts +++ b/packages/lab-extension/src/index.ts @@ -34,16 +34,16 @@ namespace CommandIDs { /** * Toggle Top Bar visibility */ - export const openClassic = 'jupyterlab-classic:open'; + export const openRetro = 'retrolab:open'; } /** - * A notebook widget extension that adds a jupyterlab classic button to the toolbar. + * A notebook widget extension that adds a retrolab button to the toolbar. */ -class ClassicButton +class RetroButton implements DocumentRegistry.IWidgetExtension { /** - * Instantiate a new ClassicButton. + * Instantiate a new RetroButton. * @param commands The command registry. */ constructor(commands: CommandRegistry) { @@ -55,13 +55,13 @@ class ClassicButton */ createNew(panel: NotebookPanel): IDisposable { const button = new ToolbarButton({ - tooltip: 'Open with JupyterLab Classic', + tooltip: 'Open with RetroLab', icon: jupyterIcon, onClick: () => { - this._commands.execute(CommandIDs.openClassic); + this._commands.execute(CommandIDs.openRetro); } }); - panel.toolbar.insertAfter('cellType', 'jupyterlabClassic', button); + panel.toolbar.insertAfter('cellType', 'retro', button); return button; } @@ -71,8 +71,8 @@ class ClassicButton /** * A plugin for the checkpoint indicator */ -const openClassic: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/lab-extension:open-classic', +const openRetro: JupyterFrontEndPlugin = { + id: '@retrolab/lab-extension:open-retro', autoStart: true, optional: [INotebookTracker, ICommandPalette, IMainMenu, ILabShell], activate: ( @@ -82,9 +82,9 @@ const openClassic: JupyterFrontEndPlugin = { menu: IMainMenu | null, labShell: ILabShell | null ) => { - // TODO: do not activate if already in a IClassicShell? + // TODO: do not activate if already in a IRetroShell? if (!notebookTracker || !labShell) { - // to prevent showing the toolbar button in JupyterLab Classic + // to prevent showing the toolbar button in RetroLab return; } @@ -98,35 +98,35 @@ const openClassic: JupyterFrontEndPlugin = { ); }; - commands.addCommand(CommandIDs.openClassic, { - label: 'Open in JupyterLab Classic', + commands.addCommand(CommandIDs.openRetro, { + label: 'Open in RetroLab', execute: () => { const current = notebookTracker.currentWidget; if (!current) { return; } const { context } = current; - window.open(`${baseUrl}classic/notebooks/${context.path}`); + window.open(`${baseUrl}retro/notebooks/${context.path}`); }, isEnabled }); if (palette) { - palette.addItem({ command: CommandIDs.openClassic, category: 'Other' }); + palette.addItem({ command: CommandIDs.openRetro, category: 'Other' }); } if (menu) { - menu.viewMenu.addGroup([{ command: CommandIDs.openClassic }], 1); + menu.viewMenu.addGroup([{ command: CommandIDs.openRetro }], 1); } - const classicButton = new ClassicButton(commands); - docRegistry.addWidgetExtension('Notebook', classicButton); + const retroButton = new RetroButton(commands); + docRegistry.addWidgetExtension('Notebook', retroButton); } }; /** * Export the plugins as default. */ -const plugins: JupyterFrontEndPlugin[] = [openClassic]; +const plugins: JupyterFrontEndPlugin[] = [openRetro]; export default plugins; diff --git a/packages/notebook-extension/package.json b/packages/notebook-extension/package.json index 3d054922..a46271b5 100644 --- a/packages/notebook-extension/package.json +++ b/packages/notebook-extension/package.json @@ -1,14 +1,14 @@ { - "name": "@jupyterlab-classic/notebook-extension", + "name": "@retrolab/notebook-extension", "version": "0.1.10", - "description": "JupyterLab Classic - Notebook Extension", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - Notebook Extension", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", "author": "Project Jupyter", @@ -39,7 +39,7 @@ "watch": "tsc -b --watch" }, "dependencies": { - "@jupyterlab-classic/application": "^0.1.10", + "@retrolab/application": "^0.1.10", "@jupyterlab/application": "^3.0.0", "@jupyterlab/apputils": "^3.0.0", "@jupyterlab/docmanager": "^3.0.0", diff --git a/packages/notebook-extension/src/index.ts b/packages/notebook-extension/src/index.ts index 3ba3ca8e..609d2193 100644 --- a/packages/notebook-extension/src/index.ts +++ b/packages/notebook-extension/src/index.ts @@ -14,11 +14,7 @@ import { IDocumentManager } from '@jupyterlab/docmanager'; import { NotebookPanel } from '@jupyterlab/notebook'; -import { - App, - ClassicShell, - IClassicShell -} from '@jupyterlab-classic/application'; +import { App, RetroShell, IRetroShell } from '@retrolab/application'; import { Poll } from '@lumino/polling'; @@ -27,40 +23,40 @@ import { Widget } from '@lumino/widgets'; /** * The class for kernel status errors. */ -const KERNEL_STATUS_ERROR_CLASS = 'jp-ClassicKernelStatus-error'; +const KERNEL_STATUS_ERROR_CLASS = 'jp-RetroKernelStatus-error'; /** * The class for kernel status warnings. */ -const KERNEL_STATUS_WARN_CLASS = 'jp-ClassicKernelStatus-warn'; +const KERNEL_STATUS_WARN_CLASS = 'jp-RetroKernelStatus-warn'; /** * The class for kernel status infos. */ -const KERNEL_STATUS_INFO_CLASS = 'jp-ClassicKernelStatus-info'; +const KERNEL_STATUS_INFO_CLASS = 'jp-RetroKernelStatus-info'; /** * The class to fade out the kernel status. */ -const KERNEL_STATUS_FADE_OUT_CLASS = 'jp-ClassicKernelStatus-fade'; +const KERNEL_STATUS_FADE_OUT_CLASS = 'jp-RetroKernelStatus-fade'; /** * A plugin for the checkpoint indicator */ const checkpoints: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:checkpoints', + id: '@retrolab/application-extension:checkpoints', autoStart: true, requires: [IDocumentManager], - optional: [IClassicShell], + optional: [IRetroShell], activate: ( app: JupyterFrontEnd, docManager: IDocumentManager, - classicShell: IClassicShell + retroShell: IRetroShell ) => { const { shell } = app; const widget = new Widget(); widget.id = DOMUtils.createDomID(); - widget.addClass('jp-ClassicCheckpoint'); + widget.addClass('jp-RetroCheckpoint'); app.shell.add(widget, 'top', { rank: 100 }); const onChange = async () => { @@ -83,8 +79,8 @@ const checkpoints: JupyterFrontEndPlugin = { )}`; }; - if (classicShell) { - classicShell.currentChanged.connect(onChange); + if (retroShell) { + retroShell.currentChanged.connect(onChange); } new Poll({ @@ -103,10 +99,10 @@ const checkpoints: JupyterFrontEndPlugin = { * The kernel logo plugin. */ const kernelLogo: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:kernel-logo', + id: '@retrolab/application-extension:kernel-logo', autoStart: true, - requires: [IClassicShell], - activate: (app: JupyterFrontEnd, shell: IClassicShell) => { + requires: [IRetroShell], + activate: (app: JupyterFrontEnd, shell: IRetroShell) => { const { serviceManager } = app; const baseUrl = PageConfig.getBaseUrl(); @@ -144,7 +140,7 @@ const kernelLogo: JupyterFrontEndPlugin = { img.title = spec.display_name; node.appendChild(img); widget = new Widget({ node }); - widget.addClass('jp-ClassicKernelLogo'); + widget.addClass('jp-RetroKernelLogo'); app.shell.add(widget, 'top', { rank: 10_010 }); }; @@ -156,12 +152,12 @@ const kernelLogo: JupyterFrontEndPlugin = { * A plugin to display the kernel status; */ const kernelStatus: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:kernel-status', + id: '@retrolab/application-extension:kernel-status', autoStart: true, - requires: [IClassicShell], - activate: (app: JupyterFrontEnd, shell: IClassicShell) => { + requires: [IRetroShell], + activate: (app: JupyterFrontEnd, shell: IRetroShell) => { const widget = new Widget(); - widget.addClass('jp-ClassicKernelStatus'); + widget.addClass('jp-RetroKernelStatus'); app.shell.add(widget, 'menu', { rank: 10_010 }); const removeClasses = () => { @@ -210,13 +206,13 @@ const kernelStatus: JupyterFrontEndPlugin = { }; /** - * The default paths for a JupyterLab Classic app. + * The default paths for a RetroLab app. */ const paths: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:paths', + id: '@retrolab/application-extension:paths', activate: (app: JupyterFrontEnd): JupyterFrontEnd.IPaths => { if (!(app instanceof App)) { - throw new Error(`${paths.id} must be activated in JupyterLab Classic.`); + throw new Error(`${paths.id} must be activated in RetroLab.`); } return app.paths; }, @@ -225,18 +221,18 @@ const paths: JupyterFrontEndPlugin = { }; /** - * The default JupyterLab Classic application shell. + * The default RetroLab application shell. */ -const shell: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/application-extension:shell', +const shell: JupyterFrontEndPlugin = { + id: '@retrolab/application-extension:shell', activate: (app: JupyterFrontEnd) => { - if (!(app.shell instanceof ClassicShell)) { - throw new Error(`${shell.id} did not find a ClassicShell instance.`); + if (!(app.shell instanceof RetroShell)) { + throw new Error(`${shell.id} did not find a RetroShell instance.`); } return app.shell; }, autoStart: true, - provides: IClassicShell + provides: IRetroShell }; /** diff --git a/packages/notebook-extension/style/base.css b/packages/notebook-extension/style/base.css index c6296bfc..e7c8f4ec 100644 --- a/packages/notebook-extension/style/base.css +++ b/packages/notebook-extension/style/base.css @@ -4,7 +4,7 @@ | Distributed under the terms of the Modified BSD License. |----------------------------------------------------------------------------*/ -.jp-ClassicKernelLogo { +.jp-RetroKernelLogo { flex: 0 0 auto; display: flex; align-items: center; @@ -12,13 +12,13 @@ margin-right: 8px; } -.jp-ClassicKernelLogo img { +.jp-RetroKernelLogo img { max-width: 28px; max-height: 28px; display: flex; } -.jp-ClassicKernelStatus { +.jp-RetroKernelStatus { font-size: var(--jp-ui-font-size1); margin: 0; font-weight: normal; @@ -29,19 +29,19 @@ padding-right: 5px; } -.jp-ClassicKernelStatus-error { +.jp-RetroKernelStatus-error { background-color: var(--jp-error-color0); } -.jp-ClassicKernelStatus-warn { +.jp-RetroKernelStatus-warn { background-color: var(--jp-warn-color0); } -.jp-ClassicKernelStatus-info { +.jp-RetroKernelStatus-info { background-color: var(--jp-info-color0); } -.jp-ClassicKernelStatus-fade { +.jp-RetroKernelStatus-fade { animation: 0.5s fade-out forwards; } @@ -71,7 +71,7 @@ background: var(--jp-layout-color2); } -.jp-ClassicCheckpoint { +.jp-RetroCheckpoint { font-size: 14px; margin-left: 5px; margin-right: 5px; @@ -86,7 +86,7 @@ /* Mobile View */ -body[data-format='mobile'] .jp-ClassicCheckpoint { +body[data-format='mobile'] .jp-RetroCheckpoint { display: none; } diff --git a/packages/terminal-extension/package.json b/packages/terminal-extension/package.json index c6bf93b7..c6c46949 100644 --- a/packages/terminal-extension/package.json +++ b/packages/terminal-extension/package.json @@ -1,14 +1,14 @@ { - "name": "@jupyterlab-classic/terminal-extension", + "name": "@retrolab/terminal-extension", "version": "0.1.10", - "description": "JupyterLab Classic - Terminal Extension", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - Terminal Extension", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", "author": "Project Jupyter", diff --git a/packages/terminal-extension/src/index.ts b/packages/terminal-extension/src/index.ts index b5c5c4bb..08d4193b 100644 --- a/packages/terminal-extension/src/index.ts +++ b/packages/terminal-extension/src/index.ts @@ -17,7 +17,7 @@ import { find } from '@lumino/algorithm'; * A plugin to open terminals in a new tab */ const opener: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/terminal-extension:opener', + id: '@retrolab/terminal-extension:opener', requires: [IRouter], autoStart: true, activate: (app: JupyterFrontEnd, router: IRouter) => { @@ -49,7 +49,7 @@ const opener: JupyterFrontEndPlugin = { * Open terminals in a new tab. */ const redirect: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/terminal-extension:redirect', + id: '@retrolab/terminal-extension:redirect', requires: [ITerminalTracker], autoStart: true, activate: (app: JupyterFrontEnd, tracker: ITerminalTracker) => { @@ -61,7 +61,7 @@ const redirect: JupyterFrontEndPlugin = { return; } const name = terminal.content.session.name; - window.open(`${baseUrl}classic/terminals/${name}`, '_blank'); + window.open(`${baseUrl}retro/terminals/${name}`, '_blank'); // dispose the widget since it is not used on this page terminal.dispose(); diff --git a/packages/tree-extension/package.json b/packages/tree-extension/package.json index cb6fca98..011b3d13 100644 --- a/packages/tree-extension/package.json +++ b/packages/tree-extension/package.json @@ -1,14 +1,14 @@ { - "name": "@jupyterlab-classic/tree-extension", + "name": "@retrolab/tree-extension", "version": "0.1.10", - "description": "JupyterLab Classic - Tree Extension", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - Tree Extension", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", "author": "Project Jupyter", @@ -39,7 +39,7 @@ "watch": "tsc -b --watch" }, "dependencies": { - "@jupyterlab-classic/application": "^0.1.10", + "@retrolab/application": "^0.1.10", "@jupyterlab/application": "^3.0.0", "@jupyterlab/apputils": "^3.0.0", "@jupyterlab/coreutils": "^5.0.0", diff --git a/packages/tree-extension/src/index.ts b/packages/tree-extension/src/index.ts index d48e22bc..0181ce48 100644 --- a/packages/tree-extension/src/index.ts +++ b/packages/tree-extension/src/index.ts @@ -125,7 +125,7 @@ namespace CommandIDs { * new notebooks, files and terminals. */ const newFiles: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/tree-extension:buttons', + id: '@retrolab/tree-extension:buttons', requires: [IFileBrowserFactory], autoStart: true, activate: (app: JupyterFrontEnd, filebrowser: IFileBrowserFactory) => { @@ -161,7 +161,7 @@ const newFiles: JupyterFrontEndPlugin = { * Plugin to add a "New Terminal" button to the file browser toolbar. */ const newTerminal: JupyterFrontEndPlugin = { - id: '@jupyterlab-classic/tree-extension:new-terminal', + id: '@retrolab/tree-extension:new-terminal', requires: [IFileBrowserFactory], autoStart: true, activate: (app: JupyterFrontEnd, filebrowser: IFileBrowserFactory) => { @@ -191,7 +191,7 @@ const newTerminal: JupyterFrontEndPlugin = { */ const browser: JupyterFrontEndPlugin = { activate: activateBrowser, - id: '@jupyterlab-classic/tree-extension:browser', + id: '@retrolab/tree-extension:browser', requires: [ IFileBrowserFactory, IDocumentManager, @@ -215,7 +215,7 @@ const browser: JupyterFrontEndPlugin = { */ const factory: JupyterFrontEndPlugin = { activate: activateFactory, - id: '@jupyterlab-classic/tree-extension:factory', + id: '@retrolab/tree-extension:factory', provides: IFileBrowserFactory, requires: [IDocumentManager, ITranslator], optional: [IStateDB, IRouter, JupyterFrontEnd.ITreeResolver] diff --git a/packages/tree-extension/style/base.css b/packages/tree-extension/style/base.css index 04217d89..1f176bdc 100644 --- a/packages/tree-extension/style/base.css +++ b/packages/tree-extension/style/base.css @@ -15,7 +15,7 @@ .jp-TreePanel .lm-TabBar-tab { color: var(--jp-ui-font-color0); font-size: var(--jp-ui-font-size1); - padding: 8px; + padding: 6px; } .jp-TreePanel .lm-TabBar-tabLabel { diff --git a/packages/ui-components/package.json b/packages/ui-components/package.json index 2ec3d1b3..6e79e159 100644 --- a/packages/ui-components/package.json +++ b/packages/ui-components/package.json @@ -1,14 +1,14 @@ { - "name": "@jupyterlab-classic/ui-components", + "name": "@retrolab/ui-components", "version": "0.1.10", - "description": "JupyterLab Classic - UI components", - "homepage": "https://github.com/jtpio/jupyterlab-classic", + "description": "RetroLab - UI components", + "homepage": "https://github.com/jtpio/retrolab", "bugs": { - "url": "https://github.com/jtpio/jupyterlab-classic/issues" + "url": "https://github.com/jtpio/retrolab/issues" }, "repository": { "type": "git", - "url": "https://github.com/jtpio/jupyterlab-classic.git" + "url": "https://github.com/jtpio/retrolab.git" }, "license": "BSD-3-Clause", "author": "Project Jupyter", diff --git a/packages/ui-components/src/icon/iconimports.ts b/packages/ui-components/src/icon/iconimports.ts index d1766c89..259a0391 100644 --- a/packages/ui-components/src/icon/iconimports.ts +++ b/packages/ui-components/src/icon/iconimports.ts @@ -7,14 +7,14 @@ import { LabIcon } from '@jupyterlab/ui-components'; import jupyterSvgstr from '../../style/icons/jupyter.svg'; -import jupyterlabClassicSvgstr from '../../style/icons/jupyterlab-classic.svg'; +import retroSvgstr from '../../style/icons/retrolab.svg'; export const jupyterIcon = new LabIcon({ - name: 'classic-ui-components:jupyter', + name: 'retro-ui-components:jupyter', svgstr: jupyterSvgstr }); -export const jupyterlabClassicIcon = new LabIcon({ - name: 'classic-ui-components:jupyterlab-classic', - svgstr: jupyterlabClassicSvgstr +export const retroIcon = new LabIcon({ + name: 'retro-ui-components:retrolab', + svgstr: retroSvgstr }); diff --git a/packages/ui-components/style/icons/jupyterlab-classic.svg b/packages/ui-components/style/icons/jupyterlab-classic.svg deleted file mode 100644 index 6abffe88..00000000 --- a/packages/ui-components/style/icons/jupyterlab-classic.svg +++ /dev/null @@ -1,36 +0,0 @@ - - - diff --git a/packages/ui-components/style/icons/retrolab.svg b/packages/ui-components/style/icons/retrolab.svg new file mode 100644 index 00000000..d098ecc5 --- /dev/null +++ b/packages/ui-components/style/icons/retrolab.svg @@ -0,0 +1,69 @@ + + + + + image/svg+xml + + + + + + + + RetroLab + diff --git a/retrolab.png b/retrolab.png new file mode 100644 index 00000000..2c38ba34 Binary files /dev/null and b/retrolab.png differ diff --git a/jupyterlab_classic/__init__.py b/retrolab/__init__.py similarity index 61% rename from jupyterlab_classic/__init__.py rename to retrolab/__init__.py index eb442917..8494ba1f 100644 --- a/jupyterlab_classic/__init__.py +++ b/retrolab/__init__.py @@ -1,22 +1,22 @@ from ._version import __version__ -from .app import ClassicApp +from .app import RetroApp from .serverextension import load_jupyter_server_extension def _jupyter_server_extension_paths(): return [ { - 'module': 'jupyterlab_classic' + 'module': 'retrolab' } ] def _jupyter_server_extension_points(): - return [{"module": "jupyterlab_classic", "app": ClassicApp}] + return [{"module": "retrolab", "app": RetroApp}] def _jupyter_labextension_paths(): return [{ 'src': 'labextension', - 'dest': '@jupyterlab-classic/lab-extension' + 'dest': '@retrolab/lab-extension' }] \ No newline at end of file diff --git a/retrolab/__main__.py b/retrolab/__main__.py new file mode 100644 index 00000000..4368415c --- /dev/null +++ b/retrolab/__main__.py @@ -0,0 +1,5 @@ +import sys + +from retrolab.app import main + +sys.exit(main()) diff --git a/jupyterlab_classic/_version.py b/retrolab/_version.py similarity index 100% rename from jupyterlab_classic/_version.py rename to retrolab/_version.py diff --git a/jupyterlab_classic/app.py b/retrolab/app.py similarity index 80% rename from jupyterlab_classic/app.py rename to retrolab/app.py index 676698a0..35f44d7d 100644 --- a/jupyterlab_classic/app.py +++ b/retrolab/app.py @@ -22,7 +22,7 @@ version = __version__ -class ClassicHandler(ExtensionHandlerJinjaMixin, ExtensionHandlerMixin, JupyterHandler): +class RetroHandler(ExtensionHandlerJinjaMixin, ExtensionHandlerMixin, JupyterHandler): def get_page_config(self): config = LabConfig() app = self.extensionapp @@ -34,7 +34,7 @@ def get_page_config(self): "terminalsAvailable": self.settings.get('terminals_available', False), "token": self.settings["token"], "fullStaticUrl": ujoin(self.base_url, "static", self.name), - "frontendUrl": ujoin(self.base_url, "classic/"), + "frontendUrl": ujoin(self.base_url, "retro/"), } mathjax_config = self.settings.get("mathjax_config", "TeX-AMS_HTML-full,Safe") @@ -72,42 +72,42 @@ def get_page_config(self): return page_config -class ClassicTreeHandler(ClassicHandler): +class RetroTreeHandler(RetroHandler): @web.authenticated def get(self, path=None): tpl = self.render_template("tree.html", page_config=self.get_page_config()) return self.write(tpl) -class ClassicTerminalHandler(ClassicHandler): +class RetroTerminalHandler(RetroHandler): @web.authenticated def get(self, path=None): tpl = self.render_template("terminals.html", page_config=self.get_page_config()) return self.write(tpl) -class ClassicFileHandler(ClassicHandler): +class RetroFileHandler(RetroHandler): @web.authenticated def get(self, path=None): tpl = self.render_template("edit.html", page_config=self.get_page_config()) return self.write(tpl) -class ClassicNotebookHandler(ClassicHandler): +class RetroNotebookHandler(RetroHandler): @web.authenticated def get(self, path=None): tpl = self.render_template("notebooks.html", page_config=self.get_page_config()) return self.write(tpl) -class ClassicApp(NBClassicConfigShimMixin, LabServerApp): - name = "classic" - app_name = "JupyterLab Classic" - description = "JupyterLab Classic - A JupyterLab Distribution with the Classic Notebook look and feel" +class RetroApp(NBClassicConfigShimMixin, LabServerApp): + name = "retro" + app_name = "RetroLab" + description = "RetroLab - A JupyterLab Distribution with a retro look and feel" app_version = version - extension_url = "/classic" - default_url = "/classic/tree" - file_url_prefix = "/classic/notebooks" + extension_url = "/retro" + default_url = "/retro/tree" + file_url_prefix = "/retro/notebooks" load_other_extensions = True app_dir = app_dir app_settings_dir = pjoin(app_dir, "settings") @@ -122,13 +122,13 @@ def initialize_handlers(self): ( rf"/{self.file_url_prefix}/((?!.*\.ipynb($|\?)).*)", web.RedirectHandler, - {"url": "/classic/edit/{0}"} + {"url": "/retro/edit/{0}"} ) ) - self.handlers.append(("/classic/tree(.*)", ClassicTreeHandler)) - self.handlers.append(("/classic/notebooks(.*)", ClassicNotebookHandler)) - self.handlers.append(("/classic/edit(.*)", ClassicFileHandler)) - self.handlers.append(("/classic/terminals/(.*)", ClassicTerminalHandler)) + self.handlers.append(("/retro/tree(.*)", RetroTreeHandler)) + self.handlers.append(("/retro/notebooks(.*)", RetroNotebookHandler)) + self.handlers.append(("/retro/edit(.*)", RetroFileHandler)) + self.handlers.append(("/retro/terminals/(.*)", RetroTerminalHandler)) super().initialize_handlers() def initialize_templates(self): @@ -146,7 +146,7 @@ def initialize(self, argv=None): super().initialize() -main = launch_new_instance = ClassicApp.launch_instance +main = launch_new_instance = RetroApp.launch_instance if __name__ == "__main__": main() diff --git a/jupyterlab_classic/serverextension.py b/retrolab/serverextension.py similarity index 81% rename from jupyterlab_classic/serverextension.py rename to retrolab/serverextension.py index 706e875a..e3a0be62 100644 --- a/jupyterlab_classic/serverextension.py +++ b/retrolab/serverextension.py @@ -1,8 +1,8 @@ -from .app import ClassicApp +from .app import RetroApp def load_jupyter_server_extension(serverapp): - extension = ClassicApp() + extension = RetroApp() extension.serverapp = serverapp extension.load_config_file() extension.update_config(serverapp.config) diff --git a/jupyterlab_classic/templates/edit.html b/retrolab/templates/edit.html similarity index 95% rename from jupyterlab_classic/templates/edit.html rename to retrolab/templates/edit.html index f680c020..3fca9895 100644 --- a/jupyterlab_classic/templates/edit.html +++ b/retrolab/templates/edit.html @@ -17,7 +17,7 @@ {% set _ = page_config_full.update(baseUrl=base_url, wsUrl=ws_url) %} {# Sentinel value to say that we are on the tree page #} - {% set _ = page_config_full.update(classicPage='edit') %} + {% set _ = page_config_full.update(retroPage='edit') %}
Name