Remove CachedPredicate

Author: In3luki

src/module/apps/compendium-browser/tabs/base.svelte.ts

@@ -1,7 +1,7 @@
 import type { CompendiumIndexData } from "@client/documents/collections/compendium-collection.d.mts";
 import type { TableResultSource } from "@common/documents/table-result.d.mts";
 import { CompendiumDirectoryPF2e } from "@module/apps/sidebar/compendium-directory.ts";
-import { CachedPredicate, type PredicateStatement } from "@system/predication.ts";
+import { Predicate, type PredicateStatement } from "@system/predication.ts";
 import { ErrorPF2e, htmlQuery, sluggify } from "@util";
 import MiniSearch from "minisearch";
 import * as R from "remeda";
@@ -141,7 +141,7 @@ export abstract class CompendiumBrowserTab {
     protected abstract prepareFilterData(): this["filterData"];
 
     /** Build a `CachedPredicate` from the applied filters */
-    protected buildPredicate(): CachedPredicate {
+    protected buildPredicate(): Predicate {
         if (!this.filterData) {
             throw ErrorPF2e(`Tab "${this.tabLabel}" is not initialized!`);
         }
@@ -203,7 +203,7 @@ export abstract class CompendiumBrowserTab {
             }
         }
 
-        return new CachedPredicate([{ and: statements }]);
+        return new Predicate([{ and: statements }]);
     }
 
     /** Sort result array by name, level or price */

src/module/system/predication.ts

@@ -41,7 +41,7 @@ class Predicate extends Array<PredicateStatement> {
         }
 
         const domain = options instanceof Set ? options : new Set(options);
-        return this.every((s) => this.isTrue(s, domain));
+        return this.every((s) => this.#isTrue(s, domain));
     }
 
     toObject(): RawPredicate {
@@ -53,15 +53,15 @@ class Predicate extends Array<PredicateStatement> {
     }
 
     /** Is the provided statement true? */
-    protected isTrue(statement: PredicateStatement, domain: Set<string>): boolean {
+    #isTrue(statement: PredicateStatement, domain: Set<string>): boolean {
         return (
             (typeof statement === "string" && domain.has(statement)) ||
-            (StatementValidator.isBinaryOp(statement) && this.testBinaryOp(statement, domain)) ||
-            (StatementValidator.isCompound(statement) && this.testCompound(statement, domain))
+            (StatementValidator.isBinaryOp(statement) && this.#testBinaryOp(statement, domain)) ||
+            (StatementValidator.isCompound(statement) && this.#testCompound(statement, domain))
         );
     }
 
-    protected testBinaryOp(statement: BinaryOperation, domain: Set<string>): boolean {
+    #testBinaryOp(statement: BinaryOperation, domain: Set<string>): boolean {
         if ("eq" in statement) {
             return typeof statement.eq[1] === "string"
                 ? statement.eq[0] === statement.eq[1]
@@ -102,44 +102,22 @@ class Predicate extends Array<PredicateStatement> {
     }
 
     /** Is the provided compound statement true? */
-    protected testCompound(statement: Exclude<PredicateStatement, Atom>, domain: Set<string>): boolean {
+    #testCompound(statement: Exclude<PredicateStatement, Atom>, domain: Set<string>): boolean {
         return (
-            ("and" in statement && statement.and.every((s) => this.isTrue(s, domain))) ||
-            ("nand" in statement && !statement.nand.every((s) => this.isTrue(s, domain))) ||
-            ("or" in statement && statement.or.some((s) => this.isTrue(s, domain))) ||
-            ("xor" in statement && statement.xor.filter((s) => this.isTrue(s, domain)).length === 1) ||
-            ("nor" in statement && !statement.nor.some((s) => this.isTrue(s, domain))) ||
-            ("not" in statement && !this.isTrue(statement.not, domain)) ||
-            ("if" in statement && !(this.isTrue(statement.if, domain) && !this.isTrue(statement.then, domain))) ||
+            ("and" in statement && statement.and.every((s) => this.#isTrue(s, domain))) ||
+            ("nand" in statement && !statement.nand.every((s) => this.#isTrue(s, domain))) ||
+            ("or" in statement && statement.or.some((s) => this.#isTrue(s, domain))) ||
+            ("xor" in statement && statement.xor.filter((s) => this.#isTrue(s, domain)).length === 1) ||
+            ("nor" in statement && !statement.nor.some((s) => this.#isTrue(s, domain))) ||
+            ("not" in statement && !this.#isTrue(statement.not, domain)) ||
+            ("if" in statement && !(this.#isTrue(statement.if, domain) && !this.#isTrue(statement.then, domain))) ||
             ("iff" in statement &&
-                (statement.iff.every((s) => this.isTrue(s, domain)) ||
-                    statement.iff.every((s) => !this.isTrue(s, domain))))
+                (statement.iff.every((s) => this.#isTrue(s, domain)) ||
+                    statement.iff.every((s) => !this.#isTrue(s, domain))))
         );
     }
 }
 
-/** A `Predicate` that caches the test method for all contained `PredicateStatements`.
- *  This is a 4-5x speed increase for cases where the same predicate is tested against 1000+
- *  different domains.
- */
-class CachedPredicate extends Predicate {
-    #statementCache = new Map<PredicateStatement, (d: Set<string>) => boolean>();
-
-    protected override isTrue(statement: PredicateStatement, domain: Set<string>): boolean {
-        if (typeof statement === "string") return domain.has(statement);
-
-        if (!this.#statementCache.has(statement)) {
-            if (StatementValidator.isBinaryOp(statement)) {
-                this.#statementCache.set(statement, (d) => this.testBinaryOp(statement, d));
-            } else if (StatementValidator.isCompound(statement)) {
-                this.#statementCache.set(statement, (d) => this.testCompound(statement, d));
-            }
-        }
-
-        return !!this.#statementCache.get(statement)?.(domain);
-    }
-}
-
 class StatementValidator {
     static isStatement(statement: unknown): statement is PredicateStatement {
         return R.isPlainObject(statement)
@@ -272,5 +250,5 @@ type PredicateStatement = Atom | CompoundStatement;
 
 type RawPredicate = PredicateStatement[];
 
-export { CachedPredicate, Predicate, StatementValidator };
+export { Predicate, StatementValidator };
 export type { PredicateStatement, RawPredicate };