@es-joy/jsoe 0.28.2 → 0.29.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,15 @@
+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`.
+ * @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":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;GAOG;AACH,+BAFU,gBAAgB,CAgDxB"}

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":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAoB5D;;;;;GAKG;AACH,gCAFU,gBAAgB,CA8BxB"}

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":";+BAIa,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,10 @@
+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.
+ * @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":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAmB5D;;;;;GAKG;AACH,8BAFU,gBAAgB,CAyCxB"}

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

@@ -0,0 +1,16 @@
+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`.
+ * @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":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;GAQG;AACH,sCAFU,gBAAgB,CAoCxB"}

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

@@ -0,0 +1,22 @@
+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.
+ * @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;;;;;;;;;;;;;;GAcG;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,19 @@
+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.
+ * @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":";+BAIa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;;GAWG;AACH,8BAFU,gBAAgB,CAqBxB"}

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

@@ -0,0 +1,32 @@
+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;
+};
+/**
+ * @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
+ * `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.
+ * @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":";+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"}

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

@@ -0,0 +1,18 @@
+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
+ * 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.
+ * @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":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,kCAFU,gBAAgB,CAyDxB"}

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

@@ -0,0 +1,18 @@
+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
+ * 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`.
+ * @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":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;;;;;GAUG;AACH,6BAFU,gBAAgB,CAkExB"}

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":";+BAKa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;GAGG;AACH,gCAFU,gBAAgB,CAuCxB"}

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

@@ -0,0 +1,15 @@
+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
+ * (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.
+ * @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":";+BAUa,OAAO,sBAAsB,EAAE,gBAAgB;AA6D5D;;;;;;;;;;GAUG;AACH,gCAFU,gBAAgB,CAiExB"}

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,14 @@
+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).
+ * @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":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;GAMG;AACH,gCAFU,gBAAgB,CA+BxB"}

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

@@ -0,0 +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`).
+ * @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":";+BAMa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;;GAMG;AACH,6BAFU,gBAAgB,CAgDxB"}

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

@@ -0,0 +1,13 @@
+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).
+ * @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":";+BAIa,OAAO,sBAAsB,EAAE,gBAAgB;AAD5D;;GAEG;AAEH;;;;;GAKG;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":";+BAIa,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

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

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