@difizen/libro-core 0.0.0-snapshot-20241017072317

package/src/libro-protocol.ts

@@ -0,0 +1,435 @@
+/* eslint-disable @typescript-eslint/unified-signatures */
+import type { IModel, IModelContentChange } 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 type { Disposable, Event } from '@difizen/mana-app';
+import type { View } from '@difizen/mana-app';
+
+import type { LibroCell } from './cell/index.js';
+import type { LibroView } from './libro-view.js';
+import type { VirtualizedManager } from './virtualized-manager.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 PerformaceStatisticOption = Symbol('PerformaceStatisticOption');
+export type PerformaceStatisticOption = Options;
+
+export const ModelFactory = Symbol('ModelFactory');
+export type ModelFactory<T = NotebookOption> = (options: T) => NotebookModel;
+
+export const NotebookModel = Symbol('NotebookModel');
+
+export enum EditorStatus {
+  NOTLOADED = 'not loaded',
+  LOADING = 'loading',
+  LOADED = 'loaded',
+}
+
+export type Options = {
+  id?: string;
+  [key: string]: any;
+};
+
+export interface ScrollParams {
+  cellIndex: number;
+  cellOffset?: number;
+}
+
+export type NotebookModel = BaseNotebookModel & DndListModel;
+
+export interface ICellContentChange {
+  cell: CellView;
+  changes: IModelContentChange[];
+}
+export interface BaseNotebookModel {
+  id: string;
+  version: number;
+  /**
+   * 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;
+
+  /**
+   * Controlling whether the cell input is editable
+   */
+  inputEditable: boolean;
+
+  outputEditable: boolean;
+
+  /**
+   * Controlling whether the cells list is editable
+   */
+  cellsEditable: boolean;
+  /**
+   * Controlling whether the cells can execute
+   */
+  runnable: boolean;
+  /**
+   * Controlling whether the notebook can save
+   */
+  savable: boolean;
+  /**
+   * The command mode of the model.
+   */
+  commandMode: boolean;
+
+  trusted: boolean;
+
+  onCommandModeChanged: Event<boolean>;
+
+  /**
+   * all changes
+   */
+  onChanged: Event<boolean>;
+
+  /**
+   * cell content & type
+   */
+  onSourceChanged: Event<boolean>;
+
+  /**
+   * cell create & delete
+   */
+  onCellViewChanged: Event<CellViewChange>;
+
+  /**
+   * cell content change detail
+   */
+  onCellContentChanged: Event<ICellContentChange>;
+
+  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;
+
+  /**
+   * all changes: cell value\cell type\cell output\ cell executecount\ cell or notebook metadata\cell create & delete
+   * @returns
+   */
+  onChange?: () => void;
+
+  onRestart?: Event<void>;
+
+  onSourceChange?: (cells: CellView[]) => void;
+
+  onCellContentChange: (changes: ICellContentChange) => void;
+
+  interrupt?: () => void;
+
+  canRun?: () => boolean;
+
+  restart?: () => void;
+
+  shutdown?: () => void;
+
+  undo: () => void;
+
+  redo: () => void;
+
+  readonly sharedModel: ISharedNotebook;
+
+  scrollToView: (cell: CellView, cellOffset?: number) => void;
+
+  customParams: Record<string, any>;
+  getCustomKey: (key: string) => any;
+  setCustomKey: (key: string, val: any) => void;
+
+  libroViewClass: string;
+
+  onScrollToCellView: Event<ScrollParams>;
+
+  disposeScrollToCellViewEmitter: () => void;
+}
+
+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;
+
+  shouldEnterEditorMode: (e: React.FocusEvent<HTMLElement>) => boolean;
+
+  hasCellHidden: () => boolean;
+
+  hasInputHidden: boolean;
+
+  hasModal: boolean;
+
+  /**
+   * 是否被折叠隐藏
+   */
+  collapsedHidden: boolean;
+
+  toJSON: () => ICell;
+
+  toJSONWithoutId: () => ICell;
+
+  editorAreaHeight?: number;
+
+  cellViewTopPos?: number;
+
+  noEditorAreaHeight: number;
+
+  editorStatus?: EditorStatus;
+
+  calcEditorAreaHeight?: () => number;
+
+  calcEditorOffset?: () => number;
+
+  renderEditorIntoVirtualized?: boolean;
+}
+function isView(data: object): data is View {
+  return (
+    !!data &&
+    typeof data === 'object' &&
+    'id' in data &&
+    'view' in data &&
+    typeof data['view'] === 'function'
+  );
+}
+export function isCellView(view: View): view is CellView {
+  return (
+    isView(view) &&
+    'model' in view &&
+    'parent' in view &&
+    'run' in view &&
+    'toJSON' 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 CellViewChange {
+  insert?: { cells: CellView[]; index: number };
+  delete?: { index: number; number: number; cells: CellView[] };
+}
+
+export interface CellModel extends IModel, Disposable {
+  /**
+   * A unique identifier for the cell.
+   */
+  id: string;
+
+  version: number;
+
+  source: 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
+
+export interface VirtualizedManagerOption {
+  libroModel: NotebookModel;
+}
+export const VirtualizedManagerOption = Symbol('VirtualizedManagerOption');
+
+export const VirtualizedManagerOptionFactory = Symbol(
+  'VirtualizedManagerOptionFactory',
+);
+
+export type VirtualizedManagerOptionFactory = (
+  meta: VirtualizedManagerOption,
+) => VirtualizedManager;

package/src/libro-service.ts

@@ -0,0 +1,234 @@
+import type { Disposable } from '@difizen/mana-app';
+import { DisposableCollection, 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 {
+  CellView,
+  ICellContentChange,
+  NotebookOption,
+  NotebookView,
+} from './libro-protocol.js';
+import {
+  notebookViewFactoryId,
+  ModelFactory,
+  NotebookService,
+} from './libro-protocol.js';
+import { LibroViewTracker } from './libro-view-tracker.js';
+
+export interface NotebookViewChange {
+  libroView: NotebookView;
+  contentChanges: Array<{
+    range: {
+      start: number;
+      end: number;
+    };
+    addedCells: CellView[];
+    removedCells: CellView[];
+  }>;
+  cellChanges: Array<{
+    cell: CellView;
+  }>;
+}
+
+@singleton({ contrib: NotebookService })
+export class LibroService implements NotebookService, Disposable {
+  protected toDispose = new DisposableCollection();
+  @inject(ModelFactory) protected libroModelFactory: ModelFactory;
+  @inject(ViewManager) protected viewManager: ViewManager;
+  @inject(LibroViewTracker) protected libroViewTracker: LibroViewTracker;
+  protected themeService: ThemeService;
+  @prop()
+  themeMode: string;
+
+  @prop()
+  hasFormatter = false;
+
+  constructor(@inject(ThemeService) themeService: ThemeService) {
+    this.themeService = themeService;
+    this.themeMode = this.themeService.getCurrentTheme().type;
+    this.themeService.onDidColorThemeChange((e) => {
+      this.themeMode = e.newTheme.type;
+    });
+  }
+
+  @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;
+  }
+  protected onNotebookViewSavedEmitter: Emitter<NotebookView> = new Emitter();
+  get onNotebookViewSaved() {
+    return this.onNotebookViewSavedEmitter.event;
+  }
+  protected onNotebookViewChangedEmitter: Emitter<NotebookViewChange> = new Emitter();
+  get onNotebookViewChanged() {
+    return this.onNotebookViewChangedEmitter.event;
+  }
+  protected onNotebookViewClosedEmitter: Emitter<NotebookView> = new Emitter();
+  get onNotebookViewClosed() {
+    return this.onNotebookViewClosedEmitter.event;
+  }
+  protected onNotebookCellCreatedEmitter: Emitter<CellView[]> = new Emitter();
+  get onNotebookCellCreated() {
+    return this.onNotebookCellCreatedEmitter.event;
+  }
+  protected onNotebookCellSavedEmitter: Emitter<CellView[]> = new Emitter();
+  get onNotebookCellSaved() {
+    return this.onNotebookCellSavedEmitter.event;
+  }
+  protected onNotebookCellChangedEmitter: Emitter<ICellContentChange> = new Emitter();
+  get onNotebookCellChanged() {
+    return this.onNotebookCellChangedEmitter.event;
+  }
+  protected onNotebookCellDeletedEmitter: Emitter<CellView[]> = new Emitter();
+  get onNotebookCellDeleted() {
+    return this.onNotebookCellDeletedEmitter.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.onNotebookViewClosedEmitter.fire(instance);
+    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(options.modelId || 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;
+    if (!this.libroViewTracker.viewCache.has(notebookView.id)) {
+      this.watchNotebookView(notebookView);
+    }
+    this.libroViewTracker.viewCache.set(notebookView.id, notebookView);
+
+    return notebookViewPromise;
+  }
+
+  protected watchNotebookView(view: NotebookView) {
+    view.initialized
+      .then(() => {
+        return this.onNotebookViewCreatedEmitter.fire(view);
+      })
+      .catch(() => {
+        //
+      });
+    this.toDispose.push(
+      view.onSave(() => {
+        this.onNotebookViewSavedEmitter.fire(view);
+      }),
+    );
+    this.toDispose.push(
+      view.model.onCellContentChanged((e) => {
+        this.onNotebookCellChangedEmitter.fire(e);
+      }),
+    );
+    this.toDispose.push(
+      view.model.onCellViewChanged((e) => {
+        const changes: NotebookViewChange = {
+          libroView: view,
+          cellChanges: [],
+          contentChanges: [],
+        };
+
+        if (e.delete) {
+          changes.contentChanges.push({
+            range: {
+              start: e.delete.index,
+              end: e.delete.index + e.delete?.number,
+            },
+            removedCells: e.delete.cells,
+            addedCells: [],
+          });
+          this.onNotebookCellDeletedEmitter.fire(e.delete.cells);
+        }
+
+        if (e.insert) {
+          changes.contentChanges.push({
+            range: {
+              start: e.insert.index,
+              end: e.insert.index + e.insert?.cells.length,
+            },
+            removedCells: [],
+            addedCells: e.insert.cells,
+          });
+          this.onNotebookCellCreatedEmitter.fire(e.insert.cells);
+        }
+
+        this.onNotebookViewChangedEmitter.fire(changes);
+      }),
+    );
+  }
+
+  setActive(view?: NotebookView): void {
+    this._active = view;
+    this.onActiveChangedEmitter.fire(view);
+  }
+
+  setHasFocus(hasFocus: boolean): void {
+    this._hasFocus = hasFocus;
+  }
+
+  protected isDisposed = false;
+  get disposed() {
+    return this.isDisposed;
+  }
+  dispose() {
+    this.toDispose.dispose();
+    this.isDisposed = true;
+  }
+}

package/src/libro-setting-contribution.ts

@@ -0,0 +1,28 @@
+import { singleton, ConfigurationContribution } from '@difizen/mana-app';
+
+import {
+  AutoInsertWhenNoCell,
+  CellSideToolbarVisible,
+  CellTopToolbarSetting,
+  CollapserClickActive,
+  EnterEditModeWhenAddCell,
+  HeaderToolbarVisible,
+  MultiSelectionWhenShiftClick,
+  RightContentFixed,
+} from './libro-setting.js';
+
+@singleton({ contrib: ConfigurationContribution })
+export class LibroSettingContribution implements ConfigurationContribution {
+  registerConfigurations() {
+    return [
+      HeaderToolbarVisible,
+      CellTopToolbarSetting,
+      CellSideToolbarVisible,
+      AutoInsertWhenNoCell,
+      EnterEditModeWhenAddCell,
+      CollapserClickActive,
+      MultiSelectionWhenShiftClick,
+      RightContentFixed,
+    ];
+  }
+}