shelving 1.86.0 → 1.86.2

package/markup/rules.d.ts

@@ -1,49 +1,14 @@
-import type { Data } from "../util/data.js";
 import type { JSXElement } from "../util/jsx.js";
-import { NamedRegExp, NamedRegExpData } from "../util/regexp.js";
-import { MarkupMatcher } from "./regexp.js";
+import { NamedRegExp } from "../util/regexp.js";
 import type { MarkupOptions } from "./options.js";
-/** Rule for parsing string markup into a JSX element. */
-export interface MarkupRule<T extends Data | undefined = Data | undefined> {
-    /**
-     * Regular expression or custom matching function.
-     */
-    readonly match: (T extends undefined ? RegExp : T extends NamedRegExpData ? NamedRegExp<T> : never) | MarkupMatcher<T>;
-    /**
-     * Render the JSX element for this rule using the props matched by
-     */
-    readonly render: (orops: T, options: MarkupOptions) => JSXElement;
-    /**
-     * Contexts this rule should be applied in,
-     *
-     * @example `["block", "inline", "list"]`
-     */
-    readonly contexts: string[];
-    /**
-     * Context that children should be rendered with.
-     *
-     * @example `"inline"` // Children of the element rendered by this rule will be parsed against markup rules applied in the "inline" context.
-     */
-    readonly subcontext?: string;
-    /**
-     * Priority for this rule (defaults to zero).
-     *
-     * @example e.g. `<p>` rule is lower priority than other blocks so it matches last and paragraphs can be interrupted by e.g. `<ul>` and `<blockquote>`.
-     * @example e.g. `<code>` rule is higher priority than other inlines so e.g. `<strong>` or `<em>` don't match inside a code block.
-     */
-    readonly priority?: number;
-}
-/** Any markup rule. */
-export declare type AnyMarkupRule = MarkupRule<any>;
-/** A set of markup rules (as an object or array). */
-export declare type MarkupRules = AnyMarkupRule[];
+import { LinkRegExpMarkupRule, MarkupRules, 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: MarkupRule<{
+export declare const HEADING_RULE: NamedRegExpMarkupRule<{
     prefix: string;
     heading: string;
 }>;
@@ -54,14 +19,14 @@ export declare const HEADING_RULE: 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: MarkupRule;
-export declare const UNORDERED_RULE: MarkupRule<{
+export declare const SEPARATOR_RULE: RegExpMarkupRule;
+export declare const UNORDERED_RULE: NamedRegExpMarkupRule<{
     list: string;
 }>;
-export declare const ORDERED_RULE: MarkupRule<{
+export declare const ORDERED_RULE: NamedRegExpMarkupRule<{
     list: string;
 }>;
-export declare const BLOCKQUOTE_RULE: MarkupRule<{
+export declare const BLOCKQUOTE_RULE: NamedRegExpMarkupRule<{
     quote: string;
 }>;
 /**
@@ -71,7 +36,7 @@ export declare const BLOCKQUOTE_RULE: 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: MarkupRule<{
+export declare const FENCED_CODE_RULE: NamedRegExpMarkupRule<{
     wrap: string;
     title?: string;
     code: string;
@@ -80,23 +45,14 @@ export declare const FENCED_CODE_RULE: MarkupRule<{
  * Paragraph.
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
-export declare const PARAGRAPH_RULE: MarkupRule<{
+export declare const PARAGRAPH_RULE: NamedRegExpMarkupRule<{
     paragraph: string;
 }>;
-/**
- * Function that checks a link against the schemas allowed by rendering.
- * - Used by `URL_RULE~ and `LINK_RULE`
- * - Validates that the link is a valid URL (using `getOptionalURL()` to resolve relative links relative to `options.url`).
- * - Validates that the link's URL scheme is in the `options.schemes` whitelist (defaults to `http` and `https`).
- * - Generates a default title for the link using `formatURL()` (e.g. `shax.com/my/dir`).
- */
-export declare function getLinkMatcher(regexp: NamedRegExp<{
-    title?: string;
-    href: string;
-}>): MarkupMatcher<{
+/** Render function for URL and LINK rules. */
+export declare function renderLinkRule({ href, title }: {
     title: string;
     href: string;
-}>;
+}, { rel }: MarkupOptions): JSXElement;
 /**
  * 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).
@@ -108,10 +64,7 @@ export declare const URL_REGEXP: NamedRegExp<{
     title?: string;
     href: string;
 }>;
-export declare const URL_RULE: MarkupRule<{
-    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)`
@@ -124,10 +77,7 @@ export declare const LINK_REGEXP: NamedRegExp<{
     title: string;
     href: string;
 }>;
-export declare const LINK_RULE: MarkupRule<{
-    title: string;
-    href: string;
-}>;
+export declare const LINK_RULE: LinkRegExpMarkupRule;
 /**
  * Inline code.
  * - Text surrounded by one or more "`" backtick tilde characters.
@@ -135,7 +85,7 @@ export declare const LINK_RULE: MarkupRule<{
  * - Closing characters must exactly match opening characters.
  * - Same as Markdown syntax.
  */
-export declare const CODE_RULE: MarkupRule<{
+export declare const CODE_RULE: NamedRegExpMarkupRule<{
     code: string;
 }>;
 /**
@@ -160,7 +110,7 @@ declare const INLINE_CHARS: {
     "=": string;
     ":": string;
 };
-export declare const INLINE_RULE: MarkupRule<{
+export declare const INLINE_RULE: NamedRegExpMarkupRule<{
     char: keyof typeof INLINE_CHARS;
     wrap: string;
     text: string;
@@ -173,7 +123,7 @@ export declare const INLINE_RULE: 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: MarkupRule;
+export declare const LINEBREAK_RULE: RegExpMarkupRule;
 /**
  * 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,7 +1,7 @@
 /* eslint-disable import/export */
 import { getRegExp } from "../util/regexp.js";
-import { formatURL, getOptionalURL } from "../util/url.js";
 import { getBlockRegExp, getLineRegExp, BLOCK_REGEXP, LINE_REGEXP, WordRegExp } from "./regexp.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");
 /**
@@ -10,18 +10,13 @@ const $$typeof = Symbol.for("react.element");
  * - Same as Markdown syntax.
  * - Markdown's underline syntax is not supported (for simplification).
  */
-export const HEADING_RULE = {
-    match: getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${LINE_REGEXP.source})`),
-    render: ({ prefix, heading }) => ({
-        type: `h${prefix.length}`,
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: heading.trim() },
-    }),
-    contexts: ["block"],
-    subcontext: "inline",
-};
+export const HEADING_RULE = new NamedRegExpMarkupRule(getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${LINE_REGEXP.source})`), ({ prefix, heading }) => ({
+    type: `h${prefix.length}`,
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: heading.trim() },
+}), ["block"], "inline");
 /**
  * Separator (horizontal rule / thematic break).
  * - Same as Markdown syntax but also allows `•` bullet character (in addition to `-` dash, `+` plus, `*` asterisk, `_` underscore).
@@ -29,17 +24,13 @@ export const HEADING_RULE = {
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
-export const SEPARATOR_RULE = {
-    match: getLineRegExp("([-*•+_=])(?: *\\1){2,}"),
-    render: () => ({
-        type: "hr",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: {},
-    }),
-    contexts: ["block"],
-};
+export const SEPARATOR_RULE = new RegExpMarkupRule(getLineRegExp("([-*•+_=])(?: *\\1){2,}"), () => ({
+    type: "hr",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: {},
+}), ["block"]);
 /**
  * Unordered list.
  * - Roughly the same syntax as Markdown (might be some differences with indenting).
@@ -50,18 +41,13 @@ export const SEPARATOR_RULE = {
 const UNORDERED_PREFIX = "[-*•+] +";
 const UNORDERED_SPLIT = new RegExp(`(?:^|\n)+${UNORDERED_PREFIX}`, "g");
 const UNORDERED_INDENT = /^\t/gm;
-export const UNORDERED_RULE = {
-    match: getBlockRegExp(`(?<list>${UNORDERED_PREFIX}${BLOCK_REGEXP.source})`),
-    render: ({ list }) => ({
-        type: "ul",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: list.split(UNORDERED_SPLIT).filter(Boolean).map(_mapUnordered) },
-    }),
-    contexts: ["block", "list"],
-    subcontext: "list",
-};
+export const UNORDERED_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<list>${UNORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
+    type: "ul",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: list.split(UNORDERED_SPLIT).filter(Boolean).map(_mapUnordered) },
+}), ["block", "list"], "list");
 const _mapUnordered = (item, key) => ({
     type: "li",
     key,
@@ -77,18 +63,13 @@ 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 = {
-    match: getBlockRegExp(`(?<list>${ORDERED_PREFIX}${BLOCK_REGEXP.source})`),
-    render: ({ list }) => ({
-        type: "ol",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: list.split(ORDERED_SPLIT).map(_mapOrdered) },
-    }),
-    contexts: ["block", "list"],
-    subcontext: "list",
-};
+export const ORDERED_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<list>${ORDERED_PREFIX}${BLOCK_REGEXP.source})`), ({ list }) => ({
+    type: "ol",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: list.split(ORDERED_SPLIT).map(_mapOrdered) },
+}), ["block", "list"], "list");
 const _mapOrdered = (item, key) => ({
     type: "li",
     key,
@@ -110,18 +91,13 @@ const _mapOrdered = (item, key) => ({
  */
 const BLOCKQUOTE_PREFIX = "> *";
 const BLOCKQUOTE_INDENT = new RegExp(`^${BLOCKQUOTE_PREFIX}`, "gm");
-export const BLOCKQUOTE_RULE = {
-    match: getLineRegExp(`(?<quote>${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source}(?:\n${BLOCKQUOTE_PREFIX}${LINE_REGEXP.source})*)`),
-    render: ({ quote }) => ({
-        type: "blockquote",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: quote.replace(BLOCKQUOTE_INDENT, "") },
-    }),
-    contexts: ["block", "list"],
-    subcontext: "block",
-};
+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,
+    $$typeof,
+    props: { children: quote.replace(BLOCKQUOTE_INDENT, "") },
+}), ["block", "list"], "block");
 /**
  * Fenced code blocks
  * - Same as Markdown syntax.
@@ -129,62 +105,42 @@ export const BLOCKQUOTE_RULE = {
  * - 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 = {
-    // Matcher has its own end that only stops when it reaches a matching closing fence or the end of the string.
-    match: getLineRegExp(`(?<wrap>\`{3,}|~{3,}) *(?<title>${LINE_REGEXP.source})\n(?<code>${BLOCK_REGEXP.source})`, `(?:\n\\k<wrap>|$)`),
-    render: ({ title, code }) => ({
-        type: "pre",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: {
-            children: {
-                type: "code",
-                key: null,
-                ref: null,
-                $$typeof,
-                props: { title: (title === null || title === void 0 ? void 0 : title.trim()) || undefined, children: code.trim() },
-            },
+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",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: {
+        children: {
+            type: "code",
+            key: null,
+            ref: null,
+            $$typeof,
+            props: { title: (title === null || title === void 0 ? void 0 : title.trim()) || undefined, children: code.trim() },
         },
-    }),
-    contexts: ["block", "list"],
-    priority: 10, // Higher priority than other blocks so e.g. lists inside fenced code don't become lists.
-};
+    },
+}), ["block", "list"], null, 10);
 /**
  * Paragraph.
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
-export const PARAGRAPH_RULE = {
-    match: getBlockRegExp(`(?<paragraph>${BLOCK_REGEXP.source})`),
-    render: ({ paragraph }) => ({
-        type: `p`,
+export const PARAGRAPH_RULE = new NamedRegExpMarkupRule(getBlockRegExp(`(?<paragraph>${BLOCK_REGEXP.source})`), ({ paragraph }) => ({
+    type: `p`,
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: paragraph.trim() },
+}), ["block"], "inline", -10);
+/** Render function for URL and LINK rules. */
+export function renderLinkRule({ href, title }, { rel }) {
+    return {
+        type: "a",
         key: null,
         ref: null,
         $$typeof,
-        props: { children: paragraph.trim() },
-    }),
-    contexts: ["block"],
-    subcontext: "inline",
-    priority: -10, // Lower precedence than other blocks so it matches last and paragraphs can be broken by other blocks.
-};
-/**
- * Function that checks a link against the schemas allowed by rendering.
- * - Used by `URL_RULE~ and `LINK_RULE`
- * - Validates that the link is a valid URL (using `getOptionalURL()` to resolve relative links relative to `options.url`).
- * - Validates that the link's URL scheme is in the `options.schemes` whitelist (defaults to `http` and `https`).
- * - Generates a default title for the link using `formatURL()` (e.g. `shax.com/my/dir`).
- */
-export function getLinkMatcher(regexp) {
-    return (input, { schemes, url: base }) => {
-        const match = regexp.exec(input);
-        if (match) {
-            const { 0: first, index, groups } = match;
-            const { href, title } = groups;
-            const url = getOptionalURL(href, base);
-            if (url && schemes.includes(url.protocol)) {
-                return { 0: first, index, groups: { href: url.href, title: (title === null || title === void 0 ? void 0 : title.trim()) || formatURL(url) } };
-            }
-        }
+        props: { children: title, href, rel },
     };
 }
 /**
@@ -195,18 +151,7 @@ export function getLinkMatcher(regexp) {
  * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
 export const URL_REGEXP = getRegExp(/(?<href>[a-z]+:[-$_@.&!*,=;/#?:%a-zA-Z0-9]+)(?: +(?:\((?<title>[^)]*?)\)))?/);
-export const URL_RULE = {
-    match: getLinkMatcher(URL_REGEXP),
-    render: ({ href, title }, { rel }) => ({
-        type: "a",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: title, href, rel },
-    }),
-    contexts: ["inline", "list"],
-    subcontext: "link",
-};
+export const URL_RULE = new LinkRegExpMarkupRule(URL_REGEXP, renderLinkRule, ["inline", "list"], "link");
 /**
  * Markdown-style link.
  * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
@@ -216,10 +161,7 @@ export const URL_RULE = {
  * - For security only `http://` or `https://` links will work (if invalid the unparsed text will be returned).
  */
 export const LINK_REGEXP = getRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/);
-export const LINK_RULE = {
-    ...URL_RULE,
-    match: getLinkMatcher(LINK_REGEXP),
-};
+export const LINK_RULE = new LinkRegExpMarkupRule(LINK_REGEXP, renderLinkRule, ["inline", "list"], "link");
 /**
  * Inline code.
  * - Text surrounded by one or more "`" backtick tilde characters.
@@ -227,18 +169,13 @@ export const LINK_RULE = {
  * - Closing characters must exactly match opening characters.
  * - Same as Markdown syntax.
  */
-export const CODE_RULE = {
-    match: new RegExp(`(?<wrap>\`+)(?<code>${BLOCK_REGEXP.source})\\k<wrap>`),
-    render: ({ code }) => ({
-        type: "code",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: code },
-    }),
-    contexts: ["inline", "list"],
-    priority: 10, // Higher priority than e.g. `strong` or `em` (from CommonMark spec: "Code span backticks have higher precedence than any other inline constructs except HTML tags and autolinks.")
-};
+export const CODE_RULE = new NamedRegExpMarkupRule(new RegExp(`(?<wrap>\`+)(?<code>${BLOCK_REGEXP.source})\\k<wrap>`), ({ code }) => ({
+    type: "code",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: { children: code },
+}), ["inline", "list"], null, 10);
 /**
  * Inline strong, emphasis, insert, delete, highlight.
  * - Inline strong text wrapped in one or more `*` asterisks.
@@ -253,18 +190,14 @@ export const CODE_RULE = {
  * - 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 = {
-    match: new WordRegExp(`(?<wrap>(?<char>[${Object.keys(INLINE_CHARS).join("")}])+)(?<text>(?!\\k<char>)\\S|(?!\\k<char>)\\S[\\s\\S]*?(?!\\k<char>)\\S)\\k<wrap>`),
-    render: ({ char, text }) => ({
-        type: INLINE_CHARS[char],
-        key: null,
-        ref: null,
-        $$typeof,
-        props: { children: text },
-    }),
-    contexts: ["inline", "list", "link"],
-    subcontext: "inline",
-};
+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,
+    ref: null,
+    $$typeof,
+    props: { children: text },
+}), ["inline", "list", "link"], "inline");
 /**
  * Hard linebreak (`<br />` tag).
  * - Any line break in a paragraph will become a hard `<br />` tag.
@@ -273,18 +206,13 @@ export const INLINE_RULE = {
  *   - 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 = {
-    match: /\n/,
-    render: () => ({
-        type: "br",
-        key: null,
-        ref: null,
-        $$typeof,
-        props: {},
-    }),
-    contexts: ["inline", "list", "link"],
-    subcontext: "inline",
-};
+export const LINEBREAK_RULE = new RegExpMarkupRule(/\n/, () => ({
+    type: "br",
+    key: null,
+    ref: null,
+    $$typeof,
+    props: {},
+}), ["inline", "list", "link"], "inline");
 /**
  * All markup rules.
  * - Syntax parsed by `renderMarkup()` is defined entirely by the list of rules (i.e. not by code).

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.86.0",
+	"version": "1.86.2",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -43,7 +43,7 @@
 	"sideEffects": false,
 	"engineStrict": true,
 	"engines": {
-		"node": ">=14.0.0"
+		"node": ">=16.0.0"
 	},
 	"scripts": {
 		"fix": "npm run fix:prettier && npm run fix:eslint",
@@ -64,26 +64,26 @@
 		"build:jest": "node --experimental-vm-modules node_modules/jest/bin/jest.js --config=jest.config.build.cjs"
 	},
 	"devDependencies": {
-		"@google-cloud/firestore": "^6.4.0",
-		"@types/jest": "^29.2.0",
-		"@types/react": "^18.0.21",
-		"@types/react-dom": "^18.0.4",
-		"@typescript-eslint/eslint-plugin": "^5.40.0",
-		"@typescript-eslint/parser": "^5.40.0",
-		"dpdm": "^3.9.0",
-		"esbuild": "^0.15.11",
+		"@google-cloud/firestore": "^6.4.2",
+		"@types/jest": "^29.4.0",
+		"@types/react": "^18.0.27",
+		"@types/react-dom": "^18.0.10",
+		"@typescript-eslint/eslint-plugin": "^5.49.0",
+		"@typescript-eslint/parser": "^5.49.0",
+		"dpdm": "^3.11.0",
+		"esbuild": "^0.15.18",
 		"esbuild-jest": "^0.5.0",
-		"eslint": "^8.25.0",
-		"eslint-config-prettier": "^8.5.0",
-		"eslint-plugin-import": "^2.26.0",
+		"eslint": "^8.33.0",
+		"eslint-config-prettier": "^8.6.0",
+		"eslint-plugin-import": "^2.27.5",
 		"eslint-plugin-prettier": "^4.0.0",
-		"firebase": "^9.12.1",
-		"jest": "^29.2.1",
+		"firebase": "^9.16.0",
+		"jest": "^29.4.1",
 		"jest-ts-webcompat-resolver": "^1.0.0",
-		"prettier": "^2.6.2",
+		"prettier": "^2.8.3",
 		"react": "^18.1.0",
 		"react-dom": "^18.1.0",
-		"typescript": "^4.8.4"
+		"typescript": "^4.9.4"
 	},
 	"peerDependencies": {
 		"@google-cloud/firestore": ">=4.0.0",

package/react/useItem.js

@@ -9,10 +9,18 @@ import { useState } from "./useState.js";
 import { useCache } from "./useCache.js";
 /** Hold the current state of a item. */
 export class ItemState extends State {
+    /** Get the data of the item (throws `RequiredError` if item doesn't exist). */
+    get data() {
+        return getData(this.value);
+    }
+    /** Does the item exist (i.e. its value isn't `null`)? */
+    get exists() {
+        return !!this.value;
+    }
     constructor(ref) {
-        var _a;
         const { db, collection, id } = ref;
-        const table = (_a = getOptionalSource(CacheProvider, db.provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
+        const cache = getOptionalSource(CacheProvider, db.provider);
+        const table = cache === null || cache === void 0 ? void 0 : cache.memory.getTable(collection);
         const time = table ? table.getItemTime(id) : null;
         const isCached = typeof time === "number";
         super(table && isCached ? table.getItem(id) : State.NOVALUE, table ? new LazyDeferredSequence(() => this.from(table.getCachedItemSequence(id))) : undefined);
@@ -28,14 +36,6 @@ export class ItemState extends State {
         if (this.loading)
             this.refresh();
     }
-    /** Get the data of the item (throws `RequiredError` if item doesn't exist). */
-    get data() {
-        return getData(this.value);
-    }
-    /** Does the item exist (i.e. its value isn't `null`)? */
-    get exists() {
-        return !!this.value;
-    }
     async _refresh() {
         this.busy.set(true);
         try {

package/react/useQuery.js

@@ -9,35 +9,6 @@ import { useState } from "./useState.js";
 import { useCache } from "./useCache.js";
 /** Hold the current state of a query. */
 export class QueryState extends State {
-    constructor(ref) {
-        var _a;
-        const { db, collection, limit } = ref;
-        const table = (_a = getOptionalSource(CacheProvider, db.provider)) === null || _a === void 0 ? void 0 : _a.memory.getTable(collection);
-        const time = table ? table.getQueryTime(ref) : null;
-        const isCached = typeof time === "number";
-        super(table && isCached ? table.getQuery(ref) : State.NOVALUE, table ? new LazyDeferredSequence(() => this.from(table.getCachedQuerySequence(ref))) : undefined);
-        this.busy = new BooleanState();
-        this._hasMore = false;
-        /** Refresh this state from the source provider. */
-        this.refresh = () => {
-            if (!this.busy.value)
-                void this._refresh();
-        };
-        /**
-         * Load more items after the last once.
-         * - Promise that needs to be handled.
-         */
-        this.loadMore = () => {
-            if (!this.busy.value)
-                void this._loadMore();
-        };
-        this._time = time;
-        this.ref = ref;
-        this.limit = limit !== null && limit !== void 0 ? limit : Infinity;
-        // Queue a request to refresh the value if it doesn't exist.
-        if (this.loading)
-            this.refresh();
-    }
     /** Can more items be loaded after the current result. */
     get hasMore() {
         return this._hasMore;
@@ -66,6 +37,35 @@ export class QueryState extends State {
     get count() {
         return this.value.length;
     }
+    constructor(ref) {
+        const { db, collection, limit } = ref;
+        const cache = getOptionalSource(CacheProvider, db.provider);
+        const table = cache === null || cache === void 0 ? void 0 : cache.memory.getTable(collection);
+        const time = table ? table.getQueryTime(ref) : null;
+        const isCached = typeof time === "number";
+        super(table && isCached ? table.getQuery(ref) : State.NOVALUE, table ? new LazyDeferredSequence(() => this.from(table.getCachedQuerySequence(ref))) : undefined);
+        this.busy = new BooleanState();
+        this._hasMore = false;
+        /** Refresh this state from the source provider. */
+        this.refresh = () => {
+            if (!this.busy.value)
+                void this._refresh();
+        };
+        /**
+         * Load more items after the last once.
+         * - Promise that needs to be handled.
+         */
+        this.loadMore = () => {
+            if (!this.busy.value)
+                void this._loadMore();
+        };
+        this._time = time;
+        this.ref = ref;
+        this.limit = limit !== null && limit !== void 0 ? limit : Infinity;
+        // Queue a request to refresh the value if it doesn't exist.
+        if (this.loading)
+            this.refresh();
+    }
     async _refresh() {
         this.busy.set(true);
         try {