@es-joy/jsoe 0.28.2 → 0.29.0

package/dist/search/index.d.ts

@@ -0,0 +1,60 @@
+/**
+ * @typedef {{
+ *   container: HTMLDivElement,
+ *   $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', ...)` since
+ * `container` is a plain `HTMLDivElement`. 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.
+ * @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 }: {
+    schemaContent: import("../formats/schema.js").ZodexSchema;
+    typeNamespace?: string;
+    topRoot?: import("../types.js").RootElement;
+    types?: import("../types.js").default;
+}): SearchChoicesControl;
+export type SearchChoicesControl = {
+    container: HTMLDivElement;
+    $getQuery: () => import("./queryTree.js").QueryAnd;
+    whenReady: Promise<void>;
+};
+//# sourceMappingURL=index.d.ts.map

package/dist/search/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/search/index.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH,qFARW;IACN,aAAa,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;IAC1D,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,aAAa,EAAE,WAAW,CAAC;IAC5C,KAAK,CAAC,EAAE,OAAO,aAAa,EAAE,OAAO,CAAA;CACtC,GACS,oBAAoB,CA4BhC;mCA1EY;IACR,SAAS,EAAE,cAAc,CAAC;IAC1B,SAAS,EAAE,MAAM,OAAO,gBAAgB,EAAE,QAAQ,CAAC;IACnD,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB"}

package/dist/search/queryTree.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queryTree.d.ts","sourceRoot":"","sources":["../../src/search/queryTree.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"queryTree.d.ts","sourceRoot":"","sources":["../../src/search/queryTree.js"],"names":[],"mappings":"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"}

package/dist/search/queryTreeBuilders.d.ts

@@ -9,6 +9,18 @@
  * @returns {import('./queryTree.js').QueryAnd}
  */
 export function makeAndNode(nodes: import("./queryTree.js").QueryNode[]): import("./queryTree.js").QueryAnd;
+/**
+ * Combines the leaves a single widget contributes (e.g. a number leaf's
+ * range plus its separate "Is/Is Not Integer" check) into one `QueryNode`:
+ * drops any `undefined` (no constraint entered there), returns `undefined`
+ * if nothing is left, the bare node if only one is left, else an `$and` of
+ * the rest - so a widget with several independent controls still honors
+ * `getQuery`'s "`undefined` means no constraint" convention without every
+ * such widget re-implementing this collapsing logic itself.
+ * @param {(import('./queryTree.js').QueryNode|undefined)[]} nodes
+ * @returns {import('./queryTree.js').QueryNode|undefined}
+ */
+export function combineAnd(nodes: (import("./queryTree.js").QueryNode | undefined)[]): import("./queryTree.js").QueryNode | undefined;
 /**
  * @param {import('./queryTree.js').QueryNode[]} nodes
  * @returns {import('./queryTree.js').QueryOr}

package/dist/search/queryTreeBuilders.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"queryTreeBuilders.d.ts","sourceRoot":"","sources":["../../src/search/queryTreeBuilders.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"queryTreeBuilders.d.ts","sourceRoot":"","sources":["../../src/search/queryTreeBuilders.js"],"names":[],"mappings":"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"}

package/dist/search/searchDispatch.d.ts

@@ -28,6 +28,35 @@ export function getSearchSchemaType(schemaObject: import("../formats/schema.js")
  * @returns {SearchTypeObject}
  */
 export function getSearchTypeObject(schemaObject: import("../formats/schema.js").ZodexSchema): SearchTypeObject;
+/**
+ * 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 }: {
+    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;
 export type QueryNode = import("./queryTree.js").QueryNode;
 /**
  * The search-side analogue of `TypeObject` (`src/types.js:308-408`): two
@@ -41,6 +70,7 @@ export type SearchTypeObject = {
         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;
@@ -74,4 +104,18 @@ export const availableSearchTypes: {
  * @type {SearchTypeObject}
  */
 export const noneditableSearchType: SearchTypeObject;
+/**
+ * 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}
+ */
+export function resolveIntersection(schemaObject: import("../formats/schema.js").ZodexSchema, originalJSON: import("../formats/schema.js").ZodexSchema): import("../formats/schema.js").ZodexSchema;
 //# sourceMappingURL=searchDispatch.d.ts.map

package/dist/search/searchDispatch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"searchDispatch.d.ts","sourceRoot":"","sources":["../../src/search/searchDispatch.js"],"names":[],"mappings":"AA2HA;;;;;;;;;;;;;;;;;GAiBG;AACH,kDAHW,OAAO,sBAAsB,EAAE,WAAW,GACxC,MAAM,CAuBlB;AAED;;;;;;;;;GASG;AACH,kDAHW,OAAO,sBAAsB,EAAE,WAAW,GACxC,gBAAgB,CAK5B;wBA9KY,OAAO,gBAAgB,EAAE,SAAS;;;;;;+BAOlC;IACR,OAAO,EAAE,CAAC,GAAG,EAAE;QACb,YAAY,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;QACzD,IAAI,EAAE,MAAM,CAAC;QACb,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,OAAO,CAAC,EAAE,OAAO,aAAa,EAAE,WAAW,CAAC;QAC5C,KAAK,CAAC,EAAE,OAAO,aAAa,EAAE,OAAO,CAAA;KACtC,KAAK,OAAO,aAAa,EAAE,YAAY,CAAC;IACzC,QAAQ,EAAE,CAAC,GAAG,EAAE;QACd,IAAI,EAAE,WAAW,CAAC;QAClB,IAAI,EAAE,MAAM,CAAA;KACb,KAAK,SAAS,GAAC,SAAS,CAAA;CAC1B;AAyBJ;;;;;;;;;;;;;;;;;GAiBG;AACH,mCAFU;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAAC,CA0DzC;AAjFF;;;;GAIG;AACH,oCAFU,gBAAgB,CAEkC"}
+{"version":3,"file":"searchDispatch.d.ts","sourceRoot":"","sources":["../../src/search/searchDispatch.js"],"names":[],"mappings":"AAqKA;;;;;;;;;;;;;;;;;GAiBG;AACH,kDAHW,OAAO,sBAAsB,EAAE,WAAW,GACxC,MAAM,CA+BlB;AAED;;;;;;;;;GASG;AACH,kDAHW,OAAO,sBAAsB,EAAE,WAAW,GACxC,gBAAgB,CAK5B;AA2BD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uGAVW;IACN,YAAY,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;IACzD,IAAI,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,OAAO,aAAa,EAAE,WAAW,CAAC;IAC5C,KAAK,CAAC,EAAE,OAAO,aAAa,EAAE,OAAO,CAAC;IACtC,YAAY,CAAC,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAA;CAC1D,GACS,OAAO,aAAa,EAAE,YAAY,CAe9C;wBAzPY,OAAO,gBAAgB,EAAE,SAAS;;;;;;+BAOlC;IACR,OAAO,EAAE,CAAC,GAAG,EAAE;QACb,YAAY,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAC;QACzD,IAAI,EAAE,MAAM,CAAC;QACb,aAAa,CAAC,EAAE,MAAM,CAAC;QACvB,OAAO,CAAC,EAAE,OAAO,aAAa,EAAE,WAAW,CAAC;QAC5C,KAAK,CAAC,EAAE,OAAO,aAAa,EAAE,OAAO,CAAC;QACtC,YAAY,CAAC,EAAE,OAAO,sBAAsB,EAAE,WAAW,CAAA;KAC1D,KAAK,OAAO,aAAa,EAAE,YAAY,CAAC;IACzC,QAAQ,EAAE,CAAC,GAAG,EAAE;QACd,IAAI,EAAE,WAAW,CAAC;QAClB,IAAI,EAAE,MAAM,CAAA;KACb,KAAK,SAAS,GAAC,SAAS,CAAA;CAC1B;AAyBJ;;;;;;;;;;;;;;;;;GAiBG;AACH,mCAFU;IAAC,CAAC,GAAG,EAAE,MAAM,GAAG,gBAAgB,CAAA;CAAC,CA+DzC;AAtFF;;;;GAIG;AACH,oCAFU,gBAAgB,CAEkC;AAmJ5D;;;;;;;;;;;;GAYG;AACH,kDAJW,OAAO,sBAAsB,EAAE,WAAW,gBAC1C,OAAO,sBAAsB,EAAE,WAAW,GACxC,OAAO,sBAAsB,EAAE,WAAW,CAYtD"}

package/dist/search/searchElementUtils.d.ts

@@ -0,0 +1,97 @@
+/**
+ * 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: ParentNode, path: string): HTMLElement | undefined;
+/**
+ * @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 }: {
+    root: HTMLElement;
+    path: string;
+}): import("./queryTree.js").QueryNode | undefined;
+/**
+ * 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: Element): el is SearchElement;
+/**
+ * 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 }: {
+    tagName: string;
+}): import("./searchDispatch.js").SearchTypeObject;
+/**
+ * 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 }: {
+    tagName: string;
+}): import("./searchDispatch.js").SearchTypeObject;
+/**
+ * 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, includeDimensionCheck }: {
+    tagName: string;
+    dimensionKeys: string[];
+    includeReadonly?: boolean;
+    includeDimensionCheck?: boolean;
+}): import("./searchDispatch.js").SearchTypeObject;
+export type SearchElement = HTMLElement & {
+    getQuery: () => import("./queryTree.js").QueryNode | undefined;
+};
+//# sourceMappingURL=searchElementUtils.d.ts.map

package/dist/search/searchElementUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchElementUtils.d.ts","sourceRoot":"","sources":["../../src/search/searchElementUtils.js"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,wCAJW,UAAU,QACV,MAAM,GACJ,WAAW,GAAC,SAAS,CAMjC;AAED;;;;GAIG;AAEH;;;;;;GAMG;AACH,mDAHW;IAAC,IAAI,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,GAC/B,OAAO,gBAAgB,EAAE,SAAS,GAAC,SAAS,CAOxD;AAED;;;;;;;;;GASG;AACH,gCAHW,OAAO,GACL,EAAE,IAAI,aAAa,CAK/B;AAED;;;;;;;;GAQG;AACH,wDAHW;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACf,OAAO,qBAAqB,EAAE,gBAAgB,CA0B1D;AAqCD;;;;;;;;;;;;;GAaG;AACH,uDAHW;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACf,OAAO,qBAAqB,EAAE,gBAAgB,CAkC1D;AAyCD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,2GARW;IACN,OAAO,EAAE,MAAM,CAAC;IAChB,aAAa,EAAE,MAAM,EAAE,CAAC;IACxB,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,qBAAqB,CAAC,EAAE,OAAO,CAAA;CAChC,GACS,OAAO,qBAAqB,EAAE,gBAAgB,CAsD1D;4BAvQY,WAAW,GAAG;IACtB,QAAQ,EAAE,MAAM,OAAO,gBAAgB,EAAE,SAAS,GAAC,SAAS,CAAA;CAC7D"}

package/dist/search/searchUtils.d.ts

@@ -0,0 +1,225 @@
+/**
+ * @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: import("../formats/schema.js").ZodexSchema | undefined, path: string): string;
+/**
+ * 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: HTMLElement, selector: string): HTMLElement | undefined;
+/**
+ * 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, min, max, step }: {
+    name: string;
+    key?: string;
+    type?: string;
+    min?: string | number;
+    max?: string | number;
+    step?: string | number;
+}): JamilihArray[];
+/**
+ * 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: HTMLElement, key?: string): {
+    gte: string;
+    lte: string;
+};
+/**
+ * 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 }: {
+    name: string;
+    options: (string | [value: string, title: string])[];
+}): JamilihArray;
+/**
+ * Reads back a `buildMultiSelect` into the selected values, `[]` if none.
+ * @param {HTMLElement} el
+ * @returns {string[]}
+ */
+export function readMultiSelect(el: HTMLElement): string[];
+/**
+ * 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 }: {
+    name: string;
+    propertyName: string;
+}): JamilihArray;
+/**
+ * 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 }: {
+    name: string;
+    key?: string;
+    trueLabel: string;
+    falseLabel: string;
+}): JamilihArray;
+/**
+ * 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: HTMLElement, key?: string): boolean | undefined;
+/**
+ * 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 }: {
+    name: string;
+    label: string;
+}): JamilihArray;
+/**
+ * Reads back a `buildCheckbox`.
+ * @param {HTMLElement} el
+ * @returns {boolean}
+ */
+export function readCheckbox(el: HTMLElement): boolean;
+/**
+ * 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 }: {
+    name: string;
+    key?: string;
+}): JamilihArray;
+/**
+ * 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: HTMLElement, path: string, key?: string): import("./queryTree.js").QueryLiteralSetLeaf | import("./queryTree.js").QueryRegexLeaf | import("./queryTree.js").QueryNotContainsLeaf | undefined;
+/**
+ * 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 }: {
+    name: string;
+    min?: number;
+    max?: number;
+    includeSparse?: boolean;
+}): JamilihArray[];
+/**
+ * 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: HTMLElement, path: string): import("./queryTree.js").QueryLengthSizeLeaf | undefined;
+export type JamilihArray = import("../types.js").JamilihArray;
+//# sourceMappingURL=searchUtils.d.ts.map

package/dist/search/searchUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"searchUtils.d.ts","sourceRoot":"","sources":["../../src/search/searchUtils.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;;;;;;;;;GASG;AACH,6CAJW,OAAO,sBAAsB,EAAE,WAAW,GAAC,SAAS,QACpD,MAAM,GACJ,MAAM,CASlB;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,qCAJW,WAAW,YACX,MAAM,GACJ,WAAW,GAAC,SAAS,CAMjC;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0EAVW;IACN,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,CAAC,EAAE,MAAM,GAAC,MAAM,CAAC;IACpB,GAAG,CAAC,EAAE,MAAM,GAAC,MAAM,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,GAAC,MAAM,CAAA;CACrB,GACS,YAAY,EAAE,CAe1B;AAED;;;;;;GAMG;AACH,wCAJW,WAAW,QACX,MAAM,GACJ;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAC,CAUtC;AAED;;;;;;;;;GASG;AACH,oDANW;IACN,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,CAAC,MAAM,GAAC,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,CAAC,EAAE,CAAA;CACnD,GACS,YAAY,CAOxB;AAED;;;;GAIG;AACH,oCAHW,WAAW,GACT,MAAM,EAAE,CAOpB;AAED;;;;;;;;;;;;;GAaG;AACH,+DAHW;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAA;CAAC,GAClC,YAAY,CAWxB;AAED;;;;;;;;;;;;;GAaG;AACH,0EAHW;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAA;CAAC,GACjE,YAAY,CAQxB;AAED;;;;;;GAMG;AACH,uCAJW,WAAW,QACX,MAAM,GACJ,OAAO,GAAC,SAAS,CAU7B;AAED;;;;;;;;GAQG;AACH,+CAHW;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,GAC3B,YAAY,CAOxB;AAED;;;;GAIG;AACH,iCAHW,WAAW,GACT,OAAO,CAMnB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDAHW;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAA;CAAC,GAC1B,YAAY,CAiBxB;AAED;;;;;;;;;;GAUG;AACH,0CAPW,WAAW,QACX,MAAM,QACN,MAAM,GACJ,OAAO,gBAAgB,EAAE,mBAAmB,GACxD,OAAW,gBAAgB,EAAE,cAAc,GAC3C,OAAW,gBAAgB,EAAE,oBAAoB,GAAC,SAAS,CAuB3D;AAED;;;;;;;;;;;;;GAaG;AACH,2EARW;IACN,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,GACS,YAAY,EAAE,CAwB1B;AAED;;;;;;GAMG;AACH,wCAJW,WAAW,QACX,MAAM,GACJ,OAAO,gBAAgB,EAAE,mBAAmB,GAAC,SAAS,CAgBlE;2BA9VY,OAAO,aAAa,EAAE,YAAY"}

package/dist/search/subTypes/blobHTMLSearchType.d.ts

@@ -0,0 +1,16 @@
+export default blobHTMLSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @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}
+ */
+declare const blobHTMLSearchType: SearchTypeObject;
+//# sourceMappingURL=blobHTMLSearchType.d.ts.map

package/dist/search/subTypes/blobHTMLSearchType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blobHTMLSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/subTypes/blobHTMLSearchType.js"],"names":[],"mappings":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;GAQG;AACH,kCAFU,gBAAgB,CA+CxB"}

package/dist/search/subTypes/recordSearchType.d.ts

@@ -0,0 +1,18 @@
+export default recordSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @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}
+ */
+declare const recordSearchType: SearchTypeObject;
+//# sourceMappingURL=recordSearchType.d.ts.map

package/dist/search/subTypes/recordSearchType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"recordSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/subTypes/recordSearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,gCAFU,gBAAgB,CA+DxB"}

package/dist/search/subTypes/tupleSearchType.d.ts

@@ -0,0 +1,21 @@
+export default tupleSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @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}
+ */
+declare const tupleSearchType: SearchTypeObject;
+//# sourceMappingURL=tupleSearchType.d.ts.map

package/dist/search/subTypes/tupleSearchType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tupleSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/subTypes/tupleSearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH,+BAFU,gBAAgB,CAuFxB"}

package/dist/search/superTypes/SpecialRealNumberSearchType.d.ts

@@ -0,0 +1,14 @@
+export default SpecialRealNumberSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @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}
+ */
+declare const SpecialRealNumberSearchType: SearchTypeObject;
+//# sourceMappingURL=SpecialRealNumberSearchType.d.ts.map

package/dist/search/superTypes/SpecialRealNumberSearchType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SpecialRealNumberSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/superTypes/SpecialRealNumberSearchType.js"],"names":[],"mappings":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;GAMG;AACH,2CAFU,gBAAgB,CA0BxB"}

package/dist/search/superTypes/buffersourceSearchType.d.ts

@@ -0,0 +1,17 @@
+export default buffersourceSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+/**
+ * BufferSource: OR Range/Is Not Range (README) - a byte-length range, per
+ * the build order's own note that `buffersource` (like `function`) is
+ * "fuzzy" enough in the README to ship as a minimal, honest stub rather
+ * than over-build past what the spec defines. `buffersource` is one of
+ * jsoe's "checked" types (`{type: 'any', checks: [{name: 'buffersource'}]}`)
+ * with no schema-level byte-length bounds to read `min`/`max` HTML
+ * attributes from, unlike `array`'s `minLength`/`maxLength`.
+ * @type {SearchTypeObject}
+ */
+declare const buffersourceSearchType: SearchTypeObject;
+//# sourceMappingURL=buffersourceSearchType.d.ts.map

package/dist/search/superTypes/buffersourceSearchType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"buffersourceSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/superTypes/buffersourceSearchType.js"],"names":[],"mappings":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;GASG;AACH,sCAFU,gBAAgB,CA4BxB"}

package/dist/search/superTypes/dommatrixSearchType.d.ts

@@ -0,0 +1,11 @@
+export default dommatrixSearchType;
+/**
+ * DOMMatrix: numeric search ranges for children; "Is/Is not Readonly";
+ * "Is/Is not 3d" (README) - see `searchElementUtils.js`'s
+ * `makeDomShapeSearchType` for the shared implementation. `dimensionKeys`
+ * covers both the 2D (`a`-`f`) and 3D (`m11`-`m44`) property sets at once;
+ * see that factory's doc for why.
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+declare const dommatrixSearchType: import("../searchDispatch.js").SearchTypeObject;
+//# sourceMappingURL=dommatrixSearchType.d.ts.map