shelving 1.47.1 → 1.48.1

package/db/Database.d.ts

@@ -163,8 +163,8 @@ export declare class DatabaseDocument<T extends Data = Data> implements Observab
 }
 /** Database data embeds the corresponding `Document` instance and string ID into the data. */
 export declare type DocumentData<T extends Data> = T & {
-    _id: string;
-    _doc: DatabaseDocument<T>;
+    id: string;
+    doc: DatabaseDocument<T>;
 };
 /** Get the data for a document from a result for that document. */
 export declare function getDocumentData<T extends Data>(result: Result<T>, ref: DatabaseDocument<T>): DocumentData<T>;

package/db/Database.js

@@ -259,7 +259,7 @@ export class DatabaseDocument {
 /** Get the data for a document from a result for that document. */
 export function getDocumentData(result, ref) {
     if (result)
-        return { ...result, _id: ref.id, _doc: ref };
+        return { ...result, id: ref.id, doc: ref };
     throw new DocumentRequiredError(ref);
 }
 /** Get the data for a document from a result for that document. */

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.47.1",
+	"version": "1.48.1",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -63,19 +63,19 @@
 		"@types/jest": "^27.4.0",
 		"@types/react": "^17.0.38",
 		"@types/react-dom": "^17.0.11",
-		"@typescript-eslint/eslint-plugin": "^5.9.0",
-		"@typescript-eslint/parser": "^5.9.0",
-		"eslint": "^8.6.0",
+		"@typescript-eslint/eslint-plugin": "^5.9.1",
+		"@typescript-eslint/parser": "^5.9.1",
+		"eslint": "^8.7.0",
 		"eslint-config-prettier": "^8.3.0",
 		"eslint-plugin-import": "^2.25.4",
 		"eslint-plugin-prettier": "^4.0.0",
-		"firebase": "^9.6.2",
+		"firebase": "^9.6.3",
 		"jest": "^27.4.7",
 		"jest-ts-webcompat-resolver": "^1.0.0",
 		"prettier": "^2.5.1",
 		"react": "^17.0.2",
 		"react-dom": "^17.0.2",
-		"ts-jest": "^27.1.2",
+		"ts-jest": "^27.1.3",
 		"typescript": "^4.5.4"
 	},
 	"peerDependencies": {

package/query/Filters.d.ts

@@ -9,8 +9,8 @@ export declare class Filters<T extends Data> extends Rules<T, Filter<T>> impleme
     filter(props: FilterProps<T>): this;
     filter(key: "id" | "!id" | "id>" | "id>=" | "id<" | "id<=", value: string): this;
     filter(key: "id" | "!id", value: ImmutableArray<string>): this;
-    filter<K extends Key<T>>(key: K | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
-    filter<K extends Key<T>>(key: K | `!${K}`, value: ImmutableArray<string>): this;
+    filter<K extends Key<T>>(key: `${K}` | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
+    filter<K extends Key<T>>(key: `${K}` | `!${K}`, value: ImmutableArray<string>): this;
     filter<K extends Key<T>>(key: `${K}[]`, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
     match(entry: Entry<T>): boolean;
     transform(iterable: Entries<T>): Entries<T>;

package/query/Query.d.ts

@@ -14,8 +14,8 @@ export declare class Query<T extends Data> extends Rule<T> implements Queryable<
     filter(props: FilterProps<T>): this;
     filter(key: "id" | "!id" | "id>" | "id>=" | "id<" | "id<=", value: string): this;
     filter(key: "id" | "!id", value: ImmutableArray<string>): this;
-    filter<K extends Key<T>>(key: K | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
-    filter<K extends Key<T>>(key: K | `!${K}`, value: ImmutableArray<T[K]>): this;
+    filter<K extends Key<T>>(key: `${K}` | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
+    filter<K extends Key<T>>(key: `${K}` | `!${K}`, value: ImmutableArray<T[K]>): this;
     filter<K extends Key<T>>(key: `${K}[]`, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
     get unfilter(): this;
     match(entry: Entry<T>): boolean;

package/query/types.d.ts

@@ -2,7 +2,7 @@ import type { Data, Key, Matchable, Entry, Rankable, ImmutableArray, ArrayType }
 /** Possible operator references. */
 export declare 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 declare type FilterKey<T extends Data> = "id" | "!id" | "id>" | "id>=" | "id<" | "id<=" | Key<T> | `!${Key<T>}` | `${Key<T>}[]` | `${Key<T>}<` | `${Key<T>}<=` | `${Key<T>}>` | `${Key<T>}>=`;
+export declare type FilterKey<T extends Data> = "id" | "!id" | "id>" | "id>=" | "id<" | "id<=" | Key<T> | `${Key<T>}` | `!${Key<T>}` | `${Key<T>}[]` | `${Key<T>}<` | `${Key<T>}<=` | `${Key<T>}>` | `${Key<T>}>=`;
 /** Format that allows multiple filters to be specified as a plain object. */
 export declare type FilterProps<T extends Data> = {
     "id"?: string | ImmutableArray<string>;
@@ -12,7 +12,7 @@ export declare type FilterProps<T extends Data> = {
     "id<"?: string;
     "id<="?: string;
 } & {
-    [K in Key<T> as K | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
+    [K in Key<T> as `${K}` | `!${K}`]?: T[K] | ImmutableArray<T[K]>;
 } & {
     [K in Key<T> as `${K}[]`]?: T[K] extends ImmutableArray ? ArrayType<T[K]> : never;
 } & {
@@ -27,14 +27,14 @@ export interface Filterable<T extends Data> extends Matchable<Entry<T>, void> {
     filter(props: FilterProps<T>): this;
     filter(key: "id" | "!id" | "id>" | "id>=" | "id<" | "id<=", value: string): this;
     filter(key: "id" | "!id", value: ImmutableArray<string>): this;
-    filter<K extends Key<T>>(key: K | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
-    filter<K extends Key<T>>(key: K | `!${K}`, value: ImmutableArray<string>): this;
+    filter<K extends Key<T>>(key: `${K}` | `!${K}` | `${K}>` | `${K}>=` | `${K}<` | `${K}<=`, value: T[K]): this;
+    filter<K extends Key<T>>(key: `${K}` | `!${K}`, value: ImmutableArray<string>): this;
     filter<K extends Key<T>>(key: `${K}[]`, value: T[K] extends ImmutableArray ? ArrayType<T[K]> : never): this;
     /** Match an entry against the filters specified for this object. */
     match(entry: Entry<T>): boolean;
 }
 /** 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 declare type SortKey<T extends Data> = "id" | "!id" | Key<T> | `!${Key<T>}`;
+export declare type SortKey<T extends Data> = "id" | "!id" | Key<T> | `${Key<T>}` | `!${Key<T>}`;
 /** One or more sort keys. */
 export declare type SortKeys<T extends Data> = SortKey<T> | ImmutableArray<SortKey<T>>;
 /** Possible operator references. */

package/util/date.d.ts

@@ -128,3 +128,5 @@ export declare const formatDate: (date: PossibleDate) => string;
 export declare const isPast: (target: PossibleDate, current?: PossibleDate | undefined) => boolean;
 /** Is a date in the future? */
 export declare const isFuture: (target: PossibleDate, current?: PossibleDate | undefined) => boolean;
+/** Is a date today (taking into account midnight). */
+export declare const isToday: (target: PossibleDate, current?: PossibleDate | undefined) => boolean;

package/util/date.js

@@ -217,3 +217,5 @@ const _formatter = new Intl.DateTimeFormat(undefined, {});
 export const isPast = (target, current) => getDate(target) < getDate(current);
 /** Is a date in the future? */
 export const isFuture = (target, current) => getDate(target) > getDate(current);
+/** Is a date today (taking into account midnight). */
+export const isToday = (target, current) => getMidnight(target) === getMidnight(current);

package/util/sort.d.ts

@@ -32,13 +32,13 @@ export declare function rankAsc(left: unknown, right: unknown): number;
 /** Rank two values in descending order. */
 export declare const rankDesc: (left: unknown, right: unknown) => number;
 /** Rank the keys of two entries in ascending order. */
-export declare const rankEntryKeyAsc: ([l]: Entry<unknown>, [r]: Entry<unknown>) => number;
+export declare const rankKeyAsc: ([l]: Entry<unknown>, [r]: Entry<unknown>) => number;
 /** Rank the keys of two entries in descending order. */
-export declare const rankEntryKeyDesc: ([l]: Entry<unknown>, [r]: Entry<unknown>) => number;
+export declare const rankKeyDesc: ([l]: Entry<unknown>, [r]: Entry<unknown>) => number;
 /** Rank the values of two entries in ascending order. */
-export declare const rankEntryValueAsc: ([, l]: Entry<unknown>, [, r]: Entry<unknown>) => number;
+export declare const rankValueAsc: ([, l]: Entry<unknown>, [, r]: Entry<unknown>) => number;
 /** Rank the values of two entries in descending order. */
-export declare const rankEntryValueDesc: ([, l]: Entry<unknown>, [, r]: Entry<unknown>) => number;
+export declare const rankValueDesc: ([, l]: Entry<unknown>, [, r]: Entry<unknown>) => number;
 /** Sort an iterable set of items using a ranker (defaults to sorting in ascending order). */
 export declare function sortItems<T>(input: Iterable<T>, ranker?: Ranker<T>): ImmutableArray<T>;
 /** Sort an array using a ranker (defaults to sorting in ascending order) */

package/util/sort.js

@@ -75,13 +75,13 @@ export function rankAsc(left, right) {
 /** Rank two values in descending order. */
 export const rankDesc = (left, right) => 0 - rankAsc(left, right);
 /** Rank the keys of two entries in ascending order. */
-export const rankEntryKeyAsc = ([l], [r]) => rankAsc(l, r);
+export const rankKeyAsc = ([l], [r]) => rankAsc(l, r);
 /** Rank the keys of two entries in descending order. */
-export const rankEntryKeyDesc = ([l], [r]) => rankDesc(l, r);
+export const rankKeyDesc = ([l], [r]) => rankDesc(l, r);
 /** Rank the values of two entries in ascending order. */
-export const rankEntryValueAsc = ([, l], [, r]) => rankAsc(l, r);
+export const rankValueAsc = ([, l], [, r]) => rankAsc(l, r);
 /** Rank the values of two entries in descending order. */
-export const rankEntryValueDesc = ([, l], [, r]) => rankDesc(l, r);
+export const rankValueDesc = ([, l], [, r]) => rankDesc(l, r);
 /**
  * Quick sort algorithm.
  * DH: We implement our own sorting algorithm so that:
@@ -144,18 +144,18 @@ export function sortArray(input, ranker = rankAsc) {
  * Sort an iterable set of entries (defaults to sorting by key in ascending order).
  * - Always returns an array
  */
-export function sortEntries(input, ranker = rankEntryKeyAsc) {
+export function sortEntries(input, ranker = rankKeyAsc) {
     const array = Array.from(input);
     _quicksort(array, ranker);
     return array;
 }
 /** Sort a map-like object using a ranker (defaults to sorting by key in ascending order). */
-export function sortObject(input, ranker = rankEntryKeyAsc) {
+export function sortObject(input, ranker = rankKeyAsc) {
     const array = Object.entries(input);
     return _quicksort(array, ranker) ? Object.fromEntries(array) : input;
 }
 /** Sort a map using a ranker (defaults to sorting by key in ascending order). */
-export function sortMap(input, ranker = rankEntryKeyAsc) {
+export function sortMap(input, ranker = rankKeyAsc) {
     const array = Array.from(input);
     return _quicksort(array, ranker) ? new Map(array) : input;
 }