shelving 1.32.0 → 1.33.0

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.32.0",
+	"version": "1.33.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",

package/util/filter.d.ts

@@ -12,32 +12,28 @@ export declare type Matcher<L, R> = Matchable<L, R> | ((item: L, target: R) => b
 /** Match two values using a `Matcher`. */
 export declare function match<L>(item: L, matcher: Matcher<L, void>): boolean;
 export declare function match<L, R>(item: L, matcher: Matcher<L, R>, target: R): boolean;
-/** Match whether an item is equal to a target. */
 export declare const IS: (item: unknown, target: unknown) => boolean;
-/** Match whether an item is not equal to match a target. */
 export declare const NOT: (item: unknown, target: unknown) => boolean;
-/** Match whether an item exists in an array of targets. */
 export declare const IN: (item: unknown, targets: ImmutableArray<unknown>) => boolean;
-/** Match whether an array of items contains a target. */
 export declare const CONTAINS: (items: unknown, target: unknown) => boolean;
-/** Match whether an item is less than a target. */
 export declare const LT: (item: unknown, target: unknown) => boolean;
-/** Match whether an item is less than or equal to a target. */
 export declare const LTE: (item: unknown, target: unknown) => boolean;
-/** Match whether an item is greater than a target. */
 export declare const GT: (item: unknown, target: unknown) => boolean;
-/** Match whether an item is greater than or equal to a target. */
 export declare const GTE: (item: unknown, target: unknown) => boolean;
-/** Match whether the key of an entry is equal to a target. */
-export declare const KEY_IS: ([item]: Entry<unknown>, target: string) => boolean;
-/** Match whether the key of an entry is in an array of targets. */
-export declare const KEY_IN: ([item]: Entry<unknown>, targets: ImmutableArray<string>) => boolean;
-/** Match whether the value of an entry is equal to a target. */
-export declare const VALUE_IS: ([, item]: Entry<unknown>, target: unknown) => boolean;
-/** Match whether the value of an entry is in an array of targets. */
-export declare const VALUE_IN: ([, item]: Entry<unknown>, targets: ImmutableArray<unknown>) => boolean;
-/** Match whether the value of an entry is defined. */
-export declare const VALUE_DEFINED: ([, item]: Entry<unknown>) => boolean;
+export declare const KEY_IS: ([key]: Entry<unknown>, target: string) => boolean;
+export declare const KEY_NOT: ([key]: Entry<unknown>, targets: ImmutableArray<string>) => boolean;
+export declare const KEY_IN: ([key]: Entry<unknown>, targets: ImmutableArray<string>) => boolean;
+export declare const KEY_LT: ([key]: Entry<unknown>, target: unknown) => boolean;
+export declare const KEY_LTE: ([key]: Entry<unknown>, target: unknown) => boolean;
+export declare const KEY_GT: ([key]: Entry<unknown>, target: unknown) => boolean;
+export declare const KEY_GTE: ([key]: Entry<unknown>, target: unknown) => boolean;
+export declare const VALUE_IS: ([, value]: Entry<unknown>, target: unknown) => boolean;
+export declare const VALUE_NOT: ([, value]: Entry<unknown>, target: unknown) => boolean;
+export declare const VALUE_IN: ([, value]: Entry<unknown>, targets: ImmutableArray<unknown>) => boolean;
+export declare const VALUE_LT: ([, value]: Entry<unknown>, target: unknown) => boolean;
+export declare const VALUE_LTE: ([, value]: Entry<unknown>, target: unknown) => boolean;
+export declare const VALUE_GT: ([, value]: Entry<unknown>, target: unknown) => boolean;
+export declare const VALUE_GTE: ([, value]: Entry<unknown>, target: unknown) => boolean;
 /** Filter an iterable set of items using a matcher (and optionally a target value). */
 export declare function yieldFiltered<L>(input: Iterable<L>, matcher: Matcher<L, void>): Iterable<L>;
 export declare function yieldFiltered<L, R>(input: Iterable<L>, matcher: Matcher<L, R>, target: R): Iterable<L>;

package/util/filter.js

@@ -3,32 +3,31 @@ import { transform } from "./transform.js";
 export function match(item, matcher, target) {
     return typeof matcher === "function" ? matcher(item, target) : matcher.match(item, target);
 }
-/** Match whether an item is equal to a target. */
+// Regular matchers.
 export const IS = (item, target) => item === target;
-/** Match whether an item is not equal to match a target. */
 export const NOT = (item, target) => item !== target;
-/** Match whether an item exists in an array of targets. */
 export const IN = (item, targets) => targets.includes(item);
-/** Match whether an array of items contains a target. */
 export const CONTAINS = (items, target) => items instanceof Array && items.includes(target);
-/** Match whether an item is less than a target. */
 export const LT = (item, target) => ASC(item, target) < 0;
-/** Match whether an item is less than or equal to a target. */
 export const LTE = (item, target) => ASC(item, target) <= 0;
-/** Match whether an item is greater than a target. */
 export const GT = (item, target) => ASC(item, target) > 0;
-/** Match whether an item is greater than or equal to a target. */
 export const GTE = (item, target) => ASC(item, target) >= 0;
-/** Match whether the key of an entry is equal to a target. */
-export const KEY_IS = ([item], target) => item === target;
-/** Match whether the key of an entry is in an array of targets. */
-export const KEY_IN = ([item], targets) => targets.includes(item);
-/** Match whether the value of an entry is equal to a target. */
-export const VALUE_IS = ([, item], target) => item === target;
-/** Match whether the value of an entry is in an array of targets. */
-export const VALUE_IN = ([, item], targets) => targets.includes(item);
-/** Match whether the value of an entry is defined. */
-export const VALUE_DEFINED = ([, item]) => item !== undefined;
+// Entry key matchers.
+export const KEY_IS = ([key], target) => IS(key, target);
+export const KEY_NOT = ([key], targets) => IN(key, targets);
+export const KEY_IN = ([key], targets) => IN(key, targets);
+export const KEY_LT = ([key], target) => LT(key, target);
+export const KEY_LTE = ([key], target) => LTE(key, target);
+export const KEY_GT = ([key], target) => GT(key, target);
+export const KEY_GTE = ([key], target) => GTE(key, target);
+// Entry value matchers.
+export const VALUE_IS = ([, value], target) => IS(value, target);
+export const VALUE_NOT = ([, value], target) => NOT(value, target);
+export const VALUE_IN = ([, value], targets) => IN(value, targets);
+export const VALUE_LT = ([, value], target) => LT(value, target);
+export const VALUE_LTE = ([, value], target) => LTE(value, target);
+export const VALUE_GT = ([, value], target) => GT(value, target);
+export const VALUE_GTE = ([, value], target) => GTE(value, target);
 export function* yieldFiltered(input, matcher, target) {
     for (const item of input)
         if (match(item, matcher, target))