@es-joy/jsoe 0.28.1 → 0.29.0

package/src/search/searchDispatch.js

@@ -0,0 +1,291 @@
+import {getSchemaType, getTypesForSchema} from '../formats/schema.js';
+
+import dateSearchType from './fundamentalTypes/dateSearchType.js';
+import numberSearchType from './fundamentalTypes/numberSearchType.js';
+import bigintSearchType from './fundamentalTypes/bigintSearchType.js';
+import stringSearchType from './fundamentalTypes/stringSearchType.js';
+import regexpSearchType from './fundamentalTypes/regexpSearchType.js';
+import booleanSearchType from './fundamentalTypes/booleanSearchType.js';
+import symbolSearchType from './fundamentalTypes/symbolSearchType.js';
+import undefinedSearchType from './fundamentalTypes/undefinedSearchType.js';
+import nullSearchType from './fundamentalTypes/nullSearchType.js';
+import nanSearchType from './fundamentalTypes/nanSearchType.js';
+import enumSearchType from './fundamentalTypes/enumSearchType.js';
+import arraySearchType from './fundamentalTypes/arraySearchType.js';
+import setSearchType from './fundamentalTypes/setSearchType.js';
+import objectSearchType from './fundamentalTypes/objectSearchType.js';
+import filelistSearchType from './fundamentalTypes/filelistSearchType.js';
+import tupleSearchType from './subTypes/tupleSearchType.js';
+import recordSearchType from './subTypes/recordSearchType.js';
+import mapSearchType from './fundamentalTypes/mapSearchType.js';
+import promiseSearchType from './fundamentalTypes/promiseSearchType.js';
+import catchSearchType from './fundamentalTypes/catchSearchType.js';
+import functionSearchType from './fundamentalTypes/functionSearchType.js';
+import fileSearchType from './fundamentalTypes/fileSearchType.js';
+import blobSearchType from './fundamentalTypes/blobSearchType.js';
+import unionSearchType from './unions/unionSearchType.js';
+import xorSearchType from './unions/xorSearchType.js';
+import discriminatedUnionSearchType from './unions/discriminatedUnionSearchType.js';
+import errorSearchType from './fundamentalTypes/errorSearchType.js';
+import errorsSpecialSearchType from './superTypes/errorsSpecialSearchType.js';
+import domexceptionSearchType from './fundamentalTypes/domexceptionSearchType.js';
+import domrectSearchType from './superTypes/domrectSearchType.js';
+import dompointSearchType from './superTypes/dompointSearchType.js';
+import dommatrixSearchType from './superTypes/dommatrixSearchType.js';
+import SpecialRealNumberSearchType from './superTypes/SpecialRealNumberSearchType.js';
+import buffersourceSearchType from './superTypes/buffersourceSearchType.js';
+import blobHTMLSearchType from './subTypes/blobHTMLSearchType.js';
+
+/**
+ * @typedef {import('./queryTree.js').QueryNode} QueryNode
+ */
+
+/**
+ * The search-side analogue of `TypeObject` (`src/types.js:308-408`): two
+ * methods, `buildUI` (a `jml` array) and `getQuery` (reads the built DOM
+ * back into a `QueryNode`, or `undefined` when no constraint was entered).
+ * @typedef {{
+ *   buildUI: (cfg: {
+ *     schemaObject: import('../formats/schema.js').ZodexSchema,
+ *     path: string,
+ *     typeNamespace?: string,
+ *     topRoot?: import('../types.js').RootElement,
+ *     types?: import('../types.js').default,
+ *     originalJSON?: import('../formats/schema.js').ZodexSchema
+ *   }) => import('../types.js').JamilihArray,
+ *   getQuery: (cfg: {
+ *     root: HTMLElement,
+ *     path: string
+ *   }) => QueryNode|undefined
+ * }} SearchTypeObject
+ */
+
+/**
+ * Temporary placeholder used while a given search type's real module is
+ * still to-do (build order, `docs/proposals/search-plan.md` §6). Renders a
+ * plainly-labelled marker rather than throwing, so the full dispatch table
+ * is exercisable end-to-end before every leaf/composite is implemented.
+ * @param {string} searchSchemaType
+ * @returns {SearchTypeObject}
+ */
+function stubSearchType (searchSchemaType) {
+  return {
+    buildUI: () => ['span', [`TODO: ${searchSchemaType}`]],
+    getQuery: () => undefined
+  };
+}
+
+/**
+ * Escape hatch for `instanceof`-outside-`FileList` and any schema shape not
+ * (yet) recognized: no widget is rendered for it, only this stand-in.
+ * @type {SearchTypeObject}
+ */
+const noneditableSearchType = stubSearchType('noneditable');
+
+/**
+ * `Record<string, SearchTypeObject>` registry, analogous to
+ * `Types.prototype.availableTypes` (`src/types.js:473-581`). Every entry is
+ * a stub for now (build order step 1); later steps replace individual
+ * entries with their real `*SearchType.js` module, one at a time, without
+ * touching this shape.
+ *
+ * A few keys deliberately share one module reference rather than getting
+ * their own: `BooleanObject`/`NumberObject`/`StringObject`/`bigintObject`
+ * point at their primitive counterpart's module because a search leaf only
+ * cares about the query semantics (e.g. "true or false"), never about how
+ * the value-editing side constructs the boxed wrapper at runtime. Likewise
+ * `arrayNonindexKeys` mirrors `array`, `looseRecord` mirrors `record`, and
+ * `templateLiteral` mirrors `string` (README: a template literal is still
+ * fundamentally a string-shape constraint for this pass; see §3 of the
+ * search plan).
+ * @type {{[key: string]: SearchTypeObject}}
+ */
+const availableSearchTypes = {
+  // fundamentalTypes
+  date: dateSearchType,
+  number: numberSearchType,
+  NumberObject: numberSearchType,
+  bigint: bigintSearchType,
+  bigintObject: bigintSearchType,
+  string: stringSearchType,
+  StringObject: stringSearchType,
+  regexp: regexpSearchType,
+  boolean: booleanSearchType,
+  BooleanObject: booleanSearchType,
+  symbol: symbolSearchType,
+  undef: undefinedSearchType,
+  null: nullSearchType,
+  nan: nanSearchType,
+  array: arraySearchType,
+  arrayNonindexKeys: arraySearchType,
+  object: objectSearchType,
+  map: mapSearchType,
+  set: setSearchType,
+  filelist: filelistSearchType,
+  file: fileSearchType,
+  blob: blobSearchType,
+  error: errorSearchType,
+  domexception: domexceptionSearchType,
+  promise: promiseSearchType,
+  function: functionSearchType,
+  enum: enumSearchType,
+
+  // subTypes
+  tuple: tupleSearchType,
+  record: recordSearchType,
+  looseRecord: recordSearchType,
+  blobHTML: blobHTMLSearchType,
+
+  // superTypes
+  domrect: domrectSearchType,
+  dompoint: dompointSearchType,
+  dommatrix: dommatrixSearchType,
+  errors: errorsSpecialSearchType,
+  SpecialNumber: stubSearchType('SpecialNumber'),
+  SpecialRealNumber: SpecialRealNumberSearchType,
+  buffersource: buffersourceSearchType,
+
+  // unions
+  union: unionSearchType,
+  xor: xorSearchType,
+  discriminatedUnion: discriminatedUnionSearchType,
+
+  // string-shape alias (§3)
+  templateLiteral: stringSearchType,
+
+  // `getSchemaType` has no case for `catch` at all (unlike `promise`/
+  //   `function`, already in `zodexToStructuredCloningTypeMap`), so it's
+  //   added as its own extra case in `getSearchSchemaType` below
+  catch: catchSearchType,
+
+  // escape hatch, also the fallback for any unrecognized/not-yet-supported
+  //   schema shape (see `getSearchTypeObject`)
+  resurrectable: noneditableSearchType
+};
+
+/**
+ * Schema-only analogue of `getSchemaType` (`src/formats/schema.js:145-166`).
+ * Must not reimplement that function's special-casing (stringbool pipe,
+ * `codec`/filelist, `instanceof`, `literal`, `enum`, `templateLiteral`,
+ * `getCheckedType` fallback) - it calls straight through to it, and only
+ * adds the extra shape distinctions `getSchemaType`'s own
+ * `AvailableArbitraryType` output collapses (tuple, record/looseRecord,
+ * union/xor/discriminatedUnion all currently reduce to `'array'`/`'object'`/
+ * nothing, per `zodexToStructuredCloningTypeMap`,
+ * `src/formats/schema.js:30-56`).
+ *
+ * Intersection schemas are deliberately not a case here - they're resolved
+ * before dispatch, by the search-widget walker calling `getTypesForSchema`
+ * (search plan §3), reusing jsoe's existing intersection-merging machinery
+ * rather than this function reinventing it.
+ * @param {import('../formats/schema.js').ZodexSchema} schemaObject
+ * @returns {string}
+ */
+export function getSearchSchemaType (schemaObject) {
+  if (schemaObject.type === 'tuple') {
+    return 'tuple';
+  }
+  if (schemaObject.type === 'record' || schemaObject.type === 'looseRecord') {
+    return schemaObject.type;
+  }
+  if (['union', 'xor', 'discriminatedUnion'].includes(schemaObject.type)) {
+    return schemaObject.type;
+  }
+
+  // An `enum` control can show a multiple-select list and template literal
+  //   parts might justify their own search controls, so need to detect
+  //   these schema types.
+  if (['templateLiteral', 'enum'].includes(schemaObject.type)) {
+    return schemaObject.type;
+  }
+
+  // `getSchemaType` (`src/formats/schema.js`) has no `catch` case at all -
+  //   its `zodexToStructuredCloningTypeMap` never mapped it, unlike
+  //   `promise`/`function` - so it's added here rather than there, matching
+  //   how tuple/record/union already extend the search-only shape space.
+  if (schemaObject.type === 'catch') {
+    return 'catch';
+  }
+
+  return /** @type {string} */ (
+    getSchemaType(schemaObject)
+  ); // inherits stringbool/codec/instanceof/checks handling verbatim
+}
+
+/**
+ * The one exported call site every recursive search widget uses (analogous
+ * to `types.getTypeObject(type)`, `src/types.js:1106-1108`, but schema-in
+ * rather than type-string-in, since there's no value to key off). Falls
+ * back to `noneditableSearchType` for any schema shape `getSearchSchemaType`
+ * reports that isn't (yet) registered, rather than throwing - the same
+ * escape hatch a bare top-level `instanceof` schema falls through to.
+ * @param {import('../formats/schema.js').ZodexSchema} schemaObject
+ * @returns {SearchTypeObject}
+ */
+export function getSearchTypeObject (schemaObject) {
+  const searchSchemaType = getSearchSchemaType(schemaObject);
+  return availableSearchTypes[searchSchemaType] ?? noneditableSearchType;
+}
+
+/**
+ * Intersection schemas are never registered in `availableSearchTypes` -
+ * resolved here instead of in `getSearchSchemaType`, reusing jsoe's
+ * existing intersection-merging machinery (`getTypesForSchema`,
+ * `src/formats/schema.js`) rather than reinventing it (search plan §3/§5).
+ * A single merged result replaces the intersection outright; more than one
+ * (e.g. one side of the intersection is itself a union) is handed to
+ * `unionSearchType.js` unchanged via a synthesized `union` wrapper, the
+ * same way `unionSearchType.js` already treats distinguishable branches.
+ * @param {import('../formats/schema.js').ZodexSchema} schemaObject
+ * @param {import('../formats/schema.js').ZodexSchema} originalJSON
+ * @returns {import('../formats/schema.js').ZodexSchema}
+ */
+function resolveIntersection (schemaObject, originalJSON) {
+  if (schemaObject.type !== 'intersection') {
+    return schemaObject;
+  }
+  const merged = [...getTypesForSchema(schemaObject, originalJSON)];
+  return merged.length === 1
+    ? merged[0]
+    : /** @type {import('../formats/schema.js').ZodexSchema} */ (
+      /** @type {unknown} */ ({type: 'union', options: merged})
+    );
+}
+
+/**
+ * The call site every *recursive* search widget uses in place of calling
+ * `getSearchTypeObject(...).buildUI(...)` directly - it's the same thing,
+ * plus `resolveIntersection` run first, so an intersection schema at any
+ * depth (not just the one `buildSearchChoices` is called with) still
+ * resolves instead of falling through to the `noneditableSearchType`
+ * escape hatch. `originalJSON` (needed for the `getTypesForSchema` call's
+ * own `$ref` resolution) defaults to `schemaObject` itself only as a last
+ * resort for a call site that has none to pass down - every recursive
+ * caller should be threading the true document root through via its own
+ * `originalJSON` parameter instead.
+ * @param {{
+ *   schemaObject: import('../formats/schema.js').ZodexSchema,
+ *   path: string,
+ *   typeNamespace?: string,
+ *   topRoot?: import('../types.js').RootElement,
+ *   types?: import('../types.js').default,
+ *   originalJSON?: import('../formats/schema.js').ZodexSchema
+ * }} cfg
+ * @returns {import('../types.js').JamilihArray}
+ */
+export function buildSearchWidget ({
+  schemaObject, path, typeNamespace, topRoot, types, originalJSON
+}) {
+  const resolvedOriginalJSON = originalJSON ?? schemaObject;
+  const resolvedSchema = resolveIntersection(schemaObject, resolvedOriginalJSON);
+  return getSearchTypeObject(resolvedSchema).buildUI({
+    schemaObject: resolvedSchema,
+    path,
+    typeNamespace,
+    topRoot,
+    types,
+    originalJSON: resolvedOriginalJSON
+  });
+}
+
+export {availableSearchTypes, noneditableSearchType, resolveIntersection};

package/src/search/searchElementUtils.js

@@ -0,0 +1,289 @@
+import {
+  buildPathLabel, buildCheckbox, readCheckbox,
+  buildLiteralRegexControls, readLiteralRegexQuery,
+  buildRangeInputsPair, readRangeInputsPair,
+  buildTriStateSelect, readTriStateSelect
+} from './searchUtils.js';
+import {combineAnd, makeRangeLeaf, makeDomShapeLeaf} from './queryTreeBuilders.js';
+
+/**
+ * Locates a built search element by the JSON-Pointer path it was built for.
+ * Compares `dataset.searchPath` in JS rather than interpolating `path` into
+ * a `querySelector` attribute-value string, since a schema path can embed
+ * arbitrary property-name characters (only `~`/`/` are escaped by
+ * `makeJSONPointer`) that would otherwise need CSS-selector escaping.
+ * @param {ParentNode} root
+ * @param {string} path
+ * @returns {HTMLElement|undefined}
+ */
+export function findSearchElement (root, path) {
+  return /** @type {HTMLElement[]} */ (
+    [...root.querySelectorAll('[data-search-path]')]
+  ).find((el) => el.dataset.searchPath === path);
+}
+
+/**
+ * @typedef {HTMLElement & {
+ *   getQuery: () => import('./queryTree.js').QueryNode|undefined
+ * }} SearchElement
+ */
+
+/**
+ * The `SearchTypeObject.getQuery` every leaf module implements identically:
+ * locate the element it built under `root` and delegate to its own
+ * (per-element, `dataset`-driven) `getQuery()` method.
+ * @param {{root: HTMLElement, path: string}} cfg
+ * @returns {import('./queryTree.js').QueryNode|undefined}
+ */
+export function getQueryViaElement ({root, path}) {
+  const el = /** @type {SearchElement|undefined} */ (
+    findSearchElement(root, path)
+  );
+  return el?.getQuery();
+}
+
+/**
+ * Type-predicate guard distinguishing a built search element (leaf or
+ * container, either answers to `.getQuery()`) from a plain DOM node - used
+ * by container elements (e.g. `objectSearchType.js`'s `<jsoe-search-object>`)
+ * that walk `this.children` polymorphically (search plan §8) without
+ * knowing which children are search elements and which are plain layout
+ * (a controls `<div>`, etc.).
+ * @param {Element} el
+ * @returns {el is SearchElement}
+ */
+export function hasGetQuery (el) {
+  return typeof (/** @type {{getQuery?: unknown}} */ (el)).getQuery ===
+    'function';
+}
+
+/**
+ * Factory for the README's "no variants to allow for distinct search"
+ * leaves (`undefined`/`void`, `null`, `NaN`): the only meaningful question
+ * is whether the path is present at all, which only matters once the path
+ * is optional or nested in a union - so all three share one tiny, single-
+ * checkbox implementation, differing only in tag name/label.
+ * @param {{tagName: string}} cfg
+ * @returns {import('./searchDispatch.js').SearchTypeObject}
+ */
+export function makePresenceOnlySearchType ({tagName}) {
+  return {
+    buildUI ({schemaObject, path, typeNamespace}) {
+      const label = buildPathLabel(schemaObject, path);
+      const name = `${typeNamespace}-${tagName}`;
+      return [tagName, {
+        dataset: {searchPath: path, searchKind: tagName},
+        title: label,
+        $define: {
+          /** @this {HTMLElement} */
+          getQuery () {
+            const checked = readCheckbox(this);
+            return checked
+              ? {kind: 'presence', path: this.dataset.searchPath ?? '', $exists: true}
+              : undefined;
+          }
+        }
+      }, [
+        ['span', {class: 'searchLabel'}, [label]],
+        buildCheckbox({name, label: `Require ${label} present`})
+      ]];
+    },
+    getQuery: getQueryViaElement
+  };
+}
+
+/**
+ * The Error family's fixed known properties (`errorType.js`'s own
+ * `setValue`/`getValue` hard-code this same set - `message`/`name`/
+ * `fileName`/`stack` as strings, `lineNumber`/`columnNumber` as numbers -
+ * since a `checked`-type schema like `error`/`errors` carries no structural
+ * detail of its own to derive property names/types from, unlike `object`).
+ * @type {string[]}
+ */
+const errorStringProps = ['message', 'name', 'fileName', 'stack'];
+
+/** @type {string[]} */
+const errorNumberProps = ['lineNumber', 'columnNumber'];
+
+/**
+ * @param {{label: string, name: string}} cfg
+ * @returns {import('./searchUtils.js').JamilihArray[]}
+ */
+function buildErrorFamilyChildren ({label, name}) {
+  /** @type {import('./searchUtils.js').JamilihArray[]} */
+  const children = [['span', {class: 'searchLabel'}, [label]]];
+  errorStringProps.forEach((prop) => {
+    children.push(['div', {class: `errorProp-${prop}`}, [
+      ['span', [`${prop}: `]],
+      buildLiteralRegexControls({name: `${name}-${prop}`, key: prop})
+    ]]);
+  });
+  errorNumberProps.forEach((prop) => {
+    children.push(['div', {class: `errorProp-${prop}`}, [
+      ['span', [`${prop}: `]],
+      ...buildRangeInputsPair({name: `${name}-${prop}`, key: prop})
+    ]]);
+  });
+  return children;
+}
+
+/**
+ * Factory for `errorSearchType.js`/`errorsSpecialSearchType.js`, offering
+ * literal/regex search of child string properties, numeric of number
+ * children (README) - one `buildLiteralRegexControls`/`buildRangeInputsPair` pair
+ * per known property (`key`-distinguished so they coexist in one widget;
+ * see those helpers' docs), combined via `$and`. `.cause` (a recursive,
+ * arbitrarily-typed property) and `errorsSpecial`'s `AggregateError.errors`
+ * array are deliberately left out of this pass - the README's bullet asks
+ * only for the flat string/number children, and open-ended recursion into
+ * an arbitrary `cause` chain is a materially bigger feature than "the same
+ * shape, twice more".
+ * @param {{tagName: string}} cfg
+ * @returns {import('./searchDispatch.js').SearchTypeObject}
+ */
+export function makeErrorFamilySearchType ({tagName}) {
+  return {
+    buildUI ({schemaObject, path, typeNamespace}) {
+      const label = buildPathLabel(schemaObject, path);
+      const name = `${typeNamespace}-${tagName}`;
+      return [tagName, {
+        dataset: {searchPath: path, searchKind: tagName},
+        title: label,
+        $define: {
+          /** @this {HTMLElement} */
+          getQuery () {
+            const searchPath = this.dataset.searchPath ?? '';
+            const stringLeaves = errorStringProps.map((prop) => (
+              readLiteralRegexQuery(this, `${searchPath}/${prop}`, prop)
+            ));
+            const numberLeaves = errorNumberProps.map((prop) => {
+              const {gte, lte} = readRangeInputsPair(this, prop);
+              if (gte === '' && lte === '') {
+                return undefined;
+              }
+              return makeRangeLeaf(`${searchPath}/${prop}`, 'number', {
+                ...(gte === '' ? {} : {$gte: Number(gte)}),
+                ...(lte === '' ? {} : {$lte: Number(lte)})
+              });
+            });
+            return combineAnd([...stringLeaves, ...numberLeaves]);
+          }
+        }
+      }, buildErrorFamilyChildren({label, name})];
+    },
+    getQuery: getQueryViaElement
+  };
+}
+
+/**
+ * @param {{
+ *   label: string, name: string, dimensionKeys: string[],
+ *   includeReadonly: boolean, includeDimensionCheck: boolean
+ * }} cfg
+ * @returns {import('./searchUtils.js').JamilihArray[]}
+ */
+function buildDomShapeChildren ({
+  label, name, dimensionKeys, includeReadonly, includeDimensionCheck
+}) {
+  /** @type {import('./searchUtils.js').JamilihArray[]} */
+  const children = [['span', {class: 'searchLabel'}, [label]]];
+  dimensionKeys.forEach((dim) => {
+    children.push(['div', {class: `domShapeDimension-${dim}`}, [
+      ['span', [`${dim}: `]],
+      ...buildRangeInputsPair({name: `${name}-${dim}`, key: dim})
+    ]]);
+  });
+  if (includeReadonly) {
+    children.push(['label', [
+      'Readonly: ',
+      buildTriStateSelect({
+        name: `${name}-readonly`, key: 'readonly',
+        trueLabel: 'Readonly', falseLabel: 'Not readonly'
+      })
+    ]]);
+  }
+  if (includeDimensionCheck) {
+    children.push(['label', [
+      '3d: ',
+      buildTriStateSelect({
+        name: `${name}-dimension`, key: 'dimension',
+        trueLabel: '3d', falseLabel: 'Not 3d'
+      })
+    ]]);
+  }
+  return children;
+}
+
+/**
+ * Factory for `domrectSearchType.js`/`dompointSearchType.js`/
+ * `dommatrixSearchType.js`: numeric search ranges for children; "Is/Is not
+ * Readonly"; DOMMatrix: "Is/Is not 3d" (README) - one `buildRangeInputsPair`
+ * per known dimension (`key`-distinguished so they coexist in one widget;
+ * `dimensionKeys` covers DOMMatrix's 2D (`a`-`f`) *and* 3D (`m11`-`m44`)
+ * shapes at once rather than switching the control set on an "Is/Is not 3d"
+ * answer that's itself just another optional search constraint, not a
+ * schema fact - `domrect`/`dompoint`/`dommatrix` are all "checked" types
+ * with no structural schema to derive dimension names from in the first
+ * place, same reasoning as `makeErrorFamilySearchType`), combined into one
+ * `domShape` leaf (`queryTree.js`) rather than separate leaves via `$and`.
+ * @param {{
+ *   tagName: string,
+ *   dimensionKeys: string[],
+ *   includeReadonly?: boolean,
+ *   includeDimensionCheck?: boolean
+ * }} cfg
+ * @returns {import('./searchDispatch.js').SearchTypeObject}
+ */
+export function makeDomShapeSearchType ({
+  tagName, dimensionKeys, includeReadonly = false, includeDimensionCheck = false
+}) {
+  return {
+    buildUI ({schemaObject, path, typeNamespace}) {
+      const label = buildPathLabel(schemaObject, path);
+      const name = `${typeNamespace}-${tagName}`;
+      return [tagName, {
+        dataset: {searchPath: path, searchKind: tagName},
+        title: label,
+        $define: {
+          /** @this {HTMLElement} */
+          getQuery () {
+            const searchPath = this.dataset.searchPath ?? '';
+            /** @type {{[dim: string]: import('./queryTree.js').QueryRangeLeaf}} */
+            const dimensions = {};
+            dimensionKeys.forEach((dim) => {
+              const {gte, lte} = readRangeInputsPair(this, dim);
+              if (gte === '' && lte === '') {
+                return;
+              }
+              dimensions[dim] = makeRangeLeaf(`${searchPath}/${dim}`, 'number', {
+                ...(gte === '' ? {} : {$gte: Number(gte)}),
+                ...(lte === '' ? {} : {$lte: Number(lte)})
+              });
+            });
+            const readonlyCheck = includeReadonly
+              ? readTriStateSelect(this, 'readonly')
+              : undefined;
+            const dimensionCheck = includeDimensionCheck
+              ? readTriStateSelect(this, 'dimension')
+              : undefined;
+            if (
+              readonlyCheck === undefined && dimensionCheck === undefined &&
+              Object.keys(dimensions).length === 0
+            ) {
+              return undefined;
+            }
+            return makeDomShapeLeaf(searchPath, dimensions, {
+              ...(readonlyCheck === undefined ? {} : {readonlyCheck}),
+              ...(dimensionCheck === undefined
+                ? {}
+                : {dimensionCheck: dimensionCheck ? 3 : 2})
+            });
+          }
+        }
+      }, buildDomShapeChildren({
+        label, name, dimensionKeys, includeReadonly, includeDimensionCheck
+      })];
+    },
+    getQuery: getQueryViaElement
+  };
+}