shelving 1.69.0 → 1.71.0

package/markup/rules.js

@@ -1,31 +1,50 @@
-import { getBlockRegExp, getLineRegExp, getWrapRegExp, MATCH_BLOCK, MATCH_LINE } from "../util/search.js";
-import { formatUrl, toURL } from "../util/url.js";
-// Regular expression partials (`\` slashes must be escaped as `\\`).
-const BULLETS = "-*•+"; // Anything that can be a bullet (used for unordered lists and horizontal rules).
-// Regular expressions.
-const MATCH_INDENT = /^ {1,2}/gm;
+/* eslint-disable import/export */
+import { getBlockRegExp, getLineRegExp, getNamedRegExp, getWrapRegExp, MATCH_BLOCK, MATCH_LINE } from "../util/regexp.js";
+import { formatURL, getOptionalURL } from "../util/url.js";
+/** React security symbol — see https://github.com/facebook/react/pull/4832 */
+const $$typeof = Symbol.for("react.element");
 /**
  * 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 const MATCH_HEADING = getLineRegExp(`(?<prefix>#{1,6}) +(?<heading>${MATCH_LINE.source})`);
 export const HEADING_RULE = {
-    regexp: getLineRegExp(`(#{1,6}) +(${MATCH_LINE.source})`),
-    render: ([, prefix = "", children = ""]) => ({ type: `h${prefix.length}`, key: null, ref: null, props: { children } }),
+    match: input => {
+        const match = MATCH_HEADING.exec(input);
+        if (match) {
+            const { index, 0: first, groups } = match;
+            const { prefix, heading } = groups;
+            return { index, 0: first, groups: { level: prefix.length, heading } };
+        }
+    },
+    render: ({ level, heading }) => ({
+        type: `h${level}`,
+        key: null,
+        ref: null,
+        $$typeof,
+        props: { children: heading.trim() },
+    }),
     contexts: ["block"],
-    childContext: "inline",
+    subcontext: "inline",
 };
 /**
  * Horizontal rules
- * - Same as Markdown syntax but also allows `•` bullet character (in addition to `-` dash, `+` plus, `*` asterisk, and `_` underscore).
+ * - Same as Markdown syntax but also allows `•` bullet character (in addition to `-` dash, `+` plus, `*` asterisk, `_` underscore).
  * - Character must be repeated three (or more) times.
  * - Character must be the same every time (can't mix)
  * - Might have infinite number of spaces between the characters.
  */
 export const HORIZONTAL_RULE = {
-    regexp: getLineRegExp(`([${BULLETS}])(?: *\\1){2,}`),
-    render: () => ({ type: "hr", key: null, ref: null, props: {} }),
+    match: getLineRegExp(`([-*•+_=])(?: *\\1){2,}`),
+    render: () => ({
+        type: "hr",
+        key: null,
+        ref: null,
+        $$typeof,
+        props: {},
+    }),
     contexts: ["block"],
 };
 /**
@@ -35,64 +54,81 @@ export const HORIZONTAL_RULE = {
  * - Lists can be created with `•` bullet characters (in addition to `-` dash, `+` plus, and `*` asterisk).
  * - Second-level list can be indented with 1-2 spaces.
  */
-const UNORDERED = `[${BULLETS}] +`; // Anything that can be a bullet (used for unordered lists and horizontal rules).
-export const UNORDERED_LIST_RULE = {
-    regexp: getBlockRegExp(`${UNORDERED}(${MATCH_BLOCK.source})`),
-    render: ([, list = ""]) => {
-        const children = list.split(SPLIT_UL_ITEMS).map(_mapUnorderedItem);
-        return { type: "ul", key: null, ref: null, props: { children } };
-    },
+const UNORDERED_PREFIX = `[-*•+] +`;
+const UNORDERED_SPLIT = new RegExp(`\n+${UNORDERED_PREFIX}`, "g");
+const UNORDERED_INDENT = /^\t/gm;
+export const UNORDERED_RULE = {
+    match: getBlockRegExp(`${UNORDERED_PREFIX}(?<list>${MATCH_BLOCK.source})`),
+    render: ({ list }) => ({
+        type: "ul",
+        key: null,
+        ref: null,
+        $$typeof,
+        props: { children: list.split(UNORDERED_SPLIT).map(_mapUnordered) },
+    }),
     contexts: ["block", "list"],
-    childContext: "list",
-};
-const SPLIT_UL_ITEMS = new RegExp(`\\n+${UNORDERED}`, "g");
-const _mapUnorderedItem = (item, key) => {
-    const children = item.replace(MATCH_INDENT, "");
-    return { type: "li", key, ref: null, props: { children } };
+    subcontext: "list",
 };
+const _mapUnordered = (item, key) => ({
+    type: "li",
+    key,
+    ref: null,
+    $$typeof,
+    props: { children: item.replace(UNORDERED_INDENT, "") },
+});
 /**
  * Ordered list.
  * - No leading spaces are allowed for the top-level list.
  * - Second-level list can be indented with 1-3 spaces.
  */
-const ORDERED = "[0-9]+[.):] +"; // Number for a numbered list (e.g. `1.` or `2)` or `3:`)
-export const ORDERED_LIST_RULE = {
-    regexp: getBlockRegExp(`(${ORDERED}${MATCH_BLOCK.source})`),
-    render: ([, list = ""]) => {
-        const children = list.split(SPLIT_OL_ITEMS).map(_mapOrderedItem);
-        return { type: "ol", key: null, ref: null, props: { children } };
-    },
+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}${MATCH_BLOCK.source})`),
+    render: ({ list }) => ({
+        type: "ol",
+        key: null,
+        ref: null,
+        $$typeof,
+        props: { children: list.split(ORDERED_SPLIT).map(_mapOrdered) },
+    }),
     contexts: ["block", "list"],
-    childContext: "list",
-};
-const SPLIT_OL_ITEMS = new RegExp(`\\n+(?=${ORDERED})`, "g");
-const _mapOrderedItem = (item, key) => {
-    const firstSpace = item.indexOf(" ");
-    const value = parseInt(item.slice(0, firstSpace), 10);
-    const children = item
-        .slice(firstSpace + 1)
-        .trimStart()
-        .replace(MATCH_INDENT, "");
-    return { type: "li", key, ref: null, props: { value, children } };
+    subcontext: "list",
 };
+const _mapOrdered = (item, key) => ({
+    type: "li",
+    key,
+    ref: null,
+    $$typeof,
+    props: {
+        value: parseInt(item, 10),
+        children: item
+            .slice(item.indexOf(" ") + 1)
+            .trim()
+            .replace(ORDERED_INDENT, ""),
+    },
+});
 /**
  * Blockquote block.
  * - Same as Markdown's syntax.
  * - Block continues until it finds a line that doesn't start with `>`
  * - Quote indent symbol can be followed by zero or more spaces.
  */
+const BLOCKQUOTE_PREFIX = "> *";
+const BLOCKQUOTE_INDENT = new RegExp(`^${BLOCKQUOTE_PREFIX}`, "gm");
 export const BLOCKQUOTE_RULE = {
-    regexp: getLineRegExp(`(>${MATCH_LINE.source}(?:\\n>${MATCH_LINE.source})*)`),
-    render: ([, quote = ""]) => ({
+    match: getLineRegExp(`(?<quote>${BLOCKQUOTE_PREFIX}${MATCH_LINE.source}(?:\n${BLOCKQUOTE_PREFIX}${MATCH_LINE.source})*)`),
+    render: ({ quote }) => ({
         type: "blockquote",
         key: null,
         ref: null,
-        props: { children: quote.replace(BLOCKQUOTE_LINES, "") },
+        $$typeof,
+        props: { children: quote.replace(BLOCKQUOTE_INDENT, "") },
     }),
     contexts: ["block", "list"],
-    childContext: "block",
+    subcontext: "block",
 };
-const BLOCKQUOTE_LINES = /^>/gm;
 /**
  * Fenced code blocks
  * - Same as Markdown syntax.
@@ -102,95 +138,85 @@ const BLOCKQUOTE_LINES = /^>/gm;
  */
 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.
-    regexp: getBlockRegExp(`(\`{3,}|~{3,}) *(${MATCH_LINE.source})\\n(${MATCH_BLOCK.source})`, `\\n\\1\\n+|\\n\\1$|$`),
-    render: ([, , file, children]) => ({
+    match: getBlockRegExp(`(\`{3,}|~{3,}) *(?<title>${MATCH_LINE.source})\n(?<code>${MATCH_BLOCK.source})`, `\n\\1\n+|\n\\1$|$`),
+    render: ({ title, code }) => ({
         type: "pre",
         key: null,
         ref: null,
+        $$typeof,
         props: {
             children: {
                 type: "code",
                 key: null,
                 ref: null,
-                props: { "data-file": file || undefined, children },
+                $$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.
 };
 /**
  * Paragraph.
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
 export const PARAGRAPH_RULE = {
-    regexp: getBlockRegExp(` *(${MATCH_BLOCK.source})`),
-    render: ([, children]) => ({ type: `p`, key: null, ref: null, props: { children } }),
+    match: getBlockRegExp(`(?<paragraph>${MATCH_BLOCK.source})`),
+    render: ({ paragraph }) => ({
+        type: `p`,
+        key: null,
+        ref: null,
+        $$typeof,
+        props: { children: paragraph.trim() },
+    }),
     contexts: ["block"],
-    childContext: "inline",
+    subcontext: "inline",
     priority: -10, // Lower precedence than other blocks so it matches last and paragraphs can be broken by other blocks.
 };
 /**
- * Markdown-style link.
- * - Link in standard Markdown format, e.g. `[Google Maps](http://google.com/maps)`
+ * 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`
- * - 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).
+ * - For security only schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
  */
-export const LINK_RULE = {
-    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) {
-            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;
-                return matches;
-            }
-        }
-    },
-    render: ([, title, href = ""], { rel }) => ({
+export const URL_CHAR = "[-$_@.&!*,=;/#?:%a-zA-Z0-9]";
+export const URL_MATCH = getNamedRegExp(`(?<href>[a-z]+:${URL_CHAR}+)(?: +(?:\\((?<title>[^)]*?)\\)))?`);
+export const URL_RULE = {
+    match: (input, options) => _urlMatch(URL_MATCH.exec(input), options),
+    render: ({ href, title }, { rel }) => ({
         type: "a",
         key: null,
         ref: null,
-        props: { children: title || formatUrl(href), href, rel },
+        $$typeof,
+        props: { children: title, href, rel },
     }),
     contexts: ["inline", "list"],
-    childContext: "link",
+    subcontext: "link",
 };
+function _urlMatch(match, { schemes, url: base }) {
+    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) } };
+        }
+    }
+}
 /**
- * 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).
+ * Markdown-style link.
+ * - 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 schemes that appear in `options.schemes` will match (defaults to `http:` and `https:`).
+ * - For security only `http://` or `https://` links will work (if invalid the unparsed text will be returned).
  */
-export const AUTOLINK_RULE = {
-    regexp: /([a-z]+:\S+)(?: +(?:\(([^)]*?)\)|\[([^\]]*?)\]))?/,
-    // Custom matcher to check the URL against the allowed schemes.
-    match: (content, { schemes, url: base }) => {
-        const matches = content.match(AUTOLINK_RULE.regexp);
-        if (matches && typeof matches.index === "number") {
-            const [, href = "", roundTitle = "", squareTitle = ""] = matches;
-            const url = toURL(href, base);
-            if (url && url.protocol && schemes.includes(url.protocol)) {
-                matches[1] = url.href;
-                matches[2] = (roundTitle || squareTitle).trim();
-                return matches;
-            }
-        }
-    },
-    render: ([, href = "", title], { rel }) => ({
-        type: "a",
-        key: null,
-        ref: null,
-        props: { children: title || formatUrl(href), href, rel },
-    }),
-    contexts: ["inline", "list"],
-    childContext: "link",
+export const LINK_MATCH = getNamedRegExp(/\[(?<title>[^\]]*?)\]\((?<href>[^)]*?)\)/);
+export const LINK_RULE = {
+    ...URL_RULE,
+    match: (input, options) => _urlMatch(LINK_MATCH.exec(input), options),
 };
 /**
  * Inline code.
@@ -200,10 +226,16 @@ export const AUTOLINK_RULE = {
  * - Same as Markdown syntax.
  */
 export const CODE_RULE = {
-    regexp: getWrapRegExp("`+", MATCH_BLOCK.source),
-    render: ([, , children]) => ({ type: "code", key: null, ref: null, props: { children } }),
+    match: getWrapRegExp("`+", MATCH_BLOCK.source),
+    render: ({ text }) => ({
+        type: "code",
+        key: null,
+        ref: null,
+        $$typeof,
+        props: { children: text },
+    }),
     contexts: ["inline", "list"],
-    priority: 10, // Higher priority than other inlines so it matches first before e.g. `strong` or `em` (from CommonMark spec: "Code span backticks have higher precedence than any other inline constructs except HTML tags and autolinks.")
+    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.")
 };
 /**
  * Inline strong.
@@ -214,10 +246,16 @@ 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').
  */
 export const STRONG_RULE = {
-    regexp: getWrapRegExp("\\*+"),
-    render: ([, , children]) => ({ type: "strong", key: null, ref: null, props: { children } }),
+    match: getWrapRegExp("\\*+"),
+    render: ({ text }) => ({
+        type: "strong",
+        key: null,
+        ref: null,
+        $$typeof,
+        props: { children: text },
+    }),
     contexts: ["inline", "list", "link"],
-    childContext: "inline",
+    subcontext: "inline",
 };
 /**
  * Inline emphasis.
@@ -228,24 +266,36 @@ export const STRONG_RULE = {
  * - Different to Markdown: strong is always surrounded by `*asterisks*` and emphasis is always surrounded by `_underscores_` (strong isn't 'double emphasis').
  */
 export const EMPHASIS_RULE = {
-    regexp: getWrapRegExp("_+"),
-    render: ([, , children]) => ({ type: "em", key: null, ref: null, props: { children } }),
+    match: getWrapRegExp("_+"),
+    render: ({ text }) => ({
+        type: "em",
+        key: null,
+        ref: null,
+        $$typeof,
+        props: { children: text },
+    }),
     contexts: ["inline", "list", "link"],
-    childContext: "inline",
+    subcontext: "inline",
 };
 /**
  * Inserted text (`<ins>` tag),
  * - Inline text wrapped in two or more `++` pluses.
- * - Works inside words (e.g. `magi+karp+carp`).
+ * - Works inside words (e.g. `magi++karp++carp`).
  * - Whitespace cannot be the first or last character of the element (e.g. `+ abc +` will not work).
  * - Closing characters must exactly match opening characters.
  * - Markdown doesn't have this.
  */
 export const INSERT_RULE = {
-    regexp: getWrapRegExp("\\+\\++"),
-    render: ([, , children]) => ({ type: "ins", key: null, ref: null, props: { children } }),
+    match: getWrapRegExp("\\+\\++"),
+    render: ({ text }) => ({
+        type: "ins",
+        key: null,
+        ref: null,
+        $$typeof,
+        props: { children: text },
+    }),
     contexts: ["inline", "list", "link"],
-    childContext: "inline",
+    subcontext: "inline",
 };
 /**
  * Deleted text (`<del>` tag),
@@ -256,10 +306,16 @@ export const INSERT_RULE = {
  * - Markdown doesn't have this.
  */
 export const DELETE_RULE = {
-    regexp: getWrapRegExp("--+|~~+"),
-    render: ([, , children]) => ({ type: "del", key: null, ref: null, props: { children } }),
+    match: getWrapRegExp("--+|~~+"),
+    render: ({ text }) => ({
+        type: "del",
+        key: null,
+        ref: null,
+        $$typeof,
+        props: { children: text },
+    }),
     contexts: ["inline", "list", "link"],
-    childContext: "inline",
+    subcontext: "inline",
 };
 /**
  * Hard linebreak (`<br />` tag).
@@ -270,10 +326,16 @@ export const DELETE_RULE = {
  *   - This works better with textareas that wrap text (since manually breaking up long lines is no longer necessary).
  */
 export const LINEBREAK_RULE = {
-    regexp: /\n/,
-    render: () => ({ type: "br", key: null, ref: null, props: {} }),
+    match: /\n/,
+    render: () => ({
+        type: "br",
+        key: null,
+        ref: null,
+        $$typeof,
+        props: {},
+    }),
     contexts: ["inline", "list", "link"],
-    childContext: "inline",
+    subcontext: "inline",
 };
 /**
  * All markup rules.
@@ -287,13 +349,13 @@ export const LINEBREAK_RULE = {
 export const MARKUP_RULES = [
     HEADING_RULE,
     HORIZONTAL_RULE,
-    UNORDERED_LIST_RULE,
-    ORDERED_LIST_RULE,
+    UNORDERED_RULE,
+    ORDERED_RULE,
     BLOCKQUOTE_RULE,
     FENCED_CODE_RULE,
     PARAGRAPH_RULE,
     LINK_RULE,
-    AUTOLINK_RULE,
+    URL_RULE,
     CODE_RULE,
     STRONG_RULE,
     EMPHASIS_RULE,
@@ -305,34 +367,37 @@ export const MARKUP_RULES = [
 export const MARKUP_RULES_BLOCK = [
     HEADING_RULE,
     HORIZONTAL_RULE,
-    UNORDERED_LIST_RULE,
-    ORDERED_LIST_RULE,
+    UNORDERED_RULE,
+    ORDERED_RULE,
     BLOCKQUOTE_RULE,
     FENCED_CODE_RULE,
     PARAGRAPH_RULE,
+    //
 ];
 /** Subset of markup rules that work in an inline context. */
 export const MARKUP_RULES_INLINE = [
     LINK_RULE,
-    AUTOLINK_RULE,
+    URL_RULE,
     CODE_RULE,
     STRONG_RULE,
     EMPHASIS_RULE,
     INSERT_RULE,
     DELETE_RULE,
     LINEBREAK_RULE,
+    //
 ];
 /** Subset of markup rules that are relevant for collapsed shortform content. */
 export const MARKUP_RULES_SHORTFORM = [
-    UNORDERED_LIST_RULE,
-    ORDERED_LIST_RULE,
+    UNORDERED_RULE,
+    ORDERED_RULE,
     PARAGRAPH_RULE,
     LINK_RULE,
-    AUTOLINK_RULE,
+    URL_RULE,
     CODE_RULE,
     STRONG_RULE,
     EMPHASIS_RULE,
     INSERT_RULE,
     DELETE_RULE,
     LINEBREAK_RULE,
+    //
 ];

package/observe/Subject.d.ts

@@ -24,7 +24,7 @@ export declare class Subject<T> implements Observable<T>, ConnectableObserver<T>
     error(reason: Error | unknown): void;
     complete(): void;
     /** Close this subject (called by `error()` and `complete()`). */
-    private _close;
+    protected _close(): void;
     /** Connect this subject to a source. */
     connect(source: Subscribable<T>): Unsubscribe;
     /** Disconnect this subject from all sources. */

package/package.json

@@ -11,7 +11,7 @@
 		"state-management",
 		"query-builder"
 	],
-	"version": "1.69.0",
+	"version": "1.71.0",
 	"repository": "https://github.com/dhoulb/shelving",
 	"author": "Dave Houlbrooke <dave@shax.com>",
 	"license": "0BSD",
@@ -62,7 +62,7 @@
 	},
 	"devDependencies": {
 		"@google-cloud/firestore": "^5.0.2",
-		"@types/jest": "^27.5.1",
+		"@types/jest": "^28.1.6",
 		"@types/react": "^18.0.9",
 		"@types/react-dom": "^18.0.4",
 		"@typescript-eslint/eslint-plugin": "^5.23.0",

package/query/Filter.d.ts

@@ -1,4 +1,4 @@
-import type { ArrayType, ImmutableArray } from "../util/array.js";
+import { ArrayType, ImmutableArray } from "../util/array.js";
 import { Data, Key } from "../util/data.js";
 import { Matchable } from "../util/match.js";
 import { Rule } from "./Rule.js";

package/query/Filter.js

@@ -1,3 +1,4 @@
+import { isArray } from "../util/array.js";
 import { getProp } from "../util/data.js";
 import { isArrayWith, isEqual, isEqualGreater, isEqualLess, isGreater, isInArray, isLess, notEqual, notInArray } from "../util/match.js";
 import { filterItems } from "../util/filter.js";
@@ -31,7 +32,7 @@ export class Filter extends Rule {
     /** Parse a set of FilterProps and return the corresponding array of `Filter` instances. */
     static on(key, value) {
         return key.startsWith("!")
-            ? new Filter(key.slice(1), value instanceof Array ? "OUT" : "NOT", value)
+            ? new Filter(key.slice(1), isArray(value) ? "OUT" : "NOT", value)
             : key.endsWith(">")
                 ? new Filter(key.slice(0, -1), "GT", value)
                 : key.endsWith(">=")
@@ -42,7 +43,7 @@ export class Filter extends Rule {
                             ? new Filter(key.slice(0, -2), "LTE", value)
                             : key.endsWith("[]")
                                 ? new Filter(key.slice(0, -2), "CONTAINS", value)
-                                : new Filter(key, value instanceof Array ? "IN" : "IS", value);
+                                : new Filter(key, isArray(value) ? "IN" : "IS", value);
     }
     match(item) {
         return MATCHERS[this.operator](getProp(item, this.key), this.value);

package/react/useDocument.js

@@ -1,4 +1,4 @@
-import { reduceMapItem } from "../util/map.js";
+import { setMapItem } from "../util/map.js";
 import { getDocumentData } from "../db/Reference.js";
 import { CacheProvider } from "../provider/CacheProvider.js";
 import { getOptionalSourceProvider } from "../provider/ThroughProvider.js";
@@ -76,11 +76,10 @@ export class DocumentState extends State {
         this.disconnect();
     }
 }
-/** Reuse the previous `DocumentState` or create a new one. */
-const _reduceDocumentState = (existing, ref) => existing || new DocumentState(ref);
 export function useDocument(ref) {
     const cache = useCache();
-    const state = ref ? reduceMapItem(cache, ref.toString(), _reduceDocumentState, ref) : undefined;
+    const key = ref === null || ref === void 0 ? void 0 : ref.toString();
+    const state = ref && key ? cache.get(key) || setMapItem(cache, key, new DocumentState(ref)) : undefined;
     useSubscribe(state);
     return state;
 }

package/react/useQuery.js

@@ -1,4 +1,4 @@
-import { reduceMapItem } from "../util/map.js";
+import { setMapItem } from "../util/map.js";
 import { getQueryFirstData, getQueryFirstValue } from "../db/Reference.js";
 import { CacheProvider } from "../provider/CacheProvider.js";
 import { getOptionalSourceProvider } from "../provider/ThroughProvider.js";
@@ -123,11 +123,10 @@ export class QueryState extends State {
         }
     }
 }
-/** Reuse the previous `QueryState` or create a new one. */
-const _reduceQueryState = (existing, ref) => existing || new QueryState(ref);
 export function useQuery(ref) {
     const cache = useCache();
-    const state = ref ? reduceMapItem(cache, ref.toString(), _reduceQueryState, ref) : undefined;
+    const key = ref === null || ref === void 0 ? void 0 : ref.toString();
+    const state = ref && key ? cache.get(key) || setMapItem(cache, key, new QueryState(ref)) : undefined;
     useSubscribe(state);
     return state;
 }

package/schema/AllowSchema.js

@@ -1,17 +1,17 @@
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
 import { getString } from "../util/string.js";
-import { isItem } from "../util/array.js";
+import { isArray, isItem } from "../util/array.js";
 import { getOptionalNumber } from "../util/number.js";
-import { isKey } from "../util/object.js";
+import { isEntry } from "../util/object.js";
 import { Schema } from "./Schema.js";
 /** Validate a value against a specific set of allowed values. */
 export function validateAllowed(value, allowed) {
-    if (allowed instanceof Array) {
+    if (isArray(allowed)) {
         if (isItem(allowed, value))
             return value;
     }
     else {
-        if (isKey(allowed, value))
+        if (isEntry(allowed, value))
             return value;
     }
     throw new InvalidFeedback("Unknown value", { value });

package/schema/ArraySchema.js

@@ -1,5 +1,5 @@
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
-import { uniqueArray } from "../util/array.js";
+import { isArray, uniqueArray } from "../util/array.js";
 import { validateArray } from "../util/validate.js";
 import { Schema } from "./Schema.js";
 /**
@@ -39,7 +39,7 @@ export class ArraySchema extends Schema {
         this.max = max;
     }
     validate(unsafeValue = this.value) {
-        if (!(unsafeValue instanceof Array))
+        if (!isArray(unsafeValue))
             throw new InvalidFeedback("Must be array", { value: unsafeValue });
         const safeArray = validateArray(unsafeValue, this.items);
         const dedupedArray = this.unique ? uniqueArray(safeArray) : safeArray;

package/schema/LinkSchema.js

@@ -1,5 +1,5 @@
 import { InvalidFeedback } from "../feedback/InvalidFeedback.js";
-import { toURL } from "../util/url.js";
+import { getOptionalURL } from "../util/url.js";
 import { OPTIONAL } from "./OptionalSchema.js";
 import { StringSchema } from "./StringSchema.js";
 /**
@@ -22,7 +22,7 @@ export class LinkSchema extends StringSchema {
     // Override to clean the URL using the builtin `URL` class and check the schemes and hosts against the whitelists.
     validate(unsafeValue) {
         const string = super.validate(unsafeValue);
-        const url = toURL(super.sanitize(string));
+        const url = getOptionalURL(super.sanitize(string));
         if (!url)
             throw new InvalidFeedback(string ? "Invalid format" : "Required", { value: string });
         if (!this.schemes.includes(url.protocol))