feat: add async interceptor

packages/core/src/common/interceptor.ts

@@ -14,8 +14,8 @@
  * limitations under the License.
  */
 
-import { remove } from './array';
 import type { Nullable } from '../shared/types';
+import { remove } from './array';
 
 export type InterceptorHandler<M = unknown, C = unknown> = (
     value: Nullable<M>,
@@ -118,3 +118,96 @@ export class InterceptorManager<P extends Record<string, IInterceptor<any, any>>
         this._interceptorsByName.clear();
     }
 }
+
+export function createAsyncInterceptorKey<T, C>(key: string): IAsyncInterceptor<T, C> {
+    const symbol = `sheet_interceptor_${key}`;
+    return symbol as unknown as IAsyncInterceptor<T, C>; // FIXME: priority and handler is completely missing?
+};
+
+export type AsyncInterceptorHandler<M = unknown, C = unknown> = (
+    value: Nullable<M>,
+    context: C,
+    next?: (value: Nullable<M>) => Promise<Nullable<M>>
+) => Promise<Nullable<M>>;
+
+export interface IAsyncInterceptor<M, C> {
+    priority?: number;
+    handler: AsyncInterceptorHandler<M, C>;
+}
+
+export type IComposeAsyncInterceptors<T = any, C = any> = (
+    interceptors: Array<IAsyncInterceptor<T, C>>
+) => (initValue: Nullable<T>, initContext: C) => Promise<Nullable<T>>;
+
+export const composeAsyncInterceptors = <T, C>(
+    interceptors: Array<IAsyncInterceptor<T, C>>
+): ((initialValue: Nullable<T>, context: C) => Promise<Nullable<T>>) => {
+    return async function (initialValue: Nullable<T>, context: C) {
+        let index = -1;
+        let value: Nullable<T> = initialValue;
+
+        for (let i = 0; i <= interceptors.length; i++) {
+            if (i <= index) {
+                throw new Error('[SheetInterceptorService]: next() called multiple times!');
+            }
+
+            index = i;
+
+            if (i === interceptors.length) {
+                return value;
+            }
+
+            const interceptor = interceptors[i];
+            let nextCalled = false;
+
+            value = await interceptor.handler!(value, context, async (nextValue) => {
+                nextCalled = true;
+                return nextValue;
+            });
+
+            if (!nextCalled) {
+                break;
+            }
+        }
+
+        return value;
+    };
+};
+
+export class AsyncInterceptorManager<P extends Record<string, IAsyncInterceptor<any, any>>> {
+    private _asyncInterceptorsByName: Map<string, Array<IAsyncInterceptor<unknown, unknown>>> = new Map();
+    private _asyncInterceptorPoints: P;
+
+    constructor(asyncInterceptorPoints: P) {
+        this._asyncInterceptorPoints = asyncInterceptorPoints;
+    }
+
+    public fetchThroughAsyncInterceptors<T, C>(name: IAsyncInterceptor<T, C>) {
+        const key = name as unknown as string;
+        const interceptors = this._asyncInterceptorsByName.get(key) as unknown as Array<typeof name>;
+        return composeAsyncInterceptors(interceptors || []);
+    }
+
+    public async interceptAsync<T extends IAsyncInterceptor<any, any>>(name: T, interceptor: T) {
+        const key = name as unknown as string;
+        if (!this._asyncInterceptorsByName.has(key)) {
+            this._asyncInterceptorsByName.set(key, []);
+        }
+        const interceptors = this._asyncInterceptorsByName.get(key)!;
+        interceptors.push(interceptor);
+
+        this._asyncInterceptorsByName.set(
+            key,
+            interceptors.sort((a, b) => (b.priority ?? 0) - (a.priority ?? 0)) // from large to small
+        );
+        return () => remove(this._asyncInterceptorsByName.get(key)!, interceptor);
+    }
+
+    public getInterceptPoints() {
+        return this._asyncInterceptorPoints;
+    }
+
+    public dispose() {
+        this._asyncInterceptorsByName.clear();
+    }
+}

packages/core/src/index.ts

@@ -36,7 +36,7 @@ export { shallowEqual } from './common/equal';
 export { CustomCommandExecutionError } from './common/error';
 export { throttle } from './common/function';
 export type { ICellInterceptor, IComposeInterceptors, IInterceptor, InterceptorHandler } from './common/interceptor';
-export { composeInterceptors, createInterceptorKey, InterceptorEffectEnum, InterceptorManager } from './common/interceptor';
+export { AsyncInterceptorManager, composeInterceptors, createAsyncInterceptorKey, createInterceptorKey, InterceptorEffectEnum, InterceptorManager } from './common/interceptor';
 export type { Serializable } from './common/json';
 export { MemoryCursor } from './common/memory-cursor';
 export { mixinClass } from './common/mixin';