@es-joy/jsoe 0.28.2 → 0.29.0

package/src/search/searchUtils.js

@@ -0,0 +1,355 @@
+import {schemaLabel} from '../utils/schemaMeta.js';
+import {getJSONPointerParts} from '../utils/jsonPointer.js';
+
+/**
+ * @typedef {import('../types.js').JamilihArray} JamilihArray
+ */
+
+/**
+ * Label for a leaf/container's own control, preferring the schema's own
+ * `meta.title`/`meta.description`/`description` (via `schemaLabel`, same
+ * precedence the value-editing side uses) and falling back to the JSON
+ * Pointer path's final segment so every control still has a legible label
+ * even when the schema carries no metadata.
+ * @param {import('../formats/schema.js').ZodexSchema|undefined} schemaObject
+ * @param {string} path
+ * @returns {string}
+ */
+export function buildPathLabel (schemaObject, path) {
+  const label = schemaLabel(schemaObject);
+  if (label) {
+    return label;
+  }
+  const parts = getJSONPointerParts(path);
+  return parts.length ? String(parts.at(-1)) : path;
+}
+
+/**
+ * Finds a control belonging directly to `root`'s own widget - as opposed to
+ * one belonging to a search widget recursively nested inside it (e.g.
+ * `arraySearchType.js`'s own "size" input vs. a nested array-of-arrays'
+ * element widget's own "size" input, both reachable from `root` via a plain
+ * `querySelectorAll`). A match only counts if the nearest ancestor of the
+ * match carrying `data-search-path` is `root` itself; every search element
+ * carries that attribute (`searchElementUtils.js`'s `findSearchElement`), so
+ * this reliably stops at the first nested search element's boundary.
+ *
+ * This is also why every `build*`/`read*` pair below reads its class-based
+ * selector back through this helper rather than a raw
+ * `root.querySelector(...)`: a fixed class name is safe to reuse across
+ * every instance of a given control on the page precisely because lookups
+ * are always scoped this way, and - unlike a `name` built from a
+ * `typeNamespace` closed over inside a `$define` mixin, which is installed
+ * once on the shared custom-element prototype the first time a tag is
+ * defined - nothing here depends on a per-instance closure at all.
+ * @param {HTMLElement} root
+ * @param {string} selector
+ * @returns {HTMLElement|undefined}
+ */
+export function findOwnControl (root, selector) {
+  return /** @type {HTMLElement[]} */ (
+    [...root.querySelectorAll(selector)]
+  ).find((el) => el.closest('[data-search-path]') === root);
+}
+
+/**
+ * A "from"/"to" pair of native inputs sharing one `type`, for the OR-range/
+ * Is-Not-Range README affordance (number/bigint/buffersource; `date` uses
+ * `dateType.js`'s own `buildDateInputControl` instead, since a
+ * `datetime-local` input needs its own ISO-slicing).
+ *
+ * `key` distinguishes multiple range pairs *within one widget* (e.g.
+ * `domrectSearchType.js`'s `x`/`y`/`width`/`height` dimensions, or
+ * `errorSearchType.js`'s `lineNumber`/`columnNumber`): `findOwnControl`
+ * already isolates one widget's controls from another's, but can't tell
+ * apart two same-class controls belonging to the *same* widget, so those
+ * need distinct classes. Leave it at the default `''` for the common case
+ * of a widget with only one range pair.
+ * @param {{
+ *   name: string,
+ *   key?: string,
+ *   type?: string,
+ *   min?: string|number,
+ *   max?: string|number,
+ *   step?: string|number
+ * }} cfg
+ * @returns {JamilihArray[]}
+ */
+export function buildRangeInputsPair ({
+  name, key = '', type = 'number', min, max, step
+}) {
+  return [
+    ['label', [
+      'From: ',
+      ['input', {name: `${name}-gte`, class: `jsoeSearchRangeGte--${key}`, type, min, max, step}]
+    ]],
+    ['label', [
+      'To: ',
+      ['input', {name: `${name}-lte`, class: `jsoeSearchRangeLte--${key}`, type, min, max, step}]
+    ]]
+  ];
+}
+
+/**
+ * Reads back a `buildRangeInputsPair` - pass the same `key` it was built
+ * with.
+ * @param {HTMLElement} el
+ * @param {string} [key]
+ * @returns {{gte: string, lte: string}}
+ */
+export function readRangeInputsPair (el, key = '') {
+  const gte = /** @type {HTMLInputElement|undefined} */ (
+    findOwnControl(el, `input.jsoeSearchRangeGte--${key}`)
+  )?.value ?? '';
+  const lte = /** @type {HTMLInputElement|undefined} */ (
+    findOwnControl(el, `input.jsoeSearchRangeLte--${key}`)
+  )?.value ?? '';
+  return {gte, lte};
+}
+
+/**
+ * A `<select multiple>` populated from a fixed candidate list - used by
+ * `enum`/`multiSelect`/`literalSet` leaf controls (README: "multiple
+ * select").
+ * @param {{
+ *   name: string,
+ *   options: (string|[value: string, title: string])[]
+ * }} cfg
+ * @returns {JamilihArray}
+ */
+export function buildMultiSelect ({name, options}) {
+  return ['select', {name, multiple: true, class: 'jsoeSearchMultiSelect'}, options.map((opt) => {
+    const [value, title] = Array.isArray(opt) ? opt : [opt, opt];
+    return ['option', {value}, [title]];
+  })];
+}
+
+/**
+ * Reads back a `buildMultiSelect` into the selected values, `[]` if none.
+ * @param {HTMLElement} el
+ * @returns {string[]}
+ */
+export function readMultiSelect (el) {
+  const select = /** @type {HTMLSelectElement|undefined} */ (
+    findOwnControl(el, 'select.jsoeSearchMultiSelect')
+  );
+  return [...(select?.selectedOptions ?? [])].map((opt) => opt.value);
+}
+
+/**
+ * A tri-state "has property" control for one already-chosen property name
+ * (README: "Has property &lt;property pull-down&gt;", "avoid listing
+ * required"). `objectSearchType.js` supplies the additive pull-down that
+ * lets a user pick *which* property to add one of these for; this helper is
+ * only the fixed per-property toggle it adds each time, so the "any" state
+ * (no constraint entered) is distinguishable from an explicit "has"/
+ * "doesn't have" - matching `SearchTypeObject.getQuery`'s
+ * `undefined`-means-"no constraint" convention. Shares `readTriStateSelect`
+ * with `buildTriStateSelect` below - same three-value shape, just different
+ * option labels.
+ * @param {{name: string, propertyName: string}} cfg
+ * @returns {JamilihArray}
+ */
+export function buildHasPropertyToggle ({name, propertyName}) {
+  return ['label', [
+    `Has property "${propertyName}": `,
+    ['select', {name, class: 'jsoeSearchTriState--'}, [
+      ['option', {value: ''}, ['(any)']],
+      ['option', {value: 'true'}, ['Has']],
+      ['option', {value: 'false'}, ['Doesn’t have']]
+    ]]
+  ]];
+}
+
+/**
+ * A generic "(any)"/true/false `<select>`, shared by every leaf whose only
+ * constraint is a plain boolean choice - `booleanSearchType.js`'s "true or
+ * false" (README) and `numberSearchType.js`'s "Is/Is Not Integer" both read
+ * back through this same three-way convention rather than each rolling
+ * their own.
+ *
+ * `key` distinguishes multiple tri-states *within one widget* (e.g.
+ * `dommatrixSearchType.js`'s "Is/Is not Readonly" and "Is/Is not 3d" side
+ * by side); see `buildRangeInputsPair`'s doc for why. Leave it at the
+ * default `''` for the common case of a widget with only one tri-state.
+ * @param {{name: string, key?: string, trueLabel: string, falseLabel: string}} cfg
+ * @returns {JamilihArray}
+ */
+export function buildTriStateSelect ({name, key = '', trueLabel, falseLabel}) {
+  return ['select', {name, class: `jsoeSearchTriState--${key}`}, [
+    ['option', {value: ''}, ['(any)']],
+    ['option', {value: 'true'}, [trueLabel]],
+    ['option', {value: 'false'}, [falseLabel]]
+  ]];
+}
+
+/**
+ * Reads back a `buildTriStateSelect`/`buildHasPropertyToggle` - pass the
+ * same `key` it was built with. `''` (any) maps to `undefined`.
+ * @param {HTMLElement} el
+ * @param {string} [key]
+ * @returns {boolean|undefined}
+ */
+export function readTriStateSelect (el, key = '') {
+  const select = /** @type {HTMLSelectElement|undefined} */ (
+    findOwnControl(el, `select.jsoeSearchTriState--${key}`)
+  );
+  if (!select || select.value === '') {
+    return undefined;
+  }
+  return select.value === 'true';
+}
+
+/**
+ * A single checkbox - the only search affordance the README grants
+ * `undefined`/`void`/`null`/`NaN` ("Require present"; they have "no
+ * variants to allow for distinct search", since existence only becomes a
+ * meaningful question once the path is optional or nested in a union), and
+ * also used by `recordSearchType.js` for its "require same entry" toggle.
+ * @param {{name: string, label: string}} cfg
+ * @returns {JamilihArray}
+ */
+export function buildCheckbox ({name, label}) {
+  return ['label', [
+    `${label}: `,
+    ['input', {type: 'checkbox', name, class: 'jsoeSearchCheckbox'}]
+  ]];
+}
+
+/**
+ * Reads back a `buildCheckbox`.
+ * @param {HTMLElement} el
+ * @returns {boolean}
+ */
+export function readCheckbox (el) {
+  return Boolean(/** @type {HTMLInputElement|undefined} */ (
+    findOwnControl(el, 'input.jsoeSearchCheckbox')
+  )?.checked);
+}
+
+/**
+ * The mode selector for the README's "string, StringObject, Blob, File,
+ * regexp (source), symbol (description): OR literal or regex search/Does
+ * Not contain search" - one shared control (and reader, below) that
+ * `stringSearchType.js`, `symbolSearchType.js`, and `regexpSearchType.js`
+ * (for its source) each build their own custom element around, since the
+ * query semantics are identical and only the label/target facet differs.
+ *
+ * `key` distinguishes multiple literal/regex controls *within one widget*
+ * (e.g. `errorSearchType.js`'s `message`/`name`/`fileName`/`stack`); see
+ * `buildRangeInputsPair`'s doc for why. Leave it at the default `''` for
+ * the common case of a widget with only one such control.
+ * @param {{name: string, key?: string}} cfg
+ * @returns {JamilihArray}
+ */
+export function buildLiteralRegexControls ({name, key = ''}) {
+  return ['span', [
+    ['label', [
+      'Mode: ',
+      ['select', {name: `${name}-mode`, class: `jsoeSearchMode--${key}`}, [
+        ['option', {value: 'literal'}, ['One of (comma-separated)']],
+        ['option', {value: 'regex'}, ['Matches regex']],
+        ['option', {value: 'notContains'}, ['Does not contain']]
+      ]]
+    ]],
+    ['label', [
+      'Value: ',
+      ['input', {type: 'text', name: `${name}-value`, class: `jsoeSearchValue--${key}`}]
+    ]]
+  ]];
+}
+
+/**
+ * Reads back `buildLiteralRegexControls` into the corresponding
+ * `literalSet`/`regex`/`notContains` leaf - pass the same `key` it was
+ * built with.
+ * @param {HTMLElement} el
+ * @param {string} path
+ * @param {string} [key]
+ * @returns {import('./queryTree.js').QueryLiteralSetLeaf|
+ *   import('./queryTree.js').QueryRegexLeaf|
+ *   import('./queryTree.js').QueryNotContainsLeaf|undefined}
+ */
+export function readLiteralRegexQuery (el, path, key = '') {
+  const mode = /** @type {HTMLSelectElement|undefined} */ (
+    findOwnControl(el, `select.jsoeSearchMode--${key}`)
+  )?.value;
+  const value = /** @type {HTMLInputElement|undefined} */ (
+    findOwnControl(el, `input.jsoeSearchValue--${key}`)
+  )?.value;
+  if (!value) {
+    return undefined;
+  }
+  if (mode === 'regex') {
+    return {kind: 'regex', path, $regex: value};
+  }
+  if (mode === 'notContains') {
+    return {kind: 'notContains', path, value};
+  }
+  return {
+    kind: 'literalSet',
+    path,
+    $in: value.split(',').map((v) => v.trim()).filter(Boolean)
+  };
+}
+
+/**
+ * Has length/size of &lt;number&gt; (README; array/set/tuple-with-rest/
+ * filelist), + "Is/Is not sparse" for arrays only. Returns `[]` (no
+ * control) when the schema pins an exact length/size, since searching on a
+ * constant is uninteresting - the schema's `min`/`max` otherwise become the
+ * input's HTML `min`/`max` attributes.
+ * @param {{
+ *   name: string,
+ *   min?: number,
+ *   max?: number,
+ *   includeSparse?: boolean
+ * }} cfg
+ * @returns {JamilihArray[]}
+ */
+export function buildLengthSizeControls ({name, min, max, includeSparse}) {
+  const fixed = min !== undefined && min === max;
+  /** @type {JamilihArray[]} */
+  const controls = [];
+  if (!fixed) {
+    controls.push(['label', [
+      'Has length/size of: ',
+      ['input', {
+        type: 'number', name: `${name}-size`, class: 'jsoeSearchSize',
+        min, max, step: 1
+      }]
+    ]]);
+  }
+  if (includeSparse) {
+    controls.push(['label', [
+      'Sparse: ',
+      buildTriStateSelect({
+        name: `${name}-sparse`, trueLabel: 'Sparse', falseLabel: 'Not sparse'
+      })
+    ]]);
+  }
+  return controls;
+}
+
+/**
+ * Reads back `buildLengthSizeControls` into one `lengthSize` leaf, or
+ * `undefined` if neither the size nor the sparse control was set.
+ * @param {HTMLElement} el
+ * @param {string} path
+ * @returns {import('./queryTree.js').QueryLengthSizeLeaf|undefined}
+ */
+export function readLengthSizeQuery (el, path) {
+  const sizeStr = /** @type {HTMLInputElement|undefined} */ (
+    findOwnControl(el, 'input.jsoeSearchSize')
+  )?.value;
+  const sparseCheck = readTriStateSelect(el);
+  if (!sizeStr && sparseCheck === undefined) {
+    return undefined;
+  }
+  return {
+    kind: 'lengthSize',
+    path,
+    ...(sizeStr ? {$size: Number(sizeStr)} : {}),
+    ...(sparseCheck === undefined ? {} : {sparseCheck})
+  };
+}

package/src/search/subTypes/blobHTMLSearchType.js

@@ -0,0 +1,65 @@
+import {buildPathLabel, findOwnControl} from '../searchUtils.js';
+import {makeBlobHTMLLeaf} from '../queryTreeBuilders.js';
+import {getQueryViaElement} from '../searchElementUtils.js';
+
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+
+/**
+ * Blob HTML: XPath, CSS selectors, full text search, regex search of raw
+ * HTML (README) - a mode `<select>` plus one text `<input>`, the same
+ * "pick a mode, give it one value" shape as `buildLiteralRegexControls`
+ * (`searchUtils.js`), but not built through it: the four modes and the
+ * `blobHTML` leaf kind they produce are specific to this one type, with no
+ * second caller to share the helper with.
+ * @type {SearchTypeObject}
+ */
+const blobHTMLSearchType = {
+  buildUI ({schemaObject, path, typeNamespace}) {
+    const label = buildPathLabel(schemaObject, path);
+    const name = `${typeNamespace}-blobHTML`;
+    return ['jsoe-search-blob-html', {
+      dataset: {searchPath: path, searchKind: 'blobHTML'},
+      title: label,
+      $define: {
+        /** @this {HTMLElement} */
+        getQuery () {
+          const searchPath = this.dataset.searchPath ?? '';
+          const mode = /** @type {HTMLSelectElement|undefined} */ (
+            findOwnControl(this, 'select.jsoeSearchBlobHTMLMode')
+          )?.value;
+          const value = /** @type {HTMLInputElement|undefined} */ (
+            findOwnControl(this, 'input.jsoeSearchBlobHTMLValue')
+          )?.value;
+          if (!value || !mode) {
+            return undefined;
+          }
+          return makeBlobHTMLLeaf(
+            searchPath,
+            /** @type {import('../queryTree.js').QueryBlobHTMLLeaf['mode']} */ (mode),
+            value
+          );
+        }
+      }
+    }, [
+      ['span', {class: 'searchLabel'}, [label]],
+      ['label', [
+        'Mode: ',
+        ['select', {name: `${name}-mode`, class: 'jsoeSearchBlobHTMLMode'}, [
+          ['option', {value: 'xpath'}, ['XPath']],
+          ['option', {value: 'cssSelector'}, ['CSS selector']],
+          ['option', {value: 'fullText'}, ['Full text search']],
+          ['option', {value: 'rawHTMLRegex'}, ['Regex search of raw HTML']]
+        ]]
+      ]],
+      ['label', [
+        'Value: ',
+        ['input', {type: 'text', name: `${name}-value`, class: 'jsoeSearchBlobHTMLValue'}]
+      ]]
+    ]];
+  },
+  getQuery: getQueryViaElement
+};
+
+export default blobHTMLSearchType;

package/src/search/subTypes/recordSearchType.js

@@ -0,0 +1,84 @@
+import {buildPathLabel, buildCheckbox, readCheckbox} from '../searchUtils.js';
+import {makeMapRecordJointLeaf} from '../queryTreeBuilders.js';
+import {findSearchElement, getQueryViaElement, hasGetQuery} from '../searchElementUtils.js';
+import {buildSearchWidget} from '../searchDispatch.js';
+
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+
+/**
+ * Record search is "key-schema search AND/OR value-schema search,"
+ * structurally unlike object's additive "has property" (search plan §1) -
+ * recurses into both the `key` and `value` schemas' own search widgets
+ * (`*key`/`*value` path segments, `queryTree.js`), and lets the user say
+ * whether a match must come from the *same* entry ("has key 2-4 and value
+ * 7-9", README) via the "joint" toggle on the resulting `mapRecordJoint`
+ * leaf - also used for `looseRecord`, aliased to this same module in
+ * `searchDispatch.js` since the search semantics are identical.
+ * @type {SearchTypeObject}
+ */
+const recordSearchType = {
+  buildUI ({schemaObject, path, typeNamespace, topRoot, types, originalJSON}) {
+    const label = buildPathLabel(schemaObject, path);
+    const name = `${typeNamespace}-record`;
+    const recordSchemaObject = /** @type {import('zodexy').SzRecord} */ (
+      schemaObject
+    );
+    const keyPath = `${path}/*key`;
+    const valuePath = `${path}/*value`;
+    const keyArr = buildSearchWidget({
+      schemaObject: recordSchemaObject.key,
+      path: keyPath,
+      typeNamespace,
+      topRoot,
+      types,
+      originalJSON
+    });
+    const valueArr = buildSearchWidget({
+      schemaObject: recordSchemaObject.value,
+      path: valuePath,
+      typeNamespace,
+      topRoot,
+      types,
+      originalJSON
+    });
+    return ['jsoe-search-record', {
+      dataset: {searchPath: path, searchKind: 'record'},
+      title: label,
+      $define: {
+        /** @this {HTMLElement} */
+        getQuery () {
+          const searchPath = this.dataset.searchPath ?? '';
+          const keyEl = findSearchElement(this, `${searchPath}/*key`);
+          const valueEl = findSearchElement(this, `${searchPath}/*value`);
+          const keyQuery = keyEl && hasGetQuery(keyEl)
+            ? keyEl.getQuery()
+            : undefined;
+          const valueQuery = valueEl && hasGetQuery(valueEl)
+            ? valueEl.getQuery()
+            : undefined;
+          if (!keyQuery && !valueQuery) {
+            return undefined;
+          }
+          const joint = readCheckbox(this);
+          return makeMapRecordJointLeaf(searchPath, joint, keyQuery, valueQuery);
+        }
+      }
+    }, [
+      ['span', {class: 'searchLabel'}, [label]],
+      ['div', {class: 'searchRecordKey'}, [
+        ['span', ['Key matches: ']],
+        keyArr
+      ]],
+      ['div', {class: 'searchRecordValue'}, [
+        ['span', ['Value matches: ']],
+        valueArr
+      ]],
+      buildCheckbox({name: `${name}-joint`, label: 'Require same entry'})
+    ]];
+  },
+  getQuery: getQueryViaElement
+};
+
+export default recordSearchType;

package/src/search/subTypes/tupleSearchType.js

@@ -0,0 +1,111 @@
+import {buildPathLabel, buildLengthSizeControls, readLengthSizeQuery} 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
+ */
+
+/**
+ * Each fixed position gets its own control from `.items[i]`, not one
+ * control repeated per element (search plan §1 - unlike the value-editing
+ * side, this gets a dedicated module rather than delegating to
+ * `arraySearchType.js`, since positions aren't interchangeable). A tuple
+ * with no `rest` has an inherently fixed length (`items.length`), so - as
+ * with a fixed-length array - no length control is shown for it; "with rest
+ * has size search as with arrays" (README) applies once `rest` is present:
+ * total length becomes a variable-length `lengthSize` control (`min:
+ * items.length`, no sparse toggle - not applicable to a tuple), and the
+ * `rest` element itself recurses into its own search widget under the same
+ * `*` path-segment convention `arraySearchType.js` uses for its element.
+ * @type {SearchTypeObject}
+ */
+const tupleSearchType = {
+  buildUI ({schemaObject, path, typeNamespace, topRoot, types, originalJSON}) {
+    const label = buildPathLabel(schemaObject, path);
+    const name = `${typeNamespace}-tuple`;
+    const tupleSchemaObject = /** @type {import('zodexy').SzTuple} */ (
+      schemaObject
+    );
+    const {items, rest} = tupleSchemaObject;
+
+    const itemArrs = items.map((itemSchema, idx) => buildSearchWidget({
+      schemaObject: itemSchema,
+      path: `${path}/${idx}`,
+      typeNamespace,
+      topRoot,
+      types,
+      originalJSON
+    }));
+
+    const restElementPath = `${path}/*`;
+    const restArr = rest
+      ? buildSearchWidget({
+        schemaObject: rest,
+        path: restElementPath,
+        typeNamespace,
+        topRoot,
+        types,
+        originalJSON
+      })
+      : undefined;
+
+    /** @type {import('../../types.js').JamilihArray[]} */
+    const children = [['span', {class: 'searchLabel'}, [label]]];
+    itemArrs.forEach((itemArr, idx) => {
+      children.push(['div', {class: 'searchTupleItem'}, [
+        ['span', [`Position ${idx}: `]],
+        itemArr
+      ]]);
+    });
+    if (rest) {
+      children.push(
+        ...buildLengthSizeControls({
+          name, min: items.length, max: undefined, includeSparse: false
+        }),
+        ['div', {class: 'searchTupleRest'}, [
+          ['span', ['Rest element matches: ']],
+          /** @type {import('../../types.js').JamilihArray} */ (restArr)
+        ]]
+      );
+    }
+
+    return ['jsoe-search-tuple', {
+      dataset: {
+        searchPath: path, searchKind: 'tuple',
+        itemCount: String(items.length), hasRest: rest ? 'true' : ''
+      },
+      title: label,
+      $define: {
+        // Reads `itemCount`/`hasRest` off `this.dataset` rather than
+        //   closing over `items`/`rest`: `$define`'s mixin is installed
+        //   once on the shared prototype the first time this tag is
+        //   defined, so a second tuple widget on the same page would
+        //   otherwise silently reuse the first tuple's item count/rest-ness.
+        /** @this {HTMLElement} */
+        getQuery () {
+          const searchPath = this.dataset.searchPath ?? '';
+          const itemCount = Number(this.dataset.itemCount ?? '0');
+          const hasRest = this.dataset.hasRest === 'true';
+          const itemLeaves = Array.from({length: itemCount}, (_, idx) => {
+            const itemEl = findSearchElement(this, `${searchPath}/${idx}`);
+            return itemEl && hasGetQuery(itemEl) ? itemEl.getQuery() : undefined;
+          });
+          if (!hasRest) {
+            return combineAnd(itemLeaves);
+          }
+          const lengthLeaf = readLengthSizeQuery(this, searchPath);
+          const restEl = findSearchElement(this, `${searchPath}/*`);
+          const restLeaf = restEl && hasGetQuery(restEl)
+            ? restEl.getQuery()
+            : undefined;
+          return combineAnd([...itemLeaves, lengthLeaf, restLeaf]);
+        }
+      }
+    }, children];
+  },
+  getQuery: getQueryViaElement
+};
+
+export default tupleSearchType;

package/src/search/superTypes/SpecialRealNumberSearchType.js

@@ -0,0 +1,42 @@
+import {buildPathLabel, buildMultiSelect, readMultiSelect} from '../searchUtils.js';
+import {makeMultiSelectLeaf} from '../queryTreeBuilders.js';
+import {getQueryViaElement} from '../searchElementUtils.js';
+
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+
+/**
+ * Special number: multiple select of "Infinity", "-Infinity" (README;
+ * `NaN` is covered separately by `nanSearchType.js`'s presence-only
+ * control, since it's its own zodex schema type - `SpecialRealNumberType.js`
+ * itself covers exactly `Infinity`/`-Infinity`/`-0`, not `NaN`).
+ * @type {SearchTypeObject}
+ */
+const SpecialRealNumberSearchType = {
+  buildUI ({schemaObject, path, typeNamespace}) {
+    const label = buildPathLabel(schemaObject, path);
+    const name = `${typeNamespace}-SpecialRealNumber`;
+    return ['jsoe-search-special-real-number', {
+      dataset: {searchPath: path, searchKind: 'SpecialRealNumber'},
+      title: label,
+      $define: {
+        /** @this {HTMLElement} */
+        getQuery () {
+          const selected = readMultiSelect(this);
+          return selected.length
+            ? makeMultiSelectLeaf(this.dataset.searchPath ?? '', {$in: selected})
+            : undefined;
+        }
+      }
+    }, [
+      ['span', {class: 'searchLabel'}, [label]],
+      buildMultiSelect({
+        name, options: ['Infinity', '-Infinity', '-0']
+      })
+    ]];
+  },
+  getQuery: getQueryViaElement
+};
+
+export default SpecialRealNumberSearchType;