@es-joy/jsoe 0.28.2 → 0.30.0

package/dist/jtltExtensions.d.ts

@@ -0,0 +1,112 @@
+/**
+ * A minimal structural stand-in for the jtlt template `this` context — just
+ * the two members these extensions use. Defined locally (rather than
+ * imported from jtlt) so this module adds no dependency on jtlt itself;
+ * jtlt's own `ContextExtensions` augmentation is a wider, compatible type.
+ * `get` mirrors `JSONPathTransformerContext#get(select, wrap)`: a JSONPath
+ * query against the current template data (or that data itself when
+ * `select` is falsy).
+ * @typedef {{
+ *   appendOutput: (item: unknown) => unknown,
+ *   get: (select: string|undefined, wrap: boolean) => unknown
+ * }} JtltExtensionContext
+ */
+/**
+ * The argument object a declarative `{$generateJsoeEditUI: {...}}` /
+ * `{$generateJsoeViewUI: {...}}` node supplies, entirely unresolved — see
+ * jtlt's own extension-call mechanism (`jsonTemplate.js`'s `runOperation`,
+ * jtlt 0.21.0+): jtlt does not interpret any of these keys itself, so
+ * resolving `select` (via `this.get`) is this module's own job, not
+ * jtlt's. `db`/`store`, when given, name which store's schema should shape
+ * the built controls — independent of `select`, since the *value* being
+ * edited/viewed and the *store it belongs to* are two separate facts a
+ * template may need to supply together (e.g. when a `behavior` reads rows
+ * from a store other than the one its own route targets).
+ * @typedef {{select: string, db?: string, store?: string}} JsoeUIArgs
+ */
+/**
+ * Builds a `generateJsoeEditUI` / `generateJsoeViewUI` pair, ready to spread
+ * into a jtlt `config.extensions` object — see
+ * `~/idb-manager/ROUTE-OVERRIDES-PLAN.md` §5 ("idb-manager behavior
+ * extensions"). Each function is a jtlt extension called with the
+ * declarative node's own argument object, e.g. `{$generateJsoeEditUI:
+ * {select: '$.record', db: 'myDb', store: 'myStore'}}` → `this.
+ * generateJsoeEditUI({select: '$.record', db: 'myDb', store: 'myStore'})`
+ * (or, from the raw-JS override tier, the same call made directly). It
+ * resolves `select` itself (`this.get(select, false)`), looks up that
+ * store's schema via `getSchemaContent` when `db`/`store` are both given,
+ * builds jsoe's own edit/view control tree for the resolved value, and
+ * inserts it into the current output itself via `this.appendOutput(...)`
+ * — matching jtlt's own `$renderDefault` convention of the extension doing
+ * its own insertion rather than returning a value for the interpreter to
+ * place.
+ *
+ * Takes the caller's own `Types` instance rather than constructing one:
+ * idb-manager (for example) already has a single, app-wide `Types`
+ * instance (`new Types()` in `Router.js`) configured with whatever
+ * constructor options it needs, and every control this builds should share
+ * that configuration, not a second, independently-configured one.
+ * @param {import('./types.js').default} types
+ * @param {{
+ *   typeNamespace?: string,
+ *   getSchemaContent?: (db: string, store: string) => (
+ *     import('./formats/schema.js').ZodexSchema | undefined |
+ *     Promise<import('./formats/schema.js').ZodexSchema | undefined>
+ *   )
+ * }} [options] - `typeNamespace` scopes the jsoe-internal type-choice state
+ *   so this doesn't collide with unrelated controls the same page builds
+ *   elsewhere (see other `getControlsForFormatAndValue` call sites' own
+ *   `typeNamespace` values); defaults to `'jtlt'`. `getSchemaContent`, when
+ *   given, is called with each call's own `db`/`store` (e.g. wrapping
+ *   idb-manager's `Schemas.js` lookup) — resolved fresh per call, so a
+ *   single bundle correctly serves a `behavior` that edits/views records
+ *   from more than one store, each with its own schema. Omitted (or a
+ *   call's `db`/`store` omitted) means no schema — jsoe's controls still
+ *   work, inferring type choices from the value alone.
+ * @returns {{
+ *   generateJsoeEditUI: (
+ *     this: JtltExtensionContext, argObject: JsoeUIArgs
+ *   ) => Promise<void>,
+ *   generateJsoeViewUI: (
+ *     this: JtltExtensionContext, argObject: JsoeUIArgs
+ *   ) => Promise<void>
+ * }}
+ */
+export default function createJtltExtensions(types: import("./types.js").default, { typeNamespace, getSchemaContent }?: {
+    typeNamespace?: string;
+    getSchemaContent?: (db: string, store: string) => (import("./formats/schema.js").ZodexSchema | undefined | Promise<import("./formats/schema.js").ZodexSchema | undefined>);
+}): {
+    generateJsoeEditUI: (this: JtltExtensionContext, argObject: JsoeUIArgs) => Promise<void>;
+    generateJsoeViewUI: (this: JtltExtensionContext, argObject: JsoeUIArgs) => Promise<void>;
+};
+/**
+ * A minimal structural stand-in for the jtlt template `this` context — just
+ * the two members these extensions use. Defined locally (rather than
+ * imported from jtlt) so this module adds no dependency on jtlt itself;
+ * jtlt's own `ContextExtensions` augmentation is a wider, compatible type.
+ * `get` mirrors `JSONPathTransformerContext#get(select, wrap)`: a JSONPath
+ * query against the current template data (or that data itself when
+ * `select` is falsy).
+ */
+export type JtltExtensionContext = {
+    appendOutput: (item: unknown) => unknown;
+    get: (select: string | undefined, wrap: boolean) => unknown;
+};
+/**
+ * The argument object a declarative `{$generateJsoeEditUI: {...}}` /
+ * `{$generateJsoeViewUI: {...}}` node supplies, entirely unresolved — see
+ * jtlt's own extension-call mechanism (`jsonTemplate.js`'s `runOperation`,
+ * jtlt 0.21.0+): jtlt does not interpret any of these keys itself, so
+ * resolving `select` (via `this.get`) is this module's own job, not
+ * jtlt's. `db`/`store`, when given, name which store's schema should shape
+ * the built controls — independent of `select`, since the *value* being
+ * edited/viewed and the *store it belongs to* are two separate facts a
+ * template may need to supply together (e.g. when a `behavior` reads rows
+ * from a store other than the one its own route targets).
+ */
+export type JsoeUIArgs = {
+    select: string;
+    db?: string;
+    store?: string;
+};
+//# sourceMappingURL=jtltExtensions.d.ts.map

package/dist/jtltExtensions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"jtltExtensions.d.ts","sourceRoot":"","sources":["../src/jtltExtensions.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;GAYG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AACH,oDA1BW,OAAO,YAAY,EAAE,OAAO,wCAC5B;IACN,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,CACtD,OAAa,qBAAqB,EAAE,WAAW,GAAG,SAAS,GACrD,OAAO,CAAC,OAAO,qBAAqB,EAAE,WAAW,GAAG,SAAS,CAAC,CAC/D,CAAA;CACF,GAUS;IACR,kBAAkB,EAAE,CAClB,IAAI,EAAE,oBAAoB,EAAE,SAAS,EAAE,UAAU,KAC9C,OAAO,CAAC,IAAI,CAAC,CAAC;IACnB,kBAAkB,EAAE,CAClB,IAAI,EAAE,oBAAoB,EAAE,SAAS,EAAE,UAAU,KAC9C,OAAO,CAAC,IAAI,CAAC,CAAA;CACnB,CA4BH;;;;;;;;;;mCA9FY;IACR,YAAY,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,OAAO,CAAC;IACzC,GAAG,EAAE,CAAC,MAAM,EAAE,MAAM,GAAC,SAAS,EAAE,IAAI,EAAE,OAAO,KAAK,OAAO,CAAA;CAC1D;;;;;;;;;;;;;yBAcS;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CAAC"}

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

@@ -0,0 +1,22 @@
+export default arraySearchType;
+export type SearchTypeObject = import("../searchDispatch.js").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`. 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;
+//# sourceMappingURL=arraySearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,10 @@
+export default bigintSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * OR Ranges/Is Not Range (README) - text inputs rather than
+ * `<input type="number">`, since a native number input silently loses
+ * precision beyond `Number.MAX_SAFE_INTEGER`.
+ * @type {SearchTypeObject}
+ */
+declare const bigintSearchType: SearchTypeObject;
+//# sourceMappingURL=bigintSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,19 @@
+export default blobSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+/**
+ * Blob: OR literal or regex search/Does Not contain search (README, grouped
+ * with string/StringObject/File/regexp-source/symbol-description) - against
+ * the Blob's `.type` (MIME string), a value-level facet the schema itself
+ * carries no constraint for (`blob` is one of jsoe's "checked" types,
+ * `{type: 'any', checks: [{name: 'blob'}]}`, with no further structural
+ * fields to read), the same way `symbolSearchType.js` targets
+ * `.description`. Matching *content* rather than the MIME type belongs to
+ * `blobHTMLSearchType.js` (XPath/CSS-selector/full-text/raw-HTML-regex,
+ * README) for the Blob-as-HTML case specifically, not this generic module.
+ * @type {SearchTypeObject}
+ */
+declare const blobSearchType: SearchTypeObject;
+//# sourceMappingURL=blobSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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/booleanSearchType.d.ts

@@ -0,0 +1,11 @@
+export default booleanSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+/**
+ * True or false (README).
+ * @type {SearchTypeObject}
+ */
+declare const booleanSearchType: SearchTypeObject;
+//# sourceMappingURL=booleanSearchType.d.ts.map

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

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

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

@@ -0,0 +1,18 @@
+export default catchSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+/**
+ * Promise, Literal, catch: pass on children (README) - same shape as
+ * `promiseSearchType.js`'s pass-through (recurse into `.innerType` at the
+ * same path, wrap in a `passThrough` leaf), except `getSchemaType`
+ * (`src/formats/schema.js`) has no case for `catch` at all - unlike
+ * `promise`/`function`, which `zodexToStructuredCloningTypeMap` already
+ * maps - so `getSearchSchemaType` adds `catch` as its own extra case purely
+ * for the search side, the same way it already does for `tuple`/`record`/
+ * the union family.
+ * @type {SearchTypeObject}
+ */
+declare const catchSearchType: SearchTypeObject;
+//# sourceMappingURL=catchSearchType.d.ts.map

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

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

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

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

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,26 @@
+export default enumSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+/**
+ * Enum, Native Enum: multiple select (README). The value-editing side has
+ * no dedicated `enumType.js` (`getSchemaType` resolves `enum` to whatever
+ * its underlying value type is), but search needs the actual allowed
+ * values listed, so this is one of the search-only dedicated modules
+ * (search plan §1).
+ *
+ * The README's further "native enum also can search key vs. value" is not
+ * implemented by this pass - only the plain multi-select-of-values
+ * affordance every enum gets either way. A native enum whose keys differ
+ * 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;
+//# sourceMappingURL=enumSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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/errorSearchType.d.ts

@@ -0,0 +1,9 @@
+export default errorSearchType;
+/**
+ * Error: Literal/Regex search of child string properties, numeric of
+ * number children (README) - see `searchElementUtils.js`'s
+ * `makeErrorFamilySearchType` for the shared implementation.
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+declare const errorSearchType: import("../searchDispatch.js").SearchTypeObject;
+//# sourceMappingURL=errorSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errorSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/errorSearchType.js"],"names":[],"mappings":";AAEA;;;;;GAKG;AACH,+BAFU,OAAO,sBAAsB,EAAE,gBAAgB,CAEyB"}

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

@@ -0,0 +1,28 @@
+export default fileSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * File: OR literal or regex search/Does Not contain search (README, grouped
+ * with string/StringObject/Blob/regexp-source/symbol-description) - against
+ * 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;
+//# sourceMappingURL=fileSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,24 @@
+export default filelistSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+export type FilelistOutputSchema = {
+    type: "array";
+    element: import("../../formats/schema.js").ZodexSchema;
+    minLength?: number;
+    maxLength?: number;
+};
+/**
+ * Has length/size of <number> (README, grouped with array/set/
+ * tuple-with-rest) - no sparse toggle, matching `setSearchType.js`. A
+ * `FileList` schema serializes as `{type: 'codec', name: 'filelist',
+ * output: {type: 'array', element: {type: 'file', ...}}}`
+ * (`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. 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;
+//# sourceMappingURL=filelistSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,18 @@
+export default functionSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * Function; pass on args, return type (README) - recurses into both
+ * `.input` (itself a tuple, so its own per-position controls come for free
+ * via `tupleSearchType.js`) and `.output`, at `*args`/`*output` path
+ * segments (`queryTree.js`), combined via `$and`. The build order's own
+ * 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. 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;
+//# sourceMappingURL=functionSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,22 @@
+export default mapSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * Map, Record: string-type searches of keys, values; ideally would allow
+ * search to insist on match of key and value (README) - structurally the
+ * same as `recordSearchType.js` (`key`/`value` recursion at `*key`/`*value`
+ * segments, a "require same entry" toggle producing one `mapRecordJoint`
+ * 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`. 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;
+//# sourceMappingURL=mapSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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/nanSearchType.d.ts

@@ -0,0 +1,7 @@
+export default nanSearchType;
+/**
+ * `NaN`: "no variants to allow for distinct search" (README).
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+declare const nanSearchType: import("../searchDispatch.js").SearchTypeObject;
+//# sourceMappingURL=nanSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nanSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/nanSearchType.js"],"names":[],"mappings":";AAEA;;;GAGG;AACH,6BAFU,OAAO,sBAAsB,EAAE,gBAAgB,CAItD"}

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

@@ -0,0 +1,7 @@
+export default nullSearchType;
+/**
+ * `null`: "no variants to allow for distinct search" (README).
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+declare const nullSearchType: import("../searchDispatch.js").SearchTypeObject;
+//# sourceMappingURL=nullSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"nullSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/nullSearchType.js"],"names":[],"mappings":";AAEA;;;GAGG;AACH,8BAFU,OAAO,sBAAsB,EAAE,gBAAgB,CAItD"}

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

@@ -0,0 +1,11 @@
+export default numberSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+/**
+ * OR Ranges/Is Not Range, Is/Is Not Integer (README).
+ * @type {SearchTypeObject}
+ */
+declare const numberSearchType: SearchTypeObject;
+//# sourceMappingURL=numberSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,21 @@
+export default objectSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * Has property <property pull-down> (README), additive: only
+ * 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
+ * (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;
+//# sourceMappingURL=objectSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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/promiseSearchType.d.ts

@@ -0,0 +1,20 @@
+export default promiseSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+/**
+ * Promise, Literal, catch: pass on children (README) - a promise wraps
+ * exactly one value at the same conceptual path (no path segment to add,
+ * unlike array's `*`/record's `*key`/`*value`), so this recurses into
+ * `.value`'s own search widget and wraps whatever it produces in a
+ * `passThrough` leaf (`queryTree.js`) purely so the tree keeps visible that
+ * the leaf was reached through a promise, rather than returning the child's
+ * leaf bare. ("Literal" needs no module of its own: `getSearchSchemaType`
+ * already resolves a `literal` schema straight to its value's own type via
+ * `getSchemaType`, e.g. a literal string dispatches to `stringSearchType.js`
+ * unchanged).
+ * @type {SearchTypeObject}
+ */
+declare const promiseSearchType: SearchTypeObject;
+//# sourceMappingURL=promiseSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"promiseSearchType.d.ts","sourceRoot":"","sources":["../../../src/search/fundamentalTypes/promiseSearchType.js"],"names":[],"mappings":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;;;GAYG;AACH,iCAFU,gBAAgB,CAsCxB"}

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

@@ -0,0 +1,20 @@
+export default regexpSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+/**
+ * Regexp (source): OR literal or regex search/Does Not contain search, plus
+ * a multiple-select search of flags (README). `regexpType.js`'s own
+ * `allowedFlags` list is imported as-is for the flags control (search plan
+ * §4 - already a plain exported property, no extraction needed). Flags are
+ * a property of the regexp itself, not of how its source is being matched,
+ * but the Flags control is only shown (and only contributes to the query)
+ * while the source's own Mode is "Matches regex" - searching a source
+ * literal/substring while also constraining flags is a much rarer
+ * combination, and hiding Flags the rest of the time keeps the common case
+ * uncluttered.
+ * @type {SearchTypeObject}
+ */
+declare const regexpSearchType: SearchTypeObject;
+//# sourceMappingURL=regexpSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,15 @@
+export default setSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").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`), 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;
+//# sourceMappingURL=setSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,21 @@
+export default stringSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+/**
+ * OR literal or regex search/Does Not contain search (README; also covers
+ * `StringObject` and `templateLiteral`, aliased to this same module in
+ * `searchDispatch.js` since the query semantics are identical), plus - only
+ * while "Matches regex" is the chosen mode - a Flags multi-select
+ * (`buildLiteralRegexControls`'s `flagOptions`, `regexpType.js`'s own
+ * `allowedFlags` list reused as-is, matching `regexpSearchType.js`'s flags
+ * for the actual regexp's own flags): unlike `regexpSearchType.js`, whose
+ * "source" is already a real regexp with its own flags regardless of
+ * search mode, here the regex is only ever the search's *own* device for
+ * matching the string, so flags only make sense while that regex is
+ * actually in play.
+ * @type {SearchTypeObject}
+ */
+declare const stringSearchType: SearchTypeObject;
+//# sourceMappingURL=stringSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,16 @@
+export default symbolSearchType;
+export type SearchTypeObject = import("../searchDispatch.js").SearchTypeObject;
+/**
+ * @typedef {import('../searchDispatch.js').SearchTypeObject} SearchTypeObject
+ */
+/**
+ * Symbol (description): OR literal or regex search/Does Not contain search
+ * (README) - the same query semantics as `stringSearchType.js`'s, against
+ * the symbol's description rather than a string value, so it gets its own
+ * dedicated module/tag (matching the value-editing side's one-file-per-
+ * fundamental-type convention) while sharing that module's actual control
+ * building/reading via `searchUtils.js`.
+ * @type {SearchTypeObject}
+ */
+declare const symbolSearchType: SearchTypeObject;
+//# sourceMappingURL=symbolSearchType.d.ts.map

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

@@ -0,0 +1 @@
+{"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/fundamentalTypes/undefinedSearchType.d.ts

@@ -0,0 +1,7 @@
+export default undefinedSearchType;
+/**
+ * `undefined`/`void`: "no variants to allow for distinct search" (README).
+ * @type {import('../searchDispatch.js').SearchTypeObject}
+ */
+declare const undefinedSearchType: import("../searchDispatch.js").SearchTypeObject;
+//# sourceMappingURL=undefinedSearchType.d.ts.map