event-storage 1.2.0 → 1.3.0

package/src/Storage/WritableStorage.js

@@ -6,6 +6,7 @@ import ReadableStorage from './ReadableStorage.js';
 import { assert } from '../utils/util.js';
 import { ensureDirectory } from '../utils/fsUtil.js';
 import { matches, buildMetadataForMatcher, buildMatcherFromMetadata } from '../utils/metadataUtil.js';
+import { normalizeNamedCtorArgs } from '../utils/apiHelpers.js';
 
 const DEFAULT_WRITE_BUFFER_SIZE = 16 * 1024;
 
@@ -44,10 +45,7 @@ class WritableStorage extends ReadableStorage {
      * @param {number} [config.lock] One of LOCK_* constants that defines how an existing lock should be handled.
      */
     constructor(storageName = 'storage', config = {}) {
-        if (typeof storageName !== 'string') {
-            config = storageName;
-            storageName = undefined;
-        }
+        ({ name: storageName, options: config } = normalizeNamedCtorArgs(storageName, config));
         const defaults = {
             partitioner: (document, number) => '',
             writeBufferSize: DEFAULT_WRITE_BUFFER_SIZE,
@@ -100,7 +98,7 @@ class WritableStorage extends ReadableStorage {
      */
     forEachWritableSecondaryIndex(iterationHandler, matchDocument) {
         this.forEachSecondaryIndex((index, name) => {
-            /* istanbul ignore if */
+            /* c8 ignore next */
             if (!(index instanceof WritableIndex)) return;
             const wasOpen = index.isOpen();
             if (!wasOpen) index.open();
@@ -123,7 +121,7 @@ class WritableStorage extends ReadableStorage {
         this.forEachPartition(partition => {
             partition.open();
             const last = partition.readLast();
-            /* istanbul ignore if */
+            /* c8 ignore next */
             if (!last) return;
             const { header: { sequenceNumber, dataSize }, position } = last;
             if (position + partition.documentWriteSize(dataSize) > partition.size) {
@@ -165,7 +163,7 @@ class WritableStorage extends ReadableStorage {
             // Truncate all indexes to the torn-write boundary.
             this.index.open();
             this.index.truncate(lastValidSequenceNumber);
-            /* istanbul ignore next */
+            /* c8 ignore next */
             this.forEachWritableSecondaryIndex(index => {
                 index.truncate(index.find(lastValidSequenceNumber));
             });
@@ -231,7 +229,7 @@ class WritableStorage extends ReadableStorage {
             fs.mkdirSync(this.lockFile);
             this.locked = true;
         } catch (e) {
-            /* istanbul ignore if */
+            /* c8 ignore next */
             assert(e.code === 'EEXIST', `Error creating lock for storage ${this.storageFile}: ` + e.message)
 
             throw new StorageLockedError(`Storage ${this.storageFile} is locked by another process`);
@@ -290,7 +288,7 @@ class WritableStorage extends ReadableStorage {
         const entry = new WritableIndexEntry(this.index.length + 1, position, size, partitionId);
         this.index.add(entry, (indexPosition) => {
             this.emit('wrote', document, entry, indexPosition);
-            /* istanbul ignore if  */
+            /* c8 ignore next 3  */
             if (typeof callback === 'function') {
                 return callback(indexPosition);
             }
@@ -509,9 +507,8 @@ class WritableStorage extends ReadableStorage {
          2) truncate all partitions accordingly
          3) truncate/rewrite all indexes
          */
-        if (!this.index.isOpen()) {
-            this.index.open();
-        }
+        this.index.open();
+
         if (after < 0) {
             after += this.index.length;
         }

package/src/utils/apiHelpers.js

@@ -0,0 +1,123 @@
+/**
+ * Normalize commit overloads into a single argument object.
+ *
+ * @param {object|object[]} events Event or event list.
+ * @param {number|object|function} expectedVersion Expected version, CommitCondition, or already metadata/callback.
+ * @param {object|function} metadata Commit metadata or callback.
+ * @param {function} callback Completion callback.
+ * @param {number} ExpectedVersionAny Fallback value for "any" expectedVersion.
+ * @param {Function} CommitConditionClass Class used for CommitCondition checks.
+ * @returns {{events: object[], expectedVersion: number|object, metadata: object, callback: function}} Normalized commit arguments.
+ */
+function fixCommitArgumentTypes(events, expectedVersion, metadata, callback, ExpectedVersionAny, CommitConditionClass) {
+    if (!(events instanceof Array)) {
+        events = [events];
+    }
+    if (typeof expectedVersion !== 'number' && !(expectedVersion instanceof CommitConditionClass)) {
+        callback = metadata;
+        metadata = expectedVersion;
+        expectedVersion = ExpectedVersionAny;
+    }
+    if (typeof metadata !== 'object') {
+        callback = metadata;
+        metadata = {};
+    }
+    if (typeof callback !== 'function') {
+        callback = () => {};
+    }
+    return { events, expectedVersion, metadata, callback };
+}
+
+/**
+ * Derive the stream name from an index name.
+ *
+ * @param {string} indexName Index file/index name.
+ * @returns {string} Corresponding stream name.
+ */
+function parseStreamFromIndexName(indexName) {
+    if (indexName === '_all') {
+        return '_all';
+    }
+    if (indexName.startsWith('stream-')) {
+        return indexName.slice(7);
+    }
+    return indexName;
+}
+
+/**
+ * Support predicate/raw shorthand (`predicate=true`).
+ *
+ * @param {object|function|boolean|null} predicate Filter predicate or raw shorthand.
+ * @param {boolean} raw Raw flag from the call signature.
+ * @returns {{predicate: object|function|null, raw: boolean}} Normalized predicate/raw pair.
+ */
+function normalizePredicateRaw(predicate, raw) {
+    if (typeof predicate === 'boolean' && raw === false) {
+        return { predicate: null, raw: predicate };
+    }
+    return { predicate, raw };
+}
+
+/**
+ * Support constructor overloads with optional `name`.
+ *
+ * @param {string|object} name Name or already the options object.
+ * @param {object} options Options object when `name` is provided.
+ * @param {string|undefined} [fallbackName=undefined] Fallback name when no explicit `name` is passed.
+ * @returns {{name: string|undefined, options: object}} Normalized name/options pair.
+ */
+function normalizeNamedCtorArgs(name, options, fallbackName = undefined) {
+    if (typeof name !== 'string') {
+        return { name: fallbackName, options: name };
+    }
+    return { name, options };
+}
+
+/**
+ * Normalize negative revisions relative to stream length.
+ *
+ * @param {number} version Requested revision.
+ * @param {number} length Current stream length.
+ * @returns {number} Resolved revision.
+ */
+function normalizeRevision(version, length) {
+    return version < 0 ? version + length + 1 : version;
+}
+
+/**
+ * Clamp and normalize maxRevision, including negative values.
+ *
+ * @param {number} length Current stream length.
+ * @param {number} maxRevision Requested max revision.
+ * @returns {number} Effective max revision in valid range.
+ */
+function normalizeMaxRevision(length, maxRevision) {
+    return Math.min(length, maxRevision < 0 ? length + maxRevision + 1 : maxRevision);
+}
+
+/**
+ * Support the consumer overload where the first argument is a numeric start offset.
+ *
+ * @param {object|number} initialState Initial state or numeric start offset.
+ * @param {number} startFrom Start offset from the call signature.
+ * @returns {{initialState: object, startFrom: number}} Normalized consumer initialization values.
+ */
+function normalizeConsumerStateArgs(initialState, startFrom) {
+    if (typeof initialState === 'number') {
+        return { initialState: {}, startFrom: initialState };
+    }
+    return { initialState, startFrom };
+}
+
+export {
+    fixCommitArgumentTypes,
+    parseStreamFromIndexName,
+    normalizePredicateRaw,
+    normalizeNamedCtorArgs,
+    normalizeRevision,
+    normalizeMaxRevision,
+    normalizeConsumerStateArgs
+};
+
+
+

package/src/utils/fsUtil.js

@@ -4,8 +4,8 @@ import { mkdirpSync } from 'mkdirp';
 
 /**
  * Ensure that the given directory exists.
- * @param {string} dirName
- * @return {boolean} true if the directory existed already
+ * @param {string} dirName Target directory.
+ * @returns {boolean} True when the directory already existed.
  */
 function ensureDirectory(dirName) {
     if (!fs.existsSync(dirName)) {
@@ -21,9 +21,10 @@ function ensureDirectory(dirName) {
 /**
  * Invoke `onEach` if `relativePath` matches `regexPattern`, passing the first capture group or the full match.
  *
- * @param {string} relativePath
- * @param {RegExp} regexPattern
- * @param {function(string)} onEach
+ * @param {string} relativePath Relative file path.
+ * @param {RegExp} regexPattern Regex used for path matching.
+ * @param {function(string): void} onEach Callback invoked per match.
+ * @returns {void}
  */
 function visitMatchingPath(relativePath, regexPattern, onEach) {
     const match = relativePath.match(regexPattern);
@@ -35,11 +36,11 @@ function visitMatchingPath(relativePath, regexPattern, onEach) {
 /**
  * Classify `entries` into matching files (visited via `onEach`) and subdirectory names (returned).
  *
- * @param {fs.Dirent[]} entries
- * @param {string} relativePrefix
- * @param {RegExp} regexPattern
- * @param {function(string)} onEach
- * @returns {string[]} names of subdirectory entries
+ * @param {fs.Dirent[]} entries Directory entries from one level.
+ * @param {string} relativePrefix Relative prefix for child entries.
+ * @param {RegExp} regexPattern Regex for file paths.
+ * @param {function(string): void} onEach Callback for matching files.
+ * @returns {string[]} Names of subdirectory entries.
  */
 function classifyEntries(entries, relativePrefix, regexPattern, onEach) {
     const subdirs = [];
@@ -56,12 +57,13 @@ function classifyEntries(entries, relativePrefix, regexPattern, onEach) {
 /**
  * Sequentially scan each name in `subdirs`, calling `done` when all are complete or on first error.
  *
- * @param {string[]} subdirs
- * @param {string} dir
- * @param {string} relativePrefix
- * @param {RegExp} regexPattern
- * @param {function(string)} onEach
- * @param {function(Error?)} done
+ * @param {string[]} subdirs Subdirectory names.
+ * @param {string} dir Absolute parent path.
+ * @param {string} relativePrefix Relative prefix used during recursion.
+ * @param {RegExp} regexPattern Regex for file paths.
+ * @param {function(string): void} onEach Callback for matching files.
+ * @param {function(Error=): void} done Completion callback.
+ * @returns {void}
  */
 function scanSubdirs(subdirs, dir, relativePrefix, regexPattern, onEach, done) {
     let i = 0;
@@ -79,17 +81,18 @@ function scanSubdirs(subdirs, dir, relativePrefix, regexPattern, onEach, done) {
 /**
  * Asynchronously scan one directory level, then recurse into subdirectories sequentially.
  *
- * @param {string} dir
- * @param {string} relativePrefix
- * @param {boolean} isRoot
- * @param {RegExp} regexPattern
- * @param {function(string)} onEach
- * @param {function(Error?)} done
+ * @param {string} dir Absolute directory path.
+ * @param {string} relativePrefix Relative prefix for match paths.
+ * @param {boolean} isRoot True for the initial call.
+ * @param {RegExp} regexPattern Regex for file paths.
+ * @param {function(string): void} onEach Callback for matching files.
+ * @param {function(Error=): void} done Completion callback.
+ * @returns {void}
  */
 function scanDir(dir, relativePrefix, isRoot, regexPattern, onEach, done) {
     fs.readdir(dir, { withFileTypes: true }, (err, entries) => {
         if (err) {
-            /* istanbul ignore next */
+            /* c8 ignore next */
             if (!isRoot && err.code === 'ENOENT') return done(null);
             return done(err);
         }
@@ -112,6 +115,7 @@ function scanDir(dir, relativePrefix, isRoot, regexPattern, onEach, done) {
  * @param {RegExp} regexPattern The pattern to match relative file paths against.
  * @param {function(string)} onEach Called with the first capturing group (or full match) for each matching path.
  * @param {function(Error?)} onDone Called when the scan is complete, or with an error if one occurred.
+ * @returns {void}
  */
 function scanForFiles(directory, regexPattern, onEach, onDone) {
     scanDir(directory, '', true, regexPattern, onEach, onDone);

package/src/utils/jsonUtil.js

@@ -5,76 +5,138 @@ const BYTE_CLOSE_OBJECT = 0x7d;
 const BYTE_OPEN_ARRAY = 0x5b;
 const BYTE_CLOSE_ARRAY = 0x5d;
 const BYTE_COMMA = 0x2c;
+const BYTE_SIGN_MINUS = 0x2d;
+const BYTE_DECIMAL_SEP = 0x2e;
 
 /**
- * Find the position of `pattern` within `buffer` at depth 0 (the top-level object), starting
- * from `startOffset`.  It scans character-by-character tracking JSON nesting depth and string
- * quoting.  If `matchPosition` arrives at depth > 0 it means the pattern is inside a nested
- * object/array, so the scan continues searching for the next candidate at depth 0.  Returns -1
- * when no such position exists before the end of the buffer or when a closing brace reduces depth
- * below zero (the top-level object has ended).
+ * Advance past a JSON string whose opening `"` is at `i`.
+ * Returns the position after the closing `"`, or -1 if the string is unterminated.
+ *
+ * @param {Buffer} buffer Source JSON buffer.
+ * @param {number} i Offset of the opening quote.
+ * @returns {number} Offset after the closing quote, or -1 if unterminated.
  */
-function indexOfSameLevel(buffer, pattern, startOffset = 0, matchPosition) {
-    /* c8 ignore start */
-    // Defensive fallback: public call path precomputes an initial candidate in preCheck.
-    if (matchPosition === undefined) {
-        matchPosition = buffer.indexOf(pattern, startOffset);
+function skipString(buffer, i) {
+    let j = i + 1;
+    while (j < buffer.length) {
+        if (buffer[j] === BYTE_ESCAPE) {
+            j += 2;
+            continue;
+        }
+        if (buffer[j] === BYTE_QUOTE) {
+            return j + 1;
+        }
+        j++;
     }
-    if (matchPosition === -1) {
-        return -1;
+    /* c8 ignore next */
+    return -1;
+}
+
+/**
+ * Check if a character byte is a valid JSON value delimiter (comma, closing brace, or closing bracket).
+ * @param {number} char Byte value to test.
+ * @returns {boolean} True when `char` is `,`, `}` or `]`.
+ */
+function isDelimiter(char) {
+    return (char === BYTE_COMMA || char === BYTE_CLOSE_OBJECT || char === BYTE_CLOSE_ARRAY);
+}
+
+/**
+ * @param {number} char Byte value to test.
+ * @returns {boolean} True when `char` opens an object or array.
+ */
+function isOpeningBracket(char) {
+    return char === BYTE_OPEN_OBJECT || char === BYTE_OPEN_ARRAY;
+}
+
+/**
+ * @param {number} char Byte value to test.
+ * @returns {boolean} True when `char` closes an object or array.
+ */
+function isClosingBracket(char) {
+    return char === BYTE_CLOSE_OBJECT || char === BYTE_CLOSE_ARRAY;
+}
+
+/**
+ * @param {number} char Byte value to test.
+ * @returns {boolean} True when `char` is `{`.
+ */
+function isOpeningObject(char) {
+    return char === BYTE_OPEN_OBJECT;
+}
+
+/**
+ * @param {Buffer} buffer Source JSON buffer.
+ * @param {Buffer} pattern Pattern to find.
+ * @param {number} startOffset Search start offset.
+ * @param {number|undefined} lastMatchPosition Optional cached candidate position.
+ * @returns {number} Match position or -1.
+ */
+function nextIndexOf(buffer, pattern, startOffset, lastMatchPosition) {
+    if (lastMatchPosition === undefined || lastMatchPosition < startOffset) {
+        return buffer.indexOf(pattern, startOffset);
     }
-    /* c8 ignore stop */
+    return lastMatchPosition;
+}
 
+/**
+ * Find the position of `pattern` within `buffer` at depth 0 (the top-level object), starting
+ * from `startOffset`. Tracks JSON nesting depth and skips over string contents entirely.
+ * If `matchPosition` arrives at depth > 0 it means the pattern is inside a nested
+ * object/array, so the scan continues searching for the next candidate at depth 0.
+ *
+ * For value patterns (`"key":value`) it validates the trailing delimiter to avoid prefix matches.
+ * For key patterns (`"key":`) pass `isKeyPattern=true` to skip that trailing delimiter check.
+ * Returns -1 when no such position exists before the end of the buffer or when a closing brace
+ * reduces depth below zero (the top-level object has ended).
+ *
+ * @param {Buffer} buffer Source JSON buffer.
+ * @param {Buffer} pattern Serialized key/value pattern.
+ * @param {number} [startOffset=0] Offset where scanning begins.
+ * @param {number|undefined} [matchPosition=undefined] Optional cached candidate position.
+ * @param {boolean} [isKeyPattern=false] Skip value-delimiter validation for key-only patterns.
+ * @returns {number} Match position at the same JSON depth, or -1.
+ */
+function indexOfSameLevel(buffer, pattern, startOffset = 0, matchPosition = undefined, isKeyPattern = false) {
     let depth = 0;
-    let inString = false;
     let i = startOffset;
 
     while (i < buffer.length) {
-        if (inString) {
-            if (buffer[i] === BYTE_ESCAPE) { // '\\'
-                i += 2;
-                continue;
-            }
-            if (buffer[i] === BYTE_QUOTE) { // '"'
-                inString = false;
-            }
-            i++;
-            continue;
+        matchPosition = nextIndexOf(buffer, pattern, i, matchPosition);
+        if (matchPosition === -1) {
+            return -1;
         }
-
         const ch = buffer[i];
-        if (ch === BYTE_OPEN_OBJECT || ch === BYTE_OPEN_ARRAY) { // '{' or '['
+
+        if (isOpeningBracket(ch)) {
             depth++;
             i++;
             continue;
-        } else if (ch === BYTE_CLOSE_OBJECT || ch === BYTE_CLOSE_ARRAY) { // '}' or ']'
+        }
+        if (isClosingBracket(ch)) {
             depth--;
-
             if (depth < 0) {
                 return -1;
             }
-
             i++;
             continue;
-        } else if (ch === BYTE_QUOTE) { // '"'
-            inString = true;
         }
-
-        if (i >= matchPosition) {
-            if (i === matchPosition && ch === BYTE_QUOTE && depth === 0) { // '"'
-                const end = i + pattern.length;
-                if (pattern[pattern.length - 1] === BYTE_OPEN_OBJECT) { // '{'
+        if (ch === BYTE_QUOTE) {
+            if (i === matchPosition && depth === 0) {
+                if (isKeyPattern || isOpeningObject(pattern[pattern.length - 1])) {
                     return i;
                 }
-                if (buffer[end] === BYTE_COMMA || buffer[end] === BYTE_CLOSE_OBJECT || buffer[end] === BYTE_CLOSE_ARRAY) { // ',' or '}' or ']'
+                const end = i + pattern.length;
+                if (isDelimiter(buffer[end])) {
                     return i;
                 }
             }
-
-            matchPosition = buffer.indexOf(pattern, matchPosition + 1);
-            if (matchPosition < 0) {
+            i = skipString(buffer, i);
+            /* c8 ignore next 3 */
+            if (i === -1) {
                 return -1;
             }
+            continue;
         }
 
         i++;
@@ -84,4 +146,157 @@ function indexOfSameLevel(buffer, pattern, startOffset = 0, matchPosition) {
     return -1;
 }
 
-export { BYTE_OPEN_OBJECT, indexOfSameLevel };
+/**
+ * Find the end of a scalar JSON value so operator matching can parse only the relevant slice.
+ *
+ * @param {Buffer} buffer Source JSON buffer.
+ * @param {number} offset Offset where the scalar starts.
+ * @returns {number} End offset (exclusive), or -1 for invalid start.
+ */
+function findJsonValueEnd(buffer, offset) {
+    /* c8 ignore next 3 */
+    if (offset >= buffer.length) {
+        return -1;
+    }
+
+    if (buffer[offset] === BYTE_QUOTE) {
+        return skipString(buffer, offset);
+    }
+
+    // Number, boolean, or null: scan until delimiter (,}])
+    let i = offset;
+    while (i < buffer.length && !isDelimiter(buffer[i])) i++;
+    return i;
+}
+
+/**
+ * Parse one scalar JSON slice only after a byte-level match has already narrowed the candidate.
+ *
+ * @param {Buffer} buffer Source JSON buffer.
+ * @param {number} startOffset Start offset (inclusive).
+ * @param {number} endOffset End offset (exclusive).
+ * @returns {string|number|boolean|null|undefined} Parsed scalar, or `undefined` on parse failure.
+ */
+function parseJsonValue(buffer, startOffset, endOffset) {
+    try {
+        const valueStr = buffer.toString('utf8', startOffset, endOffset);
+        return JSON.parse(valueStr);
+    } catch {
+        return undefined;
+    }
+}
+
+/**
+ * @param {number} byte
+ * @returns {boolean} True when `byte` is an ASCII digit.
+ */
+function isAsciiDigit(byte) {
+    return byte >= 0x30 && byte <= 0x39;
+}
+
+/**
+ * Compare a contiguous ASCII digit sequence in `buffer` against expected digits.
+ * For JSON.stringify()-normalized numbers this is enough for both integer and fraction parts.
+ * Returns only the ordering; when ordering === 0, callers can compute the consumed length as startOffset + expectedDigits.length.
+ *
+ * @param {Buffer} buffer
+ * @param {number} startOffset
+ * @param {string} expectedDigits
+ * @returns {-1|0|1}
+ */
+function compareDigits(buffer, startOffset, expectedDigits) {
+    let index = startOffset;
+    let position = 0;
+    let ordering = 0;
+    const expectedLength = expectedDigits.length;
+
+    while (index < buffer.length && isAsciiDigit(buffer[index])) {
+        if (ordering === 0 && position < expectedLength) {
+            const expectedByte = expectedDigits.charCodeAt(position);
+            if (buffer[index] !== expectedByte) {
+                ordering = buffer[index] < expectedByte ? -1 : 1;
+            }
+        }
+        position++;
+        index++;
+    }
+
+    if (position !== expectedLength) {
+        ordering = position > expectedLength ? 1 : -1;
+    }
+
+    return ordering;
+}
+
+/**
+ * Compare a compact JSON numeric token in `buffer` against a precompiled expected number,
+ * using one linear pass over the buffer slice and no `parseJsonValue` call.
+ *
+ * @param {Buffer} buffer
+ * @param {number} startOffset
+ * @param {{isNegative: boolean, integerPart: string, fractionPart: string}} expected
+ * @returns {-1|0|1|null} Ordering (`actual` vs `expected`) or null for invalid/non-numeric token.
+ */
+function compareNumeric(buffer, startOffset, expected) {
+    let index = startOffset;
+    const firstByte = buffer[index];
+    if (firstByte !== BYTE_SIGN_MINUS && !isAsciiDigit(firstByte)) {
+        return null;
+    }
+
+    const isNegative = firstByte === BYTE_SIGN_MINUS;
+    if (isNegative !== expected.isNegative) {
+        return isNegative ? -1 : 1;
+    }
+
+    if (isNegative) {
+        index++;
+    }
+
+    let result = compareDigits(buffer, index, expected.integerPart);
+    if (result === 0) {
+        index += expected.integerPart.length;
+
+        const hasFraction = index < buffer.length && buffer[index] === BYTE_DECIMAL_SEP;
+        const expectedHasFraction = expected.fractionPart.length > 0;
+        if (hasFraction !== expectedHasFraction) {
+            result = hasFraction ? 1 : -1;
+        } else if (hasFraction) {
+            result = compareDigits(buffer, index + 1, expected.fractionPart);
+        }
+    }
+    return isNegative ? -result : result;
+}
+
+/**
+ * Compare a matched key's scalar value against pre-serialized candidates without reparsing JSON.
+ *
+ * @param {Buffer} buffer Source JSON buffer.
+ * @param {number} valueStart Offset where the candidate scalar begins.
+ * @param {Buffer[]} patterns Pre-serialized scalar candidates.
+ * @returns {boolean} True when any candidate matches exactly and is delimiter-terminated.
+ */
+function matchesAnyValuePattern(buffer, valueStart, patterns) {
+    for (const pattern of patterns) {
+        const valueEnd = valueStart + pattern.length;
+        if (valueEnd > buffer.length) {
+            continue;
+        }
+        let matches = true;
+        for (let i = 0; i < pattern.length; i++) {
+            if (buffer[valueStart + i] !== pattern[i]) {
+                matches = false;
+                break;
+            }
+        }
+        if (!matches) {
+            continue;
+        }
+        if (isDelimiter(buffer[valueEnd])) {
+            return true;
+        }
+    }
+    return false;
+}
+
+export { isOpeningObject, indexOfSameLevel, findJsonValueEnd, parseJsonValue, compareNumeric, matchesAnyValuePattern };