@difizen/libro-core 0.0.2-alpha.0

package/src/libro-protocol.ts

@@ -0,0 +1,322 @@
+/* eslint-disable @typescript-eslint/unified-signatures */
+import type { IModel } from '@difizen/libro-code-editor';
+import type {
+  CellType,
+  ICell,
+  ICellMetadata,
+  INotebookContent,
+  INotebookMetadata,
+} from '@difizen/libro-common';
+import type { ISharedNotebook } from '@difizen/libro-shared-model';
+import { View } from '@difizen/mana-app';
+import type { Disposable, Event } from '@difizen/mana-app';
+
+import type { LibroCell } from './cell/index.js';
+import type { LibroView } from './libro-view.js';
+
+export const LibroContextKeys = {
+  active: 'active',
+  focus: 'focus',
+  commandMode: 'commandMode',
+};
+
+export const LibroToolbarArea = {
+  HeaderLeft: 'header-left',
+  HeaderCenter: 'header-center',
+  HeaderRight: 'header-right',
+  CellTop: 'top',
+  CellRight: 'right',
+};
+export const NotebookOption = Symbol('NotebookOption');
+/**
+ * Libro 创建参数
+ * 默认可 json 序列化
+ */
+export interface NotebookOption extends Options {
+  id?: string;
+  modelId?: string;
+  [key: string]: any;
+}
+
+export const ModelFactory = Symbol('ModelFactory');
+export type ModelFactory<T = NotebookOption> = (options: T) => NotebookModel;
+
+export const NotebookModel = Symbol('NotebookModel');
+
+export type Options = {
+  id?: string;
+  [key: string]: any;
+};
+
+export type NotebookModel = BaseNotebookModel & DndListModel;
+export interface BaseNotebookModel {
+  id: string;
+  /**
+   * The dirty state of the model.
+   * #### Notes
+   * This should be cleared when the document is loaded from
+   * or saved to disk.
+   */
+  dirty: boolean;
+  executeCount: number;
+  lastClipboardInteraction?: string;
+  clipboard?: CellView | CellView[];
+  active?: CellView | undefined;
+  activeIndex: number;
+  dndAreaNullEnable: boolean;
+  /**
+   * The read-only state of the model.
+   */
+  readOnly: boolean;
+
+  /**
+   * The quick edit mode the model.
+   */
+  quickEditMode: boolean;
+
+  /**
+   * The command mode of the model.
+   */
+  commandMode: boolean;
+
+  trusted: boolean;
+
+  onCommandModeChanged: Event<boolean>;
+
+  onContentChanged: Event<boolean>;
+
+  getCells: () => CellView[];
+
+  /**
+   * Serialize the model to a string.
+   */
+  toString: () => string;
+
+  /**
+   * Deserialize the model from a string.
+   *
+   * #### Notes
+   * Should emit a [contentChanged] signal.
+   */
+  fromString: (value: string) => void;
+
+  /**
+   * The list of cells in the notebook.
+   */
+  cells: CellView[];
+
+  selections: CellView[];
+
+  canUndo?: boolean;
+
+  canRedo?: boolean;
+
+  /**
+   * The metadata associated with the notebook.
+   */
+  readonly metadata: INotebookMetadata;
+
+  /**
+   * The array of deleted cells since the notebook was last run.
+   */
+  readonly deletedCells: CellView[];
+
+  /**
+   * If the model is initialized or not.
+   */
+  isInitialized: boolean;
+
+  initialize: () => Promise<CellOptions[]>;
+
+  options: Options;
+
+  /**
+   * save notebook
+   */
+  toJSON: () => INotebookContent;
+
+  saveNotebookContent: () => Promise<void>;
+
+  fontSize: number;
+  theme: string;
+
+  /**
+   * 聚焦
+   */
+  focus?: () => void;
+  blur?: () => void;
+  /**
+   * 进入命令模式
+   */
+  enterCommandMode?: () => void;
+
+  enterEditMode?: () => void;
+
+  onChange?: () => void;
+
+  interrupt?: () => void;
+
+  canRun?: () => boolean;
+
+  restart?: () => void;
+
+  shutdown?: () => void;
+
+  undo: () => void;
+
+  redo: () => void;
+
+  readonly sharedModel: ISharedNotebook;
+
+  scrollToView: (cell: CellView) => void;
+
+  customParams: Record<string, any>;
+  getCustomKey: (key: string) => any;
+  setCustomKey: (key: string, val: any) => void;
+
+  libroViewClass: string;
+}
+
+export const notebookViewFactoryId = 'notebook-view-factory';
+
+export type NotebookView = LibroView;
+
+export interface CellView extends View {
+  model: CellModel;
+  parent: NotebookView;
+  wrapperCls?: string;
+
+  blur: () => void;
+  focus: (isEdit: boolean) => void;
+
+  run: () => Promise<boolean>;
+
+  shouldEnterEditorMode: (e: React.FocusEvent<HTMLElement>) => boolean;
+
+  hasCellHidden: () => boolean;
+
+  hasInputHidden: boolean;
+
+  hasModal: boolean;
+
+  /**
+   * 是否被折叠隐藏
+   */
+  collapsedHidden: boolean;
+
+  toJSON: () => ICell;
+
+  toJSONWithoutId: () => ICell;
+}
+export function isCellView(view: View): view is CellView {
+  return View.is(view) && 'model' in view;
+}
+
+export const CellOptions = Symbol('CellOptions');
+export interface CellOptions {
+  // parent?: NotebookView;
+  id?: string;
+  modelId?: string;
+  mimetype?: string;
+  cell: LibroCell;
+  [key: string]: any;
+}
+
+export const CellViewOptions = Symbol('CellViewOptions');
+export interface CellViewOptions {
+  parentId: string;
+  id: string;
+  modelId: string;
+  mimetype?: string;
+  cell: ICell;
+  [key: string]: any;
+}
+
+export interface CellModel extends IModel, Disposable {
+  /**
+   * A unique identifier for the cell.
+   */
+  id: string;
+
+  /**
+   * The type of the cell.
+   */
+  type: CellType;
+
+  /**
+   * A signal emitted when the content of the model changes.
+   */
+  // readonly contentChanged: Event<void>;
+
+  /**
+   * A signal emitted when a model state changes.
+   */
+  // readonly stateChanged: Event<IContentsChangedArgs<any>>;
+
+  /**
+   * Whether the cell is trusted.
+   */
+  trusted: boolean;
+
+  /**
+   * The metadata associated with the cell.
+   */
+  readonly metadata: Partial<ICellMetadata>;
+
+  /**
+   * Serialize the model to JSON.
+   * 输出时的字段顺序也要保持稳定
+   */
+  toJSON: () => Omit<ICell, 'outputs'>;
+  options: CellOptions;
+
+  // run: () => Promise<boolean>;
+}
+
+export const NotebookService = Symbol('NotebookService');
+
+export interface NotebookService {
+  getOrCreateModel: (options: NotebookOption) => NotebookModel;
+  getOrCreateView: (options: NotebookOption) => Promise<NotebookView>;
+  setActive: (view: NotebookView | undefined) => void;
+  onActiveChanged: Event<NotebookView | undefined>;
+}
+
+//#region Protocol for drag & drop
+export const DragAreaKey = Symbol('DragAreaKey');
+
+export type MouseMode = 'multipleSelection' | 'mouseDown' | 'drag';
+export interface DndListModel {
+  mouseMode?: MouseMode;
+  active?: CellView | undefined;
+  hover?: CellView | undefined;
+  selectCell: (cell: CellView) => void;
+  addCell: (cell: CellView, position?: number, mode?: string) => void;
+  insertCells: (cells: CellView[], position?: number, mode?: string) => void;
+  invertCell: (toAddcell: CellView, position: number) => void;
+  splitCell: (newCells: CellView[], position: number) => void;
+  deleteCell: {
+    (id: string): boolean;
+    (index: number): boolean;
+    (cell: CellView): boolean;
+  };
+  exchangeCell: {
+    (source: CellView, target: CellView): boolean;
+    (sourceIndex: number, targetIndex: number): boolean;
+    (sourceId: string, targetId: string): boolean;
+  };
+  exchangeCells: (source: CellView[], targetIndex: number) => void;
+}
+
+export interface DndContentProps {
+  cell: CellView;
+  index: number;
+}
+
+export interface DndItemProps {
+  isDragOver: boolean;
+  isDrag: boolean;
+  cell: CellView;
+  isMouseOverDragArea?: boolean;
+}
+//#endregion

package/src/libro-service.ts

@@ -0,0 +1,121 @@
+import { Emitter } from '@difizen/mana-app';
+import { ThemeService, ViewManager } from '@difizen/mana-app';
+import { inject, singleton } from '@difizen/mana-app';
+import { prop } from '@difizen/mana-app';
+
+import type { NotebookOption, NotebookView } from './libro-protocol.js';
+import {
+  notebookViewFactoryId,
+  ModelFactory,
+  NotebookService,
+} from './libro-protocol.js';
+import { LibroViewTracker } from './libro-view-tracker.js';
+
+@singleton({ contrib: NotebookService })
+export class LibroService implements NotebookService {
+  protected libroModelFactory: ModelFactory;
+  protected viewManager: ViewManager;
+  protected libroViewTracker: LibroViewTracker;
+
+  protected themeService: ThemeService;
+  @prop()
+  themeMode: string;
+  constructor(
+    @inject(ThemeService) themeService: ThemeService,
+    @inject(ModelFactory) libroModelFactory: ModelFactory,
+    @inject(ViewManager) viewManager: ViewManager,
+    @inject(LibroViewTracker) libroViewTracker: LibroViewTracker,
+  ) {
+    this.themeService = themeService;
+    this.themeMode = this.themeService.getCurrentTheme().type;
+    this.themeService.onDidColorThemeChange((e) => {
+      this.themeMode = e.newTheme.type;
+    });
+    this.libroModelFactory = libroModelFactory;
+    this.viewManager = viewManager;
+    this.libroViewTracker = libroViewTracker;
+  }
+
+  @prop() protected _active?: NotebookView;
+  protected onActiveChangedEmitter: Emitter<NotebookView | undefined> = new Emitter();
+  get onActiveChanged() {
+    return this.onActiveChangedEmitter.event;
+  }
+  get active(): NotebookView | undefined {
+    return this._active;
+  }
+  set active(value: NotebookView | undefined) {
+    this._active = value;
+    this.onActiveChangedEmitter.fire(value);
+  }
+
+  @prop() protected _focus?: NotebookView;
+  protected onFocusChangedEmitter: Emitter<NotebookView | undefined> = new Emitter();
+  get onFocusChanged() {
+    return this.onFocusChangedEmitter.event;
+  }
+
+  protected onNotebookViewCreatedEmitter: Emitter<NotebookView> = new Emitter();
+  get onNotebookViewCreated() {
+    return this.onNotebookViewCreatedEmitter.event;
+  }
+
+  get focus(): NotebookView | undefined {
+    return this._focus;
+  }
+  set focus(value: NotebookView | undefined) {
+    this._focus = value;
+    this.onFocusChangedEmitter.fire(value);
+  }
+
+  get hasFocus(): boolean {
+    return this._hasFocus;
+  }
+
+  getViewCache(): Map<string, NotebookView> {
+    return this.libroViewTracker.viewCache;
+  }
+
+  deleteLibroViewFromCache(instance: NotebookView) {
+    this.libroViewTracker.viewCache.delete(instance.id);
+    this.libroViewTracker.modelCache.delete(instance.model.id);
+  }
+
+  @prop()
+  protected _hasFocus = false;
+
+  getOrCreateModel(options: NotebookOption) {
+    if (options.modelId) {
+      const exist = this.libroViewTracker.modelCache.get(options.modelId);
+      if (exist) {
+        return exist;
+      }
+    }
+    const model = this.libroModelFactory(options);
+    this.libroViewTracker.modelCache.set(model.id, model);
+    return model;
+  }
+  async getOrCreateView(options: NotebookOption): Promise<NotebookView> {
+    const model = this.getOrCreateModel(options);
+    const notebookViewPromise = this.viewManager.getOrCreateView<NotebookView>(
+      notebookViewFactoryId,
+      {
+        ...(options || {}),
+        modelId: model.id,
+      },
+    );
+    const notebookView = await notebookViewPromise;
+    this.libroViewTracker.viewCache.set(notebookView.id, notebookView);
+    this.onNotebookViewCreatedEmitter.fire(notebookView);
+    return notebookViewPromise;
+  }
+
+  setActive(view?: NotebookView): void {
+    this._active = view;
+    this.onActiveChangedEmitter.fire(view);
+  }
+
+  setHasFocus(hasFocus: boolean): void {
+    this._hasFocus = hasFocus;
+  }
+}

package/src/libro-view-tracker.ts

@@ -0,0 +1,9 @@
+import { singleton } from '@difizen/mana-app';
+
+import type { NotebookModel, NotebookView } from './libro-protocol.js';
+
+@singleton()
+export class LibroViewTracker {
+  viewCache: Map<string, NotebookView> = new Map();
+  modelCache: Map<string, NotebookModel> = new Map();
+}