@es-joy/jsoe 0.28.2 → 0.30.0

package/src/search/fundamentalTypes/regexpSearchType.js

@@ -0,0 +1,72 @@
+import {
+  buildPathLabel, buildLiteralRegexControls, readLiteralRegexQuery,
+  buildMultiSelect, readMultiSelect, findOwnControl
+} from '../searchUtils.js';
+import {makeMultiSelectLeaf, combineAnd} from '../queryTreeBuilders.js';
+import {getQueryViaElement} from '../searchElementUtils.js';
+import regexpType from '../../fundamentalTypes/regexpType.js';
+
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+
+/**
+ * Regexp (source): OR literal or regex search/Does Not contain search, plus
+ * a multiple-select search of flags (README). `regexpType.js`'s own
+ * `allowedFlags` list is imported as-is for the flags control (search plan
+ * §4 - already a plain exported property, no extraction needed). Flags are
+ * a property of the regexp itself, not of how its source is being matched,
+ * but the Flags control is only shown (and only contributes to the query)
+ * while the source's own Mode is "Matches regex" - searching a source
+ * literal/substring while also constraining flags is a much rarer
+ * combination, and hiding Flags the rest of the time keeps the common case
+ * uncluttered.
+ * @type {SearchTypeObject}
+ */
+const regexpSearchType = {
+  buildUI ({schemaObject, path, typeNamespace}) {
+    const label = buildPathLabel(schemaObject, path);
+    const name = `${typeNamespace}-regexp`;
+    return ['jsoe-search-regexp', {
+      dataset: {searchPath: path, searchKind: 'regexp'},
+      title: label,
+      $define: {
+        /** @this {HTMLElement} */
+        getQuery () {
+          const searchPath = this.dataset.searchPath ?? '';
+          const sourceLeaf = readLiteralRegexQuery(this, searchPath);
+          const mode = /** @type {HTMLSelectElement|undefined} */ (
+            findOwnControl(this, 'select.jsoeSearchMode--')
+          )?.value;
+          const selectedFlags = mode === 'regex' ? readMultiSelect(this) : [];
+          const flagsLeaf = selectedFlags.length
+            ? makeMultiSelectLeaf(searchPath, {$in: selectedFlags})
+            : undefined;
+          return combineAnd([sourceLeaf, flagsLeaf]);
+        }
+      }
+    }, [
+      ['span', {class: 'searchLabel'}, [`${label} (source)`]],
+      buildLiteralRegexControls({
+        name,
+        /** @this {HTMLElement} */
+        onModeChange () {
+          const flagsLabel = this.closest('jsoe-search-regexp')?.querySelector(
+            '.searchRegexpFlags'
+          );
+          if (flagsLabel) {
+            /** @type {HTMLElement} */ (flagsLabel).hidden =
+              /** @type {HTMLSelectElement} */ (this).value !== 'regex';
+          }
+        }
+      }),
+      ['label', {class: 'searchRegexpFlags', hidden: true}, [
+        'Flags: ',
+        buildMultiSelect({name: `${name}-flags`, options: regexpType.allowedFlags})
+      ]]
+    ]];
+  },
+  getQuery: getQueryViaElement
+};
+
+export default regexpSearchType;

package/src/search/fundamentalTypes/setSearchType.js

@@ -0,0 +1,91 @@
+import {
+  buildPathLabel, buildLengthSizeControls, readLengthSizeQuery,
+  buildOptInFieldset, readOptInChecked, wireOptInFieldset,
+  buildAtLeastOneSentinel, syncAtLeastOneCheck
+} from '../searchUtils.js';
+import {combineAnd} from '../queryTreeBuilders.js';
+import {findSearchElement, getQueryViaElement, hasGetQuery} from '../searchElementUtils.js';
+import {buildSearchWidget} from '../searchDispatch.js';
+
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+
+/**
+ * @param {Element} root - a `jsoe-search-set` element
+ * @returns {void}
+ */
+function syncSetValidity (root) {
+  syncAtLeastOneCheck(
+    root, () => readLengthSizeQuery(root, '') !== undefined || readOptInChecked(root)
+  );
+}
+
+/**
+ * Has length/size of <number> (README) - no sparse toggle: unlike
+ * `array`, a `Set` cannot have holes. Also recurses into the value schema's
+ * own search widget (as `arraySearchType.js` does for its element), via the
+ * same `*` path-segment convention (`queryTree.js`), wrapped in the same
+ * `buildOptInFieldset` `arraySearchType.js` uses and for the same reason -
+ * a length/size-only search should stay valid. Leaving *both* length/size
+ * and the element match unconfigured is still invalid, though
+ * (`buildAtLeastOneSentinel`), same as `arraySearchType.js`.
+ * @type {SearchTypeObject}
+ */
+const setSearchType = {
+  buildUI ({schemaObject, path, typeNamespace, topRoot, types, originalJSON}) {
+    const label = buildPathLabel(schemaObject, path);
+    const name = `${typeNamespace}-set`;
+    const setSchemaObject = /** @type {import('zodexy').SzSet} */ (
+      schemaObject
+    );
+    const elementPath = `${path}/*`;
+    const elementArr = buildSearchWidget({
+      schemaObject: setSchemaObject.value,
+      path: elementPath,
+      typeNamespace,
+      topRoot,
+      types,
+      originalJSON
+    });
+    return ['jsoe-search-set', {
+      dataset: {searchPath: path, searchKind: 'set'},
+      title: label,
+      $define: {
+        /** @this {HTMLElement} */
+        connectedCallback () {
+          wireOptInFieldset(this, '', () => syncSetValidity(this));
+          this.querySelector('input.jsoeSearchSize')?.addEventListener(
+            'input', () => syncSetValidity(this)
+          );
+          syncSetValidity(this);
+        },
+        /** @this {HTMLElement} */
+        getQuery () {
+          const searchPath = this.dataset.searchPath ?? '';
+          const lengthLeaf = readLengthSizeQuery(this, searchPath);
+          const elementEl = findSearchElement(this, `${searchPath}/*`);
+          const elementLeaf = elementEl && hasGetQuery(elementEl) && readOptInChecked(this)
+            ? elementEl.getQuery()
+            : undefined;
+          return combineAnd([lengthLeaf, elementLeaf]);
+        }
+      }
+    }, [
+      ['span', {class: 'searchLabel'}, [label]],
+      ...buildLengthSizeControls({
+        name,
+        min: setSchemaObject.minSize,
+        max: setSchemaObject.maxSize,
+        includeSparse: false
+      }),
+      ...buildOptInFieldset({
+        name: `${name}-element`, label: 'Element matches', children: [elementArr]
+      }),
+      buildAtLeastOneSentinel()
+    ]];
+  },
+  getQuery: getQueryViaElement
+};
+
+export default setSearchType;

package/src/search/fundamentalTypes/stringSearchType.js

@@ -0,0 +1,44 @@
+import {buildPathLabel, buildLiteralRegexControls, readLiteralRegexQuery} from '../searchUtils.js';
+import {getQueryViaElement} from '../searchElementUtils.js';
+import regexpType from '../../fundamentalTypes/regexpType.js';
+
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+
+/**
+ * OR literal or regex search/Does Not contain search (README; also covers
+ * `StringObject` and `templateLiteral`, aliased to this same module in
+ * `searchDispatch.js` since the query semantics are identical), plus - only
+ * while "Matches regex" is the chosen mode - a Flags multi-select
+ * (`buildLiteralRegexControls`'s `flagOptions`, `regexpType.js`'s own
+ * `allowedFlags` list reused as-is, matching `regexpSearchType.js`'s flags
+ * for the actual regexp's own flags): unlike `regexpSearchType.js`, whose
+ * "source" is already a real regexp with its own flags regardless of
+ * search mode, here the regex is only ever the search's *own* device for
+ * matching the string, so flags only make sense while that regex is
+ * actually in play.
+ * @type {SearchTypeObject}
+ */
+const stringSearchType = {
+  buildUI ({schemaObject, path, typeNamespace}) {
+    const label = buildPathLabel(schemaObject, path);
+    const name = `${typeNamespace}-string`;
+    return ['jsoe-search-string', {
+      dataset: {searchPath: path, searchKind: 'string'},
+      title: label,
+      $define: {
+        /** @this {HTMLElement} */
+        getQuery () {
+          return readLiteralRegexQuery(this, this.dataset.searchPath ?? '');
+        }
+      }
+    }, [
+      ['span', {class: 'searchLabel'}, [label]],
+      buildLiteralRegexControls({name, flagOptions: regexpType.allowedFlags})
+    ]];
+  },
+  getQuery: getQueryViaElement
+};
+
+export default stringSearchType;

package/src/search/fundamentalTypes/symbolSearchType.js

@@ -0,0 +1,39 @@
+import {buildPathLabel, buildLiteralRegexControls, readLiteralRegexQuery} from '../searchUtils.js';
+import {getQueryViaElement} from '../searchElementUtils.js';
+import regexpType from '../../fundamentalTypes/regexpType.js';
+
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+
+/**
+ * Symbol (description): OR literal or regex search/Does Not contain search
+ * (README) - the same query semantics as `stringSearchType.js`'s, against
+ * the symbol's description rather than a string value, so it gets its own
+ * dedicated module/tag (matching the value-editing side's one-file-per-
+ * fundamental-type convention) while sharing that module's actual control
+ * building/reading via `searchUtils.js`.
+ * @type {SearchTypeObject}
+ */
+const symbolSearchType = {
+  buildUI ({schemaObject, path, typeNamespace}) {
+    const label = buildPathLabel(schemaObject, path);
+    const name = `${typeNamespace}-symbol`;
+    return ['jsoe-search-symbol', {
+      dataset: {searchPath: path, searchKind: 'symbol'},
+      title: label,
+      $define: {
+        /** @this {HTMLElement} */
+        getQuery () {
+          return readLiteralRegexQuery(this, this.dataset.searchPath ?? '');
+        }
+      }
+    }, [
+      ['span', {class: 'searchLabel'}, [`${label} (description)`]],
+      buildLiteralRegexControls({name, flagOptions: regexpType.allowedFlags})
+    ]];
+  },
+  getQuery: getQueryViaElement
+};
+
+export default symbolSearchType;

package/src/search/fundamentalTypes/undefinedSearchType.js

@@ -0,0 +1,11 @@
+import {makePresenceOnlySearchType} from '../searchElementUtils.js';
+
+/**
+ * `undefined`/`void`: "no variants to allow for distinct search" (README).
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+const undefinedSearchType = makePresenceOnlySearchType({
+  tagName: 'jsoe-search-undefined'
+});
+
+export default undefinedSearchType;

package/src/search/index.js

@@ -0,0 +1,96 @@
+import {jml} from '../vendor-imports.js';
+import {getSearchTypeObject, buildSearchWidget, resolveIntersection} from './searchDispatch.js';
+
+/**
+ * @typedef {{
+ *   container: HTMLFormElement,
+ *   $getQuery: () => import('./queryTree.js').QueryAnd,
+ *   whenReady: Promise<void>
+ * }} SearchChoicesControl
+ */
+
+/**
+ * The top-level entry point (search plan §5): builds the whole recursive
+ * search widget tree for `schemaContent` via `buildSearchWidget`
+ * (`searchDispatch.js`), starting at `path = '#/'`. Does not route through
+ * `getTypesForSchema` for the general case - that function flattens union
+ * members into one flat `Set` of leaf types for a type-choice pull-down,
+ * whereas search needs union branches to stay distinguishable nested
+ * sub-widgets for the "has type" affordance (`unionSearchType.js` et al.) -
+ * `getTypesForSchema` is only reused narrowly, for intersection resolution,
+ * inside `buildSearchWidget`/`resolveIntersection` - which run at *every*
+ * recursive call site (every composite module's own child recursion uses
+ * `buildSearchWidget` too), not just here at the root, so an intersection
+ * schema nested anywhere in the tree resolves the same way a top-level one
+ * does rather than falling through to the `noneditableSearchType` escape
+ * hatch.
+ *
+ * `resolveIntersection` is called here too (redundantly, but cheaply, since
+ * it's a no-op for anything that isn't itself an `intersection`) purely so
+ * `$getQuery()` below dispatches through the *same* resolved schema
+ * `buildSearchWidget` actually built the UI for, rather than the original
+ * (possibly-`intersection`) one.
+ *
+ * Mirrors `buildTypeChoices`'s (`src/typeChoices.js`) `whenReady`/
+ * pull-based convention rather than inventing a push/callback API:
+ * `$getQuery()` reads the live DOM into a `QueryAnd` on demand (`{$and:
+ * []}` when nothing has been entered anywhere, matching the empty-`$and`
+ * convention of "no constraint"), and a host that wants live updates wraps
+ * it in its own `container.addEventListener('input', ...)`. Every widget
+ * built so far is synchronous, so `whenReady` (unlike `buildTypeChoices`'s)
+ * has no deferred work to wait on and settles immediately - it's still
+ * returned, so a caller can `await` either function uniformly without
+ * checking which one it has.
+ *
+ * `container` is a real `<form>` (its own `submit` prevented, since it is
+ * never actually submitted) rather than a plain `<div>`, matching the edit
+ * side's own root `<form>` (`src/types.js`'s `Types.validValuesSet` reads
+ * `form.checkValidity()`) - the various cross-field checks the individual
+ * search widgets wire up (`searchUtils.js`'s `buildRangeInputsPair`,
+ * `dateSearchType.js`, etc.) are native Constraint Validation API calls
+ * (`setCustomValidity`/`required`), so a host only needs the one native
+ * `container.checkValidity()`/`container.reportValidity()` to check them
+ * all at once, the same way `demo/index-search.js`'s "Check validity"
+ * button does.
+ * @param {{
+ *   schemaContent: import('../formats/schema.js').ZodexSchema,
+ *   typeNamespace?: string,
+ *   topRoot?: import('../types.js').RootElement,
+ *   types?: import('../types.js').default
+ * }} cfg
+ * @returns {SearchChoicesControl}
+ */
+export function buildSearchChoices ({schemaContent, typeNamespace, topRoot, types}) {
+  // Not '#/': `getJSONPointerParts` (`src/utils/jsonPointer.js`) splits on
+  //   '/' and drops the leading '#', so '#/' parts to `['']` (one segment
+  //   named the empty string) rather than `[]` (the root, no segments yet)
+  //   - every recursive module here appends `${path}/segment`, so starting
+  //   from the bare '#' is what keeps the first level from coming out as
+  //   '#//segment'.
+  const path = '#';
+  const arr = buildSearchWidget({
+    schemaObject: schemaContent, path, typeNamespace, topRoot, types,
+    originalJSON: schemaContent
+  });
+  const container = /** @type {HTMLFormElement} */ (
+    jml('form', {
+      class: 'searchChoicesContainer',
+      $on: {
+        submit (e) {
+          e.preventDefault();
+        }
+      }
+    }, [arr])
+  );
+  const schemaObject = resolveIntersection(schemaContent, schemaContent);
+  return {
+    container,
+    $getQuery () {
+      const result = getSearchTypeObject(schemaObject).getQuery({
+        root: container, path
+      });
+      return {$and: result === undefined ? [] : [result]};
+    },
+    whenReady: Promise.resolve()
+  };
+}

package/src/search/queryTree.js

@@ -0,0 +1,244 @@
+/**
+ * JSDoc-only typedefs for the schema-driven search query tree. No runtime
+ * exports live here; construct nodes through `queryTreeBuilders.js` instead
+ * so every search module (and every test fixture) goes through one place.
+ *
+ * Leaf `path` values reuse the existing JSON-Pointer convention from
+ * `src/utils/jsonPointer.js` (`makeJSONPointer`/`getJSONPointerParts`)
+ * rather than Mongo's dot-notation, so the search tree shares a path format
+ * with the rest of jsoe (e.g. `arrayType.js`'s `currentPath`).
+ *
+ * The leaf vocabulary borrows MongoDB's own operator names (`$and`/`$or`,
+ * `$gt`/`$gte`/`$lt`/`$lte`, `$in`/`$nin`, `$regex`/`$options`, `$exists`)
+ * wherever a leaf kind has a clean Mongo equivalent, so a host can adapt the
+ * common cases to `sift()` (or real MongoDB) almost for free - this is not a
+ * claim of full drop-in Mongo query-document compatibility: several
+ * jsoe-specific leaf kinds have no Mongo equivalent and stay custom, and
+ * every leaf keeps jsoe's own `kind`-discriminated, path-carrying shape
+ * rather than Mongo's field-keyed document shape.
+ *
+ * A path segment of `*` (e.g. `#/tags/*`) means "any element of the array
+ * at this point" - `arraySearchType.js`/`setSearchType.js`/`filelistSearchType.js`
+ * (element/value length/count constraint aside) and `tupleSearchType.js`'s
+ * `rest` portion use it when recursing into their element/value schema's
+ * own search widget, so a single nested leaf expresses "the collection
+ * contains at least one element matching this" (Mongo's `$elemMatch` is the
+ * natural translation target for a host walking a path that contains this
+ * segment) without needing a dedicated wrapper leaf kind - the collection's
+ * own `lengthSize` leaf and the recursed element leaf simply combine via
+ * `$and`. `recordSearchType.js`/`mapSearchType.js` similarly recurse into
+ * their `key`/`value` schemas at `*key`/`*value` segments, feeding the
+ * results into a single `mapRecordJoint` leaf (below) rather than combining
+ * via `$and`, since a host needs to know whether the two must match the
+ * same entry. `functionSearchType.js` recurses into its `input`/`output`
+ * schemas at `*args`/`*output` segments (the former itself a tuple, so its
+ * own per-position segments nest under `*args`), combined via `$and`.
+ * `promiseSearchType.js`/`catchSearchType.js` recurse into their wrapped
+ * value/`innerType` at the same path (there being exactly one value, no
+ * segment to add) and wrap the result in a `passThrough` leaf (below)
+ * rather than returning it bare, so the tree keeps visible that the leaf
+ * was reached through one of these transparent wrappers.
+ */
+
+/**
+ * @typedef {{$and: QueryNode[]}} QueryAnd
+ */
+
+/**
+ * @typedef {{$or: QueryNode[]}} QueryOr
+ */
+
+/**
+ * `object` (via `$exists: true/false`).
+ * @typedef {{kind: 'hasProperty', path: string, $exists: boolean}} QueryHasPropertyLeaf
+ */
+
+/**
+ * `array`/`set`/tuple-with-rest/`filelist` (via `$size`, or a range of
+ * operators when the schema doesn't pin an exact length), +`sparseCheck`
+ * for array sparse/not-sparse.
+ * @typedef {{
+ *   kind: 'lengthSize',
+ *   path: string,
+ *   $size?: number,
+ *   $gt?: number, $gte?: number, $lt?: number, $lte?: number,
+ *   sparseCheck?: boolean
+ * }} QueryLengthSizeLeaf
+ */
+
+/**
+ * `number`/`NumberObject`/`bigint`/`date`/`buffersource`, with `valueType`
+ * distinguishing them. Bounds are Mongo-style `$gt`/`$gte`/`$lt`/`$lte`
+ * rather than a `min`/`max` pair plus an inclusive boolean - inclusivity is
+ * simply which operator is present. The README's "Is Not Range" variant
+ * wraps the same leaf in `$not` rather than being a separate kind.
+ * @typedef {{
+ *   kind: 'range',
+ *   path: string,
+ *   valueType: 'number'|'NumberObject'|'bigint'|'date'|'buffersource',
+ *   $gt?: number|bigint|string,
+ *   $gte?: number|bigint|string,
+ *   $lt?: number|bigint|string,
+ *   $lte?: number|bigint|string
+ * }} QueryRangeLeaf
+ */
+
+/**
+ * @typedef {{kind: 'not', query: QueryNode}} QueryNotLeaf
+ */
+
+/**
+ * `number`/`NumberObject`: is/is-not an integer.
+ * @typedef {{kind: 'integerCheck', path: string, isInteger: boolean}} QueryIntegerCheckLeaf
+ */
+
+/**
+ * `date`: is/is-not a valid `Date` (a structured-cloned `Date` can itself be
+ * an "Invalid Date" - a `NaN` internal time value - `dateType.js`'s own
+ * `notANum`/`ValidDate`/`InvalidDate` handling deals with the same state on
+ * the edit side).
+ * @typedef {{kind: 'validDateCheck', path: string, isValid: boolean}} QueryValidDateCheckLeaf
+ */
+
+/**
+ * `string`/`StringObject`/`Blob`/`File`/regexp-source/symbol-description
+ * (via `$in`/`$nin`).
+ * @typedef {{
+ *   kind: 'literalSet',
+ *   path: string,
+ *   $in?: unknown[],
+ *   $nin?: unknown[]
+ * }} QueryLiteralSetLeaf
+ */
+
+/**
+ * `string`/`StringObject`/`Blob`/`File`/regexp-source/symbol-description
+ * (via `$regex`/`$options`, matching Mongo's own field names).
+ * @typedef {{
+ *   kind: 'regex',
+ *   path: string,
+ *   $regex: string,
+ *   $options?: string
+ * }} QueryRegexLeaf
+ */
+
+/**
+ * `string`/`StringObject`/`Blob`/`File`/regexp-source/symbol-description:
+ * a substring the value must not contain.
+ * @typedef {{
+ *   kind: 'notContains',
+ *   path: string,
+ *   value: string
+ * }} QueryNotContainsLeaf
+ */
+
+/**
+ * `enum`, SpecialNumber's `Infinity`/`-Infinity`/`NaN`/`-0` (via
+ * `$in`/`$nin`).
+ * @typedef {{
+ *   kind: 'multiSelect',
+ *   path: string,
+ *   $in?: unknown[],
+ *   $nin?: unknown[]
+ * }} QueryMultiSelectLeaf
+ */
+
+/**
+ * Native enum key-vs-value; no Mongo equivalent, stays custom.
+ * @typedef {{
+ *   kind: 'keyValueEnum',
+ *   path: string,
+ *   matchKeys: boolean,
+ *   values: unknown[]
+ * }} QueryKeyValueEnumLeaf
+ */
+
+/**
+ * Union/xor/discriminatedUnion "has type", carrying `discriminatorValue`
+ * when applicable, including when nested under a Map/Record key or value;
+ * no Mongo equivalent, stays custom.
+ * @typedef {{
+ *   kind: 'typeOf',
+ *   path: string,
+ *   searchType: string,
+ *   discriminatorValue?: unknown
+ * }} QueryTypeOfLeaf
+ */
+
+/**
+ * XPath/CSS-selector/full-text/raw-HTML-regex; no Mongo equivalent.
+ * @typedef {{
+ *   kind: 'blobHTML',
+ *   path: string,
+ *   mode: 'xpath'|'cssSelector'|'fullText'|'rawHTMLRegex',
+ *   value: string
+ * }} QueryBlobHTMLLeaf
+ */
+
+/**
+ * Per-dimension ranges for DOMRect/Point/Matrix, each dimension itself a
+ * `range` leaf, + `readonlyCheck`/`dimensionCheck` (is/is-not readonly,
+ * is/is-not 3d); no Mongo equivalent.
+ * @typedef {{
+ *   kind: 'domShape',
+ *   path: string,
+ *   dimensions: {[dimension: string]: QueryRangeLeaf},
+ *   readonlyCheck?: boolean,
+ *   dimensionCheck?: 2|3
+ * }} QueryDomShapeLeaf
+ */
+
+/**
+ * Paired key+value leaves with a joint-match flag; no Mongo equivalent.
+ * @typedef {{
+ *   kind: 'mapRecordJoint',
+ *   path: string,
+ *   keyQuery?: QueryNode,
+ *   valueQuery?: QueryNode,
+ *   joint: boolean
+ * }} QueryMapRecordJointLeaf
+ */
+
+/**
+ * Promise/literal/catch/function: forwards to a nested `QueryNode` for the
+ * child schema so the tree stays uniform even where a type adds no
+ * constraint of its own; purely structural, no Mongo equivalent.
+ * @typedef {{
+ *   kind: 'passThrough',
+ *   path: string,
+ *   query?: QueryNode
+ * }} QueryPassThroughLeaf
+ */
+
+/**
+ * Undefined/void/null (via `$exists`).
+ * @typedef {{kind: 'presence', path: string, $exists: boolean}} QueryPresenceLeaf
+ */
+
+/**
+ * Boolean/BooleanObject - Mongo would normally express this as a bare
+ * `{field: true}` shorthand, which doesn't fit our path-carrying leaf
+ * shape, so this stays a custom kind.
+ * @typedef {{
+ *   kind: 'booleanEquals',
+ *   path: string,
+ *   value: boolean
+ * }} QueryBooleanEqualsLeaf
+ */
+
+/**
+ * @typedef {QueryHasPropertyLeaf|QueryLengthSizeLeaf|QueryRangeLeaf|
+ *   QueryNotLeaf|QueryIntegerCheckLeaf|QueryValidDateCheckLeaf|
+ *   QueryLiteralSetLeaf|QueryRegexLeaf|
+ *   QueryNotContainsLeaf|QueryMultiSelectLeaf|QueryKeyValueEnumLeaf|
+ *   QueryTypeOfLeaf|QueryBlobHTMLLeaf|QueryDomShapeLeaf|
+ *   QueryMapRecordJointLeaf|QueryPassThroughLeaf|QueryPresenceLeaf|
+ *   QueryBooleanEqualsLeaf
+ * } QueryLeaf
+ */
+
+/**
+ * @typedef {QueryAnd|QueryOr|QueryLeaf} QueryNode
+ */
+
+export {};