refactor(editor): rename block-std to std (#11250)

Closes: BS-2946

blocksuite/framework/std/src/event/state/clipboard.ts

@@ -0,0 +1,23 @@
+import { UIEventState } from '../base.js';
+
+type ClipboardEventStateOptions = {
+  event: ClipboardEvent;
+};
+
+export class ClipboardEventState extends UIEventState {
+  raw: ClipboardEvent;
+
+  override type = 'clipboardState';
+
+  constructor({ event }: ClipboardEventStateOptions) {
+    super(event);
+
+    this.raw = event;
+  }
+}
+
+declare global {
+  interface BlockSuiteUIEventState {
+    clipboardState: ClipboardEventState;
+  }
+}

blocksuite/framework/std/src/event/state/dnd.ts

@@ -0,0 +1,23 @@
+import { UIEventState } from '../base.js';
+
+type DndEventStateOptions = {
+  event: DragEvent;
+};
+
+export class DndEventState extends UIEventState {
+  raw: DragEvent;
+
+  override type = 'dndState';
+
+  constructor({ event }: DndEventStateOptions) {
+    super(event);
+
+    this.raw = event;
+  }
+}
+
+declare global {
+  interface BlockSuiteUIEventState {
+    dndState: DndEventState;
+  }
+}

blocksuite/framework/std/src/event/state/index.ts

@@ -0,0 +1,5 @@
+export * from './clipboard.js';
+export * from './dnd.js';
+export * from './keyboard.js';
+export * from './pointer.js';
+export * from './source.js';

blocksuite/framework/std/src/event/state/keyboard.ts

@@ -0,0 +1,27 @@
+import { UIEventState } from '../base.js';
+
+type KeyboardEventStateOptions = {
+  event: KeyboardEvent;
+  composing: boolean;
+};
+
+export class KeyboardEventState extends UIEventState {
+  composing: boolean;
+
+  raw: KeyboardEvent;
+
+  override type = 'keyboardState';
+
+  constructor({ event, composing }: KeyboardEventStateOptions) {
+    super(event);
+
+    this.raw = event;
+    this.composing = composing;
+  }
+}
+
+declare global {
+  interface BlockSuiteUIEventState {
+    keyboardState: KeyboardEventState;
+  }
+}

blocksuite/framework/std/src/event/state/pointer.ts

@@ -0,0 +1,83 @@
+import { UIEventState } from '../base.js';
+
+type PointerEventStateOptions = {
+  event: PointerEvent;
+  rect: DOMRect;
+  startX: number;
+  startY: number;
+  last: PointerEventState | null;
+};
+
+type Point = { x: number; y: number };
+
+export class PointerEventState extends UIEventState {
+  button: number;
+
+  containerOffset: Point;
+
+  delta: Point;
+
+  keys: {
+    shift: boolean;
+    cmd: boolean;
+    alt: boolean;
+  };
+
+  point: Point;
+
+  pressure: number;
+
+  raw: PointerEvent;
+
+  start: Point;
+
+  override type = 'pointerState';
+
+  get x() {
+    return this.point.x;
+  }
+
+  get y() {
+    return this.point.y;
+  }
+
+  constructor({ event, rect, startX, startY, last }: PointerEventStateOptions) {
+    super(event);
+
+    const offsetX = event.clientX - rect.left;
+    const offsetY = event.clientY - rect.top;
+
+    this.raw = event;
+    this.point = { x: offsetX, y: offsetY };
+    this.containerOffset = { x: rect.left, y: rect.top };
+    this.start = { x: startX, y: startY };
+    this.delta = last
+      ? { x: offsetX - last.point.x, y: offsetY - last.point.y }
+      : { x: 0, y: 0 };
+    this.keys = {
+      shift: event.shiftKey,
+      cmd: event.metaKey || event.ctrlKey,
+      alt: event.altKey,
+    };
+    this.button = last?.button || event.button;
+    this.pressure = event.pressure;
+  }
+}
+
+export class MultiPointerEventState extends UIEventState {
+  pointers: PointerEventState[];
+
+  override type = 'multiPointerState';
+
+  constructor(event: PointerEvent, pointers: PointerEventState[]) {
+    super(event);
+    this.pointers = pointers;
+  }
+}
+
+declare global {
+  interface BlockSuiteUIEventState {
+    pointerState: PointerEventState;
+    multiPointerState: MultiPointerEventState;
+  }
+}

blocksuite/framework/std/src/event/state/source.ts

@@ -0,0 +1,31 @@
+import { UIEventState } from '../base.js';
+
+export enum EventScopeSourceType {
+  // The event scope should be built by selection path
+  Selection = 'selection',
+
+  // The event scope should be built by event target
+  Target = 'target',
+}
+
+export type EventSourceStateOptions = {
+  event: Event;
+  sourceType: EventScopeSourceType;
+};
+
+export class EventSourceState extends UIEventState {
+  readonly sourceType: EventScopeSourceType;
+
+  override type = 'sourceState';
+
+  constructor({ event, sourceType }: EventSourceStateOptions) {
+    super(event);
+    this.sourceType = sourceType;
+  }
+}
+
+declare global {
+  interface BlockSuiteUIEventState {
+    sourceState: EventSourceState;
+  }
+}