@es-joy/jsoe 0.29.0 → 0.31.0

package/dist/search/fundamentalTypes/arraySearchType.d.ts

@@ -1,14 +1,21 @@
 export default arraySearchType;
 export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
-/**
- * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
- */
 /**
  * Has length/size of <number>; Is/Is not sparse (README), plus - by
  * recursing into the element schema's own search widget (search plan §6
  * build order) - "the array contains at least one element matching Y",
  * expressed via a `*` path segment (`queryTree.js`) so no dedicated wrapper
- * leaf kind is needed: the two constraints simply combine with `$and`.
+ * leaf kind is needed: the two constraints simply combine with `$and`. The
+ * element match is wrapped in `buildOptInFieldset` (default unchecked/
+ * disabled) so a length/size-only search stays valid: unlike the length/
+ * size inputs (plain, un-`required` numbers), the recursed element widget
+ * can itself carry `required` controls (e.g. a `string` element's Value),
+ * which would otherwise force this whole array invalid just for existing,
+ * whether or not the user actually wants an element constraint. Leaving
+ * both length/size and the element match unconfigured at once is still
+ * invalid, though (`buildAtLeastOneSentinel`) - the same "no absent values"
+ * reasoning as everywhere else, just with two facets where either alone
+ * already suffices.
  * @type {SearchTypeObject}
  */
 declare const arraySearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/arraySearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arraySearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/arraySearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;GAOG;AACH,+BAFU,gBAAgB,CAgDxB"}
+{"version":3,"file":"arraySearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/arraySearchType.js"],"names":[],"mappings":";+BAUa,OAAO,sBAAsB,EAAE,gBAAgB;AAa5D;;;;;;;;;;;;;;;;;GAiBG;AACH,+BAFU,gBAAgB,CA2DxB"}

package/dist/search/fundamentalTypes/bigintSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bigintSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/bigintSearchType.js"],"names":[],"mappings":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAoB5D;;;;;GAKG;AACH,gCAFU,gBAAgB,CA8BxB"}
+{"version":3,"file":"bigintSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/bigintSearchType.js"],"names":[],"mappings":";+BAOa,OAAO,sBAAsB,EAAE,gBAAgB;AAoB5D;;;;;GAKG;AACH,gCAFU,gBAAgB,CAkCxB"}

package/dist/search/fundamentalTypes/blobSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"blobSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/blobSearchType.js"],"names":[],"mappings":";+BAIa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;;GAWG;AACH,8BAFU,gBAAgB,CAqBxB"}
+{"version":3,"file":"blobSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/blobSearchType.js"],"names":[],"mappings":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;;GAWG;AACH,8BAFU,gBAAgB,CAqBxB"}

package/dist/search/fundamentalTypes/dateSearchType.d.ts

@@ -1,9 +1,14 @@
 export default dateSearchType;
 export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
 /**
- * OR date range/Is Not Range (README). `dateType.js`'s own
- * `buildDateInputControl` is reused twice (range start/end) so the min/max
- * wiring and ISO-slicing stay in one place.
+ * OR date range/Is Not Range, Is/Is not a valid date (README) -
+ * `dateType.js`'s own `buildDateInputControl` is reused twice (range start/
+ * end) so the min/max wiring and ISO-slicing stay in one place. Choosing
+ * "Invalid date" disables the range fieldset (an "Invalid Date" has no
+ * orderable time value to compare - same as `dateType.js`'s own
+ * `notANum`/`ValidDate`/`InvalidDate` handling treating it as a distinct
+ * state from an ordinary `Date`), producing a `validDateCheck` leaf
+ * (`queryTreeBuilders.js`) instead of/alongside the range leaf.
  * @type {SearchTypeObject}
  */
 declare const dateSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/dateSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dateSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/dateSearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAmB5D;;;;;GAKG;AACH,8BAFU,gBAAgB,CAyCxB"}
+{"version":3,"file":"dateSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/dateSearchType.js"],"names":[],"mappings":";+BAQa,OAAO,sBAAsB,EAAE,gBAAgB;AA0E5D;;;;;;;;;;GAUG;AACH,8BAFU,gBAAgB,CAwExB"}

package/dist/search/fundamentalTypes/domexceptionSearchType.d.ts

@@ -1,15 +1,15 @@
 export default domexceptionSearchType;
 export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
-/**
- * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
- */
 /**
  * DOMException: Literal/Regex search of child string properties; also
  * pull-down of name for DOMException (README) - `.name` gets the
  * multi-select pull-down (its standard predefined values, imported as-is
  * from `domexceptionType.js`'s own `domExceptionNames` export rather than a
- * second copy of the list), `.message` gets the usual literal/regex/
- * does-not-contain control, combined via `$and`.
+ * second copy of the list, and already properly optional on its own - an
+ * empty selection needs no opt-in gate), `.message` gets the usual literal/
+ * regex/does-not-contain control (wrapped in `buildOptInFieldset`, since
+ * that one *does* carry a `required` Value input), combined via `$and`.
+ * `buildAtLeastOneSentinel` requires at least one of the two.
  * @type {SearchTypeObject}
  */
 declare const domexceptionSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/domexceptionSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"domexceptionSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/domexceptionSearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;GAQG;AACH,sCAFU,gBAAgB,CAoCxB"}
+{"version":3,"file":"domexceptionSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/domexceptionSearchType.js"],"names":[],"mappings":";+BAWa,OAAO,sBAAsB,EAAE,gBAAgB;AAa5D;;;;;;;;;;;GAWG;AACH,sCAFU,gBAAgB,CA+CxB"}

package/dist/search/fundamentalTypes/enumSearchType.d.ts

@@ -16,6 +16,10 @@ export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
  * from its values (unlike a plain `z.enum([...])`, where they're the same)
  * still gets a usable widget here, just not that extra key-vs-value mode
  * yet; `values`'s keys are shown alongside their value as a hint.
+ * `buildMultiSelect`'s `required` leaves the whole selection invalid until
+ * at least one value is picked, natively (no build-time-empty gap like
+ * `buildRangeInputsPair`'s custom validity needed a `connectedCallback`
+ * for - `<select multiple required>` is evaluated by the browser itself).
  * @type {SearchTypeObject}
  */
 declare const enumSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/enumSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"enumSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/enumSearchType.js"],"names":[],"mappings":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;;;;;GAcG;AACH,8BAFU,gBAAgB,CAkCxB"}
+{"version":3,"file":"enumSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/enumSearchType.js"],"names":[],"mappings":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;;;;;;;;;GAkBG;AACH,8BAFU,gBAAgB,CAkCxB"}

package/dist/search/fundamentalTypes/fileSearchType.d.ts

@@ -1,18 +1,27 @@
 export default fileSearchType;
 export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
-/**
- * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
- */
 /**
  * File: OR literal or regex search/Does Not contain search (README, grouped
  * with string/StringObject/Blob/regexp-source/symbol-description) - against
- * the File's `.name`, a value-level facet the schema itself carries no
- * constraint for (`SzFile` only has `min`/`max`/`mime`), the same way
- * `symbolSearchType.js` targets `.description` rather than anything the
- * schema declares. `SzFile`'s own `min`/`max` (byte size) is left for a
- * later pass - the README's literal/regex bullet doesn't ask for a size
- * range here, and README explicitly reserves that shape of control
- * ("OR Range/Is Not Range") for `buffersource` instead.
+ * both the File's `.name` and its `.type` (content/MIME type, the same
+ * facet `blobSearchType.js` targets for `Blob`), each a value-level facet
+ * the schema itself carries no constraint for (`SzFile` only has
+ * `min`/`max`/`mime`, and `mime` is a fixed *allow-list* for validation, not
+ * a per-instance value to search against). `name`/`type` sub-paths
+ * distinguish the two facets (`${path}/name`, `${path}/type`, matching the
+ * real `File` property each reads back), the same convention
+ * `errorSearchType.js` uses for its own multiple flat facets, combined via
+ * `$and`. Each facet is independently opt-in (`buildOptInFieldset`, so
+ * checking against just the name, or just the content type, is as easy as
+ * checking against both), but leaving *both* unopted-in is itself invalid
+ * (`buildAtLeastOneSentinel`) - the same "key or value, not necessarily
+ * both" shape `mapSearchType.js`/`recordSearchType.js` use. `SzFile`'s own
+ * `min`/`max` (byte size) is left for a later pass - the README's literal/
+ * regex bullet doesn't ask for a size range here, and README explicitly
+ * reserves that shape of control ("OR Range/Is Not Range") for
+ * `buffersource` instead. `filelistSearchType.js` recurses its element
+ * schema through this same module, so a `FileList`'s per-file search gets
+ * both facets for free.
  * @type {SearchTypeObject}
  */
 declare const fileSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/fileSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fileSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/fileSearchType.js"],"names":[],"mappings":";+BAIa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;;GAWG;AACH,8BAFU,gBAAgB,CAqBxB"}
+{"version":3,"file":"fileSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/fileSearchType.js"],"names":[],"mappings":";+BAUa,OAAO,sBAAsB,EAAE,gBAAgB;AAa5D;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,8BAFU,gBAAgB,CA8CxB"}

package/dist/search/fundamentalTypes/filelistSearchType.d.ts

@@ -6,17 +6,6 @@ export type FilelistOutputSchema = {
     minLength?: number;
     maxLength?: number;
 };
-/**
- * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
- */
-/**
- * @typedef {{
- *   type: 'array',
- *   element: import('../../formats/schema.js').ZodexSchema,
- *   minLength?: number,
- *   maxLength?: number
- * }} FilelistOutputSchema
- */
 /**
  * Has length/size of <number> (README, grouped with array/set/
  * tuple-with-rest) - no sparse toggle, matching `setSearchType.js`. A
@@ -25,7 +14,10 @@ export type FilelistOutputSchema = {
  * (`src/formats/schema.js`'s `codec`/`filelist` handling); the length
  * bounds and element schema both live on that `output` array shape, whose
  * element recurses into `fileSearchType.js` under the same `*` path-segment
- * convention `arraySearchType.js` uses.
+ * convention `arraySearchType.js` uses. Leaving *both* length/size and the
+ * element match unconfigured is still invalid, though
+ * (`buildAtLeastOneSentinel`), same as `arraySearchType.js`/
+ * `setSearchType.js`.
  * @type {SearchTypeObject}
  */
 declare const filelistSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/filelistSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"filelistSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/filelistSearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;mCAI/C;IACR,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,yBAAyB,EAAE,WAAW,CAAC;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAVJ;;GAEG;AAEH;;;;;;;GAOG;AAEH;;;;;;;;;;GAUG;AACH,kCAFU,gBAAgB,CAgDxB"}
+{"version":3,"file":"filelistSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/filelistSearchType.js"],"names":[],"mappings":";+BAUa,OAAO,sBAAsB,EAAE,gBAAgB;mCAI/C;IACR,IAAI,EAAE,OAAO,CAAC;IACd,OAAO,EAAE,OAAO,yBAAyB,EAAE,WAAW,CAAC;IACvD,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAaJ;;;;;;;;;;;;;GAaG;AACH,kCAFU,gBAAgB,CAwDxB"}

package/dist/search/fundamentalTypes/functionSearchType.d.ts

@@ -1,8 +1,5 @@
 export default functionSearchType;
 export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
-/**
- * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
- */
 /**
  * Function; pass on args, return type (README) - recurses into both
  * `.input` (itself a tuple, so its own per-position controls come for free
@@ -11,7 +8,10 @@ export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
  * note that `function` is "fuzzy" in the README and could ship as a
  * minimal stub predates `tupleSearchType.js` existing; now that it does,
  * recursing into `.input` through it is no more work than `.output` alone
- * would have been.
+ * would have been. Each is wrapped in its own `buildOptInFieldset` (an args
+ * tuple's own positions are themselves individually opt-in, so args as a
+ * whole needs the same treatment one level up), with
+ * `buildAtLeastOneSentinel` requiring at least one of the two.
  * @type {SearchTypeObject}
  */
 declare const functionSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/functionSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"functionSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/functionSearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,kCAFU,gBAAgB,CAyDxB"}
+{"version":3,"file":"functionSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/functionSearchType.js"],"names":[],"mappings":";+BASa,OAAO,sBAAsB,EAAE,gBAAgB;AAa5D;;;;;;;;;;;;;GAaG;AACH,kCAFU,gBAAgB,CAiExB"}

package/dist/search/fundamentalTypes/mapSearchType.d.ts

@@ -1,8 +1,5 @@
 export default mapSearchType;
 export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
-/**
- * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
- */
 /**
  * Map, Record: string-type searches of keys, values; ideally would allow
  * search to insist on match of key and value (README) - structurally the
@@ -11,7 +8,14 @@ export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
  * leaf), plus a `lengthSize` control for `min`/`max` (a `Map`, unlike a
  * `Record`, carries its own size bounds in the schema - the same
  * affordance `setSearchType.js` gets for the analogous reason), combined
- * with the joint leaf via `$and`.
+ * with the joint leaf via `$and`. Key and value are each wrapped in their
+ * own `buildOptInFieldset` (so leaving either at "no constraint" doesn't
+ * force it via a `required` control inside), but *leaving all three*
+ * (key, value, and size) unconfigured is itself invalid via
+ * `buildAtLeastOneSentinel` - unlike `recordSearchType.js` (which has no
+ * size control of its own and so needs key or value specifically), a
+ * length/size-only search is already meaningful here, the same as
+ * `arraySearchType.js`/`setSearchType.js`.
  * @type {SearchTypeObject}
  */
 declare const mapSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/mapSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"mapSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/mapSearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,6BAFU,gBAAgB,CAkExB"}
+{"version":3,"file":"mapSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/mapSearchType.js"],"names":[],"mappings":";+BAUa,OAAO,sBAAsB,EAAE,gBAAgB;AAc5D;;;;;;;;;;;;;;;;;GAiBG;AACH,6BAFU,gBAAgB,CA0ExB"}

package/dist/search/fundamentalTypes/numberSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"numberSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/numberSearchType.js"],"names":[],"mappings":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;GAGG;AACH,gCAFU,gBAAgB,CAuCxB"}
+{"version":3,"file":"numberSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/numberSearchType.js"],"names":[],"mappings":";+BAQa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;GAGG;AACH,gCAFU,gBAAgB,CA2CxB"}

package/dist/search/fundamentalTypes/objectSearchType.d.ts

@@ -5,10 +5,16 @@ export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
  * optional properties are offered ("avoid listing required" - a required
  * property is guaranteed present, so asking about its existence is
  * meaningless), and picking one from the pull-down adds a row for it
- * (removed from the pull-down so it can't be added twice); there is no
- * remove affordance, since setting a row's toggle back to "(any)" already
- * expresses "no constraint from this row" for the existence half, same as
- * clearing the nested widget does for the value half.
+ * (disabled in the pull-down, rather than removed, so it can't be added a
+ * second time while its row exists). Each row's own "Remove" button
+ * discards the row and re-enables its property in the pull-down, for
+ * undoing an added-by-mistake property - a coarser-grained option than
+ * setting the row's toggle back to "(any)" (which already expresses "no
+ * constraint from this row" without removing it). A required property gets
+ * no pull-down entry (its existence is never in question), but does still
+ * get its own row - `buildRequiredPropertyRow`'s opt-in checkbox, defaulting
+ * unchecked/disabled, so it doesn't force a search constraint the user never
+ * asked for just by existing.
  * @type {SearchTypeObject}
  */
 declare const objectSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/objectSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"objectSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/objectSearchType.js"],"names":[],"mappings":";+BAUa,OAAO,sBAAsB,EAAE,gBAAgB;AA6D5D;;;;;;;;;;GAUG;AACH,gCAFU,gBAAgB,CAiExB"}
+{"version":3,"file":"objectSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/objectSearchType.js"],"names":[],"mappings":";+BAca,OAAO,sBAAsB,EAAE,gBAAgB;AA8O5D;;;;;;;;;;;;;;;;GAgBG;AACH,gCAFU,gBAAgB,CAiGxB"}

package/dist/search/fundamentalTypes/regexpSearchType.d.ts

@@ -7,7 +7,13 @@ export type SearchTypeObject = import("../searchDispatch.js").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).
+ * §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}
  */
 declare const regexpSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/regexpSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"regexpSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/regexpSearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;GAMG;AACH,gCAFU,gBAAgB,CA+BxB"}
+{"version":3,"file":"regexpSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/regexpSearchType.js"],"names":[],"mappings":";+BASa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH,gCAFU,gBAAgB,CA8CxB"}

package/dist/search/fundamentalTypes/setSearchType.d.ts

@@ -1,13 +1,14 @@
 export default setSearchType;
 export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
-/**
- * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
- */
 /**
  * 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`).
+ * 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}
  */
 declare const setSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/setSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"setSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/setSearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;GAMG;AACH,6BAFU,gBAAgB,CAgDxB"}
+{"version":3,"file":"setSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/setSearchType.js"],"names":[],"mappings":";+BAUa,OAAO,sBAAsB,EAAE,gBAAgB;AAa5D;;;;;;;;;;GAUG;AACH,6BAFU,gBAAgB,CAwDxB"}

package/dist/search/fundamentalTypes/stringSearchType.d.ts

@@ -6,7 +6,15 @@ export type SearchTypeObject = import("../searchDispatch.js").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).
+ * `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}
  */
 declare const stringSearchType: SearchTypeObject;

package/dist/search/fundamentalTypes/stringSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stringSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/stringSearchType.js"],"names":[],"mappings":";+BAIa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;GAKG;AACH,gCAFU,gBAAgB,CAqBxB"}
+{"version":3,"file":"stringSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/stringSearchType.js"],"names":[],"mappings":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;;;;GAaG;AACH,gCAFU,gBAAgB,CAqBxB"}

package/dist/search/fundamentalTypes/symbolSearchType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"symbolSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/symbolSearchType.js"],"names":[],"mappings":";+BAIa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;GAQG;AACH,gCAFU,gBAAgB,CAqBxB"}
+{"version":3,"file":"symbolSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/symbolSearchType.js"],"names":[],"mappings":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;GAQG;AACH,gCAFU,gBAAgB,CAqBxB"}

package/dist/search/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * @typedef {{
- *   container: HTMLDivElement,
+ *   container: HTMLFormElement,
  *   $getQuery: () => import('./queryTree.js').QueryAnd,
  *   whenReady: Promise<void>
  * }} SearchChoicesControl
@@ -32,12 +32,22 @@
  * `$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.
+ * 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,
@@ -53,7 +63,7 @@ export function buildSearchChoices({ schemaContent, typeNamespace, topRoot, type
     types?: import("../types.js").default;
 }): SearchChoicesControl;
 export type SearchChoicesControl = {
-    container: HTMLDivElement;
+    container: HTMLFormElement;
     $getQuery: () => import("./queryTree.js").QueryAnd;
     whenReady: Promise<void>;
 };

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

@@ -1 +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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/search/index.js"],"names":[],"mappings":"AAGA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;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,CAmChC;mCA3FY;IACR,SAAS,EAAE,eAAe,CAAC;IAC3B,SAAS,EAAE,MAAM,OAAO,gBAAgB,EAAE,QAAQ,CAAC;IACnD,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAA;CACzB"}

package/dist/search/queryTree.d.ts

@@ -55,6 +55,17 @@ export type QueryIntegerCheckLeaf = {
     path: string;
     isInteger: boolean;
 };
+/**
+ * `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).
+ */
+export type QueryValidDateCheckLeaf = {
+    kind: "validDateCheck";
+    path: string;
+    isValid: boolean;
+};
 /**
  * `string`/`StringObject`/`Blob`/`File`/regexp-source/symbol-description
  * (via `$in`/`$nin`).
@@ -116,12 +127,15 @@ export type QueryTypeOfLeaf = {
 };
 /**
  * XPath/CSS-selector/full-text/raw-HTML-regex; no Mongo equivalent.
+ * `$options`, mirroring `QueryRegexLeaf`'s field of the same name, is only
+ * ever populated for `mode: 'rawHTMLRegex'`.
  */
 export type QueryBlobHTMLLeaf = {
     kind: "blobHTML";
     path: string;
     mode: "xpath" | "cssSelector" | "fullText" | "rawHTMLRegex";
     value: string;
+    $options?: string;
 };
 /**
  * Per-dimension ranges for DOMRect/Point/Matrix, each dimension itself a
@@ -175,6 +189,6 @@ export type QueryBooleanEqualsLeaf = {
     path: string;
     value: boolean;
 };
-export type QueryLeaf = QueryHasPropertyLeaf | QueryLengthSizeLeaf | QueryRangeLeaf | QueryNotLeaf | QueryIntegerCheckLeaf | QueryLiteralSetLeaf | QueryRegexLeaf | QueryNotContainsLeaf | QueryMultiSelectLeaf | QueryKeyValueEnumLeaf | QueryTypeOfLeaf | QueryBlobHTMLLeaf | QueryDomShapeLeaf | QueryMapRecordJointLeaf | QueryPassThroughLeaf | QueryPresenceLeaf | QueryBooleanEqualsLeaf;
+export type QueryLeaf = QueryHasPropertyLeaf | QueryLengthSizeLeaf | QueryRangeLeaf | QueryNotLeaf | QueryIntegerCheckLeaf | QueryValidDateCheckLeaf | QueryLiteralSetLeaf | QueryRegexLeaf | QueryNotContainsLeaf | QueryMultiSelectLeaf | QueryKeyValueEnumLeaf | QueryTypeOfLeaf | QueryBlobHTMLLeaf | QueryDomShapeLeaf | QueryMapRecordJointLeaf | QueryPassThroughLeaf | QueryPresenceLeaf | QueryBooleanEqualsLeaf;
 export type QueryNode = QueryAnd | QueryOr | QueryLeaf;
 //# sourceMappingURL=queryTree.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"queryTree.d.ts","sourceRoot":"","sources":["../../src/search/queryTree.js"],"names":[],"mappings":"uBA2Ca;IAAC,IAAI,EAAE,SAAS,EAAE,CAAA;CAAC;sBAInB;IAAC,GAAG,EAAE,SAAS,EAAE,CAAA;CAAC;;;;mCAKlB;IAAC,IAAI,EAAE,aAAa,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC;;;;;;kCAOrD;IACR,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACzD,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB;;;;;;;;6BASS;IACR,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,QAAQ,GAAC,cAAc,GAAC,QAAQ,GAAC,MAAM,GAAC,cAAc,CAAC;IAClE,GAAG,CAAC,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,CAAC;IAC5B,GAAG,CAAC,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,CAAC;IAC3B,IAAI,CAAC,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,CAAA;CAC5B;2BAIS;IAAC,IAAI,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,SAAS,CAAA;CAAC;;;;oCAK/B;IAAC,IAAI,EAAE,cAAc,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,OAAO,CAAA;CAAC;;;;;kCAMxD;IACR,IAAI,EAAE,YAAY,CAAC;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;CACjB;;;;;6BAMS;IACR,IAAI,EAAE,OAAO,CAAC;IACd,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;;;;;mCAMS;IACR,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAA;CACd;;;;;mCAMS;IACR,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC;IAChB,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;CACjB;;;;oCAKS;IACR,IAAI,EAAE,cAAc,CAAC;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,SAAS,EAAE,OAAO,CAAC;IACnB,MAAM,EAAE,OAAO,EAAE,CAAA;CAClB;;;;;;8BAOS;IACR,IAAI,EAAE,QAAQ,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE,MAAM,CAAC;IACnB,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B;;;;gCAKS;IACR,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,OAAO,GAAC,aAAa,GAAC,UAAU,GAAC,cAAc,CAAC;IACtD,KAAK,EAAE,MAAM,CAAA;CACd;;;;;;gCAOS;IACR,IAAI,EAAE,UAAU,CAAC;IACjB,IAAI,EAAE,MAAM,CAAC;IACb,UAAU,EAAE;QAAC,CAAC,SAAS,EAAE,MAAM,GAAG,cAAc,CAAA;KAAC,CAAC;IAClD,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,cAAc,CAAC,EAAE,CAAC,GAAC,CAAC,CAAA;CACrB;;;;sCAKS;IACR,IAAI,EAAE,gBAAgB,CAAC;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,CAAC,EAAE,SAAS,CAAC;IACrB,UAAU,CAAC,EAAE,SAAS,CAAC;IACvB,KAAK,EAAE,OAAO,CAAA;CACf;;;;;;mCAOS;IACR,IAAI,EAAE,aAAa,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,CAAC,EAAE,SAAS,CAAA;CAClB;;;;gCAKS;IAAC,IAAI,EAAE,UAAU,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAC;;;;;;qCAOlD;IACR,IAAI,EAAE,eAAe,CAAC;IACtB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,OAAO,CAAA;CACf;wBAIS,oBAAoB,GAAC,mBAAmB,GAAC,cAAc,GAC/D,YAAY,GAAC,qBAAqB,GAAC,mBAAmB,GAAC,cAAc,GACrE,oBAAoB,GAAC,oBAAoB,GAAC,qBAAqB,GAC/D,eAAe,GAAC,iBAAiB,GAAC,iBAAiB,GACnD,uBAAuB,GAAC,oBAAoB,GAAC,iBAAiB,GAC9D,sBAAsB;wBAKd,QAAQ,GAAC,OAAO,GAAC,SAAS"}
+{"version":3,"file":"queryTree.d.ts","sourceRoot":"","sources":["../../src/search/queryTree.js"],"names":[],"mappings":"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"}

package/dist/search/queryTreeBuilders.d.ts

@@ -75,6 +75,12 @@ export function makeNotLeaf(query: import("./queryTree.js").QueryNode): import("
  * @returns {import('./queryTree.js').QueryIntegerCheckLeaf}
  */
 export function makeIntegerCheckLeaf(path: string, isInteger: boolean): import("./queryTree.js").QueryIntegerCheckLeaf;
+/**
+ * @param {string} path
+ * @param {boolean} isValid
+ * @returns {import('./queryTree.js').QueryValidDateCheckLeaf}
+ */
+export function makeValidDateCheckLeaf(path: string, isValid: boolean): import("./queryTree.js").QueryValidDateCheckLeaf;
 /**
  * @param {string} path
  * @param {{$in?: unknown[], $nin?: unknown[]}} cfg
@@ -124,9 +130,10 @@ export function makeTypeOfLeaf(path: string, searchType: string, discriminatorVa
  * @param {string} path
  * @param {import('./queryTree.js').QueryBlobHTMLLeaf['mode']} mode
  * @param {string} value
+ * @param {string} [$options]
  * @returns {import('./queryTree.js').QueryBlobHTMLLeaf}
  */
-export function makeBlobHTMLLeaf(path: string, mode: import("./queryTree.js").QueryBlobHTMLLeaf["mode"], value: string): import("./queryTree.js").QueryBlobHTMLLeaf;
+export function makeBlobHTMLLeaf(path: string, mode: import("./queryTree.js").QueryBlobHTMLLeaf["mode"], value: string, $options?: string): import("./queryTree.js").QueryBlobHTMLLeaf;
 /**
  * @param {string} path
  * @param {{[dimension: string]: import('./queryTree.js').QueryRangeLeaf}} dimensions

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":"AAAA;;;;;GAKG;AAEH;;;GAGG;AACH,mCAHW,OAAO,gBAAgB,EAAE,SAAS,EAAE,GAClC,OAAO,gBAAgB,EAAE,QAAQ,CAI7C;AAED;;;;;;;;;;GAUG;AACH,kCAHW,CAAC,OAAO,gBAAgB,EAAE,SAAS,GAAC,SAAS,CAAC,EAAE,GAC9C,OAAO,gBAAgB,EAAE,SAAS,GAAC,SAAS,CAaxD;AAED;;;GAGG;AACH,kCAHW,OAAO,gBAAgB,EAAE,SAAS,EAAE,GAClC,OAAO,gBAAgB,EAAE,OAAO,CAI5C;AAED;;;;GAIG;AACH,0CAJW,MAAM,WACN,OAAO,GACL,OAAO,gBAAgB,EAAE,oBAAoB,CAIzD;AAED;;;;;;;;GAQG;AACH,yCARW,MAAM,QACN;IACN,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IAAC,GAAG,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACzD,WAAW,CAAC,EAAE,OAAO,CAAA;CACtB,GACS,OAAO,gBAAgB,EAAE,mBAAmB,CAIxD;AAED;;;;;;;;GAQG;AACH,oCARW,MAAM,aACN,OAAO,gBAAgB,EAAE,cAAc,CAAC,WAAW,CAAC,QACpD;IACN,GAAG,CAAC,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,CAAC;IACxD,GAAG,CAAC,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,GAAC,MAAM,GAAC,MAAM,CAAA;CACxD,GACS,OAAO,gBAAgB,EAAE,cAAc,CAInD;AAED;;;GAGG;AACH,mCAHW,OAAO,gBAAgB,EAAE,SAAS,GAChC,OAAO,gBAAgB,EAAE,YAAY,CAIjD;AAED;;;;GAIG;AACH,2CAJW,MAAM,aACN,OAAO,GACL,OAAO,gBAAgB,EAAE,qBAAqB,CAI1D;AAED;;;;GAIG;AACH,6CAJW,MAAM,WACN,OAAO,GACL,OAAO,gBAAgB,EAAE,uBAAuB,CAI5D;AAED;;;;GAIG;AACH,yCAJW,MAAM,QACN;IAAC,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;CAAC,GACjC,OAAO,gBAAgB,EAAE,mBAAmB,CAIxD;AAED;;;;;GAKG;AACH,oCALW,MAAM,UACN,MAAM,aACN,MAAM,GACJ,OAAO,gBAAgB,EAAE,cAAc,CAInD;AAED;;;;GAIG;AACH,0CAJW,MAAM,SACN,MAAM,GACJ,OAAO,gBAAgB,EAAE,oBAAoB,CAIzD;AAED;;;;GAIG;AACH,0CAJW,MAAM,QACN;IAAC,GAAG,CAAC,EAAE,OAAO,EAAE,CAAC;IAAC,IAAI,CAAC,EAAE,OAAO,EAAE,CAAA;CAAC,GACjC,OAAO,gBAAgB,EAAE,oBAAoB,CAIzD;AAED;;;;;GAKG;AACH,2CALW,MAAM,aACN,OAAO,UACP,OAAO,EAAE,GACP,OAAO,gBAAgB,EAAE,qBAAqB,CAI1D;AAED;;;;;GAKG;AACH,qCALW,MAAM,cACN,MAAM,uBACN,OAAO,GACL,OAAO,gBAAgB,EAAE,eAAe,CASpD;AAED;;;;;;GAMG;AACH,uCANW,MAAM,QACN,OAAO,gBAAgB,EAAE,iBAAiB,CAAC,MAAM,CAAC,SAClD,MAAM,aACN,MAAM,GACJ,OAAO,gBAAgB,EAAE,iBAAiB,CAItD;AAED;;;;;GAKG;AACH,uCALW,MAAM,cACN;IAAC,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,gBAAgB,EAAE,cAAc,CAAA;CAAC,QAC9D;IAAC,aAAa,CAAC,EAAE,OAAO,CAAC;IAAC,cAAc,CAAC,EAAE,CAAC,GAAC,CAAC,CAAA;CAAC,GAC7C,OAAO,gBAAgB,EAAE,iBAAiB,CAItD;AAED;;;;;;GAMG;AACH,6CANW,MAAM,SACN,OAAO,aACP,OAAO,gBAAgB,EAAE,SAAS,eAClC,OAAO,gBAAgB,EAAE,SAAS,GAChC,OAAO,gBAAgB,EAAE,uBAAuB,CAU5D;AAED;;;;GAIG;AACH,0CAJW,MAAM,UACN,OAAO,gBAAgB,EAAE,SAAS,GAChC,OAAO,gBAAgB,EAAE,oBAAoB,CAIzD;AAED;;;;GAIG;AACH,uCAJW,MAAM,WACN,OAAO,GACL,OAAO,gBAAgB,EAAE,iBAAiB,CAItD;AAED;;;;GAIG;AACH,4CAJW,MAAM,SACN,OAAO,GACL,OAAO,gBAAgB,EAAE,sBAAsB,CAI3D"}

package/dist/search/searchElementUtils.d.ts

@@ -41,7 +41,12 @@ export function hasGetQuery(el: Element): el is SearchElement;
  * 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.
+ * checkbox implementation, differing only in tag name/label. Unlike every
+ * other leaf, this one is never left for the user to configure at all: its
+ * checkbox is pre-checked and `disabled` (`buildCheckbox`'s doc), since a
+ * type with only one possible value has nothing else worth offering a
+ * choice between - it's simply valid, unconditionally, the moment it
+ * exists, rather than needing a `required`-style rule of its own.
  * @param {{tagName: string}} cfg
  * @returns {import('./searchDispatch.js').SearchTypeObject}
  */
@@ -51,13 +56,17 @@ export function makePresenceOnlySearchType({ tagName }: {
 /**
  * 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
+ * children (README) - one `buildLiteralRegexControls`/`buildRangeInputsPair`
+ * pair per known property (`key`-distinguished so they coexist in one
+ * widget; see those helpers' docs), each wrapped in its own
+ * `buildOptInFieldset` (so picking, say, just `message` doesn't also force
+ * `name`/`fileName`/`stack`/`lineNumber`/`columnNumber` to be filled in),
+ * combined via `$and`, with `buildAtLeastOneSentinel` requiring at least one
+ * of the six to actually be opted into. `.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}

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

@@ -1 +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"}
+{"version":3,"file":"searchElementUtils.d.ts","sourceRoot":"","sources":["../../src/search/searchElementUtils.js"],"names":[],"mappings":"AAWA;;;;;;;;;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;;;;;;;;;;;;;GAaG;AACH,wDAHW;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACf,OAAO,qBAAqB,EAAE,gBAAgB,CA4B1D;AAsDD;;;;;;;;;;;;;;;;;GAiBG;AACH,uDAHW;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GACf,OAAO,qBAAqB,EAAE,gBAAgB,CA+C1D;AAyDD;;;;;;;;;;;;;;;;;;;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,CA8E1D;4BAxVY,WAAW,GAAG;IACtB,QAAQ,EAAE,MAAM,OAAO,gBAAgB,EAAE,SAAS,GAAC,SAAS,CAAA;CAC7D"}