shelving 1.51.3 → 1.53.0

package/db/Database.js

@@ -168,9 +168,9 @@ export class DatabaseQuery extends Query {
 }
 /** Get the data for a document from a result for that document. */
 export function getQueryData(entries, ref) {
-    const first = getFirstItem(entries);
-    if (first)
-        return getDocumentData(first[1], ref.doc(first[0]));
+    const data = getQueryResult(entries, ref);
+    if (data)
+        return data;
     throw new QueryRequiredError(ref);
 }
 /** Get the data for a document from a result for that document. */
@@ -178,7 +178,7 @@ export function getQueryResult(entries, ref) {
     const first = getFirstItem(entries);
     if (first)
         return getDocumentData(first[1], ref.doc(first[0]));
-    throw new QueryRequiredError(ref);
+    return null;
 }
 /** A document reference within a specific database. */
 export class DatabaseDocument {

package/db/errors.d.ts

@@ -7,16 +7,16 @@ export declare class DocumentRequiredError<T extends Data> extends RequiredError
     ref: DatabaseDocument<T>;
     constructor(ref: DatabaseDocument<T>);
 }
-/** Thrown if a query doesn't exist. */
-export declare class QueryRequiredError<T extends Data> extends RequiredError {
-    ref: DatabaseQuery<T>;
-    constructor(ref: DatabaseQuery<T>);
-}
 /** Thrown if a document can't validate. */
 export declare class DocumentValidationError<T extends Data> extends ValidationError {
     ref: DatabaseDocument<T>;
     constructor(ref: DatabaseDocument<T>, feedback: Feedback);
 }
+/** Thrown if a query doesn't exist. */
+export declare class QueryRequiredError<T extends Data> extends RequiredError {
+    ref: DatabaseQuery<T>;
+    constructor(ref: DatabaseQuery<T>);
+}
 /** Thrown if a query can't validate a set of results. */
 export declare class QueryValidationError<T extends Data> extends ValidationError {
     ref: DatabaseQuery<T>;

package/db/errors.js

@@ -2,27 +2,27 @@ import { RequiredError, ValidationError } from "../error/index.js";
 /** Thrown if a document doesn't exist. */
 export class DocumentRequiredError extends RequiredError {
     constructor(ref) {
-        super(`Document "${ref.toString()}" does not exist`);
+        super(`Document ${ref.toString()} does not exist`);
         this.ref = ref;
     }
 }
 DocumentRequiredError.prototype.name = "DocumentRequiredError";
-/** Thrown if a query doesn't exist. */
-export class QueryRequiredError extends RequiredError {
-    constructor(ref) {
-        super(`Query "${ref.toString()}" has no results`);
-        this.ref = ref;
-    }
-}
-QueryRequiredError.prototype.name = "QueryRequiredError";
 /** Thrown if a document can't validate. */
 export class DocumentValidationError extends ValidationError {
     constructor(ref, feedback) {
-        super(`Invalid data for "${ref.toString()}"`, feedback);
+        super(`Invalid data for ${ref.toString()}`, feedback);
         this.ref = ref;
     }
 }
 DocumentValidationError.prototype.name = "DocumentValidationError";
+/** Thrown if a query doesn't exist. */
+export class QueryRequiredError extends RequiredError {
+    constructor(ref) {
+        super(`Query ${ref.toString()} has no results`);
+        this.ref = ref;
+    }
+}
+QueryRequiredError.prototype.name = "QueryRequiredError";
 /** Thrown if a query can't validate a set of results. */
 export class QueryValidationError extends ValidationError {
     constructor(ref, feedback) {

package/markup/rules.d.ts

@@ -38,7 +38,7 @@ export declare const FENCED_CODE_RULE: MarkupRule;
 export declare const PARAGRAPH_RULE: MarkupRule;
 /**
  * Markdown-style link.
- * - Link in standard Markdown format, e.g. `[http://google.com/maps](Google Maps)`
+ * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
  * - If no title is specified a cleaned up version of the URL will be used, e.g. `google.com/maps`
  * - Does not need space before/after the link.
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
@@ -46,11 +46,11 @@ export declare const PARAGRAPH_RULE: MarkupRule;
  */
 export declare const LINK_RULE: MarkupRule;
 /**
- * Autolinked URL starts with `http:` or `https:` and matches an unlimited number of non-space characters.
+ * Autolinked URL starts with `http:` or `https:` or `mailto:` (any scheme in `options.schemes`) and matches an unlimited number of non-space characters.
  * - If followed by space and then text in `()` round or `[]` square brackets that will be used as the title, e.g. `http://google.com/maps (Google Maps)` or `http://google.com/maps [Google Maps]` (this syntax is from Todoist and maybe other things too).
  * - If no title is specified a cleaned up version of the URL will be used, e.g. `google.com/maps`
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
- * - For security only schemes that appear in the `options.schemes` will match (defaults to `http:` and `https:`).
+ * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
 export declare const AUTOLINK_RULE: MarkupRule;
 /**

package/markup/rules.js

@@ -127,58 +127,62 @@ export const PARAGRAPH_RULE = {
 };
 /**
  * Markdown-style link.
- * - Link in standard Markdown format, e.g. `[http://google.com/maps](Google Maps)`
+ * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
  * - If no title is specified a cleaned up version of the URL will be used, e.g. `google.com/maps`
  * - Does not need space before/after the link.
  * - 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 = {
-    // Custom matcher to check the URL against the allowed schemes.
     regexp: /\[([^\]]*?)\]\(([^)]*?)\)/,
+    // Custom matcher to check the URL against the allowed schemes.
     match: (content, { schemes, url: base }) => {
         const matches = content.match(LINK_RULE.regexp);
-        if (matches && typeof matches.index === "number") {
+        if (matches) {
             const [, title = "", href = ""] = matches;
             const url = toURL(href, base);
             if (url && url.protocol && schemes.includes(url.protocol)) {
                 matches[1] = title.trim();
-                matches[2] = url.href; // Use fixed URL from `new URL`
+                matches[2] = url.href;
                 return matches;
             }
         }
     },
-    render: ([, title = "", href = ""], { rel }) => ({
-        type: href ? "a" : "span",
+    render: ([, title, href = ""], { rel }) => ({
+        type: "a",
         key: null,
-        props: { children: title || formatUrl(href), href: href || undefined, rel },
+        props: { children: title || formatUrl(href), href, rel },
     }),
     contexts: ["inline", "list"],
     childContext: "link",
 };
 /**
- * Autolinked URL starts with `http:` or `https:` and matches an unlimited number of non-space characters.
+ * Autolinked URL starts with `http:` or `https:` or `mailto:` (any scheme in `options.schemes`) and matches an unlimited number of non-space characters.
  * - If followed by space and then text in `()` round or `[]` square brackets that will be used as the title, e.g. `http://google.com/maps (Google Maps)` or `http://google.com/maps [Google Maps]` (this syntax is from Todoist and maybe other things too).
  * - If no title is specified a cleaned up version of the URL will be used, e.g. `google.com/maps`
  * - If link is not valid (using `new URL(url)` then unparsed text will be returned.
- * - For security only schemes that appear in the `options.schemes` will match (defaults to `http:` and `https:`).
+ * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
 export const AUTOLINK_RULE = {
+    regexp: /([a-z]+:\S+)(?: +(?:\(([^)]*?)\)|\[([^\]]*?)\]))?/,
     // Custom matcher to check the URL against the allowed schemes.
-    regexp: /([a-zA-Z][a-zA-Z0-9-]*[a-zA-Z0-9]:\S+)(?: +(?:\(([^)]*?)\)|\[([^\]]*?)\]))?/,
     match: (content, { schemes, url: base }) => {
         const matches = content.match(AUTOLINK_RULE.regexp);
         if (matches && typeof matches.index === "number") {
-            const [, href = "", title1 = "", title2 = ""] = matches;
+            const [, href = "", roundTitle = "", squareTitle = ""] = matches;
             const url = toURL(href, base);
             if (url && url.protocol && schemes.includes(url.protocol)) {
-                matches[1] = (title1 || title2).trim();
-                matches[2] = url.href;
+                matches[1] = url.href;
+                matches[2] = (roundTitle || squareTitle).trim();
                 return matches;
             }
         }
     },
-    render: LINK_RULE.render,
+    render: ([, href = "", title], { rel }) => ({
+        type: "a",
+        key: null,
+        props: { children: title || formatUrl(href), href, rel },
+    }),
     contexts: ["inline", "list"],
     childContext: "link",
 };

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.51.3",
+	"version": "1.53.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -63,13 +63,13 @@
 		"@types/jest": "^27.4.0",
 		"@types/react": "^17.0.39",
 		"@types/react-dom": "^17.0.11",
-		"@typescript-eslint/eslint-plugin": "^5.11.0",
-		"@typescript-eslint/parser": "^5.11.0",
+		"@typescript-eslint/eslint-plugin": "^5.12.0",
+		"@typescript-eslint/parser": "^5.12.0",
 		"eslint": "^8.9.0",
-		"eslint-config-prettier": "^8.3.0",
+		"eslint-config-prettier": "^8.4.0",
 		"eslint-plugin-import": "^2.25.4",
 		"eslint-plugin-prettier": "^4.0.0",
-		"firebase": "^9.6.6",
+		"firebase": "^9.6.7",
 		"jest": "^27.5.1",
 		"jest-ts-webcompat-resolver": "^1.0.0",
 		"prettier": "^2.5.1",

package/provider/ErrorProvider.d.ts

@@ -0,0 +1,32 @@
+import { DatabaseDocument, DatabaseQuery } from "../db/Database.js";
+import { Update } from "../update/Update.js";
+import { Data, Result } from "../util/data.js";
+import { Entries } from "../util/entry.js";
+import { Observer, Unsubscriber } from "../util/observable.js";
+import { ThroughProvider } from "./ThroughProvider.js";
+/** Provider that wraps errors thrown from deeper providers in `DatabaseReadError` and `DatabaseWriteError` etc to make it easier to see what read/write caused the error. */
+export declare class ErrorProvider extends ThroughProvider {
+    get<T extends Data>(ref: DatabaseDocument<T>): Result<T> | PromiseLike<Result<T>>;
+    subscribe<T extends Data>(ref: DatabaseDocument<T>, observer: Observer<Result<T>>): Unsubscriber;
+    add<T extends Data>(ref: DatabaseQuery<T>, data: T): string | PromiseLike<string>;
+    set<T extends Data>(ref: DatabaseDocument<T>, data: T): void | PromiseLike<void>;
+    update<T extends Data>(ref: DatabaseDocument<T>, updates: Update<T>): void | PromiseLike<void>;
+    delete<T extends Data>(ref: DatabaseDocument<T>): void | PromiseLike<void>;
+    getQuery<T extends Data>(ref: DatabaseQuery<T>): Entries<T> | PromiseLike<Entries<T>>;
+    subscribeQuery<T extends Data>(ref: DatabaseQuery<T>, observer: Observer<Entries<T>>): Unsubscriber;
+    setQuery<T extends Data>(ref: DatabaseQuery<T>, data: T): number | PromiseLike<number>;
+    updateQuery<T extends Data>(ref: DatabaseQuery<T>, updates: Update<T>): number | PromiseLike<number>;
+    deleteQuery<T extends Data>(ref: DatabaseQuery<T>): number | PromiseLike<number>;
+}
+/** Thrown if an error occurs while reading a query. */
+export declare class DatabaseReadError<T extends Data> extends Error {
+    readonly error: Error;
+    readonly ref: DatabaseDocument<T> | DatabaseQuery<T>;
+    constructor(error: Error, ref: DatabaseDocument<T> | DatabaseQuery<T>);
+}
+/** Thrown if an error occurs while writing a document. */
+export declare class DatabaseWriteError<T extends Data> extends Error {
+    readonly error: Error;
+    readonly ref: DatabaseDocument<T> | DatabaseQuery<T>;
+    constructor(error: Error, ref: DatabaseDocument<T> | DatabaseQuery<T>);
+}

package/provider/ErrorProvider.js

@@ -0,0 +1,175 @@
+import { isAsync } from "../index.js";
+import { ThroughObserver } from "../util/observable.js";
+import { ThroughProvider } from "./ThroughProvider.js";
+/** Provider that wraps errors thrown from deeper providers in `DatabaseReadError` and `DatabaseWriteError` etc to make it easier to see what read/write caused the error. */
+export class ErrorProvider extends ThroughProvider {
+    get(ref) {
+        try {
+            const result = super.get(ref);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseReadError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseReadError(err, ref);
+            throw err;
+        }
+    }
+    subscribe(ref, observer) {
+        return super.subscribe(ref, new DatabaseErrorObserver(ref, observer));
+    }
+    add(ref, data) {
+        try {
+            const result = super.add(ref, data);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    set(ref, data) {
+        try {
+            const result = super.set(ref, data);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    update(ref, updates) {
+        try {
+            const result = super.update(ref, updates);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    delete(ref) {
+        try {
+            const result = super.delete(ref);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    getQuery(ref) {
+        try {
+            const results = super.getQuery(ref);
+            return isAsync(results)
+                ? results.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseReadError(err, ref) : err;
+                })
+                : results;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseReadError(err, ref);
+            throw err;
+        }
+    }
+    subscribeQuery(ref, observer) {
+        return super.subscribeQuery(ref, new DatabaseErrorObserver(ref, observer));
+    }
+    setQuery(ref, data) {
+        try {
+            const result = super.setQuery(ref, data);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    updateQuery(ref, updates) {
+        try {
+            const result = super.updateQuery(ref, updates);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+    deleteQuery(ref) {
+        try {
+            const result = super.deleteQuery(ref);
+            return isAsync(result)
+                ? result.then(undefined, err => {
+                    throw err instanceof Error ? new DatabaseWriteError(err, ref) : err;
+                })
+                : result;
+        }
+        catch (err) {
+            if (err instanceof Error)
+                throw new DatabaseWriteError(err, ref);
+            throw err;
+        }
+    }
+}
+/** Thrown if an error occurs while reading a query. */
+export class DatabaseReadError extends Error {
+    constructor(error, ref) {
+        super(`Error reading ${ref.toString()}:\n${error.message}`);
+        this.error = error;
+        this.ref = ref;
+    }
+}
+DatabaseReadError.prototype.name = "DatabaseReadError";
+/** Thrown if an error occurs while writing a document. */
+export class DatabaseWriteError extends Error {
+    constructor(error, ref) {
+        super(`Error writing ${ref.toString()}:\n${error.message}`);
+        this.error = error;
+        this.ref = ref;
+    }
+}
+DatabaseWriteError.prototype.name = "DocumentWriteError";
+/** Observer that wraps errors in subscriptions in `DatabaseReadError` */
+class DatabaseErrorObserver extends ThroughObserver {
+    constructor(ref, target) {
+        super(target);
+        this.ref = ref;
+    }
+    error(error) {
+        super.error(error instanceof Error ? new DatabaseReadError(error, this.ref) : error);
+    }
+}

package/provider/Provider.d.ts

@@ -40,7 +40,7 @@ export declare abstract class Provider {
      *
      * @throws Error If a `Update` was provided but the document does not exist (ideally a `RequiredError` but may be provider-specific).
      */
-    abstract set<T extends Data>(ref: DatabaseDocument<T>, value: T): void | PromiseLike<void>;
+    abstract set<T extends Data>(ref: DatabaseDocument<T>, data: T): void | PromiseLike<void>;
     /**
      * Update the data an existing document.
      *

package/provider/index.d.ts

@@ -4,3 +4,4 @@ export * from "./BatchProvider.js";
 export * from "./MemoryProvider.js";
 export * from "./ValidationProvider.js";
 export * from "./CacheProvider.js";
+export * from "./ErrorProvider.js";

package/provider/index.js

@@ -4,3 +4,4 @@ export * from "./BatchProvider.js";
 export * from "./MemoryProvider.js";
 export * from "./ValidationProvider.js";
 export * from "./CacheProvider.js";
+export * from "./ErrorProvider.js";

package/query/Query.js

@@ -70,6 +70,6 @@ export class Query extends Rule {
     }
     // Implement toString()
     toString() {
-        return `${this.filters}&${this.sorts}${this.limit ? `&LIMIT=${this.limit}` : ""}`;
+        return `filters=${this.filters}&sorts=${this.sorts}&limit={this.limit || ""}`;
     }
 }

package/query/Rules.js

@@ -19,7 +19,7 @@ export class Rules extends Rule {
         return this._rules.length;
     }
     toString() {
-        return this._rules.map(toString).join("&");
+        return this._rules.map(toString).join(",");
     }
     /** Clone this set of rules but add additional rules. */
     with(...rules) {

package/react/useDocument.js

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, callAsync, getDocumentData } from "../index.js";
+import { CacheProvider, throwAsync, NOERROR, findSourceProvider, NOVALUE, callAsync, getDocumentData, isAsync } from "../index.js";
 import { usePureEffect } from "./usePureEffect.js";
 import { usePureMemo } from "./usePureMemo.js";
 import { usePureState } from "./usePureState.js";
@@ -9,13 +9,14 @@ export function useAsyncDocument(ref, maxAge = 1000) {
     // Create two states to hold the value and error.
     const [value, setNext] = usePureState(getCachedResult, memoRef);
     const [error, setError] = useState(NOERROR);
-    if (error !== NOERROR)
-        throw error; // If there's an error throw it.
     // Register effect.
     usePureEffect(subscribeEffect, memoRef, maxAge, setNext, setError);
     // Always return undefined if there's no ref.
     if (!ref)
         return undefined;
+    // If there's an error throw it.
+    if (error !== NOERROR)
+        throw error;
     // If document is cached return the cached value.
     if (value !== NOVALUE)
         return value;
@@ -24,7 +25,10 @@ export function useAsyncDocument(ref, maxAge = 1000) {
     if (maxAge === true)
         setTimeout(ref.subscribe({ next: setNext, error: setError }), 10000);
     // Return a promise for the result.
-    return ref.result;
+    const result = ref.result;
+    if (isAsync(result))
+        result.then(setNext, setError);
+    return result;
 }
 /** Get the initial result for a reference from the cache. */
 function getCachedResult(ref) {
@@ -34,22 +38,30 @@ function getCachedResult(ref) {
     return provider.isCached(ref) ? provider.cache.get(ref) : NOVALUE;
 }
 /** Effect that subscribes a component to the cache for a reference. */
-function subscribeEffect(ref, maxAge, next, error) {
+function subscribeEffect(ref, maxAge, setNext, setError) {
     if (ref) {
         const provider = findSourceProvider(ref.db.provider, CacheProvider);
-        const stopCache = provider.cache.subscribe(ref, { next, error });
+        const stopCache = provider.cache.subscribe(ref, { next: setNext, error: setError });
         if (maxAge === true) {
             // If `maxAge` is true subscribe to the source for as long as this component is attached.
-            const stopSource = ref.subscribe({ next, error });
+            const stopSource = ref.subscribe({ next: setNext, error: setError });
             return () => {
                 stopCache();
                 stopSource();
             };
         }
-        else {
+        else if (provider.getCachedAge(ref) > maxAge) {
             // If cache provider's cached document is older than maxAge then force refresh the data.
-            if (provider.getCachedAge(ref) > maxAge)
-                Promise.resolve(ref.result).then(next, error);
+            try {
+                const result = ref.result;
+                if (isAsync(result))
+                    result.then(setNext, setError);
+                else
+                    setNext(result);
+            }
+            catch (e) {
+                setError(e);
+            }
         }
         return stopCache;
     }

package/react/useQuery.js

@@ -1,5 +1,5 @@
 import { useState } from "react";
-import { CacheProvider, NOERROR, findSourceProvider, NOVALUE, getMap, callAsync, getQueryData, throwAsync, ResultsObserver, getQueryResult, } from "../index.js";
+import { CacheProvider, NOERROR, findSourceProvider, NOVALUE, getMap, callAsync, getQueryData, throwAsync, ResultsObserver, getQueryResult, isAsync, } from "../index.js";
 import { usePureEffect } from "./usePureEffect.js";
 import { usePureMemo } from "./usePureMemo.js";
 import { usePureState } from "./usePureState.js";
@@ -24,7 +24,10 @@ export function useAsyncQuery(ref, maxAge = 1000) {
     if (maxAge === true)
         setTimeout(ref.subscribe({ next: setNext, error: setError }), 10000);
     // Return a promise for the result.
-    return ref.results;
+    const results = ref.results;
+    if (isAsync(results))
+        results.then(setNext, setError);
+    return results;
 }
 /** Get the initial results for a reference from the cache. */
 function getCachedResults(ref) {
@@ -34,10 +37,10 @@ function getCachedResults(ref) {
     return provider.isCached(ref) ? getMap(provider.cache.getQuery(ref)) : NOVALUE;
 }
 /** Effect that subscribes a component to the cache for a reference. */
-function subscribeEffect(ref, maxAge, next, error) {
+function subscribeEffect(ref, maxAge, setNext, setError) {
     if (ref) {
         const provider = findSourceProvider(ref.db.provider, CacheProvider);
-        const observer = new ResultsObserver({ next, error });
+        const observer = new ResultsObserver({ next: setNext, error: setError });
         const stopCache = provider.cache.subscribeQuery(ref, observer);
         if (maxAge === true) {
             // If `maxAge` is true subscribe to the source for as long as this component is attached.
@@ -47,10 +50,19 @@ function subscribeEffect(ref, maxAge, next, error) {
                 stopSource();
             };
         }
-        else {
+        else if (provider.getCachedAge(ref) > maxAge) {
             // If cache provider's cached document is older than maxAge then force refresh the data.
-            if (provider.getCachedAge(ref) > maxAge)
-                Promise.resolve(ref.results).then(next, error);
+            Promise.resolve(ref.results).then(setNext, setError);
+            try {
+                const results = ref.results;
+                if (isAsync(results))
+                    results.then(setNext, setError);
+                else
+                    setNext(results);
+            }
+            catch (e) {
+                setError(e);
+            }
         }
         return stopCache;
     }

package/util/jsx.d.ts

@@ -7,8 +7,8 @@ export declare type JSXProps = {
     readonly children?: JSXNode;
 };
 /** JSX element (similar to `React.ReactElement`)  */
-export declare type JSXElement<P extends JSXProps = JSXProps, T extends string | JSXElementCreator<P> = string | JSXElementCreator<P>> = {
-    type: T;
+export declare type JSXElement<P extends JSXProps = JSXProps> = {
+    type: string | JSXElementCreator<P>;
     props: P;
     key: string | number | null;
     $$typeof?: symbol;