@difizen/libro-widget 0.1.33 → 0.1.34

package/src/base/libro-widgets.ts

@@ -1,207 +0,0 @@
-import type { JSONObject } from '@difizen/libro-common';
-import type { IKernelConnection, KernelMessage } from '@difizen/libro-kernel';
-import type { Contribution } from '@difizen/mana-app';
-import { contrib, inject, Priority, prop, transient } from '@difizen/mana-app';
-import { Emitter } from '@difizen/mana-app';
-
-import type { Comm } from './comm.js';
-import type {
-  ISerializedState,
-  IWidgets,
-  IWidgetViewOptions,
-  IClassicComm,
-  WidgetCommOption,
-} from './protocal.js';
-import {
-  LibroWidgetCommFactory,
-  WidgetsOption,
-  WidgetViewContribution,
-} from './protocal.js';
-import { put_buffers, reject } from './utils.js';
-import { PROTOCOL_VERSION } from './version.js';
-import type { WidgetView } from './widget-view.js';
-
-const PROTOCOL_MAJOR_VERSION = PROTOCOL_VERSION.split('.', 1)[0];
-
-@transient()
-export class LibroWidgets implements IWidgets {
-  @contrib(WidgetViewContribution)
-  WidgetViewProvider: Contribution.Provider<WidgetViewContribution>;
-  widgetEmitter: Emitter<{ WidgetViewName: string }> = new Emitter();
-  widgetCommFactory: (options: WidgetCommOption) => Comm;
-  kernelConnection: IKernelConnection;
-
-  constructor(
-    @inject(WidgetsOption) options: WidgetsOption,
-    @inject(LibroWidgetCommFactory)
-    widgetCommFactory: (options: WidgetCommOption) => Comm,
-  ) {
-    this.kernelConnection = options.kc;
-    this.id = options.id;
-    this.widgetCommFactory = widgetCommFactory;
-    this.kernelConnection.registerCommTarget(this.commTargetName, async (comm, msg) => {
-      const widgetComm = this.widgetCommFactory({ comm });
-      await this.handleCommOpen(widgetComm, msg);
-    });
-  }
-  get onWidgetRender() {
-    return this.widgetEmitter.event;
-  }
-
-  protected findProvider(attributes: any): WidgetViewContribution {
-    const prioritized = Priority.sortSync(
-      this.WidgetViewProvider.getContributions(),
-      (contribution) => contribution.canHandle(attributes),
-    );
-    const sorted = prioritized.map((c) => c.value);
-    return sorted[0]!;
-  }
-
-  /**
-   * Create a comm which can be used for communication for a widget.
-   *
-   * If the data/metadata is passed in, open the comm before returning (i.e.,
-   * send the comm_open message). If the data and metadata is undefined, we
-   * want to reconstruct a comm that already exists in the kernel, so do not
-   * open the comm by sending the comm_open message.
-   *
-   * @param comm_target_name Comm target name
-   * @param model_id The comm id
-   * @param data The initial data for the comm
-   * @param metadata The metadata in the open message
-   */
-  async createComm(
-    comm_target_name: string,
-    model_id?: string,
-    data?: JSONObject,
-    metadata?: JSONObject,
-    buffers?: ArrayBuffer[] | ArrayBufferView[],
-  ): Promise<IClassicComm> {
-    const kernel = this.kernelConnection;
-    if (!kernel) {
-      throw new Error('No current kernel');
-    }
-    const comm = kernel.createComm(comm_target_name, model_id);
-    if (data || metadata) {
-      comm.open(data, metadata, buffers);
-    }
-    return this.widgetCommFactory({ comm });
-  }
-
-  /**
-   * Get a model by model id.
-   *
-   * #### Notes
-   * If the model is not found, throw error.
-   *
-   * If you would like to synchronously test if a model exists, use .hasModel().
-   */
-  getModel(model_id: string): WidgetView {
-    const model = this.models.get(model_id);
-    if (model === undefined) {
-      throw new Error('widget model not found');
-    }
-    return model;
-  }
-
-  /**
-   * Returns true if the given model is registered, otherwise false.
-   *
-   * #### Notes
-   * This is a synchronous way to check if a model is registered.
-   */
-  hasModel(model_id: string): boolean {
-    return this.models.get(model_id) !== undefined;
-  }
-
-  /**
-   * Handle when a comm is opened.
-   */
-  async handleCommOpen(
-    comm: IClassicComm,
-    msg: KernelMessage.ICommOpenMsg,
-  ): Promise<WidgetView> {
-    const protocolVersion = ((msg.metadata || {})['version'] as string) || '';
-    if (protocolVersion.split('.', 1)[0] !== PROTOCOL_MAJOR_VERSION) {
-      const error = `Wrong widget protocol version: received protocol version '${protocolVersion}', but was expecting major version '${PROTOCOL_MAJOR_VERSION}'`;
-      console.error(error);
-      return Promise.reject(error);
-    }
-    const data = msg.content.data as unknown as ISerializedState;
-    const buffer_paths = data.buffer_paths || [];
-    const buffers = msg.buffers || [];
-    put_buffers(data.state, buffer_paths, buffers);
-    // this.createComm(msg.content.target_name, msg.content.comm_id, msg.content.data, msg.metadata);
-    return this.newWidgetView(data.state, {
-      model_id: msg.content.comm_id,
-      comm,
-    }).catch(reject('Could not create a model.', true));
-  }
-
-  registerWidgetView(model_id: string, model: Promise<WidgetView>): void {
-    model
-      .then((WidgetView) => {
-        this.models.set(model_id, WidgetView);
-        this.widgetEmitter.fire({ WidgetViewName: WidgetView.model_name });
-        return;
-      })
-      .catch(() => {
-        //
-      });
-  }
-
-  handleCommClose(msg: KernelMessage.ICommCloseMsg) {
-    const comm_id = msg.content.comm_id;
-    const model = this.getModel(comm_id);
-    model.isCommClosed = true;
-  }
-
-  unregisterWidgetView(model_id: string): void {
-    const model = this.models.get(model_id);
-    model?.dispose();
-    this.models.delete(model_id);
-  }
-
-  async newWidgetView(
-    attributes: any,
-    options: IWidgetViewOptions,
-  ): Promise<WidgetView> {
-    const model_id = options.model_id;
-    if (!model_id) {
-      throw new Error(
-        'Neither comm nor model_id provided in options object. At least one must exist.',
-      );
-    }
-    options.model_id = model_id;
-    const provider = this.findProvider(attributes);
-    const WidgetView = provider.factory({ attributes: attributes, options: options });
-    this.registerWidgetView(model_id, WidgetView);
-    return WidgetView;
-  }
-
-  /**
-   * Close all widgets and empty the widget state.
-   * @return Promise that resolves when the widget state is cleared.
-   */
-  clearState() {
-    this.models.clear();
-  }
-  /**
-   * Disconnect the widget manager from the kernel, setting each model's comm
-   * as dead.
-   */
-  disconnect(): void {
-    // this.models.forEach(model => model.clear());
-  }
-  /**
-   * Dictionary of model ids and model instance promises
-   */
-  @prop()
-  protected models: Map<string, WidgetView> = new Map();
-
-  /**
-   * The comm target name to register
-   */
-  id: string;
-  readonly commTargetName = 'jupyter.widget';
-}

package/src/base/protocal.ts

@@ -1,218 +0,0 @@
-import type { JSONObject, JSONValue } from '@difizen/libro-common';
-import type { IComm, IKernelConnection, KernelMessage } from '@difizen/libro-kernel';
-import { Syringe } from '@difizen/mana-app';
-
-import type { WidgetView } from './widget-view.js';
-
-export interface IWidgetViewOptions {
-  model_id: string;
-  comm: IClassicComm;
-}
-
-export interface IWidgetViewProps {
-  attributes: any;
-  options: IWidgetViewOptions;
-}
-
-/**
- * A simple dictionary type.
- */
-export type Dict<T> = Record<string, T>;
-
-export type BufferJSON =
-  | { [property: string]: BufferJSON }
-  | BufferJSON[]
-  | string
-  | number
-  | boolean
-  | null
-  | ArrayBuffer
-  | DataView;
-
-export interface ISerializedState {
-  state: JSONObject;
-  buffers: ArrayBuffer[];
-  buffer_paths: (string | number)[][];
-}
-
-/**
- * The widget manager interface exposed on the Widget instances
- */
-export interface IWidgets {
-  getModel: (model_id: string) => WidgetView;
-
-  /**
-   * Returns true if the given model is registered, otherwise false.
-   *
-   * #### Notes
-   * This is a synchronous way to check if a model is registered.
-   */
-  hasModel: (model_id: string) => boolean;
-
-  /**
-   * Register a model instance promise with the manager.
-   *
-   * By registering the model, it can later be retrieved with `getModel`.
-   */
-  registerWidgetView: (model_id: string, model: Promise<WidgetView>) => void;
-
-  newWidgetView: (attributes: any, options: IWidgetViewOptions) => Promise<WidgetView>;
-}
-
-export const LibroWidgetsFactory = Symbol('LibroWidgetsFactory');
-export type LibroWidgetsFactory = (options: WidgetsOption) => IWidgets;
-export const WidgetsOption = Symbol('WidgetsOption');
-export interface WidgetsOption {
-  kc: IKernelConnection;
-  id: string;
-}
-
-export interface IWidgetView {
-  initialize: (props: IWidgetViewProps) => void;
-  toJSON: () => string;
-  set_state: (state: Dict<unknown>) => void;
-  handleCommMsg: (msg: KernelMessage.ICommMsgMsg) => Promise<void>;
-  model_id: string;
-  name: string;
-  module: string;
-
-  model_module: string;
-  model_name: string;
-  model_module_version: string;
-  view_module: string;
-  view_name: string | null;
-  view_module_version: string;
-  view_count: number | null;
-}
-
-export const IWidgetView = Symbol('IWidgetView');
-export const WidgetViewContribution = Syringe.defineToken('WidgetViewContribution');
-export interface WidgetViewContribution {
-  canHandle: (attributes: any) => number;
-  factory: (props: IWidgetViewProps) => Promise<WidgetView>;
-}
-
-export interface InstanceRecord {
-  startDate: number;
-  endDate: number;
-}
-
-interface Stage {
-  name: string;
-  backup_workers: number;
-  terminated_workers: number;
-  running_workers: number;
-  total_workers: number;
-  input_records: number;
-  output_records: number;
-  finished_percentage: number;
-}
-
-export interface Task {
-  name: string;
-  status: 'WAITING' | 'RUNNING' | 'SUCCESS' | 'FAILED' | 'SUSPENDED' | 'CANCELLED';
-  stages: Stage[];
-}
-
-export interface ProgressInstance {
-  id: string;
-  status: 'Running' | 'Suspended' | 'Terminated';
-  logview: string;
-  tasks: Task[];
-}
-
-export interface ProgressItem {
-  name: string;
-  key: string;
-  gen_time: string;
-  logView: string;
-  instances?: ProgressInstance[];
-}
-
-export type InstancesRecords = Record<string, InstanceRecord>;
-
-/**
- * Callbacks for services shim comms.
- */
-export interface ICallbacks {
-  shell?: Record<string, (msg: KernelMessage.IShellMessage) => void>;
-  iopub?: Record<string, (msg: KernelMessage.IIOPubMessage) => void>;
-  input?: (msg: KernelMessage.IStdinMessage) => void;
-}
-
-export const LibroWidgetCommFactory = Symbol('LibroWidgetCommFactory');
-export type LibroWidgetCommFactory = (options: WidgetCommOption) => IClassicComm;
-export const WidgetCommOption = Symbol('WidgetCommOption');
-export interface WidgetCommOption {
-  comm: IComm;
-}
-export interface IClassicComm {
-  /**
-   * Comm id
-   * @return {string}
-   */
-  comm_id: string;
-
-  /**
-   * Target name
-   * @return {string}
-   */
-  target_name: string;
-
-  /**
-   * Opens a sibling comm in the backend
-   * @param  data
-   * @param  callbacks
-   * @param  metadata
-   * @param  buffers
-   * @return msg id
-   */
-  open(
-    data: JSONValue,
-    callbacks?: ICallbacks,
-    metadata?: JSONObject,
-    buffers?: ArrayBuffer[] | ArrayBufferView[],
-  ): string;
-
-  /**
-   * Sends a message to the sibling comm in the backend
-   * @param  data
-   * @param  callbacks
-   * @param  metadata
-   * @param  buffers
-   * @return message id
-   */
-  send(
-    data: JSONValue,
-    callbacks?: ICallbacks,
-    metadata?: JSONObject,
-    buffers?: ArrayBuffer[] | ArrayBufferView[],
-  ): string;
-
-  /**
-   * Closes the sibling comm in the backend
-   * @param  data
-   * @param  callbacks
-   * @param  metadata
-   * @param  buffers
-   * @return msg id
-   */
-  close(
-    data?: JSONValue,
-    callbacks?: ICallbacks,
-    metadata?: JSONObject,
-    buffers?: ArrayBuffer[] | ArrayBufferView[],
-  ): string;
-
-  /**
-   * Register a message handler
-   * @param  callback, which is given a message
-   */
-  on_msg(callback: (x: any) => void): void;
-
-  /**
-   * Register a handler for when the comm is closed by the backend
-   * @param  callback, which is given a message
-   */
-  on_close(callback: (x: any) => void): void;
-}

package/src/base/utils.ts

@@ -1,67 +0,0 @@
-import type { BufferJSON, Dict } from './protocal.js';
-
-/**
- * Takes an object 'state' and fills in buffer[i] at 'path' buffer_paths[i]
- * where buffer_paths[i] is a list indicating where in the object buffer[i] should
- * be placed
- * Example: state = {a: 1, b: {}, c: [0, null]}
- * buffers = [array1, array2]
- * buffer_paths = [['b', 'data'], ['c', 1]]
- * Will lead to {a: 1, b: {data: array1}, c: [0, array2]}
- */
-export function put_buffers(
-  state: Dict<BufferJSON>,
-  buffer_paths: (string | number)[][],
-  buffers: (DataView | ArrayBuffer | ArrayBufferView | { buffer: ArrayBuffer })[],
-): void {
-  for (let i = 0; i < buffer_paths.length; i++) {
-    const buffer_path = buffer_paths[i];
-    // make sure the buffers are DataViews
-    let buffer = buffers[i];
-    if (!(buffer instanceof DataView)) {
-      buffer = new DataView(buffer instanceof ArrayBuffer ? buffer : buffer.buffer);
-    }
-    // say we want to set state[x][y][z] = buffer
-    let obj = state as any;
-    // we first get obj = state[x][y]
-    for (let j = 0; j < buffer_path.length - 1; j++) {
-      obj = obj[buffer_path[j]];
-    }
-    // and then set: obj[z] = buffer
-    obj[buffer_path[buffer_path.length - 1]] = buffer;
-  }
-}
-
-/**
- * Creates a wrappable Promise rejection function.
- *
- * Creates a function that logs an error message before rethrowing
- * the original error that caused the promise to reject.
- */
-export function reject(message: string, log: boolean) {
-  return function promiseRejection(error: Error): never {
-    if (log) {
-      console.error(new Error(message));
-    }
-    throw error;
-  };
-}
-
-/**
- * A polyfill for Object.assign
- *
- * This is from code that Typescript 2.4 generates for a polyfill.
- */
-export const assign =
-  (Object as any).assign ||
-  function (t: any, ...args: any[]): any {
-    for (let i = 1; i < args.length; i++) {
-      const s = args[i];
-      for (const p in s) {
-        if (Object.prototype.hasOwnProperty.call(s, p)) {
-          t[p] = s[p];
-        }
-      }
-    }
-    return t;
-  };

package/src/base/version.ts

@@ -1,2 +0,0 @@
-export const LIBRO_WIDGETS_VERSION = '2.0.0';
-export const PROTOCOL_VERSION = '2.1.0';

package/src/base/widget-manager.ts

@@ -1,41 +0,0 @@
-import { LibroService } from '@difizen/libro-core';
-import type { IKernelConnection } from '@difizen/libro-kernel';
-import { KernelConnection, LibroKernelManager } from '@difizen/libro-kernel';
-import { inject, prop, singleton, ApplicationContribution } from '@difizen/mana-app';
-
-import type { LibroWidgets } from './libro-widgets.js';
-import { LibroWidgetsFactory } from './protocal.js';
-import type { WidgetsOption } from './protocal.js';
-
-@singleton({ contrib: ApplicationContribution })
-export class LibroWidgetManager implements ApplicationContribution {
-  @inject(LibroWidgetsFactory) widgetsFactory!: (
-    options: WidgetsOption,
-  ) => LibroWidgets;
-  @inject(LibroKernelManager) kernelManager: LibroKernelManager;
-  @inject(LibroService) libroService: LibroService;
-
-  initialize = () => {
-    this.kernelManager.onConnectToKernel((kc) => {
-      if (kc instanceof KernelConnection) {
-        this.getOrCreateWidgets(kc);
-      }
-    });
-  };
-
-  getOrCreateWidgets = (kc: IKernelConnection) => {
-    const widgets = this.widgets.get(kc.id);
-    if (widgets) {
-      return widgets;
-    }
-    const newWidgets = this.widgetsFactory({ kc, id: kc.id });
-    this.widgets.set(kc.id, newWidgets);
-    return newWidgets;
-  };
-
-  /**
-   * Dictionary of model ids and model instance promises
-   */
-  @prop()
-  protected widgets: Map<string, LibroWidgets> = new Map();
-}

package/src/base/widget-view-contribution.ts

@@ -1,14 +0,0 @@
-import { ViewManager, inject, singleton } from '@difizen/mana-app';
-
-import type { IWidgetViewProps } from './protocal.js';
-import { WidgetViewContribution } from './protocal.js';
-import { WidgetView } from './widget-view.js';
-
-@singleton({ contrib: WidgetViewContribution })
-export class DefaultWidgetViewContribution implements WidgetViewContribution {
-  @inject(ViewManager) viewManager: ViewManager;
-  canHandle = () => 1;
-  factory(props: IWidgetViewProps) {
-    return this.viewManager.getOrCreateView(WidgetView, props);
-  }
-}

package/src/base/widget-view.tsx

@@ -1,146 +0,0 @@
-import type { JSONValue } from '@difizen/libro-common';
-import { LibroContextKey } from '@difizen/libro-core';
-import type { KernelMessage } from '@difizen/libro-kernel';
-import { inject, transient, ViewOption, view, BaseView } from '@difizen/mana-app';
-import type { ViewComponent } from '@difizen/mana-app';
-import { forwardRef } from 'react';
-
-import type { IWidgetViewProps } from './protocal.js';
-import type {
-  BufferJSON,
-  Dict,
-  IWidgets,
-  IWidgetView,
-  IClassicComm,
-  ICallbacks,
-} from './protocal.js';
-import { assign } from './utils.js';
-
-export const LibroWidgetComponent = forwardRef<HTMLDivElement>(
-  function LibroWidgetComponent() {
-    return <></>;
-  },
-);
-
-@transient()
-@view('libro-widget-view')
-export class WidgetView extends BaseView implements IWidgetView {
-  override view: ViewComponent = LibroWidgetComponent;
-  libroContextKey: LibroContextKey;
-  disableCommandMode = true;
-  constructor(
-    @inject(ViewOption) props: IWidgetViewProps,
-    @inject(LibroContextKey) libroContextKey: LibroContextKey,
-  ) {
-    super();
-    this.initialize(props);
-    this.libroContextKey = libroContextKey;
-  }
-
-  override onViewMount() {
-    if (this.container && this.container.current && this.disableCommandMode) {
-      this.container.current.addEventListener('focusin', () => {
-        this.libroContextKey.disableCommandMode();
-      });
-      this.container.current.addEventListener('blur', (e) => {
-        if (this.container?.current?.contains(e.relatedTarget as Node)) {
-          this.libroContextKey.disableCommandMode();
-        } else {
-          this.libroContextKey.enableCommandMode();
-        }
-      });
-    }
-  }
-
-  initialize(props: IWidgetViewProps): void {
-    this.model_module = props.attributes._model_module;
-    this.model_name = props.attributes._model_name;
-    this.model_module_version = props.attributes._model_module_version;
-    this.view_module = props.attributes._view_module;
-    this.view_name = props.attributes._view_name;
-    this.view_module_version = props.attributes._view_module_version;
-    this.view_count = props.attributes._view_count;
-
-    // Attributes should be initialized here, since user initialization may depend on it
-    // this.libroWidgets = props.options.libroWidgets;
-    const comm = props.options.comm;
-    if (comm) {
-      // Remember comm associated with the model.
-      this.comm = comm;
-
-      // Hook comm messages up to model.
-      comm.on_close(this.handleCommClosed.bind(this));
-      comm.on_msg(this.handleCommMsg.bind(this));
-    } else {
-      this.isCommClosed = false;
-    }
-    this.model_id = props.options.model_id;
-
-    this.state_change = Promise.resolve();
-  }
-
-  /**
-   * Handle incoming comm msg.
-   */
-  handleCommMsg(msg: KernelMessage.ICommMsgMsg): Promise<void> {
-    const data = msg.content.data as any;
-    const method = data.method;
-    switch (method) {
-      case 'update':
-      case 'echo_update':
-        // eslint-disable-next-line no-case-declarations
-        const state: Dict<BufferJSON> = data.state;
-        this.set_state(state);
-    }
-    return Promise.resolve();
-  }
-
-  handleCommClosed = () => {
-    this.isCommClosed = true;
-  };
-  /**
-   * Handle when a widget is updated from the backend.
-   *
-   * This function is meant for internal use only. Values set here will not be propagated on a sync.
-   */
-  set_state(state: Dict<unknown>): void {
-    assign(this, state);
-  }
-
-  /**
-   * Serialize the model.  See the deserialization function at the top of this file
-   * and the kernel-side serializer/deserializer.
-   */
-  toJSON(): string {
-    return `IPY_MODEL_${this.model_id}`;
-  }
-
-  /**
-   * Send a custom msg over the comm.
-   */
-  send = (
-    data: JSONValue,
-    callbacks?: ICallbacks,
-    buffers?: ArrayBuffer[] | ArrayBufferView[],
-  ) => {
-    if (this.comm !== undefined) {
-      this.comm.send(data, callbacks, {}, buffers);
-    }
-  };
-
-  comm: IClassicComm;
-  libroWidgets: IWidgets;
-  model_id: string;
-  state_change: Promise<any>;
-  name: string;
-  module: string;
-  isCommClosed = false;
-
-  model_module: string;
-  model_name: string;
-  model_module_version: string;
-  view_module: string;
-  view_name: string | null;
-  view_module_version: string;
-  view_count: number | null;
-}

package/src/components/index.ts

@@ -1,3 +0,0 @@
-export * from './progressBar.js';
-
-export * from './progressCircle.js';