Extension System

/**
 * An interface for using a RenderMime.IRenderer for output and read-only documents
 */
interface IExtension {
  /**
   * The ID of the extension.
   * The convention for extension IDs in JupyterLab is the full NPM package
   * name followed by a colon and a unique string token, e.g.
   * '@jupyterlab/apputils-extension:settings' or 'foo-extension:bar'.
   */
  readonly id: string;
  /**
   * Extension description.
   * This can be used to provide user documentation on the feature
   * brought by the extension.
   */
  readonly description?: string;
  /** A renderer factory to be registered to render the MIME type */
  readonly rendererFactory: IRendererFactory;
  /**
   * The rank passed to `RenderMime.addFactory`. If not given,
   * defaults to the `defaultRank` of the factory.
   */
  readonly rank?: number;
  /** The timeout after user activity to re-render the data */
  readonly renderTimeout?: number;
  /** Preferred data type from the model. Defaults to `string`. */
  readonly dataType?: 'string' | 'json';
  /** The options used to open a document with the renderer factory */
  readonly documentWidgetFactoryOptions?: IDocumentWidgetFactoryOptions | ReadonlyArray<IDocumentWidgetFactoryOptions>;
  /** The optional file type associated with the extension */
  readonly fileTypes?: ReadonlyArray<IFileType>;
}

import { IRenderMime } from "@jupyterlab/rendermime-interfaces";

// Complete extension definition
const customExtension: IRenderMime.IExtension = {
  id: '@my-org/custom-renderer:main',
  description: 'Custom renderer for specialized data formats',
  
  rendererFactory: new CustomRendererFactory(),
  rank: 50,
  renderTimeout: 1000,
  dataType: 'json',
  
  // Enable document rendering
  documentWidgetFactoryOptions: {
    name: 'Custom Format Viewer',
    label: 'Custom Viewer',
    primaryFileType: 'custom-format',
    fileTypes: ['custom-format', 'custom-alt'],
    defaultFor: ['custom-format']
  },
  
  // Associate file types
  fileTypes: [
    {
      name: 'custom-format',
      mimeTypes: ['application/my-custom-type'],
      extensions: ['.cust', '.custom'],
      displayName: 'Custom Format File',
      icon: 'custom-icon'
    }
  ]
};

// Register extension
renderMime.addFactory(
  customExtension.rendererFactory,
  customExtension.rank || customExtension.rendererFactory.defaultRank || 100
);

/**
 * The interface for a module that exports an extension or extensions as
 * the default value
 */
interface IExtensionModule {
  /** The default export - can be a single extension or array of extensions */
  readonly default: IExtension | ReadonlyArray<IExtension>;
}

import { IRenderMime } from "@jupyterlab/rendermime-interfaces";

// Single extension module
const singleExtensionModule: IRenderMime.IExtensionModule = {
  default: {
    id: '@my-org/single-renderer:main',
    rendererFactory: new MyRendererFactory(),
    // ... other extension properties
  }
};

// Multiple extensions module
const multipleExtensionsModule: IRenderMime.IExtensionModule = {
  default: [
    {
      id: '@my-org/multi-renderer:text',
      rendererFactory: new TextRendererFactory(),
      rank: 100
    },
    {
      id: '@my-org/multi-renderer:image',
      rendererFactory: new ImageRendererFactory(),
      rank: 90
    }
  ]
};

// Loading extensions from module
function loadExtensions(module: IRenderMime.IExtensionModule): void {
  const extensions = Array.isArray(module.default) ? module.default : [module.default];
  
  extensions.forEach(extension => {
    renderMime.addFactory(
      extension.rendererFactory,
      extension.rank || extension.rendererFactory.defaultRank || 100
    );
  });
}

import { IRenderMime } from "@jupyterlab/rendermime-interfaces";

// Simple extension for output rendering only
const outputExtension: IRenderMime.IExtension = {
  id: 'my-package:output-renderer',
  rendererFactory: new MyOutputRendererFactory(),
  rank: 100,
  dataType: 'string'
};

// Extension with document rendering capabilities
const documentExtension: IRenderMime.IExtension = {
  id: 'my-package:document-renderer',
  description: 'Renders custom documents in JupyterLab',
  rendererFactory: new MyDocumentRendererFactory(),
  
  documentWidgetFactoryOptions: {
    name: 'My Document Viewer',
    primaryFileType: 'my-doc-type',
    fileTypes: ['my-doc-type'],
    defaultFor: ['my-doc-type'],
    
    // Custom toolbar
    toolbarFactory: (widget) => [
      {
        name: 'refresh',
        widget: createRefreshButton()
      }
    ]
  },
  
  fileTypes: [
    {
      name: 'my-doc-type',
      mimeTypes: ['application/my-document'],
      extensions: ['.mydoc'],
      displayName: 'My Document',
      fileFormat: 'text'
    }
  ]
};

interface IRendererFactory {
  readonly safe: boolean;
  readonly mimeTypes: ReadonlyArray<string>;
  readonly defaultRank?: number;
  createRenderer(options: IRendererOptions): IRenderer;
}

interface IDocumentWidgetFactoryOptions {
  readonly name: string;
  readonly label?: string;
  readonly modelName?: string;
  readonly primaryFileType: string;
  readonly fileTypes: ReadonlyArray<string>;
  readonly defaultFor?: ReadonlyArray<string>;
  readonly defaultRendered?: ReadonlyArray<string>;
  readonly translator?: ITranslator;
  readonly toolbarFactory?: (widget?: Widget) => IToolbarItem[];
}

interface IFileType {
  readonly name: string;
  readonly mimeTypes: ReadonlyArray<string>;
  readonly extensions: ReadonlyArray<string>;
  readonly displayName?: string;
  readonly pattern?: string;
  readonly icon?: LabIcon.IResolvable;
  readonly iconClass?: string;
  readonly iconLabel?: string;
  readonly fileFormat?: string | null;
}