shelving 1.86.7 → 1.87.0

package/constraint/FilterConstraint.d.ts

@@ -1,19 +1,19 @@
-import type { Data, DataKey } from "../util/data.js";
+import { Data, DataKey, FlatDataKey } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import { ImmutableArray } from "../util/array.js";
-import { Matchable } from "../util/match.js";
+import type { Matchable } from "../util/match.js";
 import type { Constraint } from "./Constraint.js";
 /** Possible operator references. */
 export type FilterOperator = "IS" | "NOT" | "IN" | "OUT" | "CONTAINS" | "LT" | "LTE" | "GT" | "GTE";
 /** Format that allows filters to be specified as a string, e.g. `!name` means `name is not` and `age>` means `age is more than` and `tags[]` means `tags array contains` */
-export type FilterKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}` | `${DataKey<T>}[]` | `${DataKey<T>}<` | `${DataKey<T>}<=` | `${DataKey<T>}>` | `${DataKey<T>}>=`;
+export type FilterKey<T extends Data> = DataKey<FilterProps<T>>;
 /** Format that allows multiple filters to be specified as a plain object. */
 export type FilterProps<T extends Data> = {
-    [K in DataKey<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
+    [K in FlatDataKey<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
 } & {
-    [K in DataKey<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
+    [K in FlatDataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
 } & {
-    [K in DataKey<T> as `${K}<` | `${K}<=` | `${K}>` | `${K}>=`]?: T[K];
+    [K in FlatDataKey<T> as `${K}[]`]?: Required<T>[K] extends ImmutableArray<infer X> ? X : never;
 };
 /** List of filters in a flexible format. */
 export type FilterList<T extends Data> = FilterProps<T> | FilterConstraint<T> | Iterable<Nullish<FilterProps<T> | FilterConstraint<T>>>;
@@ -25,9 +25,10 @@ export type FilterList<T extends Data> = FilterProps<T> | FilterConstraint<T> |
  * @param value Value the specified property should be matched against.
  */
 export declare class FilterConstraint<T extends Data = Data> implements Constraint<T>, Matchable<[T]> {
-    readonly key: string;
+    readonly keys: readonly [string, ...string[]];
     readonly operator: FilterOperator;
     readonly value: unknown;
+    get key(): string;
     get filterKey(): string;
     constructor(filterKey: FilterKey<T>, value: unknown);
     match(item: T): boolean;

package/constraint/FilterConstraint.js

@@ -1,6 +1,9 @@
+import { getDataProps } from "../util/data.js";
 import { isArray } from "../util/array.js";
-import { isArrayWith, isEqual, isEqualGreater, isEqualLess, isGreater, isInArray, isLess, notEqual, notInArray } from "../util/match.js";
+import { isArrayWith, isEqualGreater, isEqualLess, isGreater, isInArray, isLess, notInArray, isEqual, notEqual } from "../util/equal.js";
 import { filterItems, isIterable } from "../util/iterate.js";
+import { getProp } from "../util/object.js";
+import { splitString } from "../util/string.js";
 /** Map `FilterOperator` to its corresponding `Match` function. */
 const MATCHERS = {
     IS: isEqual,
@@ -21,56 +24,60 @@ const MATCHERS = {
  * @param value Value the specified property should be matched against.
  */
 export class FilterConstraint {
+    get key() {
+        return this.keys.join(".");
+    }
     get filterKey() {
         const { operator, key } = this;
-        if (operator === "NOT" || operator === "OUT")
-            return `!${key}`;
-        else if (operator === "CONTAINS")
-            return `${key}[]`;
-        else if (operator === "LT")
-            return `${key}<`;
-        else if (operator === "LTE")
-            return `${key}<=`;
-        else if (operator === "GT")
-            return `${key}>`;
-        else if (operator === "GTE")
-            return `${key}>=`;
-        else
-            return key;
+        return operator === "IS" || operator === "IN"
+            ? key
+            : operator === "NOT" || operator === "OUT"
+                ? `!${key}`
+                : operator === "CONTAINS"
+                    ? `${key}[]`
+                    : operator === "LT"
+                        ? `${key}<`
+                        : operator === "LTE"
+                            ? `${key}<=`
+                            : operator === "GT"
+                                ? `${key}>`
+                                : operator === "GTE"
+                                    ? `${key}>=`
+                                    : operator; // Never.
     }
     constructor(filterKey, value) {
         if (filterKey.startsWith("!")) {
-            this.key = filterKey.slice(1);
+            this.keys = splitString(filterKey.slice(1), ".");
             this.operator = isArray(value) ? "OUT" : "NOT";
         }
+        else if (filterKey.endsWith("[]")) {
+            this.keys = splitString(filterKey.slice(0, -2), ".");
+            this.operator = "CONTAINS";
+        }
         else if (filterKey.endsWith(">")) {
-            this.key = filterKey.slice(0, -1);
+            this.keys = splitString(filterKey.slice(0, -1), ".");
             this.operator = "GT";
         }
         else if (filterKey.endsWith(">=")) {
-            this.key = filterKey.slice(0, -2);
+            this.keys = splitString(filterKey.slice(0, -2), ".");
             this.operator = "GTE";
         }
         else if (filterKey.endsWith("<")) {
-            this.key = filterKey.slice(0, -1);
+            this.keys = splitString(filterKey.slice(0, -1), ".");
             this.operator = "LT";
         }
         else if (filterKey.endsWith("<=")) {
-            this.key = filterKey.slice(0, -2);
+            this.keys = splitString(filterKey.slice(0, -2), ".");
             this.operator = "LTE";
         }
-        else if (filterKey.endsWith("[]")) {
-            this.key = filterKey.slice(0, -2);
-            this.operator = "CONTAINS";
-        }
         else {
-            this.key = filterKey;
+            this.keys = splitString(filterKey, ".");
             this.operator = isArray(value) ? "IN" : "IS";
         }
         this.value = value;
     }
     match(item) {
-        return MATCHERS[this.operator](item[this.key], this.value);
+        return MATCHERS[this.operator](getProp(item, ...this.keys), this.value);
     }
     transform(items) {
         return filterItems(items, this);
@@ -90,7 +97,7 @@ export function* getFilters(list) {
                 yield* getFilters(filter);
     }
     else {
-        for (const [key, value] of Object.entries(list))
+        for (const [key, value] of getDataProps(list))
             yield new FilterConstraint(key, value);
     }
 }

package/constraint/QueryConstraints.js

@@ -94,17 +94,17 @@ function* _getAfterFilters(sorts, item) {
     const lastSort = sorts.last;
     assert(lastSort);
     for (const sort of sorts) {
-        const { key, direction } = sort;
-        const filterKey = direction === "ASC" ? (sort === lastSort ? `${key}>` : `${key}>=`) : sort === lastSort ? `${key}<` : `${key}<=`;
-        yield new FilterConstraint(filterKey, getProp(item, key));
+        const { key, keys, direction } = sort;
+        const filterKey = (direction === "ASC" ? (sort === lastSort ? `${key}>` : `${key}>=`) : sort === lastSort ? `${key}<` : `${key}<=`);
+        yield new FilterConstraint(filterKey, getProp(item, ...keys));
     }
 }
 function* _getBeforeFilters(sorts, item) {
     const lastSort = sorts.last;
     assert(lastSort);
     for (const sort of sorts) {
-        const { key, direction } = sort;
-        const filterKey = direction === "ASC" ? (sort === lastSort ? `${key}<` : `${key}<=`) : sort === lastSort ? `${key}>` : `${key}>=`;
-        yield new FilterConstraint(filterKey, getProp(item, key));
+        const { key, keys, direction } = sort;
+        const filterKey = (direction === "ASC" ? (sort === lastSort ? `${key}<` : `${key}<=`) : sort === lastSort ? `${key}>` : `${key}>=`);
+        yield new FilterConstraint(filterKey, getProp(item, ...keys));
     }
 }

package/constraint/SortConstraint.d.ts

@@ -1,10 +1,10 @@
 import type { ImmutableArray } from "../util/array.js";
-import type { Data, DataKey } from "../util/data.js";
+import type { Data, FlatDataKey } from "../util/data.js";
 import type { Nullish } from "../util/null.js";
 import { Rankable } from "../util/sort.js";
 import type { Constraint } from "./Constraint.js";
 /** Format that allows sorts to be set as a plain string, e.g. `name` sorts by name in ascending order and `!date` sorts by date in descending order. */
-export type SortKey<T extends Data> = DataKey<T> | `${DataKey<T>}` | `!${DataKey<T>}`;
+export type SortKey<T extends Data> = FlatDataKey<T> | `${FlatDataKey<T>}` | `!${FlatDataKey<T>}`;
 /** One or more sort keys. */
 export type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
 /** Possible operator references. */
@@ -13,8 +13,9 @@ export type SortDirection = "ASC" | "DESC";
 export type SortList<T extends Data> = SortKey<T> | SortConstraint<T> | Iterable<Nullish<SortKey<T> | SortConstraint<T>>>;
 /** Sort a list of values. */
 export declare class SortConstraint<T extends Data = Data> implements Constraint<T>, Rankable<T> {
-    readonly key: string;
+    readonly keys: readonly [string, ...string[]];
     readonly direction: SortDirection;
+    get key(): string;
     get sortKey(): string;
     constructor(sortKey: SortKey<T>);
     rank(left: T, right: T): number;

package/constraint/SortConstraint.js

@@ -1,21 +1,26 @@
+import { getProp } from "../util/object.js";
 import { rank, rankAsc, rankDesc, sortItems } from "../util/sort.js";
+import { splitString } from "../util/string.js";
 /** Sort a list of values. */
 export class SortConstraint {
+    get key() {
+        return this.keys.join(".");
+    }
     get sortKey() {
         return `"${this.direction === "DESC" ? "!" : ""}${this.key}"`;
     }
     constructor(sortKey) {
         if (sortKey.startsWith("!")) {
-            this.key = sortKey.slice(1);
+            this.keys = splitString(sortKey.slice(1), ".");
             this.direction = "DESC";
         }
         else {
-            this.key = sortKey;
+            this.keys = splitString(sortKey, ".");
             this.direction = "ASC";
         }
     }
     rank(left, right) {
-        return rank(left[this.key], this.direction === "ASC" ? rankAsc : rankDesc, right[this.key]);
+        return rank(getProp(left, ...this.keys), this.direction === "ASC" ? rankAsc : rankDesc, getProp(right, ...this.keys));
     }
     transform(items) {
         return sortItems(items, this);

package/db/Change.d.ts

@@ -1,10 +1,9 @@
-import type { Data, Datas, DataKey } from "../util/data.js";
+import type { Datas, DataKey } from "../util/data.js";
 import type { ImmutableArray } from "../util/array.js";
 import type { Provider, AsyncProvider } from "../provider/Provider.js";
 import { Updates } from "../update/DataUpdate.js";
 import { Nullish } from "../util/null.js";
 import { DeepIterable } from "../util/iterate.js";
-import type { ItemConstraints, ItemData } from "./Item.js";
 /** Change on a collection. */
 export interface Change<T extends Datas, K extends DataKey<T> = DataKey<T>> {
     readonly action: string;
@@ -44,4 +43,3 @@ export type WriteChanges<T extends Datas, K extends DataKey<T> = DataKey<T>> = I
 export declare function changeProvider<T extends Datas, K extends DataKey<T>>(provider: Provider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): ItemChanges<T, K>;
 /** Apply a set of changes to an asynchronous provider. */
 export declare function changeAsyncProvider<T extends Datas, K extends DataKey<T>>(provider: AsyncProvider<T>, ...changes: DeepIterable<Nullish<WriteChange<T, K>>>[]): Promise<ItemChanges<T, K>>;
-export declare function _getItemConstraint<T extends Data>(id: string): ItemConstraints<ItemData<T>>;

package/db/Change.js

@@ -1,7 +1,7 @@
 import { QueryConstraints } from "../constraint/QueryConstraints.js";
-import { FilterConstraint } from "../constraint/FilterConstraint.js";
 import { notNullish } from "../util/null.js";
 import { flattenItems } from "../util/iterate.js";
+import { getItemFilterConstraints } from "./Item.js";
 /** Apply a set of changes to a synchronous provider. */
 export function changeProvider(provider, ...changes) {
     return Array.from(flattenItems(changes)).filter(notNullish).map(_changeItem, provider);
@@ -13,7 +13,7 @@ function _changeItem(change) {
     else if (action === "SET")
         this.setItem(collection, change.id, change.data);
     else if (action === "UPDATE")
-        this.updateQuery(collection, _getItemConstraint(change.id), change.updates);
+        this.updateQuery(collection, new QueryConstraints(getItemFilterConstraints(change.id), undefined, 1), change.updates);
     else if (action === "DELETE")
         this.deleteItem(collection, change.id);
     return change;
@@ -29,11 +29,8 @@ async function _changeAsyncItem(change) {
     else if (action === "SET")
         await this.setItem(collection, change.id, change.data);
     else if (action === "UPDATE")
-        await this.updateQuery(collection, _getItemConstraint(change.id), change.updates);
+        await this.updateQuery(collection, new QueryConstraints(getItemFilterConstraints(change.id), undefined, 1), change.updates);
     else if (action === "DELETE")
         await this.deleteItem(collection, change.id);
     return change;
 }
-export function _getItemConstraint(id) {
-    return new QueryConstraints(new FilterConstraint("id", id), undefined, 1);
-}

package/db/Item.d.ts

@@ -3,6 +3,7 @@ import type { Stop, Handler, Dispatch } from "../util/function.js";
 import type { QueryConstraints } from "../constraint/QueryConstraints.js";
 import { Data, Datas, DataKey } from "../util/data.js";
 import { DataUpdate, Updates } from "../update/DataUpdate.js";
+import { FilterConstraints } from "../constraint/FilterConstraints.js";
 import type { DeleteChange, SetChange, UpdateChange } from "./Change.js";
 import type { AsyncQuery, Query } from "./Query.js";
 import type { AsyncDatabase, Database } from "./Database.js";
@@ -90,4 +91,6 @@ export declare class AsyncItem<T extends Datas = Datas, K extends DataKey<T> = D
 export declare const getID: <T extends Data>({ id }: ItemData<T>) => string;
 /** Get the IDs of an iterable set item data. */
 export declare function getIDs<T extends Data>(entities: Iterable<ItemData<T>>): Iterable<string>;
+/** Get a `FilterConstraints` instance that targets a single item by its ID. */
+export declare function getItemFilterConstraints<T extends Data>(id: string): FilterConstraints<ItemData<T>>;
 export {};

package/db/Item.js

@@ -1,6 +1,7 @@
 import { getData } from "../util/data.js";
-import { FilterConstraint } from "../constraint/FilterConstraint.js";
 import { runSequence } from "../util/sequence.js";
+import { FilterConstraint } from "../constraint/FilterConstraint.js";
+import { FilterConstraints } from "../constraint/FilterConstraints.js";
 /** Reference to an item in a synchronous or asynchronous database. */
 class BaseItem {
     /** Get a set change for this item. */
@@ -37,7 +38,7 @@ export class Item extends BaseItem {
         this.id = id;
     }
     get optional() {
-        return this.db.query(this.collection, new FilterConstraint("id", this.id), undefined, 1);
+        return this.db.query(this.collection, getItemFilterConstraints(this.id), undefined, 1);
     }
     get exists() {
         return !!this.db.get(this.collection, this.id);
@@ -67,7 +68,7 @@ export class AsyncItem extends BaseItem {
         this.id = id;
     }
     get optional() {
-        return this.db.query(this.collection, new FilterConstraint("id", this.id), undefined, 1);
+        return this.db.query(this.collection, { id: this.id }, undefined, 1);
     }
     get exists() {
         return this.db.get(this.collection, this.id).then(Boolean);
@@ -95,3 +96,7 @@ export function* getIDs(entities) {
     for (const { id } of entities)
         yield id;
 }
+/** Get a `FilterConstraints` instance that targets a single item by its ID. */
+export function getItemFilterConstraints(id) {
+    return new FilterConstraints(new FilterConstraint("id", id));
+}

package/feedback/Feedback.d.ts

@@ -19,7 +19,7 @@ export declare class Feedback<T = unknown> {
     constructor(feedback: string, value?: T);
 }
 /** Is an unknown value a `Feedback` object. */
-export declare const isFeedback: <T extends Feedback<unknown>>(v: unknown) => v is Feedback<unknown>;
+export declare const isFeedback: <T extends Feedback<unknown>>(value: unknown) => value is Feedback<unknown>;
 /**
  * Yield the sub-messages in `[key: string, message: string]` format from a feedback's value.
  * - Takes the `.value` property from a `Feedback` instance and looks for keyed `Feedback` instances in either `{ key: Feedback }`. `Feedback[]`, or `Map<key, Feedback>` formats.

package/feedback/Feedback.js

@@ -29,7 +29,7 @@ __decorate([
     setPrototype("name", "Feedback")
 ], Feedback.prototype, "name", void 0);
 /** Is an unknown value a `Feedback` object. */
-export const isFeedback = (v) => isObject(v) && typeof v.name === "string" && v.name.endsWith("Feedback") && typeof v.message === "string";
+export const isFeedback = (value) => isObject(value) && typeof value.name === "string" && value.name.endsWith("Feedback") && typeof value.message === "string";
 /**
  * Yield the sub-messages in `[key: string, message: string]` format from a feedback's value.
  * - Takes the `.value` property from a `Feedback` instance and looks for keyed `Feedback` instances in either `{ key: Feedback }`. `Feedback[]`, or `Map<key, Feedback>` formats.

package/firestore/client/FirestoreClientProvider.d.ts

@@ -1,4 +1,4 @@
-import type { Firestore } from "firebase/firestore";
+import { Firestore } from "firebase/firestore";
 import type { Data } from "../../util/data.js";
 import type { AsyncProvider } from "../../provider/Provider.js";
 import type { ItemArray, ItemValue, ItemConstraints } from "../../db/Item.js";

package/firestore/client/FirestoreClientProvider.js

@@ -9,11 +9,11 @@ const OPERATORS = {
     NOT: "!=",
     IN: "in",
     OUT: "not-in",
+    CONTAINS: "array-contains",
     GT: ">",
     GTE: ">=",
     LT: "<",
     LTE: "<=",
-    CONTAINS: "array-contains",
 };
 // Map `Filter.types` to `OrderByDirection`
 const DIRECTIONS = {
@@ -28,7 +28,7 @@ function* _yieldQueryConstraints({ sorts, filters, limit }) {
     for (const { key, direction } of sorts)
         yield firestoreOrderBy(key === "id" ? ID : key, DIRECTIONS[direction]);
     for (const { operator, key, value } of filters)
-        yield firestoreWhere(key === "id" ? ID : key, OPERATORS[operator], value);
+        yield firestoreWhere(key, OPERATORS[operator], value);
     if (typeof limit === "number")
         yield firestoreLimit(limit);
 }

package/firestore/lite/FirestoreLiteProvider.js

@@ -2,8 +2,6 @@ import { documentId as firestoreDocumentId, orderBy as firestoreOrderBy, where a
 import { UnsupportedError } from "../../error/UnsupportedError.js";
 import { ArrayUpdate, DataUpdate, Increment, DictionaryUpdate, Delete, Update } from "../../update/index.js";
 // Constants.
-// const ID = "__name__"; // DH: `__name__` is the entire path of the document. `__id__` is just ID.
-// const ID = "__id__"; // Internal way Firestore Queries can reference the ID of the current document.
 const ID = firestoreDocumentId();
 // Map `Filter.types` to `WhereFilterOp`
 const OPERATORS = {
@@ -11,11 +9,11 @@ const OPERATORS = {
     NOT: "!=",
     IN: "in",
     OUT: "not-in",
+    CONTAINS: "array-contains",
     GT: ">",
     GTE: ">=",
     LT: "<",
     LTE: "<=",
-    CONTAINS: "array-contains",
 };
 // Map `Filter.types` to `OrderByDirection`
 const DIRECTIONS = {

package/firestore/server/FirestoreServerProvider.js

@@ -9,11 +9,11 @@ const OPERATORS = {
     NOT: "!=",
     IN: "in",
     OUT: "not-in",
+    CONTAINS: "array-contains",
     GT: ">",
     GTE: ">=",
     LT: "<",
     LTE: "<=",
-    CONTAINS: "array-contains",
 };
 // Map `Filter.types` to `OrderByDirection`
 const DIRECTIONS = {

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.86.7",
+	"version": "1.87.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -71,7 +71,7 @@
 		"@typescript-eslint/eslint-plugin": "^5.49.0",
 		"@typescript-eslint/parser": "^5.49.0",
 		"dpdm": "^3.11.0",
-		"esbuild": "^0.15.18",
+		"esbuild": "^0.17.12",
 		"esbuild-jest": "^0.5.0",
 		"eslint": "^8.33.0",
 		"eslint-config-prettier": "^8.6.0",
@@ -83,7 +83,7 @@
 		"prettier": "^2.8.3",
 		"react": "^18.1.0",
 		"react-dom": "^18.1.0",
-		"typescript": "^4.9.4"
+		"typescript": "^5.0.2"
 	},
 	"peerDependencies": {
 		"@google-cloud/firestore": ">=4.0.0",

package/schema/Schema.d.ts

@@ -29,4 +29,4 @@ export declare abstract class Schema<T extends unknown = unknown> implements Val
     abstract validate(unsafeValue: unknown): T;
 }
 /** Is an unknown value a `Schema` instance? */
-export declare const isSchema: <T extends Schema<unknown>>(v: unknown) => v is T;
+export declare const isSchema: <T extends Schema<unknown>>(value: unknown) => value is T;

package/schema/Schema.js

@@ -12,4 +12,4 @@ export class Schema {
     }
 }
 /** Is an unknown value a `Schema` instance? */
-export const isSchema = (v) => v instanceof Schema;
+export const isSchema = (value) => value instanceof Schema;

package/state/State.d.ts

@@ -43,4 +43,4 @@ export declare class State<T> implements AsyncIterable<T>, Validatable<T> {
     validate(value: T): T;
 }
 /** Is an unknown value a `State` instance. */
-export declare const isState: <T extends AnyState>(v: unknown) => v is T;
+export declare const isState: <T extends AnyState>(value: unknown) => value is T;

package/state/State.js

@@ -10,7 +10,7 @@ import { DeferredSequence } from "../sequence/DeferredSequence.js";
  * - To set the state to be loading, use the `State.NOVALUE` constant or a `Promise` value.
  * - To set the state to an explicit value, use that value or another `State` instance with a value.
  * */
-export class State {
+class State {
     /** Most recently dispatched value (or throw `Promise` that resolves to the next value). */
     get value() {
         if (this._value === State.NOVALUE)
@@ -79,5 +79,6 @@ export class State {
 }
 /** The `NOVALUE` symbol indicates no value has been received by a `State` instance. */
 State.NOVALUE = Symbol("shelving/State.NOVALUE");
+export { State };
 /** Is an unknown value a `State` instance. */
-export const isState = (v) => v instanceof State;
+export const isState = (value) => value instanceof State;

package/test/basics.d.ts

@@ -5,6 +5,14 @@ export declare const BASIC_SCHEMA: import("../schema/DataSchema.js").DataSchema<
     num: number;
     group: "a" | "b" | "c";
     tags: import("../index.js").ImmutableArray<string>;
+    odd: boolean;
+    even: boolean;
+    sub: {
+        str: any;
+        num: any;
+        odd: any;
+        even: any;
+    };
 }>;
 export type BasicData = ValidatorType<typeof BASIC_SCHEMA>;
 export type BasicItemData = ItemData<BasicData>;
@@ -18,3 +26,4 @@ export declare const basic7: BasicItemData;
 export declare const basic8: BasicItemData;
 export declare const basic9: BasicItemData;
 export declare const basics: ReadonlyArray<BasicItemData>;
+export declare const basic999: BasicData;

package/test/basics.js

@@ -3,19 +3,24 @@ import { ARRAY } from "../schema/ArraySchema.js";
 import { DATA } from "../schema/DataSchema.js";
 import { NUMBER } from "../schema/NumberSchema.js";
 import { STRING } from "../schema/StringSchema.js";
+import { BOOLEAN } from "../schema/BooleanSchema.js";
 export const BASIC_SCHEMA = DATA({
     str: STRING,
     num: NUMBER,
     group: ALLOW_STRING({ a: "A", b: "B", c: "C" }),
     tags: ARRAY(STRING),
+    odd: BOOLEAN,
+    even: BOOLEAN,
+    sub: DATA({ str: STRING, num: NUMBER, odd: BOOLEAN, even: BOOLEAN }),
 });
-export const basic1 = { id: "basic1", str: "aaa", num: 100, group: "a", tags: ["odd", "prime"] };
-export const basic2 = { id: "basic2", str: "bbb", num: 200, group: "a", tags: ["even", "prime"] };
-export const basic3 = { id: "basic3", str: "ccc", num: 300, group: "a", tags: ["odd", "prime"] };
-export const basic4 = { id: "basic4", str: "ddd", num: 400, group: "b", tags: ["even"] };
-export const basic5 = { id: "basic5", str: "eee", num: 500, group: "b", tags: ["odd", "prime"] };
-export const basic6 = { id: "basic6", str: "fff", num: 600, group: "b", tags: ["even"] };
-export const basic7 = { id: "basic7", str: "ggg", num: 700, group: "c", tags: ["odd", "prime"] };
-export const basic8 = { id: "basic8", str: "hhh", num: 800, group: "c", tags: ["even"] };
-export const basic9 = { id: "basic9", str: "iii", num: 900, group: "c", tags: ["odd"] };
+export const basic1 = { id: "basic1", str: "aaa", num: 100, even: false, odd: true, group: "a", tags: ["odd", "prime"], sub: { str: "aaa", num: 100, even: false, odd: true } };
+export const basic2 = { id: "basic2", str: "bbb", num: 200, even: true, odd: false, group: "a", tags: ["even", "prime"], sub: { str: "bbb", num: 200, even: true, odd: false } };
+export const basic3 = { id: "basic3", str: "ccc", num: 300, even: false, odd: true, group: "a", tags: ["odd", "prime"], sub: { str: "ccc", num: 300, even: false, odd: true } };
+export const basic4 = { id: "basic4", str: "ddd", num: 400, even: true, odd: false, group: "b", tags: ["even"], sub: { str: "ddd", num: 400, even: true, odd: false } };
+export const basic5 = { id: "basic5", str: "eee", num: 500, even: false, odd: true, group: "b", tags: ["odd", "prime"], sub: { str: "eee", num: 500, even: false, odd: true } };
+export const basic6 = { id: "basic6", str: "fff", num: 600, even: true, odd: false, group: "b", tags: ["even"], sub: { str: "fff", num: 600, even: true, odd: false } };
+export const basic7 = { id: "basic7", str: "ggg", num: 700, even: false, odd: true, group: "c", tags: ["odd", "prime"], sub: { str: "ggg", num: 700, even: false, odd: true } };
+export const basic8 = { id: "basic8", str: "hhh", num: 800, even: true, odd: false, group: "c", tags: ["even"], sub: { str: "hhh", num: 800, even: true, odd: false } };
+export const basic9 = { id: "basic9", str: "iii", num: 900, even: false, odd: true, group: "c", tags: ["odd"], sub: { str: "iii", num: 900, even: false, odd: true } };
 export const basics = [basic3, basic5, basic7, basic4, basic1, basic2, basic8, basic6, basic9];
+export const basic999 = { str: "zzz", num: 999, even: false, odd: true, group: "a", tags: ["odd", "prime"], sub: { str: "zzz", num: 999, even: false, odd: true } };

package/test/index.d.ts

@@ -8,6 +8,14 @@ export declare const TEST_COLLECTIONS: {
         num: number;
         group: "a" | "b" | "c";
         tags: import("../index.js").ImmutableArray<string>;
+        odd: boolean;
+        even: boolean;
+        sub: {
+            str: any;
+            num: any;
+            odd: any;
+            even: any;
+        };
     }>;
     people: import("../index.js").DataSchema<{
         name: {

package/util/array.d.ts

@@ -1,5 +1,5 @@
-import { Arguments } from "./function.js";
-import { Matcher } from "./match.js";
+import type { Arguments } from "./function.js";
+import type { Matcher } from "./match.js";
 /**
  * Mutable array: an array that can be changed.
  * - Consistency with `MutableObject<T>` and `ImmutableArray<T>`
@@ -15,16 +15,15 @@ export type ArrayItem<T extends ImmutableArray> = T[number];
 /** Things that can be converted to arrays. */
 export type PossibleArray<T> = ImmutableArray<T> | Iterable<T>;
 /** Is an unknown value an array? */
-export declare const isArray: <T extends ImmutableArray<unknown>>(v: unknown) => v is T;
+export declare const isArray: <T extends ImmutableArray<unknown>>(value: unknown) => value is T;
 /** Assert that a value is an array. */
 export declare function assertArray<T>(arr: ImmutableArray<T> | unknown): asserts arr is ImmutableArray<T>;
 /** Is an unknown value an item in a specified array? */
-export declare const isArrayItem: <T>(arr: ImmutableArray<T>, item: unknown) => item is T;
-export declare const isItem: <T>(arr: ImmutableArray<T>, item: unknown) => item is T;
+export declare const isArrayItem: <T>(arr: ImmutableArray<T>, value: unknown) => value is T;
 /** Convert an iterable to an array (if its not already an array). */
 export declare function getArray<T>(items: PossibleArray<T>): ImmutableArray<T>;
 /** Add multiple items to an array (immutably) and return a new array with those items (or the same array if no changes were made). */
-export declare function withArrayItems<T>(input: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
+export declare function withArrayItems<T>(arr: ImmutableArray<T>, ...items: T[]): ImmutableArray<T>;
 /** Pick multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */
 export declare function pickArrayItems<T>(input: ImmutableArray<T> | Iterable<T>, ...pick: T[]): ImmutableArray<T>;
 /** Remove multiple items from an array (immutably) and return a new array without those items (or the same array if no changes were made). */

package/util/array.js

@@ -3,23 +3,22 @@ import { RequiredError } from "../error/RequiredError.js";
 import { filterItems, omitItems, pickItems } from "./iterate.js";
 import { formatRange } from "./number.js";
 /** Is an unknown value an array? */
-export const isArray = (v) => Array.isArray(v);
+export const isArray = (value) => Array.isArray(value);
 /** Assert that a value is an array. */
 export function assertArray(arr) {
     if (!isArray(arr))
         throw new AssertionError(`Must be array`, arr);
 }
 /** Is an unknown value an item in a specified array? */
-export const isArrayItem = (arr, item) => arr.includes(item);
-export const isItem = isArrayItem;
+export const isArrayItem = (arr, value) => arr.includes(value);
 /** Convert an iterable to an array (if its not already an array). */
 export function getArray(items) {
     return isArray(items) ? items : Array.from(items);
 }
 /** Add multiple items to an array (immutably) and return a new array with those items (or the same array if no changes were made). */
-export function withArrayItems(input, ...items) {
-    const extras = items.filter(_doesNotInclude, input);
-    return extras.length ? [...input, ...extras] : input;
+export function withArrayItems(arr, ...items) {
+    const extras = items.filter(_doesNotInclude, arr);
+    return extras.length ? [...arr, ...extras] : arr;
 }
 function _doesNotInclude(value) {
     return !this.includes(value);

package/util/assert.d.ts

@@ -1,6 +1,6 @@
 /** Assert a boolean condition is true. */
 export declare function assert(condition: unknown, ...received: unknown[]): asserts condition;
 /** Assert two values are equal. */
-export declare function assertEqual<T>(v: T | unknown, target: T): asserts v is T;
+export declare function assertEqual<T>(left: T | unknown, right: T): asserts left is T;
 /** Assert two values are equal. */
-export declare function assertNot<T, N>(v: T | N, target: N): asserts v is T;
+export declare function assertNot<T, N>(left: T | N, right: N): asserts left is T;