chore: remove unused methods on slot (#9472)

blocksuite/framework/global/src/__tests__/slot.unit.spec.ts

@@ -43,16 +43,4 @@ describe('slot', () => {
     slot.emit();
     expect(callback).toBeCalledTimes(0);
   });
-
-  test('subscribe', () => {
-    type Data = {
-      name: string;
-      age: number;
-    };
-    const slot = new Slot<Data>();
-    const callback = vi.fn(v => expect(v).toBe('田所'));
-    slot.subscribe(v => v.name, callback);
-    slot.emit({ name: '田所', age: 24 });
-    expect(callback).toBeCalledTimes(1);
-  });
 });

blocksuite/framework/global/src/utils/slot.ts

@@ -1,7 +1,5 @@
 import { type Disposable, flattenDisposables } from './disposable.js';
 
-// Credits to blocky-editor
-// https://github.com/vincentdchan/blocky-editor
 export class Slot<T = void> implements Disposable {
   private _callbacks: ((v: T) => unknown)[] = [];
 
@@ -9,28 +7,6 @@ export class Slot<T = void> implements Disposable {
 
   private _emitting = false;
 
-  subscribe = <U>(
-    selector: (state: T) => U,
-    callback: (value: U) => void,
-    config?: {
-      equalityFn?: (a: U, b: U) => boolean;
-      filter?: (state: T) => boolean;
-    }
-  ) => {
-    let prevState: U | undefined;
-    const { filter, equalityFn = Object.is } = config ?? {};
-    return this.on(state => {
-      if (filter && !filter(state)) {
-        return;
-      }
-      const nextState = selector(state);
-      if (prevState === undefined || !equalityFn(prevState, nextState)) {
-        callback(nextState);
-        prevState = nextState;
-      }
-    });
-  };
-
   dispose() {
     flattenDisposables(this._disposables).dispose();
     this._callbacks = [];
@@ -50,40 +26,6 @@ export class Slot<T = void> implements Disposable {
     this._emitting = prevEmitting;
   }
 
-  filter(testFun: (v: T) => boolean): Slot<T> {
-    const result = new Slot<T>();
-    // if the original slot is disposed, dispose the filtered one
-    this._disposables.push({
-      dispose: () => result.dispose(),
-    });
-
-    this.on((v: T) => {
-      if (testFun(v)) {
-        result.emit(v);
-      }
-    });
-
-    return result;
-  }
-
-  flatMap<U>(mapper: (v: T) => U[] | U): Slot<U> {
-    const result = new Slot<U>();
-    this._disposables.push({
-      dispose: () => result.dispose(),
-    });
-
-    this.on((v: T) => {
-      const data = mapper(v);
-      if (Array.isArray(data)) {
-        data.forEach(v => result.emit(v));
-      } else {
-        result.emit(data);
-      }
-    });
-
-    return result;
-  }
-
   on(callback: (v: T) => unknown): Disposable {
     if (this._emitting) {
       const newCallback = [...this._callbacks, callback];
@@ -118,34 +60,19 @@ export class Slot<T = void> implements Disposable {
     return disposable;
   }
 
-  pipe(that: Slot<T>): Slot<T> {
+  filter(testFun: (v: T) => boolean): Slot<T> {
-    this._callbacks.push(v => that.emit(v));
+    const result = new Slot<T>();
-    return this;
+    // if the original slot is disposed, dispose the filtered one
-  }
+    this._disposables.push({
+      dispose: () => result.dispose(),
+    });
 
-  toDispose(disposables: Disposable[]): Slot<T> {
+    this.on((v: T) => {
-    disposables.push(this);
+      if (testFun(v)) {
-    return this;
+        result.emit(v);
       }
+    });
 
-  unshift(callback: (v: T) => unknown): Disposable {
+    return result;
-    if (this._emitting) {
-      const newCallback = [callback, ...this._callbacks];
-      this._callbacks = newCallback;
-    } else {
-      this._callbacks.unshift(callback);
-    }
-    return {
-      dispose: () => {
-        if (this._emitting) {
-          this._callbacks = this._callbacks.filter(v => v !== callback);
-        } else {
-          const index = this._callbacks.indexOf(callback);
-          if (index > -1) {
-            this._callbacks.splice(index, 1); // remove one item only
-          }
-        }
-      },
-    };
   }
 }