@difizen/libro-core 0.0.2-alpha.0

package/src/cell/libro-cell-service.ts

@@ -0,0 +1,157 @@
+import type { Contribution } from '@difizen/mana-app';
+import { Priority, prop } from '@difizen/mana-app';
+import { ApplicationContribution, ViewManager } from '@difizen/mana-app';
+import { contrib, inject, singleton } from '@difizen/mana-app';
+
+import type { CellView, CellModel, CellOptions } from '../libro-protocol.js';
+import { LibroService } from '../libro-service.js';
+
+import type { CellMeta } from './libro-cell-protocol.js';
+import {
+  CellService,
+  getLibroCellType,
+  CellViewContribution,
+  CellModelContribution,
+} from './libro-cell-protocol.js';
+
+@singleton({ contrib: [CellService, ApplicationContribution] })
+export class LibroCellService implements CellService, ApplicationContribution {
+  @prop()
+  cellsMeta: CellMeta[] = [];
+
+  protected readonly modelProvider: Contribution.Provider<CellModelContribution>;
+  protected readonly viewProvider: Contribution.Provider<CellViewContribution>;
+  protected cellTypeToModelContribution: Map<string, CellModelContribution> = new Map();
+  protected readonly viewManager: ViewManager;
+  protected modelCache: Map<string, Map<string, CellModel>> = new Map();
+
+  libroService: LibroService;
+  constructor(
+    @inject(ViewManager)
+    viewManager: ViewManager,
+    @inject(LibroService) libroService: LibroService,
+    @contrib(CellModelContribution)
+    modelProvider: Contribution.Provider<CellModelContribution>,
+    @contrib(CellViewContribution)
+    viewProvider: Contribution.Provider<CellViewContribution>,
+  ) {
+    this.modelProvider = modelProvider;
+    this.viewProvider = viewProvider;
+    this.viewManager = viewManager;
+    this.libroService = libroService;
+  }
+
+  protected getContributionDefaultCellOption(ctb: CellModelContribution): CellOptions {
+    if (ctb.getDefaultCellOption) {
+      return ctb.getDefaultCellOption();
+    }
+    return this.cellTypeToOption(ctb.cellMeta.type);
+  }
+
+  initialize() {
+    const prioritized = this.getDefaultOptionModelContributionPrioritized();
+    const metas: CellMeta[] = [];
+    prioritized.forEach((item) => {
+      if (!this.cellTypeToModelContribution.get(item.cellMeta.type)) {
+        this.cellTypeToModelContribution.set(item.cellMeta.type, item);
+        metas.push(item.cellMeta);
+      }
+    });
+    this.cellsMeta = metas;
+  }
+
+  getDefaultCellOption(cellType: string) {
+    const contribution = this.cellTypeToModelContribution.get(cellType);
+    if (!contribution) {
+      throw new Error(`no cell model contribution found for cell type ${cellType}`);
+    }
+    return this.getContributionDefaultCellOption(contribution);
+  }
+
+  protected cellTypeToOption(cellType: string): CellOptions {
+    return { cell: { cell_type: cellType, source: '', metadata: {} } };
+  }
+
+  getModelFromCache(groupId: string, modelId: string) {
+    return this.modelCache.get(groupId)?.get(modelId);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  async getOrCreateModel(options: CellOptions, cacheGroupId = ''): Promise<CellModel> {
+    let cellmodelCache = this.modelCache.get(cacheGroupId);
+
+    if (!cellmodelCache) {
+      cellmodelCache = new Map();
+      this.modelCache.set(cacheGroupId, cellmodelCache);
+    }
+    if (options.modelId) {
+      const exist = this.modelCache.get(cacheGroupId)?.get(options.modelId);
+      if (exist) {
+        return exist;
+      }
+    }
+    const modelProvider = this.findModelProvider(options);
+    if (!modelProvider) {
+      throw new Error('no cell model provider found');
+    }
+    const model = await modelProvider.createModel(options);
+    cellmodelCache.set(model.id, model);
+    return model;
+  }
+  async getOrCreateView(options: CellOptions, parentId: string): Promise<CellView> {
+    const model = await this.getOrCreateModel(options, parentId);
+    const viewProvider = this.findViewProvider(options);
+    if (!viewProvider) {
+      throw new Error('no cell view provider found');
+    }
+
+    const cellViewPromise = this.viewManager.getOrCreateView(viewProvider.view, {
+      ...options,
+      modelId: model.id,
+      parentId: parentId,
+    });
+
+    const cellView = await cellViewPromise;
+    const parent = this.libroService.getViewCache().get(parentId);
+    if (parent) {
+      cellView.parent = parent;
+    }
+    return cellView;
+  }
+
+  findViewProvider(options: CellOptions): CellViewContribution | undefined {
+    const prioritized = Priority.sortSync(
+      this.viewProvider.getContributions(),
+      (contribution) => this.canHandleOption(contribution, options),
+    );
+
+    const sorted = prioritized.map((c) => c.value);
+    return sorted[0];
+  }
+  findModelProvider(options: CellOptions): CellModelContribution | undefined {
+    const prioritized = Priority.sortSync(
+      this.modelProvider.getContributions(),
+      (contribution) => this.canHandleOption(contribution, options),
+    );
+    const sorted = prioritized.map((c) => c.value);
+    return sorted[0];
+  }
+
+  protected getDefaultOptionModelContributionPrioritized(): CellModelContribution[] {
+    const prioritized = Priority.sortSync(
+      this.modelProvider.getContributions(),
+      (contribution) => {
+        const options = this.getContributionDefaultCellOption(contribution);
+        return this.canHandleOption(contribution, options);
+      },
+    );
+    const sorted = prioritized.map((c) => c.value);
+    return sorted;
+  }
+  protected canHandleOption(
+    ctb: CellModelContribution | CellViewContribution,
+    options: CellOptions,
+  ) {
+    return ctb.canHandle(options, getLibroCellType(options));
+  }
+}

package/src/cell/libro-cell-view.tsx

@@ -0,0 +1,128 @@
+import type { ViewComponent } from '@difizen/mana-app';
+import { useInject, watch } from '@difizen/mana-app';
+import { BaseView, view, ViewInstance, ViewOption } from '@difizen/mana-app';
+import { inject } from '@difizen/mana-app';
+import { DisposableCollection } from '@difizen/mana-app';
+import { prop } from '@difizen/mana-app';
+import React from 'react';
+
+import type { CellViewOptions, CellModel } from '../libro-protocol.js';
+import type { CellView, NotebookView } from '../libro-protocol.js';
+
+import { CellService } from './libro-cell-protocol.js';
+import type { LibroCell } from './libro-cell-protocol.js';
+import { ExecutableCellModel } from './libro-executable-cell-model.js';
+
+export const LibroCellComponent = React.forwardRef(function LibroCellComponent() {
+  const instance = useInject<LibroCellView>(ViewInstance);
+  return <>{instance.model.value}</>;
+});
+
+@view('libro-cell-view')
+export class LibroCellView extends BaseView implements CellView {
+  protected override toDispose = new DisposableCollection();
+  options: CellViewOptions;
+
+  @prop()
+  model: CellModel;
+  protected cellService: CellService;
+  override view: ViewComponent = LibroCellComponent;
+  parent!: NotebookView;
+
+  @prop()
+  override className?: string | undefined = 'libro-cell-view-container';
+
+  @prop()
+  hasInputHidden: boolean;
+
+  @prop()
+  collapsedHidden = false;
+
+  @prop()
+  hasModal = false;
+
+  constructor(
+    @inject(ViewOption) options: CellViewOptions,
+    @inject(CellService) cellService: CellService,
+  ) {
+    super();
+    this.cellService = cellService;
+    this.options = options;
+    this.hasInputHidden = false;
+
+    const model = cellService.getModelFromCache(options.parentId, options.modelId);
+    if (!model) {
+      console.warn('cell model does not exist');
+      throw new Error('cell model does not exist');
+    }
+    this.model = model;
+    this.cellWatch();
+  }
+
+  cellWatch() {
+    this.toDispose.push(
+      watch(this.model, 'value', () => {
+        this.parent.model.onChange?.();
+      }),
+    );
+    this.toDispose.push(
+      watch(this.model, 'type', () => {
+        this.parent.model.onChange?.();
+      }),
+    );
+    if (ExecutableCellModel.is(this.model)) {
+      this.toDispose.push(
+        watch(this.model, 'executeCount', () => {
+          this.parent.model.onChange?.();
+        }),
+      );
+    }
+  }
+
+  hasCellHidden() {
+    return this.hasInputHidden;
+  }
+
+  async run() {
+    return Promise.resolve(true);
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  shouldEnterEditorMode(_e: React.FocusEvent<HTMLElement>) {
+    return false;
+  }
+
+  blur() {
+    //
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  focus(_isEdit: boolean) {
+    //
+  }
+
+  disposed = false;
+  override dispose() {
+    if (!this.disposed) {
+      this.toDispose.dispose();
+      super.dispose();
+    }
+    this.disposed = true;
+  }
+  toJSON(): LibroCell {
+    const meta = { ...(this.model.toJSON() as LibroCell) };
+    const modelContribution = this.cellService.findModelProvider(this.model.options);
+    if (modelContribution?.cellMeta.nbformatType) {
+      meta.metadata.libroCellType = modelContribution?.cellMeta.type;
+      meta.cell_type = modelContribution?.cellMeta.nbformatType;
+    }
+    return meta;
+  }
+
+  toJSONWithoutId = () => {
+    const JsonObject = this.toJSON();
+    delete JsonObject.id;
+    return {
+      ...JsonObject,
+    };
+  };
+}

package/src/cell/libro-edit-cell-view.tsx

@@ -0,0 +1,60 @@
+import type { IEditor, IRange } from '@difizen/libro-code-editor';
+import { prop } from '@difizen/mana-app';
+
+import type { CellView } from '../libro-protocol.js';
+import { isCellView } from '../libro-protocol.js';
+
+import { LibroCellView } from './libro-cell-view.js';
+
+export interface EditorCellView extends CellView {
+  editor: IEditor | undefined;
+
+  redo: () => void;
+
+  undo: () => void;
+  getSelections: () => IRange[];
+  getSelectionsOffsetAt: (selection: IRange) => {
+    start: number;
+    end: number;
+  };
+}
+
+export const EditorCellView = {
+  is: (arg: Record<any, any> | undefined): arg is EditorCellView => {
+    return (
+      !!arg &&
+      isCellView(arg as any) &&
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      'redo' in arg &&
+      typeof (arg as any).redo === 'function' &&
+      'undo' in arg &&
+      typeof (arg as any).undo === 'function'
+    );
+  },
+};
+
+/**
+ * 带有编辑器能力的cell view，例如raw、markdown、python、sql等
+ * 超出编辑器的相关能力放在其他的更高抽象中
+ */
+export abstract class LibroEditorCellView
+  extends LibroCellView
+  implements EditorCellView
+{
+  @prop()
+  editor: IEditor | undefined;
+
+  abstract getSelections: () => IRange[];
+  abstract getSelectionsOffsetAt: (selection: IRange) => { start: number; end: number };
+  get wrapperCls() {
+    return '';
+  }
+
+  redo(): void {
+    this.editor?.redo();
+  }
+
+  undo(): void {
+    this.editor?.undo();
+  }
+}

package/src/cell/libro-executable-cell-model.ts

@@ -0,0 +1,32 @@
+import type { ExecutionCount } from '@difizen/libro-common';
+import type { Emitter } from '@difizen/mana-app';
+
+export interface ExecutableCellModel {
+  // 执行中
+  executing: boolean;
+
+  // 执行次数
+  executeCount: ExecutionCount;
+
+  hasOutputHidden: boolean;
+
+  hasOutputsScrolled: boolean;
+
+  // Emitter Msg
+  msgChangeEmitter: Emitter<any>;
+
+  clearExecution: () => void;
+}
+
+export const ExecutableCellModel = {
+  is: (arg: Record<any, any> | undefined): arg is ExecutableCellModel => {
+    return (
+      !!arg &&
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      'executing' in arg &&
+      typeof (arg as any).executing === 'boolean' &&
+      'executeCount' in arg &&
+      (typeof (arg as any).executeCount === 'number' || !(arg as any).executeCount)
+    );
+  },
+};

package/src/cell/libro-executable-cell-view.ts

@@ -0,0 +1,74 @@
+import { watch } from '@difizen/mana-app';
+import { ViewOption } from '@difizen/mana-app';
+import { inject } from '@difizen/mana-app';
+
+import type { CellModel } from '../libro-protocol.js';
+import type { CellViewOptions } from '../libro-protocol.js';
+import type { BaseOutputArea } from '../output/index.js';
+
+import { CellService } from './libro-cell-protocol.js';
+import { EditorCellView, LibroEditorCellView } from './libro-edit-cell-view.js';
+import { ExecutableCellModel } from './libro-executable-cell-model.js';
+
+interface ExecutableCellView extends EditorCellView {
+  clearExecution: () => void;
+
+  outputArea: BaseOutputArea;
+}
+
+export const ExecutableCellView = {
+  is: (arg: Record<any, any> | undefined): arg is ExecutableCellView => {
+    return (
+      !!arg &&
+      EditorCellView.is(arg as any) &&
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      'outputArea' in arg &&
+      typeof (arg as any).outputArea === 'object' &&
+      'clearExecution' in arg &&
+      typeof (arg as any).clearExecution === 'function'
+    );
+  },
+};
+
+/**
+ * 带有编辑器、执行、output相关能力的cell view，例如python、sql
+ * model 必须为 ExecutableCellModel
+ */
+export abstract class LibroExecutableCellView
+  extends LibroEditorCellView
+  implements ExecutableCellView
+{
+  declare model: CellModel & ExecutableCellModel;
+
+  declare outputArea: BaseOutputArea;
+
+  constructor(
+    @inject(ViewOption) options: CellViewOptions,
+    @inject(CellService) cellService: CellService,
+  ) {
+    super(options, cellService);
+    this.outputWatch();
+  }
+
+  clearExecution: () => void = () => {
+    //
+  };
+
+  override hasCellHidden() {
+    if (
+      !ExecutableCellModel.is(this.model) ||
+      (this.outputArea && this.outputArea.length < 1)
+    ) {
+      return this.hasInputHidden;
+    }
+    return this.hasInputHidden && this.model.hasOutputHidden;
+  }
+
+  outputWatch() {
+    this.toDispose.push(
+      watch(this.outputArea, 'outputs', () => {
+        this.parent.model.onChange?.();
+      }),
+    );
+  }
+}

package/src/cell/libro-markdown-cell-model.ts

@@ -0,0 +1,20 @@
+import type { CellModel } from '../libro-protocol.js';
+
+export interface LibroMarkdownCellModel extends CellModel {
+  isEdit: boolean;
+
+  preview: string;
+}
+
+export const LibroMarkdownCellModel = {
+  is: (arg: Record<any, any> | undefined): arg is LibroMarkdownCellModel => {
+    return (
+      !!arg &&
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      'isEdit' in arg &&
+      typeof (arg as any).isEdit === 'boolean' &&
+      'preview' in arg &&
+      typeof (arg as any).preview === 'string'
+    );
+  },
+};

package/src/collapse-service.ts

@@ -0,0 +1,69 @@
+import { inject, prop, transient } from '@difizen/mana-app';
+
+import type { CellView } from './libro-protocol.js';
+import type { LibroView } from './libro-view.js';
+
+export interface CollapseServiceOption {
+  view: LibroView;
+}
+export const CollapseServiceOption = Symbol('CollapseServiceOption');
+
+export type CollapseServiceFactory = (option: CollapseServiceOption) => CollapseService;
+export const CollapseServiceFactory = Symbol('CollapseServiceFactory');
+
+export interface CellCollapsible {
+  /**
+   * 是否折叠子项
+   */
+  headingCollapsed: boolean;
+  /**
+   * 折叠的子项的数量
+   */
+  collapsibleChildNumber: number;
+}
+
+export const CellCollapsible = {
+  is: (arg: Record<any, any> | undefined): arg is CellCollapsible => {
+    return (
+      !!arg &&
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      'headingCollapsed' in arg &&
+      typeof (arg as any).headingCollapsed === 'boolean'
+    );
+  },
+};
+
+export interface CollapseService {
+  collapserVisible: boolean;
+
+  view: LibroView;
+
+  setHeadingCollapse: (cell: CellView, collapsing: boolean) => void;
+
+  getCollapsibleChildNumber: (cell: CellView) => number;
+}
+
+export const CollapseService = Symbol('CollapseService');
+
+@transient({ token: CollapseService })
+export class DefaultCollapseService implements CollapseService {
+  @prop()
+  collapserVisible = false;
+
+  view: LibroView;
+
+  constructor(@inject(CollapseServiceOption) option: CollapseServiceOption) {
+    this.view = option.view;
+  }
+
+  setHeadingCollapse(cell: CellView, collapsing: boolean) {
+    if (CellCollapsible.is(cell)) {
+      cell.headingCollapsed = collapsing;
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  getCollapsibleChildNumber(_cell: CellView) {
+    return 0;
+  }
+}

package/src/command/document-commands.ts

@@ -0,0 +1,18 @@
+import { SaveOutlined, SettingOutlined } from '@ant-design/icons';
+import type { Command } from '@difizen/mana-app';
+
+export const DocumentCommands: Record<
+  string,
+  Command & { keybind?: string | string[] | undefined; when?: string | undefined }
+> = {
+  Save: {
+    id: 'document:save',
+    icon: SaveOutlined,
+    label: 'SAVE',
+    keybind: 'ctrlcmd+s',
+  },
+  OpenSettings: {
+    id: 'document.notebook.open_setting',
+    icon: SettingOutlined,
+  },
+};

package/src/command/index.ts

@@ -0,0 +1,6 @@
+export * from './notebook-commands.js';
+export * from './document-commands.js';
+export * from './kernel-command.js';
+export * from './libro-command-contribution.js';
+export * from './libro-command-register.js';
+export * from './module.js';

package/src/command/kernel-command.ts

@@ -0,0 +1,41 @@
+import type { Command } from '@difizen/mana-app';
+import { l10n } from '@difizen/mana-l10n';
+
+export const KernelCommands: Record<string, Command & { keybind?: string }> = {
+  //#region libro command
+
+  //#endregion
+
+  //#region jupyterlab command
+  ChangeKernel: {
+    id: 'notebook:change-kernel',
+    label: `Change Kernel`,
+  },
+  GetKernel: {
+    id: 'notebook:get-kernel',
+    label: `Get Kernel`,
+  },
+  InterruptKernel: {
+    id: 'notebook:interrupt-kernel',
+    label: `Interrupt Kernel`,
+  },
+  ReconnectToKernel: {
+    id: 'notebook:reconnect-to-kernel',
+    label: `Reconnect to Kernel`,
+  },
+  RestartKernel: {
+    id: 'notebook:restart-kernel',
+    label: l10n.t('Restart Kernel…'),
+  },
+  ShutdownKernel: {
+    id: 'notebook:shutdown-kernel',
+    label: `Shutdown Kernel`,
+  },
+  ShowKernelStatus: {
+    id: 'notebook:show-kernel-status',
+  },
+  ShowKernelStatusAndSelector: {
+    id: 'notebook:show-kernel-status-and-selector',
+  },
+  //#endregion
+};