shelving 1.110.1 → 1.110.3

package/db/CacheProvider.d.ts

@@ -11,6 +11,9 @@ export declare class CacheProvider<T extends Database> implements AsyncProvider<
     constructor(source: AsyncProvider<T>, cache?: MemoryProvider<T>);
     getItem<K extends DataKey<T>>(collection: K, id: string): Promise<OptionalItem<T[K]>>;
     getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<OptionalItem<T[K]>>;
+    getCachedItem<K extends DataKey<T>>(collection: K, id: string): OptionalItem<T[K]>;
+    getCachedItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<OptionalItem<T[K]>>;
+    getCachedItemTime<K extends DataKey<T>>(collection: K, id: string): number | undefined;
     addItem<K extends DataKey<T>>(collection: K, data: T[K]): Promise<string>;
     setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): Promise<void>;
     updateItem<K extends DataKey<T>>(collection: K, id: string, updates: Updates<T[K]>): Promise<void>;
@@ -18,6 +21,9 @@ export declare class CacheProvider<T extends Database> implements AsyncProvider<
     countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Promise<number>;
     getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Promise<Items<T[K]>>;
     getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
+    getCachedQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Items<T[K]>;
+    getCachedQuerySequence<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
+    getCachedQueryTime<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): number | undefined;
     setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): Promise<void>;
     updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): Promise<void>;
     deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): Promise<void>;

package/db/CacheProvider.js

@@ -15,6 +15,15 @@ export class CacheProvider {
     getItemSequence(collection, id) {
         return this.memory.setItemSequence(collection, id, this.source.getItemSequence(collection, id));
     }
+    getCachedItem(collection, id) {
+        return this.memory.getItem(collection, id);
+    }
+    getCachedItemSequence(collection, id) {
+        return this.memory.getItemSequence(collection, id);
+    }
+    getCachedItemTime(collection, id) {
+        return this.memory.getItemTime(collection, id);
+    }
     async addItem(collection, data) {
         const id = await this.source.addItem(collection, data);
         this.memory.setItem(collection, id, data);
@@ -43,6 +52,15 @@ export class CacheProvider {
     getQuerySequence(collection, query) {
         return this.memory.setItemsSequence(collection, this.source.getQuerySequence(collection, query), query);
     }
+    getCachedQuery(collection, query) {
+        return this.memory.getQuery(collection, query);
+    }
+    getCachedQuerySequence(collection, query) {
+        return this.memory.getQuerySequence(collection, query);
+    }
+    getCachedQueryTime(collection, query) {
+        return this.memory.getQueryTime(collection, query);
+    }
     async setQuery(collection, query, data) {
         await this.source.setQuery(collection, query, data);
         this.memory.setQuery(collection, query, data);

package/db/ItemStore.d.ts

@@ -3,9 +3,9 @@ import type { StopCallback } from "../util/callback.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { Item, OptionalItem } from "../util/item.js";
 import { BooleanStore } from "../store/BooleanStore.js";
-import { Store } from "../store/Store.js";
+import { LazyStore } from "../store/LazyStore.js";
 /** Store a single item. */
-export declare class ItemStore<T extends Database, K extends DataKey<T>> extends Store<OptionalItem<T[K]>> {
+export declare class ItemStore<T extends Database, K extends DataKey<T>> extends LazyStore<OptionalItem<T[K]>> {
     readonly provider: AbstractProvider<T>;
     readonly collection: K;
     readonly id: string;
@@ -24,12 +24,4 @@ export declare class ItemStore<T extends Database, K extends DataKey<T>> extends
     refreshStale(maxAge: number, provider?: AbstractProvider<T>): void;
     /** Subscribe this store to a provider. */
     connect(provider?: AbstractProvider<T>): StopCallback;
-    [Symbol.asyncIterator](): AsyncGenerator<OptionalItem<T[K]>, void, void>;
-    private _iterating;
-    /** Start subscription to `MemoryProvider` if there is one. */
-    start(): void;
-    /** Stop subscription to `MemoryProvider` if there is one. */
-    stop(): void;
-    private _stop;
-    [Symbol.dispose](): void;
 }

package/db/ItemStore.js

@@ -1,14 +1,14 @@
 import { BooleanStore } from "../store/BooleanStore.js";
-import { Store } from "../store/Store.js";
-import { call } from "../util/callback.js";
+import { LazyStore } from "../store/LazyStore.js";
 import { NONE } from "../util/constants.js";
+import { BLACKHOLE } from "../util/function.js";
 import { getItem } from "../util/item.js";
 import { getRequired } from "../util/optional.js";
 import { runSequence } from "../util/sequence.js";
 import { getOptionalSource } from "../util/source.js";
 import { CacheProvider } from "./CacheProvider.js";
 /** Store a single item. */
-export class ItemStore extends Store {
+export class ItemStore extends LazyStore {
     provider;
     collection;
     id;
@@ -26,15 +26,15 @@ export class ItemStore extends Store {
         return !!this.value;
     }
     constructor(provider, collection, id) {
-        const memory = getOptionalSource(CacheProvider, provider)?.memory;
-        const time = memory?.getItemTime(collection, id);
-        const value = memory && typeof time === "number" ? memory.getItem(collection, id) : NONE; // Use the value in the memory provider if it's cached, or use mark this store as loading otherwise (which will trigger `refresh()` below.
-        super(value, time);
+        const cache = getOptionalSource(CacheProvider, provider);
+        const time = cache?.getCachedItemTime(collection, id);
+        const value = cache && typeof time === "number" ? cache.getCachedItem(collection, id) : NONE; // Use the value in the cache if it's cached, or use mark this store as loading otherwise (which will trigger `refresh()` below).
+        super(store => (cache ? runSequence(store.through(cache.getCachedItemSequence(collection, id))) : BLACKHOLE), value, time);
         this.provider = provider;
         this.collection = collection;
         this.id = id;
-        // Queue a request to refresh the value if it doesn't exist.
-        if (typeof time !== "number")
+        // Start loading the value from the provider if it doesn't exist.
+        if (this.loading)
             this.refresh();
     }
     /** Refresh this store from the source provider. */
@@ -64,36 +64,4 @@ export class ItemStore extends Store {
     connect(provider = this.provider) {
         return runSequence(this.through(provider.getItemSequence(this.collection, this.id)));
     }
-    // Override to subscribe to `MemoryProvider` while things are iterating over this store.
-    async *[Symbol.asyncIterator]() {
-        this.start();
-        this._iterating++;
-        try {
-            yield* super[Symbol.asyncIterator]();
-        }
-        finally {
-            this._iterating--;
-            if (this._iterating < 1)
-                this.stop();
-        }
-    }
-    _iterating = 0;
-    /** Start subscription to `MemoryProvider` if there is one. */
-    start() {
-        if (!this._stop) {
-            const table = getOptionalSource(CacheProvider, this.provider)?.memory.getTable(this.collection);
-            if (table)
-                this._stop = runSequence(this.through(table.getCachedItemSequence(this.id)));
-        }
-    }
-    /** Stop subscription to `MemoryProvider` if there is one. */
-    stop() {
-        if (this._stop)
-            this._stop = void call(this._stop);
-    }
-    _stop = undefined;
-    // Implement `Disposable`
-    [Symbol.dispose]() {
-        this.stop();
-    }
 }

package/db/MemoryProvider.d.ts

@@ -16,6 +16,7 @@ export declare class MemoryProvider<T extends Database> implements Provider<T> {
     getItemTime<K extends DataKey<T>>(collection: K, id: string): number | undefined;
     getItem<K extends DataKey<T>>(collection: K, id: string): OptionalItem<T[K]>;
     getItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<OptionalItem<T[K]>>;
+    getCachedItemSequence<K extends DataKey<T>>(collection: K, id: string): AsyncIterable<OptionalItem<T[K]>>;
     addItem<K extends DataKey<T>>(collection: K, data: T[K]): string;
     setItem<K extends DataKey<T>>(collection: K, id: string, data: T[K]): void;
     setItemSequence<K extends DataKey<T>>(collection: K, id: string, sequence: AsyncIterable<OptionalItem<T[K]>>): AsyncIterable<OptionalItem<T[K]>>;
@@ -25,6 +26,7 @@ export declare class MemoryProvider<T extends Database> implements Provider<T> {
     countQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): number;
     getQuery<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): Items<T[K]>;
     getQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
+    getCachedQuerySequence<K extends DataKey<T>>(collection: K, query?: ItemQuery<T[K]>): AsyncIterable<Items<T[K]>>;
     setQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, data: T[K]): void;
     updateQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>, updates: Updates<T[K]>): void;
     deleteQuery<K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>): void;

package/db/MemoryProvider.js

@@ -27,6 +27,9 @@ export class MemoryProvider {
     getItemSequence(collection, id) {
         return this.getTable(collection).getItemSequence(id);
     }
+    getCachedItemSequence(collection, id) {
+        return this.getTable(collection).getCachedItemSequence(id);
+    }
     addItem(collection, data) {
         return this.getTable(collection).addItem(data);
     }
@@ -54,6 +57,9 @@ export class MemoryProvider {
     getQuerySequence(collection, query) {
         return this.getTable(collection).getQuerySequence(query);
     }
+    getCachedQuerySequence(collection, query) {
+        return this.getTable(collection).getCachedQuerySequence(query);
+    }
     setQuery(collection, query, data) {
         return this.getTable(collection).setQuery(query, data);
     }

package/db/QueryStore.d.ts

@@ -3,9 +3,9 @@ import type { StopCallback } from "../util/callback.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { Item, ItemQuery, Items, OptionalItem } from "../util/item.js";
 import { BooleanStore } from "../store/BooleanStore.js";
-import { Store } from "../store/Store.js";
+import { LazyStore } from "../store/LazyStore.js";
 /** Store a set of multiple items. */
-export declare class QueryStore<T extends Database, K extends DataKey<T>> extends Store<Items<T[K]>> implements Iterable<Item<T[K]>> {
+export declare class QueryStore<T extends Database, K extends DataKey<T>> extends LazyStore<Items<T[K]>> implements Iterable<Item<T[K]>> {
     readonly provider: AbstractProvider<T>;
     readonly collection: K;
     readonly query: ItemQuery<T[K]>;
@@ -40,13 +40,5 @@ export declare class QueryStore<T extends Database, K extends DataKey<T>> extend
      */
     loadMore(): void;
     private _loadMore;
-    [Symbol.asyncIterator](): AsyncGenerator<Items<T[K]>, void, void>;
-    private _iterating;
-    /** Start subscription to `MemoryProvider` if there is one. */
-    start(): void;
-    /** Stop subscription to `MemoryProvider` if there is one. */
-    stop(): void;
-    private _stop;
-    [Symbol.dispose](): void;
     [Symbol.iterator](): Iterator<Item<T[K]>>;
 }

package/db/QueryStore.js

@@ -1,14 +1,14 @@
 import { BooleanStore } from "../store/BooleanStore.js";
-import { Store } from "../store/Store.js";
+import { LazyStore } from "../store/LazyStore.js";
 import { getFirstItem, getLastItem, getOptionalFirstItem, getOptionalLastItem } from "../util/array.js";
-import { call } from "../util/callback.js";
 import { NONE } from "../util/constants.js";
+import { BLACKHOLE } from "../util/function.js";
 import { getAfterQuery, getLimit } from "../util/query.js";
 import { runSequence } from "../util/sequence.js";
 import { getOptionalSource } from "../util/source.js";
 import { CacheProvider } from "./CacheProvider.js";
 /** Store a set of multiple items. */
-export class QueryStore extends Store {
+export class QueryStore extends LazyStore {
     provider;
     collection;
     query;
@@ -44,16 +44,16 @@ export class QueryStore extends Store {
         return this.value.length;
     }
     constructor(provider, collection, query) {
-        const memory = getOptionalSource(CacheProvider, provider)?.memory;
-        const time = memory?.getQueryTime(collection, query);
-        const value = memory?.getQuery(collection, query) || NONE; // Always use any matching items currently in the memory store (this might update when we call `refresh()` below).
-        super(value, time);
+        const cache = getOptionalSource(CacheProvider, provider);
+        const time = cache?.getCachedQueryTime(collection, query);
+        const value = cache?.getCachedQuery(collection, query) || NONE; // Always use any matching items currently in the cache (this might update when we call `refresh()` below).
+        super(store => (cache ? runSequence(store.through(cache.getCachedQuerySequence(collection, query))) : BLACKHOLE), value, time);
         this.provider = provider;
         this.collection = collection;
         this.query = query;
         this.limit = getLimit(query) ?? Infinity;
-        // Queue a request to refresh the value if it doesn't exist.
-        if (typeof time !== "number")
+        // Start loading the value from the provider if it doesn't exist.
+        if (this.loading)
             this.refresh();
     }
     /** Refresh this store from the source provider. */
@@ -110,38 +110,6 @@ export class QueryStore extends Store {
             this.busy.value = false;
         }
     }
-    // Override to subscribe to `MemoryProvider` while things are iterating over this store.
-    async *[Symbol.asyncIterator]() {
-        this.start();
-        this._iterating++;
-        try {
-            yield* super[Symbol.asyncIterator]();
-        }
-        finally {
-            this._iterating--;
-            if (this._iterating < 1)
-                this.stop();
-        }
-    }
-    _iterating = 0;
-    /** Start subscription to `MemoryProvider` if there is one. */
-    start() {
-        if (!this._stop) {
-            const table = getOptionalSource(CacheProvider, this.provider)?.memory.getTable(this.collection);
-            if (table)
-                this._stop = runSequence(this.through(table.getCachedQuerySequence(this.query)));
-        }
-    }
-    /** Stop subscription to `MemoryProvider` if there is one. */
-    stop() {
-        if (this._stop)
-            this._stop = void call(this._stop);
-    }
-    _stop = undefined;
-    // Implement `Disposable`
-    [Symbol.dispose]() {
-        this.stop();
-    }
     // Implement `Iteratable`
     [Symbol.iterator]() {
         return this.value.values();

package/firestore/server/FirestoreServerProvider.js

@@ -78,7 +78,8 @@ export class FirestoreServerProvider {
     getItemSequence(c, id) {
         const ref = _getCollection(this._firestore, c).doc(id);
         return new LazyDeferredSequence(sequence => ref.onSnapshot(snapshot => sequence.resolve(_getOptionalItem(snapshot)), //
-        sequence.reject));
+        //
+        reason => sequence.reject(reason)));
     }
     async addItem(c, data) {
         return (await _getCollection(this._firestore, c).add(data)).id;
@@ -102,7 +103,8 @@ export class FirestoreServerProvider {
     getQuerySequence(c, q) {
         const ref = _getQuery(this._firestore, c, q);
         return new LazyDeferredSequence(sequence => ref.onSnapshot(snapshot => sequence.resolve(_getItemArray(snapshot)), //
-        sequence.reject));
+        //
+        reason => sequence.reject(reason)));
     }
     async setQuery(c, q, data) {
         return await bulkWrite(this._firestore, c, q, (w, s) => void w.set(s.ref, data));

package/markup/rule.d.ts

@@ -27,22 +27,37 @@ export interface MarkupRule {
     /** Match an input string against this and return an element if there was a match. */
     match(input: string, options: MarkupOptions): MarkupElement | undefined;
 }
-export declare function getMarkupRule<T extends string = string>(regexp: TypedRegExp<T>, //
-render: (props: TypedRegExpExecArray<T>, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, priority?: number): MarkupRule & {
-    regexp: TypedRegExp<T>;
-};
-export declare function getNamedMarkupRule<T extends NamedRegExpData>(regexp: NamedRegExp<T>, //
-render: (data: T, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, priority?: number): MarkupRule & {
-    regexp: NamedRegExp<T>;
-};
-export declare function getLinkMarkupRule(regexp: NamedRegExp<{
-    title?: string;
-    href: string;
-}>, //
-render: (title: string, href: string, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, priority?: number): MarkupRule & {
-    regexp: NamedRegExp<{
+export declare class RegExpMarkupRule<T extends string = string> implements MarkupRule {
+    readonly regexp: TypedRegExp<T>;
+    readonly render: (props: TypedRegExpExecArray<T>, options: MarkupOptions) => JSXElement;
+    readonly contexts: ImmutableArray<string>;
+    readonly priority?: number | undefined;
+    constructor(regexp: TypedRegExp<T>, //
+    render: (props: TypedRegExpExecArray<T>, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, priority?: number | undefined);
+    match(input: string, options: MarkupOptions): MarkupElement | undefined;
+}
+export declare class NamedRegExpMarkupRule<T extends NamedRegExpData> implements MarkupRule {
+    readonly regexp: NamedRegExp<T>;
+    readonly render: (data: T, options: MarkupOptions) => JSXElement;
+    readonly contexts: ImmutableArray<string>;
+    readonly priority?: number | undefined;
+    constructor(regexp: NamedRegExp<T>, //
+    render: (data: T, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, priority?: number | undefined);
+    match(input: string, options: MarkupOptions): MarkupElement | undefined;
+}
+export declare class LinkRegExpMarkupRule implements MarkupRule {
+    readonly regexp: NamedRegExp<{
         title?: string;
         href: string;
     }>;
-};
+    readonly render: (title: string, href: string, options: MarkupOptions) => JSXElement;
+    readonly contexts: ImmutableArray<string>;
+    readonly priority?: number | undefined;
+    constructor(regexp: NamedRegExp<{
+        title?: string;
+        href: string;
+    }>, //
+    render: (title: string, href: string, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, priority?: number | undefined);
+    match(input: string, options: MarkupOptions): MarkupElement | undefined;
+}
 export type MarkupRules = MarkupRule[];

package/markup/rule.js

@@ -1,49 +1,67 @@
 import { formatURL, getOptionalURL } from "../util/url.js";
-export function getMarkupRule(regexp, //
-render, contexts, priority) {
-    return {
-        regexp,
-        match(input, options) {
-            const match = regexp.exec(input);
-            if (match) {
-                const { index, 0: { length }, } = match;
-                return { index, length, ...render(match, options) };
-            }
-        },
-        contexts,
-        priority,
-    };
+export class RegExpMarkupRule {
+    regexp;
+    render;
+    contexts;
+    priority;
+    constructor(regexp, //
+    render, contexts, priority) {
+        this.regexp = regexp;
+        this.render = render;
+        this.contexts = contexts;
+        this.priority = priority;
+        //
+    }
+    match(input, options) {
+        const match = this.regexp.exec(input);
+        if (match) {
+            const { index, 0: { length }, } = match;
+            return { index, length, ...this.render(match, options) };
+        }
+    }
 }
-export function getNamedMarkupRule(regexp, //
-render, contexts, priority) {
-    return {
-        regexp,
-        match(input, options) {
-            const match = regexp.exec(input);
-            if (match) {
-                const { index, 0: { length }, groups, } = match;
-                return { index, length, ...render(groups, options) };
-            }
-        },
-        contexts,
-        priority,
-    };
+export class NamedRegExpMarkupRule {
+    regexp;
+    render;
+    contexts;
+    priority;
+    constructor(regexp, //
+    render, contexts, priority) {
+        this.regexp = regexp;
+        this.render = render;
+        this.contexts = contexts;
+        this.priority = priority;
+        //
+    }
+    match(input, options) {
+        const match = this.regexp.exec(input);
+        if (match) {
+            const { index, 0: { length }, groups, } = match;
+            return { index, length, ...this.render(groups, options) };
+        }
+    }
 }
-export function getLinkMarkupRule(regexp, //
-render, contexts, priority) {
-    return {
-        regexp,
-        match(input, options) {
-            const match = this.regexp.exec(input);
-            if (match) {
-                const { schemes, url: base } = options;
-                const { 0: { length }, index, groups: { href, title }, } = match;
-                const url = getOptionalURL(href, base);
-                if (url && schemes.includes(url.protocol))
-                    return { index, length, ...render(title?.trim() || formatURL(url), url.href, options) };
-            }
-        },
-        contexts,
-        priority,
-    };
+export class LinkRegExpMarkupRule {
+    regexp;
+    render;
+    contexts;
+    priority;
+    constructor(regexp, //
+    render, contexts, priority) {
+        this.regexp = regexp;
+        this.render = render;
+        this.contexts = contexts;
+        this.priority = priority;
+        //
+    }
+    match(input, options) {
+        const match = this.regexp.exec(input);
+        if (match) {
+            const { schemes, url: base } = options;
+            const { 0: { length }, index, groups: { href, title }, } = match;
+            const url = getOptionalURL(href, base);
+            if (url && schemes.includes(url.protocol))
+                return { index, length, ...this.render(title?.trim() || formatURL(url), url.href, options) };
+        }
+    }
 }

package/markup/rules.d.ts

@@ -1,18 +1,16 @@
 import type { MarkupOptions } from "./options.js";
 import type { MarkupRules } from "./rule.js";
-import type { NamedRegExp } from "../util/regexp.js";
+import { LinkRegExpMarkupRule, NamedRegExpMarkupRule, RegExpMarkupRule } from "./rule.js";
 /**
  * Headings are single line only (don't allow multiline).
  * - 1-6 hashes then 1+ spaces, then the title.
  * - Same as Markdown syntax.
  * - Markdown's underline syntax is not supported (for simplification).
  */
-export declare const HEADING_RULE: import("./rule.js").MarkupRule & {
-    regexp: NamedRegExp<{
-        prefix: string;
-        heading: string;
-    }>;
-};
+export declare const HEADING_RULE: NamedRegExpMarkupRule<{
+    prefix: string;
+    heading: string;
+}>;
 /**
  * Separator (horizontal rule / thematic break).
  * - Same as Markdown syntax but also allows `•` bullet character (in addition to `-` dash, `+` plus, `*` asterisk, `_` underscore).
@@ -20,24 +18,16 @@ export declare const HEADING_RULE: import("./rule.js").MarkupRule & {
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
-export declare const SEPARATOR_RULE: import("./rule.js").MarkupRule & {
-    regexp: import("../util/regexp.js").TypedRegExp<string>;
-};
-export declare const UNORDERED_RULE: import("./rule.js").MarkupRule & {
-    regexp: NamedRegExp<{
-        list: string;
-    }>;
-};
-export declare const ORDERED_RULE: import("./rule.js").MarkupRule & {
-    regexp: NamedRegExp<{
-        list: string;
-    }>;
-};
-export declare const BLOCKQUOTE_RULE: import("./rule.js").MarkupRule & {
-    regexp: NamedRegExp<{
-        quote: string;
-    }>;
-};
+export declare const SEPARATOR_RULE: RegExpMarkupRule<string>;
+export declare const UNORDERED_RULE: NamedRegExpMarkupRule<{
+    list: string;
+}>;
+export declare const ORDERED_RULE: NamedRegExpMarkupRule<{
+    list: string;
+}>;
+export declare const BLOCKQUOTE_RULE: NamedRegExpMarkupRule<{
+    quote: string;
+}>;
 /**
  * Fenced code blocks
  * - Same as Markdown syntax.
@@ -45,22 +35,18 @@ export declare const BLOCKQUOTE_RULE: import("./rule.js").MarkupRule & {
  * - If there's no closing fence the code block will run to the end of the current string.
  * - Markdown-style four-space indent syntax is not supported (only fenced code, since it's easier to use).
  */
-export declare const FENCED_CODE_RULE: import("./rule.js").MarkupRule & {
-    regexp: NamedRegExp<{
-        wrap: string;
-        title?: string;
-        code: string;
-    }>;
-};
+export declare const FENCED_CODE_RULE: NamedRegExpMarkupRule<{
+    wrap: string;
+    title?: string;
+    code: string;
+}>;
 /**
  * Paragraph.
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
-export declare const PARAGRAPH_RULE: import("./rule.js").MarkupRule & {
-    regexp: NamedRegExp<{
-        paragraph: string;
-    }>;
-};
+export declare const PARAGRAPH_RULE: NamedRegExpMarkupRule<{
+    paragraph: string;
+}>;
 /** Render function for URL and LINK rules. */
 export declare function renderLinkRule(title: string, href: string, { rel }: MarkupOptions): {
     type: string;
@@ -81,12 +67,7 @@ export declare function renderLinkRule(title: string, href: string, { rel }: Mar
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
-export declare const URL_RULE: import("./rule.js").MarkupRule & {
-    regexp: NamedRegExp<{
-        title?: string;
-        href: string;
-    }>;
-};
+export declare const URL_RULE: LinkRegExpMarkupRule;
 /**
  * Markdown-style link.
  * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
@@ -95,12 +76,7 @@ export declare const URL_RULE: import("./rule.js").MarkupRule & {
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only `http://` or `https://` links will work (if invalid the unparsed text will be returned).
  */
-export declare const LINK_RULE: import("./rule.js").MarkupRule & {
-    regexp: NamedRegExp<{
-        title?: string;
-        href: string;
-    }>;
-};
+export declare const LINK_RULE: LinkRegExpMarkupRule;
 /**
  * Inline code.
  * - Text surrounded by one or more "`" backtick tilde characters.
@@ -108,11 +84,9 @@ export declare const LINK_RULE: import("./rule.js").MarkupRule & {
  * - Closing characters must exactly match opening characters.
  * - Same as Markdown syntax.
  */
-export declare const CODE_RULE: import("./rule.js").MarkupRule & {
-    regexp: NamedRegExp<{
-        code: string;
-    }>;
-};
+export declare const CODE_RULE: NamedRegExpMarkupRule<{
+    code: string;
+}>;
 /**
  * Inline strong, emphasis, insert, delete, highlight.
  * - Inline strong text wrapped in one or more `*` asterisks.
@@ -135,13 +109,11 @@ declare const INLINE_CHARS: {
     "=": string;
     ":": string;
 };
-export declare const INLINE_RULE: import("./rule.js").MarkupRule & {
-    regexp: NamedRegExp<{
-        char: keyof typeof INLINE_CHARS;
-        wrap: string;
-        text: string;
-    }>;
-};
+export declare const INLINE_RULE: NamedRegExpMarkupRule<{
+    char: keyof typeof INLINE_CHARS;
+    wrap: string;
+    text: string;
+}>;
 /**
  * Hard linebreak (`<br />` tag).
  * - Any line break in a paragraph will become a hard `<br />` tag.
@@ -150,9 +122,7 @@ export declare const INLINE_RULE: import("./rule.js").MarkupRule & {
  *   - This is more intuitive (a linebreak becomes a linebreak is isn't silently ignored).
  *   - This works better with textareas that wrap text (since manually breaking up long lines is no longer necessary).
  */
-export declare const LINEBREAK_RULE: import("./rule.js").MarkupRule & {
-    regexp: import("../util/regexp.js").TypedRegExp<string>;
-};
+export declare const LINEBREAK_RULE: RegExpMarkupRule<string>;
 /**
  * All markup rules.
  * - Syntax parsed by `renderMarkup()` is defined entirely by the list of rules (i.e. not by code).

package/markup/rules.js

@@ -1,6 +1,6 @@
 import { getRegExp } from "../util/regexp.js";
 import { BLOCK_REGEXP, LINE_REGEXP, WordRegExp, getBlockRegExp, getLineRegExp } from "./regexp.js";
-import { getLinkMarkupRule, getMarkupRule, getNamedMarkupRule } from "./rule.js";
+import { LinkRegExpMarkupRule, NamedRegExpMarkupRule, RegExpMarkupRule } from "./rule.js";
 /** React security symbol — see https://github.com/facebook/react/pull/4832 */
 const $$typeof = Symbol.for("react.element");
 /**
@@ -9,7 +9,7 @@ const $$typeof = Symbol.for("react.element");
  * - Same as Markdown syntax.
  * - Markdown's underline syntax is not supported (for simplification).
  */
-export const HEADING_RULE = getNamedMarkupRule(getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${LINE_REGEXP.source})`), ({ prefix, heading }) => ({
+export const HEADING_RULE = new NamedRegExpMarkupRule(getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${LINE_REGEXP.source})`), ({ prefix, heading }) => ({
     type: `h${prefix.length}`,
     key: null,
     ref: null,
@@ -24,7 +24,7 @@ export const HEADING_RULE = getNamedMarkupRule(getLineRegExp(`(?<prefix>#{1,6})
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
-export const SEPARATOR_RULE = getMarkupRule(getLineRegExp("([-*•+_=])(?: *\\1){2,}"), () => ({
+export const SEPARATOR_RULE = new RegExpMarkupRule(getLineRegExp("([-*•+_=])(?: *\\1){2,}"), () => ({
     type: "hr",
     key: null,
     ref: null,
@@ -41,7 +41,7 @@ export const SEPARATOR_RULE = getMarkupRule(getLineRegExp("([-*•+_=])(?: *\\1)
 const UNORDERED_PREFIX = "[-*•+] +";
 const UNORDERED_SPLIT = new RegExp(`(?:^|\n)+${UNORDERED_PREFIX}`, "g");
 const UNORDERED_INDENT = /^\t/gm;
-export const UNORDERED_RULE = getNamedMarkupRule(getBlockRegExp(`(?<list>${UNORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
+export const UNORDERED_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<list>${UNORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
     type: "ul",
     key: null,
     ref: null,
@@ -64,7 +64,7 @@ const _mapUnordered = (item, key) => ({
 const ORDERED_PREFIX = "[1-9][0-9]{0,8}[.):] +"; // Number for a numbered list, e.g. `1.` or `2)` or `3:`
 const ORDERED_SPLIT = new RegExp(`\n+(?=${ORDERED_PREFIX})`, "g");
 const ORDERED_INDENT = UNORDERED_INDENT;
-export const ORDERED_RULE = getNamedMarkupRule(getBlockRegExp(`(?<list>${ORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
+export const ORDERED_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<list>${ORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
     type: "ol",
     key: null,
     ref: null,
@@ -93,7 +93,7 @@ const _mapOrdered = (item, key) => ({
  */
 const BLOCKQUOTE_PREFIX = "> *";
 const BLOCKQUOTE_INDENT = new RegExp(`^${BLOCKQUOTE_PREFIX}`, "gm");
-export const BLOCKQUOTE_RULE = getNamedMarkupRule(getLineRegExp(`(?<quote>${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source}(?:\n${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source})*)`), ({ quote }) => ({
+export const BLOCKQUOTE_RULE = new NamedRegExpMarkupRule(getLineRegExp(`(?<quote>${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source}(?:\n${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source})*)`), ({ quote }) => ({
     type: "blockquote",
     key: null,
     ref: null,
@@ -108,7 +108,7 @@ export const BLOCKQUOTE_RULE = getNamedMarkupRule(getLineRegExp(`(?<quote>${BLOC
  * - If there's no closing fence the code block will run to the end of the current string.
  * - Markdown-style four-space indent syntax is not supported (only fenced code, since it's easier to use).
  */
-export const FENCED_CODE_RULE = getNamedMarkupRule(
+export const FENCED_CODE_RULE = new NamedRegExpMarkupRule(
 // Matcher has its own end that only stops when it reaches a matching closing fence or the end of the string.
 getLineRegExp(`(?<wrap>\`{3,}|~{3,}) *(?<title>${LINE_REGEXP.source})\n(?<code>${BLOCK_REGEXP.source})`, `(?:\n\\k<wrap>|$)`), ({ title, code }) => ({
     type: "pre",
@@ -129,7 +129,7 @@ getLineRegExp(`(?<wrap>\`{3,}|~{3,}) *(?<title>${LINE_REGEXP.source})\n(?<code>$
  * Paragraph.
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
-export const PARAGRAPH_RULE = getNamedMarkupRule(getBlockRegExp(`(?<paragraph>${BLOCK_REGEXP.source})`), ({ paragraph }) => ({
+export const PARAGRAPH_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<paragraph>${BLOCK_REGEXP.source})`), ({ paragraph }) => ({
     type: `p`,
     key: null,
     ref: null,
@@ -155,7 +155,7 @@ export function renderLinkRule(title, href, { rel }) {
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
-export const URL_RULE = getLinkMarkupRule(getRegExp(/(?<href>[a-z]+:[-$_@.&!*,=;/#?:%a-zA-Z0-9]+)(?: +(?:\((?<title>[^)]*?)\)))?/), //
+export const URL_RULE = new LinkRegExpMarkupRule(getRegExp(/(?<href>[a-z]+:[-$_@.&!*,=;/#?:%a-zA-Z0-9]+)(?: +(?:\((?<title>[^)]*?)\)))?/), //
 renderLinkRule, ["inline", "list"]);
 /**
  * Markdown-style link.
@@ -165,7 +165,7 @@ renderLinkRule, ["inline", "list"]);
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
  * - For security only `http://` or `https://` links will work (if invalid the unparsed text will be returned).
  */
-export const LINK_RULE = getLinkMarkupRule(getRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/), //
+export const LINK_RULE = new LinkRegExpMarkupRule(getRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/), //
 renderLinkRule, ["inline", "list"]);
 /**
  * Inline code.
@@ -174,7 +174,7 @@ renderLinkRule, ["inline", "list"]);
  * - Closing characters must exactly match opening characters.
  * - Same as Markdown syntax.
  */
-export const CODE_RULE = getNamedMarkupRule(new RegExp(`(?<wrap>\`+)(?<code>${BLOCK_REGEXP.source})\\k<wrap>`), ({ code }) => ({
+export const CODE_RULE = new NamedRegExpMarkupRule(new RegExp(`(?<wrap>\`+)(?<code>${BLOCK_REGEXP.source})\\k<wrap>`), ({ code }) => ({
     type: "code",
     key: null,
     ref: null,
@@ -195,7 +195,7 @@ export const CODE_RULE = getNamedMarkupRule(new RegExp(`(?<wrap>\`+)(?<code>${BL
  * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
  */
 const INLINE_CHARS = { "-": "del", "~": "del", "+": "ins", "*": "strong", "_": "em", "=": "mark", ":": "mark" }; // Hyphen must be first so it works when we use the keys as a character class.
-export const INLINE_RULE = getNamedMarkupRule(new WordRegExp(`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}])+)(?<text>(?!\\k<char>)\\S|(?!\\k<char>)\\S[\\s\\S]*?(?!\\k<char>)\\S)\\k<wrap>`), // prettier-ignore
+export const INLINE_RULE = new NamedRegExpMarkupRule(new WordRegExp(`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}])+)(?<text>(?!\\k<char>)\\S|(?!\\k<char>)\\S[\\s\\S]*?(?!\\k<char>)\\S)\\k<wrap>`), // prettier-ignore
 ({ char, text }) => ({
     type: INLINE_CHARS[char],
     key: null,
@@ -212,7 +212,7 @@ export const INLINE_RULE = getNamedMarkupRule(new WordRegExp(`(?<wrap>(?<char>[$
  *   - This is more intuitive (a linebreak becomes a linebreak is isn't silently ignored).
  *   - This works better with textareas that wrap text (since manually breaking up long lines is no longer necessary).
  */
-export const LINEBREAK_RULE = getMarkupRule(/\n/, () => ({
+export const LINEBREAK_RULE = new RegExpMarkupRule(/\n/, () => ({
     type: "br",
     key: null,
     ref: null,

package/package.json

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

package/react/createDataContext.d.ts

@@ -2,18 +2,27 @@
 import type { AbstractProvider } from "../db/Provider.js";
 import type { DataKey, Database } from "../util/data.js";
 import type { ItemQuery } from "../util/item.js";
+import type { Optional } from "../util/optional.js";
 import { ItemStore } from "../db/ItemStore.js";
 import { QueryStore } from "../db/QueryStore.js";
-import { type Optional } from "../util/optional.js";
-/**
- * Create a data context that can be provided to React elements and allows them to call `useItem()` and `useQuery()`
- */
-export declare function createDataContext<T extends Database>(provider: AbstractProvider<T>): {
-    readonly useItem: <K extends DataKey<T>>(collection: K, id: string) => ItemStore<T, K>;
-    readonly useQuery: <K extends DataKey<T>>(collection: K, query: ItemQuery<T[K]>) => QueryStore<T, K>;
-    readonly useOptionalItem: <K extends DataKey<T>>(collection: Optional<K>, id: Optional<string>) => ItemStore<T, K> | undefined;
-    readonly useOptionalQuery: <K extends DataKey<T>>(collection: Optional<K>, query: Optional<ItemQuery<T[K]>>) => QueryStore<T, K> | undefined;
+export interface DataContext<T extends Database> {
+    /** Get an `ItemStore` for the specified collection item in the current `DataProvider` context. */
+    useCacheItem<K extends DataKey<T>>(this: void, collection: K, id: string): ItemStore<T, K>;
+    useCacheItem<K extends DataKey<T>>(this: void, collection: Optional<K>, id: Optional<string>): ItemStore<T, K> | undefined;
+    /** Get an `QueryStore` for the specified collection query in the current `DataProvider` context. */
+    useCacheQuery<K extends DataKey<T>>(this: void, collection: K, query: ItemQuery<T[K]>): QueryStore<T, K>;
+    useCacheQuery<K extends DataKey<T>>(this: void, collection: Optional<K>, query: Optional<ItemQuery<T[K]>>): QueryStore<T, K> | undefined;
+    /** Get an `ItemStore` for the specified collection item in the current `DataProvider` context and subscribe to any changes in it. */
+    useItem<K extends DataKey<T>>(this: void, collection: K, id: string): ItemStore<T, K>;
+    useItem<K extends DataKey<T>>(this: void, collection: Optional<K>, id: Optional<string>): ItemStore<T, K> | undefined;
+    /** Get an `QueryStore` for the specified collection query in the current `DataProvider` context and subscribe to any changes in it. */
+    useQuery<K extends DataKey<T>>(this: void, collection: K, query: ItemQuery<T[K]>): QueryStore<T, K>;
+    useQuery<K extends DataKey<T>>(this: void, collection: Optional<K>, query: Optional<ItemQuery<T[K]>>): QueryStore<T, K> | undefined;
     readonly DataProvider: ({ children }: {
         children: React.ReactNode;
     }) => React.ReactElement;
-};
+}
+/**
+ * Create a data context that can be provided to React elements and allows them to call `useItem()` and `useQuery()`
+ */
+export declare function createDataContext<T extends Database>(provider: AbstractProvider<T>): DataContext<T>;

package/react/createDataContext.js

@@ -1,7 +1,6 @@
 import { ItemStore } from "../db/ItemStore.js";
 import { QueryStore } from "../db/QueryStore.js";
 import { setMapItem } from "../util/map.js";
-import { getRequired } from "../util/optional.js";
 import { createCacheContext } from "./createCacheContext.js";
 import { useStore } from "./useStore.js";
 /**
@@ -9,21 +8,21 @@ import { useStore } from "./useStore.js";
  */
 export function createDataContext(provider) {
     const { CacheProvider, useCache } = createCacheContext(); // eslint-disable-line @typescript-eslint/no-explicit-any
-    const useOptionalItem = (collection, id) => {
+    const useCacheItem = (collection, id) => {
         const cache = useCache();
         const key = collection && id && `${collection}/${id}`;
-        return useStore(key ? cache.get(key) || setMapItem(cache, key, new ItemStore(provider, collection, id)) : undefined);
+        return key ? cache.get(key) || setMapItem(cache, key, new ItemStore(provider, collection, id)) : undefined;
     };
-    const useOptionalQuery = (collection, query) => {
+    const useCacheQuery = (collection, query) => {
         const cache = useCache();
         const key = collection && query && `${collection}?${JSON.stringify(query)}`;
-        return useStore(key ? cache.get(key) || setMapItem(cache, key, new QueryStore(provider, collection, query)) : undefined);
+        return key ? cache.get(key) || setMapItem(cache, key, new QueryStore(provider, collection, query)) : undefined;
     };
     return {
-        useOptionalItem,
-        useOptionalQuery,
-        useItem: (collection, id) => getRequired(useOptionalItem(collection, id)),
-        useQuery: (collection, query) => getRequired(useOptionalQuery(collection, query)),
+        useCacheItem,
+        useCacheQuery,
+        useItem: (collection, id) => useStore(useCacheItem(collection, id)),
+        useQuery: (collection, query) => useStore(useCacheQuery(collection, query)),
         DataProvider: CacheProvider,
     };
 }

package/sequence/DeferredSequence.d.ts

@@ -1,5 +1,4 @@
 import type { Deferred } from "../util/async.js";
-import type { ErrorCallback, ValueCallback } from "../util/callback.js";
 import { AbstractSequence } from "./AbstractSequence.js";
 /**
  * Deferred sequence of values that can be async iterated and new values can be published.
@@ -16,13 +15,13 @@ export declare class DeferredSequence<T = void> extends AbstractSequence<T, void
     /** Get the next promise to be deferred/rejected. */
     get promise(): Promise<T>;
     /** Resolve the current deferred in the sequence. */
-    readonly resolve: ValueCallback<T>;
+    resolve(value: T): void;
     private _nextValue;
     /** Reject the current deferred in the sequence. */
-    readonly reject: ErrorCallback;
+    reject(reason: unknown): void;
     private _nextReason;
     /** Fulfill the current deferred by resolving or rejecting it. */
-    private readonly _fulfill;
+    private _fulfill;
     next(): Promise<IteratorResult<T, void>>;
     then<X = T, Y = never>(onNext?: (v: T) => X | PromiseLike<X>, onError?: (r: unknown) => Y | PromiseLike<Y>): Promise<X | Y>;
     catch<Y>(onError: (r: unknown) => Y | PromiseLike<Y>): Promise<T | Y>;

package/sequence/DeferredSequence.js

@@ -19,21 +19,21 @@ export class DeferredSequence extends AbstractSequence {
         return (this._deferred ||= getDeferred()).promise;
     }
     /** Resolve the current deferred in the sequence. */
-    resolve = value => {
+    resolve(value) {
         this._nextValue = value;
         this._nextReason = _NOVALUE;
-        queueMicrotask(this._fulfill);
-    };
+        queueMicrotask(() => this._fulfill());
+    }
     _nextValue = _NOVALUE;
     /** Reject the current deferred in the sequence. */
-    reject = reason => {
+    reject(reason) {
         this._nextValue = _NOVALUE;
         this._nextReason = reason;
-        queueMicrotask(this._fulfill);
-    };
+        queueMicrotask(() => this._fulfill());
+    }
     _nextReason = _NOVALUE;
     /** Fulfill the current deferred by resolving or rejecting it. */
-    _fulfill = () => {
+    _fulfill() {
         const { _deferred, _nextReason, _nextValue } = this;
         this._deferred = undefined;
         this._nextReason = _NOVALUE;
@@ -44,7 +44,7 @@ export class DeferredSequence extends AbstractSequence {
             else if (_nextValue !== _NOVALUE)
                 _deferred.resolve(_nextValue);
         }
-    };
+    }
     // Implement `AsyncIterator`
     async next() {
         return { value: await this.promise };

package/store/LazyStore.d.ts

@@ -0,0 +1,17 @@
+/// <reference types="node" resolution-mode="require"/>
+import type { NONE } from "../util/constants.js";
+import { type StartCallback } from "../util/callback.js";
+import { Store } from "./Store.js";
+/** Store that starts/stops a source subscription when things subscribe to it, and stops when everything has unsubscribed from it. */
+export declare class LazyStore<T> extends Store<T> implements Disposable {
+    constructor(start: StartCallback<Store<T>>, value: T | typeof NONE, time?: number);
+    [Symbol.asyncIterator](): AsyncGenerator<T, void, void>;
+    private _iterating;
+    /** Start subscription to `MemoryProvider` if there is one. */
+    start(): void;
+    private _start;
+    /** Stop subscription to `MemoryProvider` if there is one. */
+    stop(): void;
+    private _stop;
+    [Symbol.dispose](): void;
+}

package/store/LazyStore.js

@@ -0,0 +1,39 @@
+import { call } from "../util/callback.js";
+import { Store } from "./Store.js";
+/** Store that starts/stops a source subscription when things subscribe to it, and stops when everything has unsubscribed from it. */
+export class LazyStore extends Store {
+    constructor(start, value, time) {
+        super(value, time);
+        this._start = start;
+    }
+    // Override to subscribe to start/stop the source subscription when things subscribe to this.
+    async *[Symbol.asyncIterator]() {
+        this.start();
+        this._iterating++;
+        try {
+            yield* super[Symbol.asyncIterator]();
+        }
+        finally {
+            this._iterating--;
+            if (this._iterating < 1)
+                this.stop();
+        }
+    }
+    _iterating = 0;
+    /** Start subscription to `MemoryProvider` if there is one. */
+    start() {
+        if (!this._stop)
+            this._stop = this._start(this);
+    }
+    _start;
+    /** Stop subscription to `MemoryProvider` if there is one. */
+    stop() {
+        if (this._stop)
+            this._stop = void call(this._stop);
+    }
+    _stop = undefined;
+    // Implement `Disposable`
+    [Symbol.dispose]() {
+        this.stop();
+    }
+}

package/store/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./Store.js";
+export * from "./LazyStore.js";
 export * from "./ArrayStore.js";
 export * from "./BooleanStore.js";
 export * from "./DataStore.js";

package/store/index.js

@@ -1,4 +1,5 @@
 export * from "./Store.js";
+export * from "./LazyStore.js";
 export * from "./ArrayStore.js";
 export * from "./BooleanStore.js";
 export * from "./DataStore.js";