shelving 1.47.0 → 1.48.0

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/db/Operation.d.ts

@@ -8,10 +8,8 @@ export declare abstract class Operation {
 }
 /** Represent a list of write operations on a database run in series. */
 export declare class Operations extends Operation {
-    /** Return a new write operations list with a set of write operations. */
-    static with(...operations: Nullish<Operation>[]): Operations;
     readonly operations: ImmutableArray<Operation>;
-    constructor(operations: ImmutableArray<Nullish<Operation>>);
+    constructor(...operations: Nullish<Operation>[]);
     run(db: Database): Promise<Operations>;
     /** Return a new write operations list with an additional write operation added. */
     with(...operations: Nullish<Operation>[]): {

package/db/Operation.js

@@ -4,23 +4,20 @@ export class Operation {
 }
 /** Represent a list of write operations on a database run in series. */
 export class Operations extends Operation {
-    constructor(operations) {
+    constructor(...operations) {
         super();
         this.operations = operations.filter(notNullish);
     }
-    /** Return a new write operations list with a set of write operations. */
-    static with(...operations) {
-        return new Operations(operations);
-    }
     async run(db) {
-        return new Operations(await callAsyncSeries(_write, this.operations, db));
+        const ops = await callAsyncSeries(_run, this.operations, db);
+        return new Operations(...ops);
     }
     /** Return a new write operations list with an additional write operation added. */
     with(...operations) {
         return { __proto__: Object.getPrototypeOf(this), ...this, operations: [...this.operations, operations] };
     }
 }
-const _write = (operation, db) => operation.run(db);
+const _run = (operation, db) => operation.run(db);
 /** Represent a add operation made to a collection in a database. */
 export class AddOperation extends Operation {
     constructor(collection, data) {

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.47.0",
+	"version": "1.48.0",
 	"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/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;
 }