@difizen/libro-core 0.0.2-alpha.0

package/src/output/output-area.tsx

@@ -0,0 +1,255 @@
+import type { IOutput } from '@difizen/libro-common';
+import { isError, isStream } from '@difizen/libro-common';
+import type { ViewComponent } from '@difizen/mana-app';
+import type { Contribution } from '@difizen/mana-app';
+import {
+  ViewOption,
+  getOrigin,
+  ViewRender,
+  BaseView,
+  Priority,
+  useInject,
+  view,
+  ViewInstance,
+} from '@difizen/mana-app';
+import { Emitter } from '@difizen/mana-app';
+import { contrib, inject, transient } from '@difizen/mana-app';
+import { prop } from '@difizen/mana-app';
+import React, { useEffect } from 'react';
+import { v4 } from 'uuid';
+
+import { ExecutableCellView } from '../cell/index.js';
+import type { CellView } from '../libro-protocol.js';
+
+import type {
+  BaseOutputArea,
+  BaseOutputView,
+  IOutputAreaOption,
+} from './output-protocol.js';
+import { OutputContribution } from './output-protocol.js';
+
+const LibroOutputAreaRender = React.forwardRef<HTMLDivElement>(
+  function LibroOutputAreaRender(_props, ref) {
+    const outputArea = useInject<LibroOutputArea>(ViewInstance);
+
+    useEffect(() => {
+      outputArea.onUpdateEmitter.fire();
+    }, [outputArea.onUpdateEmitter, outputArea.outputs]);
+
+    return (
+      <div className="libro-output-area" ref={ref}>
+        {outputArea.outputs.map((output) => {
+          return <ViewRender view={output} key={output.id} />;
+        })}
+      </div>
+    );
+  },
+);
+
+@transient()
+@view('libro-output-area')
+export class LibroOutputArea extends BaseView implements BaseOutputArea {
+  override view: ViewComponent = LibroOutputAreaRender;
+  cell: CellView;
+  @prop()
+  outputs: BaseOutputView[] = [];
+
+  @contrib(OutputContribution)
+  outputProvider: Contribution.Provider<OutputContribution>;
+
+  constructor(@inject(ViewOption) option: IOutputAreaOption) {
+    super();
+    this.cell = option.cell;
+  }
+  disposed?: boolean | undefined;
+
+  get length() {
+    return this.outputs.length;
+  }
+
+  protected clearNext = false;
+  protected lastStream = '';
+
+  protected lastName?: 'stdout' | 'stderr';
+
+  /**
+   * @internal
+   */
+  onUpdateEmitter = new Emitter<void>();
+
+  get onUpdate() {
+    return this.onUpdateEmitter.event;
+  }
+
+  get(index: number): BaseOutputView {
+    if (index >= 0 && index < this.outputs.length) {
+      return this.outputs[index];
+    }
+    throw new Error('index out of range');
+  }
+  protected doCreateOutput(options: IOutput): Promise<BaseOutputView> {
+    const provider = this.findProvider(options);
+
+    return provider.factory({
+      output: { _librOutputId: v4(), ...options },
+      trusted: this.cell.model.trusted,
+      cell: this.cell,
+    });
+  }
+  add = async (output: IOutput): Promise<number> => {
+    // if (this.clearNext) {
+    //   this.clear();
+    //   this.clearNext = false;
+    // }
+    // Consolidate outputs if they are stream outputs of the same kind.
+    if (
+      isStream(output) &&
+      this.lastStream &&
+      output.name === this.lastName &&
+      this.shouldCombine({
+        output,
+        lastModel: this.outputs[this.length - 1],
+      })
+    ) {
+      // In order to get a list change event, we add the previous
+      // text to the current item and replace the previous item.
+      // This also replaces the metadata of the last item.
+      this.lastStream += normalize(output.text);
+      this.lastStream = removeOverwrittenChars(this.lastStream);
+      output.text = this.lastStream;
+      const index = this.length - 1;
+      this.set(index, output);
+      return this.length;
+    }
+
+    if (isStream(output)) {
+      output.text = removeOverwrittenChars(normalize(output.text));
+    }
+
+    const outputModel = this.doCreateOutput(output);
+
+    // Update the stream information.
+    if (isStream(output)) {
+      this.lastStream = normalize(output.text);
+      this.lastName = output.name;
+    } else {
+      this.lastStream = '';
+    }
+    return this.outputs.push(await outputModel);
+  };
+  set = async (index: number, output: IOutput) => {
+    const outputModel = this.doCreateOutput(output);
+    const current = this.outputs[index];
+    current.dispose();
+    this.outputs[index] = await outputModel;
+  };
+  clear(wait?: boolean | undefined) {
+    this.lastStream = '';
+    if (wait) {
+      this.clearNext = true;
+      return;
+    }
+    this.outputs.forEach((output) => {
+      output.dispose();
+    });
+    this.outputs = [];
+  }
+  fromJSON = async (values: IOutput[]) => {
+    if (!values) {
+      return;
+    }
+    // this.clear();
+    for (const value of values) {
+      await this.add(value);
+    }
+  };
+  toJSON = (): IOutput[] => {
+    return this.outputs.map((output) => output.toJSON());
+  };
+
+  setupCellView(cell: CellView) {
+    this.cell = cell;
+  }
+
+  protected findProvider(options: IOutput): OutputContribution {
+    const prioritized = Priority.sortSync(
+      this.outputProvider.getContributions(),
+      (contribution) => contribution.canHandle(options),
+    );
+    const sorted = prioritized.map((c) => c.value);
+    return sorted[0]!;
+  }
+
+  /**
+   * Whether a new value should be consolidated with the previous output.
+   *
+   * This will only be called if the minimal criteria of both being stream
+   * messages of the same type.
+   */
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  protected shouldCombine(_options: {
+    output: IOutput;
+    lastModel: BaseOutputView;
+  }): boolean {
+    return true;
+  }
+}
+
+/**
+ * Remove characters that are overridden by backspace characters.
+ */
+function fixBackspace(txt: string): string {
+  let tmp = txt;
+  do {
+    // eslint-disable-next-line no-param-reassign
+    txt = tmp;
+    // Cancel out anything-but-newline followed by backspace
+    tmp = txt.replace(/[^\n]\x08/gm, ''); // eslint-disable-line no-control-regex
+  } while (tmp.length < txt.length);
+  return txt;
+}
+
+/**
+ * Remove chunks that should be overridden by the effect of
+ * carriage return characters.
+ */
+function fixCarriageReturn(txt: string): string {
+  // eslint-disable-next-line no-param-reassign
+  txt = txt.replace(/\r+\n/gm, '\n'); // \r followed by \n --> newline
+  while (txt.search(/\r[^$]/g) > -1) {
+    const base = txt.match(/^(.*)\r+/m)![1];
+    let insert = txt.match(/\r+(.*)$/m)![1];
+    insert = insert + base.slice(insert.length, base.length);
+    // eslint-disable-next-line no-param-reassign
+    txt = txt.replace(/\r+.*$/m, '\r').replace(/^.*\r/m, insert);
+  }
+  return txt;
+}
+
+/*
+ * Remove characters overridden by backspaces and carriage returns
+ */
+export function removeOverwrittenChars(text: string): string {
+  return fixCarriageReturn(fixBackspace(text));
+}
+
+/**
+ * Normalize an output.
+ */
+//TODO: output处理
+export function normalize(value: string[] | string): string {
+  if (Array.isArray(value)) {
+    return value.join('');
+  }
+  return value;
+}
+
+export function hasErrorOutput(cell: CellView): boolean {
+  if (!ExecutableCellView.is(cell)) {
+    return false;
+  }
+  if (cell.outputArea && cell.outputArea.length) {
+    return !!cell.outputArea.outputs.find((output) => isError(getOrigin(output.raw)));
+  }
+  return false;
+}

package/src/output/output-contribution.ts

@@ -0,0 +1,18 @@
+import { ViewManager } from '@difizen/mana-app';
+import { inject, singleton } from '@difizen/mana-app';
+
+import { LibroOutputView } from './output-model.js';
+import type { IOutputOptions } from './output-protocol.js';
+import { OutputContribution } from './output-protocol.js';
+
+@singleton({ contrib: OutputContribution })
+export class DefaultOutputContribution implements OutputContribution {
+  viewManager: ViewManager;
+  constructor(@inject(ViewManager) viewManager: ViewManager) {
+    this.viewManager = viewManager;
+  }
+  canHandle = () => 1;
+  factory(output: IOutputOptions) {
+    return this.viewManager.getOrCreateView(LibroOutputView, output);
+  }
+}

package/src/output/output-model.tsx

@@ -0,0 +1,66 @@
+import type { IOutput, JSONObject, PartialJSONObject } from '@difizen/libro-common';
+import { BaseView, prop, view, ViewOption } from '@difizen/mana-app';
+import { inject, transient } from '@difizen/mana-app';
+import type { FC } from 'react';
+import { v4 } from 'uuid';
+
+import type { CellView } from '../libro-protocol.js';
+
+import type { IOutputOptions } from './output-protocol.js';
+import type { ISetDataOptions, BaseOutputView } from './output-protocol.js';
+
+const LibroOutputModelRender: FC<{ output: BaseOutputView }> = (props: {
+  output: BaseOutputView;
+}) => {
+  const { output } = props;
+  return <div>{JSON.stringify(output.toJSON(), null, 2)}</div>;
+};
+
+@transient()
+@view('libro-output-model')
+export class LibroOutputView extends BaseView implements BaseOutputView {
+  override id = v4();
+
+  // 增加cell属性，使得通过output可以找到Cell
+  cell: CellView;
+  type: string;
+
+  @prop()
+  raw: IOutput;
+
+  @prop()
+  data: JSONObject;
+  @prop()
+  metadata: PartialJSONObject;
+  constructor(@inject(ViewOption) options: IOutputOptions) {
+    super();
+    this.raw = options.output;
+    this.trusted = options.trusted;
+    this.cell = options.cell;
+    this.type = 'libro-default-output';
+    this.data = {};
+    this.metadata = {};
+  }
+
+  render: FC<{ output: BaseOutputView }> = LibroOutputModelRender;
+  trusted: boolean;
+  override dispose() {
+    //
+  }
+  toJSON() {
+    return this.raw;
+  }
+  setData(options: ISetDataOptions): void {
+    if (options.data) {
+      this.data = options.data;
+    }
+    if (options.metadata) {
+      this.metadata = options.metadata;
+    }
+  }
+}
+
+/**
+ * @deprecated use LibroOutputView instead.
+ */
+export const LibroOutputModel = LibroOutputView;

package/src/output/output-module.ts

@@ -0,0 +1,10 @@
+import { ManaModule } from '@difizen/mana-app';
+
+import { LibroOutputArea } from './output-area.js';
+import { DefaultOutputContribution } from './output-contribution.js';
+import { LibroOutputModel } from './output-model.js';
+import { OutputContribution } from './output-protocol.js';
+
+export const OutputModule = ManaModule.create()
+  .contribution(OutputContribution)
+  .register(LibroOutputArea, LibroOutputModel, DefaultOutputContribution);

package/src/output/output-protocol.ts

@@ -0,0 +1,164 @@
+import type {
+  IOutput,
+  ReadonlyPartialJSONObject,
+  JSONObject,
+} from '@difizen/libro-common';
+import type { Event } from '@difizen/mana-app';
+import type { View } from '@difizen/mana-app';
+import { Syringe } from '@difizen/mana-app';
+
+import type { CellView } from '../libro-protocol.js';
+// import type { CellModel } from '../libro-protocol';
+
+export const CellOption = Symbol('CellOption');
+
+export interface IOutputAreaOption {
+  cellId: string;
+  outputAreaId?: string;
+  cell: CellView;
+}
+
+export interface BaseOutputArea extends View {
+  /**
+   * The length of the items in the model.
+   */
+  readonly length: number;
+
+  /**
+   * Whether the output area is trusted.
+   */
+  // trusted: boolean;
+
+  /**
+   * Get an item at the specified index.
+   */
+  get: (index: number) => BaseOutputModel;
+
+  /**
+   * Add an output, which may be combined with previous output.
+   *
+   * @returns The total number of outputs.
+   *
+   * #### Notes
+   * The output bundle is copied.
+   * Contiguous stream outputs of the same `name` are combined.
+   */
+  add: (output: IOutput) => Promise<number>;
+
+  /**
+   * Set the value at the specified index.
+   */
+  set: (index: number, output: IOutput) => Promise<void>;
+
+  /**
+   * Clear all of the output.
+   *
+   * @param wait - Delay clearing the output until the next message is added.
+   */
+  clear: (wait?: boolean) => void;
+
+  /**
+   * Deserialize the model from JSON.
+   *
+   * #### Notes
+   * This will clear any existing data.
+   */
+  fromJSON: (values: IOutput[]) => Promise<void>;
+
+  /**
+   * Serialize the model to JSON.
+   */
+  toJSON: () => IOutput[];
+
+  outputs: BaseOutputModel[];
+
+  cell: CellView;
+
+  setupCellView: (cell: CellView) => void;
+
+  get onUpdate(): Event<void>;
+}
+
+/**
+ * The interface for an output model.
+ */
+export interface BaseOutputView extends View {
+  id: string;
+
+  raw: IOutput;
+
+  cell: CellView;
+
+  /**
+   * The output type.
+   */
+  readonly type: string;
+
+  /**
+   * Whether the output is trusted.
+   */
+  trusted: boolean;
+  /**
+   * The data associated with the model.
+   */
+  readonly data: JSONObject;
+
+  /**
+   * The metadata associated with the model.
+   *
+   * Among others, it can include an attribute named `fragment`
+   * that stores a URI fragment identifier for the MIME resource.
+   */
+  readonly metadata: ReadonlyPartialJSONObject;
+  /**
+   * Dispose of the resources used by the output model.
+   */
+  dispose: () => void;
+
+  /**
+   * Serialize the model to JSON.
+   */
+  toJSON: () => IOutput;
+
+  /**
+   * Set the data associated with the model.
+   *
+   * #### Notes
+   * Depending on the implementation of the mime model,
+   */
+  setData(options: ISetDataOptions): void;
+}
+
+/**
+ * @deprecated use BaseOutputView instead
+ */
+export type BaseOutputModel = BaseOutputView;
+
+/**
+ * The options used to update a output model.
+ */
+export interface ISetDataOptions {
+  /**
+   * The new data object.
+   */
+  data?: JSONObject;
+
+  /**
+   * The new metadata object.
+   */
+  metadata?: JSONObject;
+}
+
+export interface IOutputOptions {
+  output: IOutput;
+  trusted: boolean;
+  cell: CellView;
+}
+
+export type OutputModelFactory = (options: IOutputOptions) => Promise<BaseOutputModel>;
+
+export const OutputContribution = Syringe.defineToken('OutputContribution');
+export interface OutputContribution {
+  canHandle: (output: IOutput) => number;
+  factory: OutputModelFactory;
+}

package/src/slot/index.ts

@@ -0,0 +1,4 @@
+export * from './libro-slot-protocol.js';
+export * from './libro-slot-manager.js';
+export * from './libro-slot-view.js';
+export * from './module.js';

package/src/slot/libro-slot-manager.ts

@@ -0,0 +1,37 @@
+import type { Contribution } from '@difizen/mana-app';
+import { SlotViewManager } from '@difizen/mana-app';
+import { contrib, inject, singleton } from '@difizen/mana-app';
+
+import type { LibroView } from '../libro-view.js';
+
+import type { LibroSlot } from './libro-slot-protocol.js';
+import { LibroExtensionSlotContribution } from './libro-slot-protocol.js';
+
+@singleton()
+export class LibroSlotManager {
+  protected slotViewManager: SlotViewManager;
+  protected readonly libroExtraProvider: Contribution.Provider<LibroExtensionSlotContribution>;
+  constructor(
+    @inject(SlotViewManager) slotViewManager: SlotViewManager,
+    @contrib(LibroExtensionSlotContribution)
+    libroExtraProvider: Contribution.Provider<LibroExtensionSlotContribution>,
+  ) {
+    this.libroExtraProvider = libroExtraProvider;
+    this.slotViewManager = slotViewManager;
+  }
+
+  getSlotName(libro: LibroView, slot: LibroSlot): string {
+    return `libro-slot-${slot}-${libro.id}`;
+  }
+
+  setup(libro: LibroView) {
+    this.libroExtraProvider.getContributions().forEach(async (item) => {
+      const extra = await item.factory(libro);
+      this.slotViewManager.addView(
+        extra,
+        this.getSlotName(libro, item.slot),
+        item.viewOpenOption,
+      );
+    });
+  }
+}

package/src/slot/libro-slot-protocol.ts

@@ -0,0 +1,28 @@
+import type { View } from '@difizen/mana-app';
+import { Syringe } from '@difizen/mana-app';
+
+import type { LibroView } from '../libro-view.js';
+
+export type LibroExtensionSlotFactory = (view: LibroView) => Promise<View>;
+
+export const LibroExtensionSlotContribution = Syringe.defineToken(
+  'LibroExtensionSlotContribution',
+);
+export interface LibroExtensionSlotContribution {
+  factory: LibroExtensionSlotFactory;
+  slot: LibroSlot;
+  viewOpenOption?: {
+    order?: string;
+    reveal?: boolean;
+  };
+}
+
+export type LibroSlot = 'content' | 'container' | 'list' | 'right' | 'containerLog';
+
+export interface DisplayView {
+  isDisplay: boolean;
+}
+
+export function isDisplayView(object: any): object is DisplayView {
+  return 'isDisplay' in object;
+}

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

@@ -0,0 +1,51 @@
+import { DefaultSlotView, view, ViewRender, ViewInstance } from '@difizen/mana-app';
+import { transient } from '@difizen/mana-app';
+import { equals, prop, useInject } from '@difizen/mana-app';
+import React, { forwardRef } from 'react';
+
+import { isDisplayView } from './libro-slot-protocol.js';
+
+export const LibroExtensionViewComponent = forwardRef(
+  function LibroExtensionViewComponent(
+    _props,
+    ref: React.ForwardedRef<HTMLDivElement>,
+  ) {
+    const instance = useInject<LibroSlotView>(ViewInstance);
+    //过滤出实现了DisplayView接口的View,用于控制抢占逻辑
+    const filteredChildren = instance.children.filter((item) => {
+      return isDisplayView(item) && item.isDisplay;
+    });
+    if (filteredChildren.length < 1) {
+      return (
+        <div className={'libro-slot-container'} ref={ref}>
+          {instance.children.map(
+            (item) => !isDisplayView(item) && <ViewRender view={item} key={item.id} />,
+          )}
+        </div>
+      );
+    } else {
+      const activeView =
+        filteredChildren.find(
+          (item) => instance.active && equals(item, instance.active),
+        ) || filteredChildren[filteredChildren.length - 1];
+      return (
+        <div className={'libro-slot-container'} ref={ref}>
+          <ViewRender view={activeView} />
+          {instance.children.map(
+            (item) => !isDisplayView(item) && <ViewRender view={item} key={item.id} />,
+          )}
+        </div>
+      );
+    }
+  },
+);
+
+@transient()
+@view('libro-slot-view')
+export class LibroSlotView extends DefaultSlotView {
+  override label: React.ReactNode = null;
+  override view = LibroExtensionViewComponent;
+  @prop()
+  override sort?: boolean = false;
+  // sort?: boolean = true;
+}

package/src/slot/module.ts

@@ -0,0 +1,9 @@
+import { ManaModule } from '@difizen/mana-app';
+
+import { LibroSlotManager } from './libro-slot-manager.js';
+import { LibroExtensionSlotContribution } from './libro-slot-protocol.js';
+import { LibroSlotView } from './libro-slot-view.js';
+
+export const LibroSlotModule = ManaModule.create()
+  .contribution(LibroExtensionSlotContribution)
+  .register(LibroSlotManager, LibroSlotView);