synstate 6.1.1 → 7.0.0

package/src/core/operators/flat-map-sync-inner.test.mts

@@ -24,7 +24,8 @@ describe('an inner observable that holds a value is passed on in the update that
 
     a$.next(3);
 
-    assert.deepStrictEqual(mut_history, ['m2,s2', 'm3,s3']);
+    // 'm1,s1' from the value `a$` held when the operators were created.
+    assert.deepStrictEqual(mut_history, ['m1,s1', 'm2,s2', 'm3,s3']);
   });
 
   test('switchMap: a child of both it and its parent emits once per update', () => {
@@ -43,6 +44,7 @@ describe('an inner observable that holds a value is passed on in the update that
     a$.next(3);
 
     assert.deepStrictEqual(mut_history, [
+      [1, 10],
       [2, 20],
       [3, 30],
     ]);
@@ -85,6 +87,6 @@ describe('an inner observable that holds a value is passed on in the update that
 
     a$.next(2);
 
-    assert.deepStrictEqual(mut_history, ['m2,s2']);
+    assert.deepStrictEqual(mut_history, ['m1,s1', 'm2,s2']);
   });
 });

package/src/core/operators/inner-ownership.test.mts

@@ -1,5 +1,7 @@
-import { source } from '../create/index.mjs';
-import { createScope } from '../scope/index.mjs';
+import { panic } from 'ts-std-forge';
+import { toNode } from '../class/index.mjs';
+import { just, source } from '../create/index.mjs';
+import { createScope, onScopeDispose } from '../scope/index.mjs';
 import { map } from './map.mjs';
 import { mergeMap } from './merge-map.mjs';
 import { switchMap } from './switch-map.mjs';
@@ -278,3 +280,144 @@ describe('mergeMap releases only the inner observables its projection created (#
     assert.isFalse(shared$.isCompleted);
   });
 });
+
+describe('mergeMap releases an inner observable as soon as it completes (#2769)', () => {
+  test('disposes what the projection made once its inner observable completes', () => {
+    const click$ = source<number>();
+
+    const mut_inners: ReturnType<typeof source<string>>[] = [];
+
+    const mut_disposed: number[] = [];
+
+    const merged$ = click$.pipe(
+      mergeMap((n) => {
+        onScopeDispose(() => {
+          mut_disposed.push(n);
+        });
+
+        const inner$ = source<string>();
+
+        mut_inners.push(inner$);
+
+        return inner$;
+      }),
+    );
+
+    const mut_values: string[] = [];
+
+    merged$.subscribe((v) => {
+      mut_values.push(v);
+    });
+
+    click$.next(1);
+
+    click$.next(2);
+
+    mut_inners[0]?.next('a');
+
+    mut_inners[0]?.complete();
+
+    assert.deepStrictEqual(mut_disposed, [1]);
+
+    mut_inners[1]?.next('b');
+
+    assert.deepStrictEqual(mut_values, ['a', 'b']);
+
+    merged$.complete();
+
+    // Each projection's scope is disposed once.
+    assert.deepStrictEqual(mut_disposed, [1, 2]);
+  });
+
+  test('disposes at once what the projection made when its inner observable completes while subscribed', () => {
+    const click$ = source<number>();
+
+    const mut_disposed: number[] = [];
+
+    const merged$ = click$.pipe(
+      mergeMap((n) => {
+        onScopeDispose(() => {
+          mut_disposed.push(n);
+        });
+
+        return just(n);
+      }),
+    );
+
+    const mut_values: number[] = [];
+
+    merged$.subscribe((v) => {
+      mut_values.push(v);
+    });
+
+    click$.next(1);
+
+    click$.next(2);
+
+    assert.deepStrictEqual(mut_values, [1, 2]);
+
+    assert.deepStrictEqual(mut_disposed, [1, 2]);
+
+    merged$.complete();
+
+    assert.deepStrictEqual(mut_disposed, [1, 2]);
+  });
+
+  test('disposes what a projection that threw made when mergeMap completes', () => {
+    const click$ = source<number>();
+
+    const mut_disposed: number[] = [];
+
+    const merged$ = click$.pipe(
+      mergeMap((n) => {
+        onScopeDispose(() => {
+          mut_disposed.push(n);
+        });
+
+        return panic('projection failed');
+      }),
+    );
+
+    merged$.subscribe(() => {});
+
+    expect(() => {
+      click$.next(1);
+    }).toThrow('projection failed');
+
+    merged$.complete();
+
+    assert.deepStrictEqual(mut_disposed, [1]);
+  });
+
+  test('releases an inner observable when mergeMap completes while subscribing to it', () => {
+    const click$ = source<number>();
+
+    const inner$ = source<string>('first');
+
+    const mut_disposed: number[] = [];
+
+    const merged$ = click$.pipe(
+      mergeMap((n) => {
+        onScopeDispose(() => {
+          mut_disposed.push(n);
+        });
+
+        return inner$;
+      }),
+    );
+
+    merged$.subscribe((v) => {
+      if (v === 'first') {
+        merged$.complete();
+      }
+    });
+
+    click$.next(1);
+
+    assert.isTrue(merged$.isCompleted);
+
+    assert.deepStrictEqual(mut_disposed, [1]);
+
+    assert.isFalse(toNode(inner$).hasSubscriber);
+  });
+});

package/src/core/operators/keep-equal-parts.mts

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
@@ -20,19 +20,19 @@ import type {
 
 /**
  * Passes on each value with every part deeply equal to the same part of the
- * value passed on before replaced by that part, and skips a value deeply
- * equal to it altogether (structural sharing). A reader of a part that did
- * not change keeps the object it has, so `skipIfNoChange()` with `Object.is`
- * stops it. Superset of `skipIfNoChange(fastDeepEqual)`.
+ * value passed on before replaced by that part, and skips a value deeply equal
+ * to it altogether (structural sharing). A reader of a part that did not change
+ * keeps the object it has, so `skipIfNoChange()` with `Object.is` stops it.
+ * Superset of `skipIfNoChange(fastDeepEqual)`.
  *
  * **Prefer keeping references where the value is written** — compare before
- * `setState`, and skip it when nothing changed — so that nothing downstream
- * has anything to undo. The `keepEqualParts` option of `createState` and
- * `createReducer` does it for a state written whole, and `replaceEqualDeep`
- * of ts-data-forge does it for any other write. This operator lets every
- * update that changes nothing reach the source and everything up to it, and
- * walks the whole value again on each one; reach for it when the source is
- * not yours to change (a stream that arrives whole from outside).
+ * `setState`, and skip it when nothing changed — so that nothing downstream has
+ * anything to undo. The `keepEqualParts` option of `createState` and
+ * `createReducer` does it for a state written whole, and `replaceEqualDeep` of
+ * ts-data-forge does it for any other write. This operator lets every update
+ * that changes nothing reach the source and everything up to it, and walks the
+ * whole value again on each one; reach for it when the source is not yours to
+ * change (a stream that arrives whole from outside).
  *
  * Array items are matched by index; pass `{ key }` to match them by key, an
  * item for which `key` returns `undefined` being matched by index. Only plain
@@ -51,10 +51,9 @@ import type {
  *   cards: { id: number; text: string }[];
  * }>;
  *
- * // A stream that arrives whole from outside (a WebSocket, say), each
- * // message a new object even when nothing changed. A state you write
- * // yourself takes `createState(initial, { keepEqualParts: true })`
- * // instead.
+ * // A stream that arrives whole from outside (a WebSocket, say), each message
+ * // a new object even when nothing changed. A state you write yourself takes
+ * // `createState(initial, { keepEqualParts: true })` instead.
  * const message$ = source<Board>();
  *
  * const board$ = message$.pipe(keepEqualParts());

package/src/core/operators/map.mts

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function

package/src/core/operators/merge-map.mts

@@ -1,11 +1,12 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
 // @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
-import { Arr, Optional } from 'ts-data-forge';
+import { Optional } from 'ts-data-forge';
+import type { MutableMap } from 'ts-type-forge';
 import { AsyncChildObservableClass } from '../class/index.mjs';
 import { createScope, getCurrentScope } from '../scope/index.mjs';
 import type {
@@ -21,10 +22,14 @@ import type {
  * Projects each source value to an observable and merges all inner observables.
  * Unlike `switchMap`, does not cancel previous inner observables.
  *
+ * A value the source already holds when `mergeMap` is created is projected at
+ * once, as with `switchMap`. A completed source is not projected.
+ *
  * Each projection runs in a scope of its own (see `createScope`): what it
- * creates is disposed when `mergeMap` completes. An observable it only
- * returns — one created outside the projection and shared with others — is
- * unsubscribed and left running.
+ * creates is disposed when the observable it returned completes, or when
+ * `mergeMap` completes, whichever comes first. An observable it only returns —
+ * one created outside the projection and shared with others — is unsubscribed
+ * and left running.
  *
  * @template A - The type of values from the source
  * @template B - The type of values from the projected observable
@@ -136,8 +141,12 @@ class MergeMapObservableClass<A, B>
   /** See `SwitchMapObservableClass`. */
   readonly #ownerScope: Scope | undefined;
 
-  #mut_innerScopes: readonly Scope[];
-  #mut_subscriptions: readonly Subscription[];
+  /**
+   * The inner observables still live, by the scope their projection ran in.
+   * One that completes is released at once, so a long-lived `mergeMap` holds
+   * only those (#2769).
+   */
+  readonly #mut_liveInners: MutableMap<Scope, Subscription | undefined>;
 
   constructor(
     parentObservable: Observable<A>,
@@ -152,11 +161,47 @@ class MergeMapObservableClass<A, B>
 
     this.#ownerScope = getCurrentScope();
 
-    this.#mut_innerScopes = [];
+    this.#mut_liveInners = new Map<Scope, Subscription | undefined>();
+
+    this.attachProjectingHeldValue(parentObservable, (value, updateToken) => {
+      this.#project(value, updateToken);
+    });
+  }
+
+  /**
+   * Unsubscribes from an inner observable and disposes what its projection
+   * made.
+   */
+  #releaseInner(innerScope: Scope): void {
+    this.#mut_liveInners.get(innerScope)?.unsubscribe();
 
-    this.#mut_subscriptions = [];
+    this.#mut_liveInners.delete(innerScope);
 
-    this.attach();
+    innerScope.dispose();
+  }
+
+  /** Adds the inner observable of `value` to those merged. */
+  #project(value: A, updateToken: UpdateToken): void {
+    const innerScope = createScope(this.#ownerScope);
+
+    // Held before the projection runs, so that `teardown` disposes what it made
+    // even if it throws, or if `mergeMap` completes while the inner observable
+    // is being subscribed.
+    this.#mut_liveInners.set(innerScope, undefined);
+
+    const observable = innerScope.run(() => this.#mapToObservable(value));
+
+    const subscription = this.subscribeInner(observable, updateToken, () => {
+      this.#releaseInner(innerScope);
+    });
+
+    if (this.#mut_liveInners.has(innerScope)) {
+      this.#mut_liveInners.set(innerScope, subscription);
+    } else {
+      // Released while it was subscribed: the inner observable completed
+      // (`just(x)`), or `mergeMap` did.
+      subscription.unsubscribe();
+    }
   }
 
   override tryUpdate(updateToken: UpdateToken): void {
@@ -168,28 +213,13 @@ class MergeMapObservableClass<A, B>
       return; // skip update
     }
 
-    const innerScope = createScope(this.#ownerScope);
-
-    this.#mut_innerScopes = Arr.toPushed(this.#mut_innerScopes, innerScope);
-
-    const observable = innerScope.run(() => this.#mapToObservable(sn.value));
-
-    const subscription = this.subscribeInner(observable, updateToken);
-
-    this.#mut_subscriptions = Arr.toPushed(
-      this.#mut_subscriptions,
-      subscription,
-    );
+    this.#project(sn.value, updateToken);
   }
 
   /** Releases the inner observables, and only those this operator made. */
   protected override teardown(): void {
-    for (const s of this.#mut_subscriptions) {
-      s.unsubscribe();
-    }
-
-    for (const scope of this.#mut_innerScopes) {
-      scope.dispose();
+    for (const innerScope of this.#mut_liveInners.keys()) {
+      this.#releaseInner(innerScope);
     }
   }
 }

package/src/core/operators/pairwise.mts

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
@@ -90,8 +90,8 @@ class PairwiseObservableClass<A>
       initialValue: Optional.none,
     });
 
-    // parentObservable.snapshot has value
-    // if parentObservable is InitializedObservable
+    // parentObservable.snapshot has value if parentObservable is
+    // InitializedObservable
     this.#mut_previousValue = parentObservable.getSnapshot();
 
     this.attach();

package/src/core/operators/scan.mts

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function

package/src/core/operators/skip-if-no-change.mts

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
@@ -104,8 +104,8 @@ class SkipIfNoChangeObservableClass<A>
       initialValue: parentObservable.getSnapshot(),
     });
 
-    // parentObservable.snapshot has value
-    // if parentObservable is InitializedObservable
+    // parentObservable.snapshot has value if parentObservable is
+    // InitializedObservable
     this.#mut_previousValue = parentObservable.getSnapshot();
 
     this.#eq = eq;

package/src/core/operators/skip-until.mts

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
@@ -83,8 +83,8 @@ class SkipUntilObservableClass<A>
       initialValue: Optional.none,
     });
 
-    // A notifier that already holds a value, or has completed, would stop
-    // the skipping inside `subscribe`, before the subscription is stored.
+    // A notifier that already holds a value, or has completed, would stop the
+    // skipping inside `subscribe`, before the subscription is stored.
     this.#mut_isSkipping =
       Optional.isNone(notifier.getSnapshot()) && !notifier.isCompleted;
 

package/src/core/operators/skip-while.mts

@@ -1,11 +1,11 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
 // @sumi-expect-error-file mutation/no-mutation-without-mut-prefix
-import { Optional, SafeUint, asSafeUint, pipe } from 'ts-data-forge';
+import { Optional, asSafeUint, pipe, type SafeUint } from 'ts-data-forge';
 import { SyncChildObservableClass } from '../class/index.mjs';
 import type {
   DropInitialValueOperator,
@@ -93,16 +93,20 @@ class SkipWhileObservableClass<A>
     parentObservable: Observable<A>,
     predicate: (value: A, index: SafeUint | -1) => boolean,
   ) {
+    const initialValue = pipe(parentObservable.getSnapshot()).map((sn) =>
+      Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn,
+    ).value;
+
     super({
       parents: [parentObservable],
-      initialValue: pipe(parentObservable.getSnapshot()).map((sn) =>
-        Optional.isNone(sn) || predicate(sn.value, -1) ? Optional.none : sn,
-      ).value,
+      initialValue,
     });
 
     this.#mut_index = -1;
 
-    this.#mut_isSkipping = true;
+    // A parent value the predicate let through has ended the skipping, as any
+    // later one would.
+    this.#mut_isSkipping = Optional.isNone(initialValue);
 
     this.#predicate = predicate;
 
@@ -118,10 +122,10 @@ class SkipWhileObservableClass<A>
       return; // skip update
     }
 
-    this.#mut_index =
-      this.#mut_index === -1 ? asSafeUint(0) : SafeUint.add(1, this.#mut_index);
+    this.#mut_index = asSafeUint(this.#mut_index + 1);
 
-    if (!this.#predicate(sn.value, this.#mut_index)) {
+    // Once skipping has ended, the predicate is not asked again.
+    if (this.#mut_isSkipping && !this.#predicate(sn.value, this.#mut_index)) {
       this.#mut_isSkipping = false;
     }
 

package/src/core/operators/skip-while.test.mts

@@ -1,4 +1,5 @@
 import { Optional } from 'ts-data-forge';
+import { createState } from '../../utils/index.mjs';
 import { just } from '../create/index.mjs';
 import { skipWhile } from './skip-while.mjs';
 
@@ -17,4 +18,62 @@ describe(skipWhile, () => {
 
     assert.isTrue(Optional.isNone(dropped$.getSnapshot()));
   });
+
+  test('passes every later value once the initial value has ended the skipping', () => {
+    const [s$, setS] = createState(5);
+
+    const passed$ = s$.pipe(skipWhile((x) => x < 3));
+
+    const mut_history: number[] = [];
+
+    passed$.subscribe((x) => {
+      mut_history.push(x);
+    });
+
+    setS(1);
+
+    setS(2);
+
+    assert.deepStrictEqual(mut_history, [5, 1, 2]);
+  });
+
+  test('keeps skipping after an initial value the predicate skips', () => {
+    const [s$, setS] = createState(1);
+
+    const passed$ = s$.pipe(skipWhile((x) => x < 3));
+
+    const mut_history: number[] = [];
+
+    passed$.subscribe((x) => {
+      mut_history.push(x);
+    });
+
+    setS(2);
+
+    setS(5);
+
+    setS(1);
+
+    assert.deepStrictEqual(mut_history, [5, 1]);
+  });
+
+  test('asks the predicate no more once the initial value has ended the skipping', () => {
+    const [s$, setS] = createState(5);
+
+    let mut_calls = 0;
+
+    s$.pipe(
+      skipWhile((x) => {
+        mut_calls += 1;
+
+        return x < 3;
+      }),
+    ).subscribe(() => {});
+
+    setS(1);
+
+    setS(2);
+
+    assert.strictEqual(mut_calls, 1);
+  });
 });

package/src/core/operators/switch-map.mts

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function
@@ -21,6 +21,10 @@ import type {
  * Projects each source value to an observable, subscribes to it, and emits its values.
  * When a new value arrives from the source, the previous inner observable is unsubscribed.
  *
+ * A value the source already holds when `switchMap` is created (a state, an
+ * observable with an initial value) is projected at once, as `map` and `filter`
+ * start from it. A completed source is not projected.
+ *
  * The projection runs in a scope of its own (see `createScope`): what it
  * creates is disposed when the next value switches away from it and when
  * `switchMap` completes. An observable it only returns — one created outside
@@ -126,9 +130,9 @@ class SwitchMapObservableClass<A, B>
   readonly #mapToObservable: (curr: A) => Observable<B>;
 
   /**
-   * The scope the operator was created in, so that each inner scope is
-   * disposed with it; the projection itself runs during propagation, when the
-   * current scope is whatever happens to be running.
+   * The scope the operator was created in, so that each inner scope is disposed
+   * with it; the projection itself runs during propagation, when the current
+   * scope is whatever happens to be running.
    */
   readonly #ownerScope: Scope | undefined;
 
@@ -152,7 +156,9 @@ class SwitchMapObservableClass<A, B>
 
     this.#mut_subscription = undefined;
 
-    this.attach();
+    this.attachProjectingHeldValue(parentObservable, (value, updateToken) => {
+      this.#project(value, updateToken);
+    });
   }
 
   /** Releases the inner observable, and only the one this operator made. */
@@ -162,6 +168,19 @@ class SwitchMapObservableClass<A, B>
     this.#mut_innerScope?.dispose();
   }
 
+  /** Switches to the inner observable of `value`. */
+  #project(value: A, updateToken: UpdateToken): void {
+    this.#releaseInner();
+
+    const innerScope = createScope(this.#ownerScope);
+
+    this.#mut_innerScope = innerScope;
+
+    const observable = innerScope.run(() => this.#mapToObservable(value));
+
+    this.#mut_subscription = this.subscribeInner(observable, updateToken);
+  }
+
   override tryUpdate(updateToken: UpdateToken): void {
     const par = this.parents[0];
 
@@ -171,15 +190,7 @@ class SwitchMapObservableClass<A, B>
       return; // skip update
     }
 
-    this.#releaseInner();
-
-    const innerScope = createScope(this.#ownerScope);
-
-    this.#mut_innerScope = innerScope;
-
-    const observable = innerScope.run(() => this.#mapToObservable(sn.value));
-
-    this.#mut_subscription = this.subscribeInner(observable, updateToken);
+    this.#project(sn.value, updateToken);
   }
 
   protected override teardown(): void {

package/src/core/operators/take-until.mts

@@ -1,6 +1,6 @@
 // Sumi bans classes, `this`, method syntax and writes to `this` outside a
-// `mut_` binding; an observable is a class (`ObservableBaseClass` says why),
-// so those rules are waived here (D-63).
+// `mut_` binding; an observable is a class (`ObservableBaseClass` says why), so
+// those rules are waived here (D-63).
 // @sumi-expect-error-file classes/no-class
 // @sumi-expect-error-file banned-syntax/no-this
 // @sumi-expect-error-file functions/prefer-arrow-function