jupyterlab_tabular_data_viewer_extension 1.1.20

package/package.json

@@ -0,0 +1,217 @@
+{
+    "name": "jupyterlab_tabular_data_viewer_extension",
+    "version": "1.1.20",
+    "description": "Jupyterlab extension to browse tabular data files (Parquet, Excel, CSV, TSV) with filtering and sorting capabilities",
+    "keywords": [
+        "jupyter",
+        "jupyterlab",
+        "jupyterlab-extension",
+        "parquet",
+        "excel",
+        "csv",
+        "tsv",
+        "tabular-data"
+    ],
+    "homepage": "https://github.com/stellarshenson/jupyterlab_tabular_data_viewer_extension",
+    "bugs": {
+        "url": "https://github.com/stellarshenson/jupyterlab_tabular_data_viewer_extension/issues"
+    },
+    "license": "BSD-3-Clause",
+    "author": {
+        "name": "Stellars Henson",
+        "email": "konrad.jelen@gmail.com"
+    },
+    "files": [
+        "lib/**/*.{d.ts,eot,gif,html,jpg,js,js.map,json,png,svg,woff2,ttf}",
+        "style/**/*.{css,js,eot,gif,html,jpg,json,png,svg,woff2,ttf}",
+        "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/stellarshenson/jupyterlab_tabular_data_viewer_extension.git"
+    },
+    "scripts": {
+        "build": "jlpm build:lib && jlpm build:labextension:dev",
+        "build:prod": "jlpm clean && jlpm build:lib:prod && jlpm build:labextension",
+        "build:labextension": "jupyter labextension build .",
+        "build:labextension:dev": "jupyter labextension build --development True .",
+        "build:lib": "tsc --sourceMap",
+        "build:lib:prod": "tsc",
+        "clean": "jlpm clean:lib",
+        "clean:lib": "rimraf lib tsconfig.tsbuildinfo",
+        "clean:lintcache": "rimraf .eslintcache .stylelintcache",
+        "clean:labextension": "rimraf jupyterlab_tabular_data_viewer_extension/labextension jupyterlab_tabular_data_viewer_extension/_version.py",
+        "clean:all": "jlpm clean:lib && jlpm clean:labextension && jlpm clean:lintcache",
+        "eslint": "jlpm eslint:check --fix",
+        "eslint:check": "eslint . --cache --ext .ts,.tsx",
+        "install:extension": "jlpm build",
+        "lint": "jlpm stylelint && jlpm prettier && jlpm eslint",
+        "lint:check": "jlpm stylelint:check && jlpm prettier:check && jlpm eslint:check",
+        "prettier": "jlpm prettier:base --write --list-different",
+        "prettier:base": "prettier \"**/*{.ts,.tsx,.js,.jsx,.css,.json,.md}\"",
+        "prettier:check": "jlpm prettier:base --check",
+        "stylelint": "jlpm stylelint:check --fix",
+        "stylelint:check": "stylelint --cache \"style/**/*.css\"",
+        "test": "jest --coverage",
+        "watch": "run-p watch:src watch:labextension",
+        "watch:src": "tsc -w --sourceMap",
+        "watch:labextension": "jupyter labextension watch ."
+    },
+    "dependencies": {
+        "@jupyterlab/application": "^4.0.0",
+        "@jupyterlab/apputils": "^4.0.0",
+        "@jupyterlab/coreutils": "^6.0.0",
+        "@jupyterlab/docregistry": "^4.0.0",
+        "@jupyterlab/services": "^7.0.0",
+        "@lumino/widgets": "^2.0.0",
+        "rimraf": "^6.1.0"
+    },
+    "devDependencies": {
+        "@jupyterlab/builder": "^4.0.0",
+        "@jupyterlab/testutils": "^4.0.0",
+        "@types/jest": "^29.2.0",
+        "@types/json-schema": "^7.0.11",
+        "@types/react": "^18.0.26",
+        "@types/react-addons-linked-state-mixin": "^0.14.22",
+        "@typescript-eslint/eslint-plugin": "^6.1.0",
+        "@typescript-eslint/parser": "^6.1.0",
+        "css-loader": "^6.7.1",
+        "eslint": "^8.36.0",
+        "eslint-config-prettier": "^8.8.0",
+        "eslint-plugin-prettier": "^5.0.0",
+        "jest": "^29.2.0",
+        "mkdirp": "^1.0.3",
+        "npm-run-all2": "^7.0.1",
+        "prettier": "^3.0.0",
+        "source-map-loader": "^1.0.2",
+        "style-loader": "^3.3.1",
+        "stylelint": "^15.10.1",
+        "stylelint-config-recommended": "^13.0.0",
+        "stylelint-config-standard": "^34.0.0",
+        "stylelint-csstree-validator": "^3.0.0",
+        "stylelint-prettier": "^4.0.0",
+        "typescript": "~5.8.0",
+        "yjs": "^13.5.0"
+    },
+    "sideEffects": [
+        "style/*.css",
+        "style/index.js"
+    ],
+    "styleModule": "style/index.js",
+    "publishConfig": {
+        "access": "public"
+    },
+    "jupyterlab": {
+        "discovery": {
+            "server": {
+                "managers": [
+                    "pip"
+                ],
+                "base": {
+                    "name": "jupyterlab_tabular_data_viewer_extension"
+                }
+            }
+        },
+        "extension": true,
+        "outputDir": "jupyterlab_tabular_data_viewer_extension/labextension",
+        "schemaDir": "schema"
+    },
+    "eslintIgnore": [
+        "node_modules",
+        "dist",
+        "coverage",
+        "**/*.d.ts",
+        "tests",
+        "**/__tests__",
+        "ui-tests"
+    ],
+    "eslintConfig": {
+        "extends": [
+            "eslint:recommended",
+            "plugin:@typescript-eslint/eslint-recommended",
+            "plugin:@typescript-eslint/recommended",
+            "plugin:prettier/recommended"
+        ],
+        "parser": "@typescript-eslint/parser",
+        "parserOptions": {
+            "project": "tsconfig.json",
+            "sourceType": "module"
+        },
+        "plugins": [
+            "@typescript-eslint"
+        ],
+        "rules": {
+            "@typescript-eslint/naming-convention": [
+                "error",
+                {
+                    "selector": "interface",
+                    "format": [
+                        "PascalCase"
+                    ],
+                    "custom": {
+                        "regex": "^I[A-Z]",
+                        "match": true
+                    }
+                }
+            ],
+            "@typescript-eslint/no-unused-vars": [
+                "warn",
+                {
+                    "args": "none"
+                }
+            ],
+            "@typescript-eslint/no-explicit-any": "off",
+            "@typescript-eslint/no-namespace": "off",
+            "@typescript-eslint/no-use-before-define": "off",
+            "@typescript-eslint/quotes": [
+                "error",
+                "single",
+                {
+                    "avoidEscape": true,
+                    "allowTemplateLiterals": false
+                }
+            ],
+            "curly": [
+                "error",
+                "all"
+            ],
+            "eqeqeq": "error",
+            "prefer-arrow-callback": "error"
+        }
+    },
+    "prettier": {
+        "singleQuote": true,
+        "trailingComma": "none",
+        "arrowParens": "avoid",
+        "endOfLine": "auto",
+        "overrides": [
+            {
+                "files": "package.json",
+                "options": {
+                    "tabWidth": 4
+                }
+            }
+        ]
+    },
+    "stylelint": {
+        "extends": [
+            "stylelint-config-recommended",
+            "stylelint-config-standard",
+            "stylelint-prettier/recommended"
+        ],
+        "plugins": [
+            "stylelint-csstree-validator"
+        ],
+        "rules": {
+            "csstree/validator": true,
+            "property-no-vendor-prefix": null,
+            "selector-class-pattern": "^([a-z][A-z\\d]*)(-[A-z\\d]+)*$",
+            "selector-no-vendor-prefix": null,
+            "value-no-vendor-prefix": null
+        }
+    }
+}

package/schema/plugin.json

@@ -0,0 +1,32 @@
+{
+  "title": "Tabular Data Viewer Extension",
+  "description": "Settings for the Tabular Data Viewer Extension. Supports Parquet, Excel, CSV, and TSV files.",
+  "type": "object",
+  "properties": {
+    "enableParquet": {
+      "title": "Enable Parquet files",
+      "description": "Use this extension to view .parquet files",
+      "type": "boolean",
+      "default": true
+    },
+    "enableExcel": {
+      "title": "Enable Excel files",
+      "description": "Use this extension to view .xlsx files",
+      "type": "boolean",
+      "default": true
+    },
+    "enableCSV": {
+      "title": "Enable CSV files",
+      "description": "Use this extension to view .csv files",
+      "type": "boolean",
+      "default": true
+    },
+    "enableTSV": {
+      "title": "Enable TSV files",
+      "description": "Use this extension to view .tsv files",
+      "type": "boolean",
+      "default": true
+    }
+  },
+  "additionalProperties": false
+}

package/src/__tests__/jupyterlab_tabular_data_viewer_extension.spec.ts

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

package/src/document.ts

@@ -0,0 +1,11 @@
+import { DocumentWidget } from '@jupyterlab/docregistry';
+import { TabularDataViewer } from './widget';
+
+/**
+ * A document widget for tabular data files (Parquet, Excel)
+ */
+export class TabularDataDocument extends DocumentWidget<TabularDataViewer> {
+  constructor(options: DocumentWidget.IOptions<TabularDataViewer>) {
+    super(options);
+  }
+}

package/src/index.ts

@@ -0,0 +1,276 @@
+import {
+  JupyterFrontEnd,
+  JupyterFrontEndPlugin
+} from '@jupyterlab/application';
+
+import {
+  IDocumentWidget,
+  DocumentRegistry,
+  ABCWidgetFactory
+} from '@jupyterlab/docregistry';
+
+import { ISettingRegistry } from '@jupyterlab/settingregistry';
+
+import { TabularDataViewer } from './widget';
+import { TabularDataDocument } from './document';
+
+/**
+ * A widget factory for Parquet files
+ */
+class TabularDataWidgetFactory extends ABCWidgetFactory<
+  IDocumentWidget<TabularDataViewer>
+> {
+  private _setLastContextMenuRow: (row: any) => void;
+  private _setActiveWidget: (widget: TabularDataViewer) => void;
+
+  constructor(
+    options: DocumentRegistry.IWidgetFactoryOptions,
+    setLastContextMenuRow: (row: any) => void,
+    setActiveWidget: (widget: TabularDataViewer) => void
+  ) {
+    super(options);
+    this._setLastContextMenuRow = setLastContextMenuRow;
+    this._setActiveWidget = setActiveWidget;
+  }
+
+  /**
+   * Create a new widget given a context
+   */
+  protected createNewWidget(
+    context: DocumentRegistry.Context
+  ): IDocumentWidget<TabularDataViewer> {
+    // console.log(`[Tabular Data Viewer] Creating widget for file: ${context.path}`);
+    // console.log(`[Tabular Data Viewer] File type: ${context.contentsModel?.type}, Format: ${context.contentsModel?.format}`);
+
+    const content = new TabularDataViewer(context.path, this._setLastContextMenuRow);
+    const widget = new TabularDataDocument({ content, context });
+    widget.title.label = context.path.split('/').pop() || 'Tabular Data File';
+
+    // Track this as the active widget when context menu is used
+    this._setActiveWidget(content);
+
+    return widget;
+  }
+}
+
+/**
+ * Settings interface
+ */
+interface ISettings {
+  enableParquet: boolean;
+  enableExcel: boolean;
+  enableCSV: boolean;
+  enableTSV: boolean;
+}
+
+/**
+ * Initialization data for the jupyterlab_tabular_data_viewer_extension extension.
+ */
+const plugin: JupyterFrontEndPlugin<void> = {
+  id: 'jupyterlab_tabular_data_viewer_extension:plugin',
+  description:
+    'Jupyterlab extension to allow simple browsing of tabular data files (Parquet, Excel) with filtering and sorting capabilities',
+  autoStart: true,
+  requires: [ISettingRegistry],
+  activate: async (app: JupyterFrontEnd, settingRegistry: ISettingRegistry) => {
+    // console.log(
+    //   'JupyterLab extension jupyterlab_tabular_data_viewer_extension is activated!'
+    // );
+
+    const { docRegistry, commands, contextMenu } = app;
+
+    // Track last right-clicked row for context menu
+    let lastContextMenuRow: any = null;
+    let activeWidget: TabularDataViewer | null = null;
+
+    // Load settings
+    let settings: ISettings = {
+      enableParquet: true,
+      enableExcel: true,
+      enableCSV: true,
+      enableTSV: true
+    };
+
+    // console.log('[Tabular Data Viewer] Default settings:', settings);
+
+    try {
+      // console.log('[Tabular Data Viewer] Loading settings from registry with id:', plugin.id);
+      const pluginSettings = await settingRegistry.load(plugin.id);
+      settings = pluginSettings.composite as unknown as ISettings;
+      // console.log('[Tabular Data Viewer] Loaded settings:', settings);
+      // console.log('[Tabular Data Viewer] Settings detail - enableParquet:', settings.enableParquet, 'enableExcel:', settings.enableExcel);
+
+      // Watch for settings changes
+      pluginSettings.changed.connect(() => {
+        settings = pluginSettings.composite as unknown as ISettings;
+        // console.log('[Tabular Data Viewer] Settings changed:', settings);
+      });
+    } catch (error) {
+      console.error('[Tabular Data Viewer] Failed to load settings:', error);
+      // console.log('[Tabular Data Viewer] Using default settings:', settings);
+    }
+
+    // Command to copy row as JSON
+    const copyRowCommand = 'tabular-data-viewer:copy-row-json';
+    commands.addCommand(copyRowCommand, {
+      label: 'Copy Row as JSON',
+      caption: 'Copy the row data as JSON to clipboard',
+      isEnabled: () => {
+        return lastContextMenuRow !== null;
+      },
+      execute: async () => {
+        if (lastContextMenuRow) {
+          const jsonString = JSON.stringify(lastContextMenuRow, null, 2);
+          await navigator.clipboard.writeText(jsonString);
+          // console.log('Row copied to clipboard as JSON');
+
+          // Clean up highlight after copy
+          if (activeWidget) {
+            activeWidget.getCleanupHighlight()();
+          }
+        }
+      }
+    });
+
+    // Add to context menu for tabular data viewer rows
+    contextMenu.addItem({
+      command: copyRowCommand,
+      selector: '.jp-TabularDataViewer-row',
+      rank: 10
+    });
+
+    // Register file types based on settings
+    // console.log('[Tabular Data Viewer] Starting file type registration...');
+    // console.log('[Tabular Data Viewer] Current settings state:', settings);
+    const binaryFileTypes: string[] = [];
+    const textFileTypes: string[] = [];
+
+    // Register Parquet file type if enabled
+    if (settings.enableParquet) {
+      try {
+        docRegistry.addFileType({
+          name: 'parquet',
+          displayName: 'Parquet',
+          extensions: ['.parquet'],
+          mimeTypes: ['application/x-parquet'],
+          iconClass: 'jp-MaterialIcon jp-SpreadsheetIcon',
+          contentType: 'file',
+          fileFormat: 'base64'
+        });
+        binaryFileTypes.push('parquet');
+        // console.log('[Tabular Data Viewer] Parquet file type registered');
+      } catch (e) {
+        console.warn('[Tabular Data Viewer] Parquet file type already registered', e);
+      }
+    }
+
+    // Register Excel file type if enabled
+    if (settings.enableExcel) {
+      try {
+        docRegistry.addFileType({
+          name: 'xlsx-parquet-viewer',
+          displayName: 'Excel (Parquet Viewer)',
+          extensions: ['.xlsx'],
+          mimeTypes: ['application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'],
+          iconClass: 'jp-MaterialIcon jp-SpreadsheetIcon',
+          contentType: 'file',
+          fileFormat: 'base64'
+        });
+        binaryFileTypes.push('xlsx-parquet-viewer');
+        // console.log('[Tabular Data Viewer] Excel file type registered');
+      } catch (e) {
+        console.warn('[Tabular Data Viewer] Excel file type already registered', e);
+      }
+    }
+
+    // Register CSV file type if enabled
+    if (settings.enableCSV) {
+      try {
+        docRegistry.addFileType({
+          name: 'csv-tabular-viewer',
+          displayName: 'CSV (Tabular Viewer)',
+          extensions: ['.csv'],
+          mimeTypes: ['text/csv'],
+          iconClass: 'jp-MaterialIcon jp-SpreadsheetIcon',
+          contentType: 'file',
+          fileFormat: 'text'
+        });
+        textFileTypes.push('csv-tabular-viewer');
+        // console.log('[Tabular Data Viewer] CSV file type registered');
+      } catch (e) {
+        console.warn('[Tabular Data Viewer] CSV file type already registered', e);
+      }
+    }
+
+    // Register TSV file type if enabled
+    if (settings.enableTSV) {
+      try {
+        docRegistry.addFileType({
+          name: 'tsv-tabular-viewer',
+          displayName: 'TSV (Tabular Viewer)',
+          extensions: ['.tsv'],
+          mimeTypes: ['text/tab-separated-values'],
+          iconClass: 'jp-MaterialIcon jp-SpreadsheetIcon',
+          contentType: 'file',
+          fileFormat: 'text'
+        });
+        textFileTypes.push('tsv-tabular-viewer');
+        // console.log('[Tabular Data Viewer] TSV file type registered');
+      } catch (e) {
+        console.warn('[Tabular Data Viewer] TSV file type already registered', e);
+      }
+    }
+
+    // Create binary factory for Parquet and Excel files
+    if (binaryFileTypes.length > 0) {
+      const binaryFactory = new TabularDataWidgetFactory(
+        {
+          name: 'Tabular Data Viewer (Binary)',
+          modelName: 'base64',
+          fileTypes: binaryFileTypes,
+          defaultFor: binaryFileTypes,
+          defaultRendered: binaryFileTypes,
+          readOnly: true
+        },
+        (row: any) => {
+          lastContextMenuRow = row;
+        },
+        (widget: TabularDataViewer) => {
+          activeWidget = widget;
+        }
+      );
+
+      docRegistry.addWidgetFactory(binaryFactory);
+      // console.log(`[Tabular Data Viewer] Binary factory registered for: ${binaryFileTypes.join(', ')}`);
+    }
+
+    // Create text factory for CSV and TSV files
+    if (textFileTypes.length > 0) {
+      const textFactory = new TabularDataWidgetFactory(
+        {
+          name: 'Tabular Data Viewer (Text)',
+          modelName: 'text',
+          fileTypes: textFileTypes,
+          defaultFor: textFileTypes,
+          defaultRendered: textFileTypes,
+          readOnly: true
+        },
+        (row: any) => {
+          lastContextMenuRow = row;
+        },
+        (widget: TabularDataViewer) => {
+          activeWidget = widget;
+        }
+      );
+
+      docRegistry.addWidgetFactory(textFactory);
+      // console.log(`[Tabular Data Viewer] Text factory registered for: ${textFileTypes.join(', ')}`);
+    }
+
+    if (binaryFileTypes.length === 0 && textFileTypes.length === 0) {
+      console.warn('[Tabular Data Viewer] No file types enabled in settings');
+    }
+  }
+};
+
+export default plugin;

package/src/request.ts

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