Apply @Immediate, see microsoft/TypeScript#58729

Author: LukeAbby

src/foundry/client/apps/sidebar/directory-tab-mixin.d.mts

@@ -46,7 +46,7 @@ declare class DirectoryApplication {
    */
   protected _matchSearchFolders(
     query: RegExp,
-    includeFolder: (folder: Folder.ConfiguredInstance, autoExpand?: boolean) => boolean,
+    /** @immediate */ includeFolder: (folder: Folder.ConfiguredInstance, autoExpand?: boolean) => boolean,
   ): void;
 
   /**
@@ -61,7 +61,7 @@ declare class DirectoryApplication {
     query: RegExp,
     entryIds: Set<string>,
     folderIds: Set<string>,
-    includeFolder: (folder: Folder.ConfiguredInstance, autoExpand?: boolean) => boolean,
+    /** @immediate */ includeFolder: (folder: Folder.ConfiguredInstance, autoExpand?: boolean) => boolean,
   ): void;
 
   /**

src/foundry/common/primitives/array.d.mts

@@ -25,8 +25,8 @@ declare global {
      * @param rule - The rule to partition by
      * @returns An Array of length two whose elements are the partitioned pieces of the original
      */
-    partition<S extends T>(rule: (val: T) => val is S): [Exclude<T, S>[], S[]];
-    partition(rule: (val: T) => boolean): [T[], T[]];
+    partition<S extends T>(/** @immediate */ rule: (val: T) => val is S): [Exclude<T, S>[], S[]];
+    partition(/** @immediate */ rule: (val: T) => boolean): [T[], T[]];
 
     /**
      * Join an Array using a string separator, first filtering out any parts which return a false-y value
@@ -41,7 +41,7 @@ declare global {
      * @param replace - A replacement for the spliced element
      * @returns The replacement element, the removed element, or null if no element was found.
      */
-    findSplice(find: (value: T, index: number, obj: T[]) => boolean, replace?: T): T | null;
+    findSplice(/** @immediate */ find: (value: T, index: number, obj: T[]) => boolean, replace?: T): T | null;
   }
 
   interface ArrayConstructor {

src/foundry/common/primitives/math.d.mts

@@ -98,6 +98,12 @@ declare global {
      *                  Its period must be 2π
      * @returns The oscillation according to t. `((maxValue - minValue) * (f(2π * t / p) + 1) / 2) + minValue`
      */
-    oscillation(minVal: number, maxVal: number, t: number, p?: number, func?: (radians: number) => number): number;
+    oscillation(
+      minVal: number,
+      maxVal: number,
+      t: number,
+      p?: number,
+      /** @immediate */ func?: (radians: number) => number,
+    ): number;
   }
 }

src/foundry/common/primitives/set.d.mts

@@ -57,33 +57,33 @@ declare global {
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being tested.
      * @returns Does every element in the set satisfy the test criterion?
      */
-    every(test: (value: T, index: number, set: Set<T>) => boolean): boolean;
+    every(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): boolean;
 
     /**
      * Filter this set to create a subset of elements which satisfy a certain test criterion.
      * @see {@link Array#filter}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being filtered.
      * @returns A new Set containing only elements which satisfy the test criterion.
      */
-    filter<F extends T>(test: (value: T, index: number, set: Set<T>) => value is F): Set<F>;
-    filter(test: (value: T, index: number, set: Set<T>) => boolean): Set<T>;
+    filter<F extends T>(/** @immediate */ test: (value: T, index: number, set: Set<T>) => value is F): Set<F>;
+    filter(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): Set<T>;
 
     /**
      * Find the first element in this set which satisfies a certain test criterion.
      * @see {@link Array#find}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being searched.
      * @returns The first element in the set which satisfies the test criterion, or undefined.
      */
-    find<F extends T>(test: (value: T, index: number, set: Set<T>) => value is F): F | undefined;
-    find(test: (value: T, index: number, set: Set<T>) => boolean): T | undefined;
+    find<F extends T>(/** @immediate */ test: (value: T, index: number, set: Set<T>) => value is F): F | undefined;
+    find(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): T | undefined;
 
     /**
      * Create a new Set where every element is modified by a provided transformation function.
      * @see {@link Array#map}
      * @param transform - The transformation function to apply.Positional arguments are the value, the index of iteration, and the set being transformed.
      * @returns A new Set of equal size containing transformed elements.
      */
-    map<V>(transform: (value: T, index: number, set: Set<T>) => V): Set<V>;
+    map<V>(/** @immediate */ transform: (value: T, index: number, set: Set<T>) => V): Set<V>;
 
     /**
      * Create a new Set with elements that are filtered and transformed by a provided reducer function.
@@ -92,14 +92,17 @@ declare global {
      * @param accumulator - The initial value of the returned accumulator.
      * @returns The final value of the accumulator.
      */
-    reduce<V>(reducer: (accumulator: V, value: T, index: number, set: Set<T>) => V, accumulator: V): V;
+    reduce<V>(
+      /** @immediate */ reducer: (accumulator: V, value: T, index: number, set: Set<T>) => V,
+      accumulator: V,
+    ): V;
 
     /**
      * Test whether any element in this Set satisfies a certain test criterion.
      * @see {@link Array#some}
      * @param test - The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being tested.
      * @returns Does any element in the set satisfy the test criterion?
      */
-    some(test: (value: T, index: number, set: Set<T>) => boolean): boolean;
+    some(/** @immediate */ test: (value: T, index: number, set: Set<T>) => boolean): boolean;
   }
 }

src/foundry/common/prosemirror/dropdown.d.mts

@@ -47,7 +47,7 @@ declare class ProseMirrorDropDown {
    * Recurse through the menu structure and apply a function to each item in it.
    * @param fn - The function to call on each item. Return false to prevent iterating over any further items.
    */
-  forEachItem(fn: (entry: ProseMirrorDropDownMenu.Entry) => boolean): void;
+  forEachItem(/** @immediate */ fn: (entry: ProseMirrorDropDownMenu.Entry) => boolean): void;
 
   /**
    * Render a list of drop-down menu items.

src/foundry/common/utils/collection.d.mts

@@ -39,8 +39,10 @@ declare class Collection<V> extends Map<string, V> {
    * c.get("a") === c.find(entry => entry === "A"); // true
    * ```
    */
-  find<S extends V>(condition: (e: V, index: number, collection: Collection<V>) => e is S): S | undefined;
-  find(condition: (e: V, index: number, collection: Collection<V>) => boolean): V | undefined;
+  find<S extends V>(
+    /** @immediate */ condition: (e: V, index: number, collection: Collection<V>) => e is S,
+  ): S | undefined;
+  find(/** @immediate */ condition: (e: V, index: number, collection: Collection<V>) => boolean): V | undefined;
 
   /**
    * Filter the Collection, returning an Array of entries which match a functional condition.
@@ -56,8 +58,8 @@ declare class Collection<V> extends Map<string, V> {
    * let hasA = c.filters(entry => entry.slice(0) === "A");
    * ```
    */
-  filter<S extends V>(condition: (e: V, index: number, collection: Collection<V>) => e is S): S[];
-  filter(condition: (e: V, index: number, collection: Collection<V>) => boolean): V[];
+  filter<S extends V>(/** @immediate */ condition: (e: V, index: number, collection: Collection<V>) => e is S): S[];
+  filter(/** @immediate */ condition: (e: V, index: number, collection: Collection<V>) => boolean): V[];
 
   /**
    * Apply a function to each element of the collection
@@ -70,7 +72,7 @@ declare class Collection<V> extends Map<string, V> {
    * c.forEach(e => e.active = true);
    * ```
    */
-  forEach(fn: (e: V) => void): void;
+  forEach(/** @immediate */ fn: (e: V) => void): void;
 
   /**
    * Get an element from the Collection by its key.
@@ -116,7 +118,7 @@ declare class Collection<V> extends Map<string, V> {
    * @typeParam M       - The type of the mapped values
    * @returns An Array of transformed values
    */
-  map<M>(transformer: (entity: V, index: number, collection: Collection<V>) => M): M[];
+  map<M>(/** @immediate */ transformer: (entity: V, index: number, collection: Collection<V>) => M): M[];
 
   /**
    * Reduce the Collection by applying an evaluator function and accumulating entries
@@ -135,7 +137,10 @@ declare class Collection<V> extends Map<string, V> {
    * }, ""); // "ABC"
    * ```
    */
-  reduce<A>(evaluator: (accumulator: A, entity: V, index: number, collection: Collection<V>) => A, initial: A): A;
+  reduce<A>(
+    /** @immediate */ evaluator: (accumulator: A, entity: V, index: number, collection: Collection<V>) => A,
+    initial: A,
+  ): A;
 
   /**
    * Test whether a condition is met by some entry in the Collection.
@@ -144,7 +149,7 @@ declare class Collection<V> extends Map<string, V> {
    *                    and the collection being tested.
    * @returns Was the test condition passed by at least one entry?
    */
-  some(condition: (e: V, index: number, collection: Collection<V>) => boolean): boolean;
+  some(/** @immediate */ condition: (e: V, index: number, collection: Collection<V>) => boolean): boolean;
 
   /**
    * Convert the Collection to a primitive array of its contents.

tsdoc.json

@@ -4,6 +4,10 @@
     {
       "tagName": "@abstract",
       "syntaxKind": "modifier"
+    },
+    {
+      "tagName": "@immediate",
+      "syntaxKind": "modifier"
     }
   ]
 }