shelving 1.50.2 → 1.51.0

package/markup/rules.d.ts

@@ -1,8 +1,4 @@
-import type { MarkupRule, MarkupRuleMatcher } from "./types.js";
-export declare const getMarkupMatcher: (regexp: RegExp) => MarkupRuleMatcher;
-export declare const getMarkupBlockMatcher: (middle?: string, end?: string, start?: string) => MarkupRuleMatcher;
-export declare const getMarkupLineMatcher: (middle?: string, end?: string, start?: string) => MarkupRuleMatcher;
-export declare const getMarkupWrapMatcher: (chars: string, middle?: string) => MarkupRuleMatcher;
+import type { MarkupRule } from "./types.js";
 /**
  * Headings are single line only (don't allow multiline).
  * - 1-6 hashes then 1+ spaces, then the title.

package/markup/rules.js

@@ -1,23 +1,10 @@
-import { formatUrl, toURL } from "../util/index.js";
+import { formatUrl, toURL, getLineRegExp, MATCH_LINE, getBlockRegExp, MATCH_BLOCK, getWrapRegExp } from "../util/index.js";
 // Regular expression partials (`\` slashes must be escaped as `\\`).
-const LINE = "[^\\n]*"; // Match line of content (anything that's not a newline).
-const LINE_START = "^\\n*|\\n+"; // Starts at start of line (one or more linebreak or start of string).
-const LINE_END = "\\n+|$"; // Ends at end of line (one or more linebreak or end of string).
-const BLOCK = "[\\s\\S]*?"; // Match block of content (including newlines so don't be greedy).
-const BLOCK_START = "^\\n*|\\n+"; // Starts at start of a block (one or more linebreak or start of string).
-const BLOCK_END = "\\n*$|\\n\\n+"; // End of a block (two or more linebreaks or end of string).
 const BULLETS = "-*•+"; // Anything that can be a bullet (used for unordered lists and horizontal rules).
-const WORDS = `\\S(?:[\\s\\S]*?\\S)?`; // Run of text that starts and ends with non-space characters (possibly multi-line).
 // Regular expressions.
 const REPLACE_INDENT = /^ {1,2}/gm;
 // Regular expression makers.
-export const getMarkupMatcher = regexp => content => content.match(regexp);
-export const getMarkupBlockMatcher = (middle = BLOCK, end = BLOCK_END, start = BLOCK_START) => getMarkupMatcher(new RegExp(`(?:${start})${middle}(?:${end})`));
-export const getMarkupLineMatcher = (middle = LINE, end = LINE_END, start = LINE_START) => getMarkupMatcher(new RegExp(`(?:${start})${middle}(?:${end})`));
-export const getMarkupWrapMatcher = (chars, middle = WORDS) => {
-    const regexp = new RegExp(`(${chars})(${middle})\\1`);
-    return content => content.match(regexp);
-};
+const getMatcher = regexp => content => content.match(regexp);
 /**
  * Headings are single line only (don't allow multiline).
  * - 1-6 hashes then 1+ spaces, then the title.
@@ -25,7 +12,7 @@ export const getMarkupWrapMatcher = (chars, middle = WORDS) => {
  * - Markdown's underline syntax is not supported (for simplification).
  */
 export const HEADING_RULE = {
-    match: getMarkupLineMatcher(`(#{1,6}) +(${LINE})`),
+    match: getMatcher(getLineRegExp(`(#{1,6}) +(${MATCH_LINE})`)),
     render: ([, prefix = "", children = ""]) => ({ type: `h${prefix.length}`, key: null, props: { children } }),
     contexts: ["block"],
     childContext: "inline",
@@ -38,7 +25,7 @@ export const HEADING_RULE = {
  * - Might have infinite number of spaces between the characters.
  */
 export const HORIZONTAL_RULE = {
-    match: getMarkupLineMatcher(`([${BULLETS}])(?: *\\1){2,}`),
+    match: getMatcher(getLineRegExp(`([${BULLETS}])(?: *\\1){2,}`)),
     render: () => ({ type: "hr", key: null, props: {} }),
     contexts: ["block"],
 };
@@ -51,7 +38,7 @@ export const HORIZONTAL_RULE = {
  */
 const UNORDERED = `[${BULLETS}] +`; // Anything that can be a bullet (used for unordered lists and horizontal rules).
 export const UNORDERED_LIST_RULE = {
-    match: getMarkupBlockMatcher(`${UNORDERED}(${BLOCK})`),
+    match: getMatcher(getBlockRegExp(`${UNORDERED}(${MATCH_BLOCK})`)),
     render: ([, list = ""]) => {
         const children = list.split(SPLIT_UL_ITEMS).map(mapUnorderedItem);
         return { type: "ul", key: null, props: { children } };
@@ -71,7 +58,7 @@ const mapUnorderedItem = (item, key) => {
  */
 const ORDERED = "[0-9]+[.):] +"; // Number for a numbered list (e.g. `1.` or `2)` or `3:`)
 export const ORDERED_LIST_RULE = {
-    match: getMarkupBlockMatcher(`(${ORDERED}${BLOCK})`),
+    match: getMatcher(getBlockRegExp(`(${ORDERED}${MATCH_BLOCK})`)),
     render: ([, list = ""]) => {
         const children = list.split(SPLIT_OL_ITEMS).map(mapOrderedItem);
         return { type: "ol", key: null, props: { children } };
@@ -96,7 +83,7 @@ const mapOrderedItem = (item, key) => {
  * - Quote indent symbol can be followed by zero or more spaces.
  */
 export const BLOCKQUOTE_RULE = {
-    match: getMarkupLineMatcher(`(>${LINE}(?:\\n>${LINE})*)`),
+    match: getMatcher(getLineRegExp(`(>${MATCH_LINE}(?:\\n>${MATCH_LINE})*)`)),
     render: ([, quote = ""]) => ({
         type: "blockquote",
         key: null,
@@ -115,7 +102,7 @@ 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.
-    match: getMarkupBlockMatcher(`(\`{3,}|~{3,}) *(${LINE})\\n(${BLOCK})`, `\\n\\1\\n+|\\n\\1$|$`),
+    match: getMatcher(getBlockRegExp(`(\`{3,}|~{3,}) *(${MATCH_LINE})\\n(${MATCH_BLOCK})`, `\\n\\1\\n+|\\n\\1$|$`)),
     render: ([, , file, children]) => ({
         type: "pre",
         key: null,
@@ -134,7 +121,7 @@ export const FENCED_CODE_RULE = {
  * - When ordering rules, paragraph should go after other "block" context elements (because it has a very generous capture).
  */
 export const PARAGRAPH_RULE = {
-    match: getMarkupBlockMatcher(` *(${BLOCK})`),
+    match: getMatcher(getBlockRegExp(` *(${MATCH_BLOCK})`)),
     render: ([, children]) => ({ type: `p`, key: null, props: { children } }),
     contexts: ["block"],
     childContext: "inline",
@@ -205,7 +192,7 @@ const MATCH_AUTOLINK = /([a-z][a-z0-9-]*[a-z0-9]:\S+)(?: +(?:\(([^)]*?)\)|\[([^\
  * - Same as Markdown syntax.
  */
 export const CODE_RULE = {
-    match: getMarkupWrapMatcher("`+", BLOCK),
+    match: getMatcher(getWrapRegExp("`+", MATCH_BLOCK)),
     render: ([, , children]) => ({ type: "code", key: null, props: { children } }),
     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.")
@@ -219,7 +206,7 @@ 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_MARKUP = {
-    match: getMarkupWrapMatcher("\\*+"),
+    match: getMatcher(getWrapRegExp("\\*+")),
     render: ([, , children]) => ({ type: "strong", key: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
@@ -233,7 +220,7 @@ export const STRONG_MARKUP = {
  * - 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 = {
-    match: getMarkupWrapMatcher("_+"),
+    match: getMatcher(getWrapRegExp("_+")),
     render: ([, , children]) => ({ type: "em", key: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
@@ -247,7 +234,7 @@ export const EMPHASIS_RULE = {
  * - Markdown doesn't have this.
  */
 export const INSERT_RULE = {
-    match: getMarkupWrapMatcher("\\+\\++"),
+    match: getMatcher(getWrapRegExp("\\+\\++")),
     render: ([, , children]) => ({ type: "ins", key: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
@@ -261,7 +248,7 @@ export const INSERT_RULE = {
  * - Markdown doesn't have this.
  */
 export const DELETE_RULE = {
-    match: getMarkupWrapMatcher("--+|~~+"),
+    match: getMatcher(getWrapRegExp("--+|~~+")),
     render: ([, , children]) => ({ type: "del", key: null, props: { children } }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",
@@ -275,7 +262,7 @@ 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 = {
-    match: getMarkupMatcher(/\n/),
+    match: getMatcher(/\n/),
     render: () => ({ type: "br", key: null, props: {} }),
     contexts: ["inline", "list", "link"],
     childContext: "inline",

package/package.json

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

package/util/search.d.ts

@@ -1,25 +1,37 @@
 import type { ImmutableArray } from "./array.js";
 import { Matchable } from "./filter.js";
 /**
- * Match a string against a regular expression.
+ * Convert a string to a regular expression that matches that string.
  *
- * @param item The item to search for the regexp in.
- * - Item is an array: recurse into each item of the array to look for strings that match.
- * - Item is an object: recurse into each property of the object to look for strings that match.
- * - Item is string: match the string against the regular expression.
- * - Item is anything else: return false (can't be matched).
- *
- * @param regexp The `RegExp` instance to match the
+ * @param str The input string.
+ * @param flags RegExp flags that are passed into the created RegExp.
  */
-export declare function MATCHES(item: unknown, regexp: RegExp): boolean;
+export declare const toRegExp: (str: string, flags?: string) => RegExp;
+/** Escape special characters in a string regular expression. */
+export declare const escapeRegExp: (str: string) => string;
+export declare const MATCH_LINE = "[^\\n]*";
+export declare const MATCH_LINE_START = "^\\n*|\\n+";
+export declare const MATCH_LINE_END = "\\n+|$";
+export declare const MATCH_BLOCK = "[\\s\\S]*?";
+export declare const MATCH_BLOCK_START = "^\\n*|\\n+";
+export declare const MATCH_BLOCK_END = "\\n*$|\\n\\n+";
+export declare const MATCH_WORDS = "\\S(?:[\\s\\S]*?\\S)?";
+/** Create regular expression that matches a block of content. */
+export declare const getBlockRegExp: (middle?: string, end?: string, start?: string) => RegExp;
+/** Create regular expression that matches a line of content. */
+export declare const getLineRegExp: (middle?: string, end?: string, start?: string) => RegExp;
+/** Create regular expression that matches piece of text wrapped by a set of characters. */
+export declare const getWrapRegExp: (chars: string, middle?: string) => RegExp;
 /**
- * Match an item matching all words in a query.
- *
- * @param item The item to search for the query in.
- * @param query The query string to search for.
- * - Supports `"compound queries"` with quotes.
+ * Convert a string query to the corresponding set of case-insensitive regular expressions.
+ * - Splies the query into words (respecting "quoted phrases").
+ * - Return a regex for each word or quoted phrase.
+ * - Unquoted words match partially (starting with a word boundary).
+ * - Quoted phrases match fully (starting and ending with a word boundary).
  */
-export declare function MATCHES_ALL(item: unknown, regexps: ImmutableArray<RegExp>): boolean;
+export declare const toWordRegExps: (query: string) => ImmutableArray<RegExp>;
+/** Convert a string to a regular expression matching the start of a word boundary. */
+export declare const toWordRegExp: (word: string) => RegExp;
 /**
  * Match an item matching all words in a query.
  *
@@ -27,17 +39,14 @@ export declare function MATCHES_ALL(item: unknown, regexps: ImmutableArray<RegEx
  * @param query The query string to search for.
  * - Supports `"compound queries"` with quotes.
  */
-export declare function MATCHES_ANY(item: unknown, regexps: ImmutableArray<RegExp>): boolean;
+export declare function matchesAll(item: unknown, regexps: Iterable<RegExp>): boolean;
 /**
- * Convert a string query to the corresponding set of case-insensitive regular expressions.
- * - Splies the query into words (respecting "quoted phrases").
- * - Return a regex for each word or quoted phrase.
- * - Unquoted words match partially (starting with a word boundary).
- * - Quoted phrases match fully (starting and ending with a word boundary).
+ * Match an item any of several regular expressions.
+ *
+ * @param item The item to search for the query in.
+ * @param regexps An iterable set of regular expressions.
  */
-export declare const toWordRegExps: (query: string) => ImmutableArray<RegExp>;
-/** Convert a string to a regular expression matching the start of a word boundary. */
-export declare const toWordRegExp: (word: string) => RegExp;
+export declare function matchesAny(item: unknown, regexps: Iterable<RegExp>): boolean;
 /** Matcher that matches any words in a string. */
 export declare class MatchAnyWord implements Matchable<unknown, void> {
     private _regexps;

package/util/search.js

@@ -1,18 +1,38 @@
-import { toWords, escapeRegExp, normalizeString } from "./string.js";
+import { toWords, normalizeString } from "./string.js";
 /**
- * Match a string against a regular expression.
+ * Convert a string to a regular expression that matches that string.
  *
- * @param item The item to search for the regexp in.
- * - Item is an array: recurse into each item of the array to look for strings that match.
- * - Item is an object: recurse into each property of the object to look for strings that match.
- * - Item is string: match the string against the regular expression.
- * - Item is anything else: return false (can't be matched).
- *
- * @param regexp The `RegExp` instance to match the
+ * @param str The input string.
+ * @param flags RegExp flags that are passed into the created RegExp.
  */
-export function MATCHES(item, regexp) {
-    return typeof item === "string" && !!item.match(regexp);
-}
+export const toRegExp = (str, flags = "") => new RegExp(escapeRegExp(str), flags);
+/** Escape special characters in a string regular expression. */
+export const escapeRegExp = (str) => str.replace(REPLACE_ESCAPED, "\\$&");
+const REPLACE_ESCAPED = /[-[\]/{}()*+?.\\^$|]/g;
+// Regular expression partials (`\` slashes must be escaped as `\\`).
+export const MATCH_LINE = "[^\\n]*"; // Match line of content (anything that's not a newline).
+export const MATCH_LINE_START = "^\\n*|\\n+"; // Starts at start of line (one or more linebreak or start of string).
+export const MATCH_LINE_END = "\\n+|$"; // Ends at end of line (one or more linebreak or end of string).
+export const MATCH_BLOCK = "[\\s\\S]*?"; // Match block of content (including newlines so don't be greedy).
+export const MATCH_BLOCK_START = "^\\n*|\\n+"; // Starts at start of a block (one or more linebreak or start of string).
+export const MATCH_BLOCK_END = "\\n*$|\\n\\n+"; // End of a block (two or more linebreaks or end of string).
+export const MATCH_WORDS = `\\S(?:[\\s\\S]*?\\S)?`; // Run of text that starts and ends with non-space characters (possibly multi-line).
+/** Create regular expression that matches a block of content. */
+export const getBlockRegExp = (middle = MATCH_BLOCK, end = MATCH_BLOCK_END, start = MATCH_BLOCK_START) => new RegExp(`(?:${start})${middle}(?:${end})`);
+/** Create regular expression that matches a line of content. */
+export const getLineRegExp = (middle = MATCH_LINE, end = MATCH_LINE_END, start = MATCH_LINE_START) => new RegExp(`(?:${start})${middle}(?:${end})`);
+/** Create regular expression that matches piece of text wrapped by a set of characters. */
+export const getWrapRegExp = (chars, middle = MATCH_WORDS) => new RegExp(`(${chars})(${middle})\\1`);
+/**
+ * Convert a string query to the corresponding set of case-insensitive regular expressions.
+ * - Splies the query into words (respecting "quoted phrases").
+ * - Return a regex for each word or quoted phrase.
+ * - Unquoted words match partially (starting with a word boundary).
+ * - Quoted phrases match fully (starting and ending with a word boundary).
+ */
+export const toWordRegExps = (query) => toWords(query).map(toWordRegExp);
+/** Convert a string to a regular expression matching the start of a word boundary. */
+export const toWordRegExp = (word) => new RegExp(`\\b${escapeRegExp(normalizeString(word))}`, "i");
 /**
  * Match an item matching all words in a query.
  *
@@ -20,46 +40,37 @@ export function MATCHES(item, regexp) {
  * @param query The query string to search for.
  * - Supports `"compound queries"` with quotes.
  */
-export function MATCHES_ALL(item, regexps) {
-    if (typeof item === "string" && regexps.length) {
-        for (const regexp of regexps)
-            if (!item.match(regexp))
+export function matchesAll(item, regexps) {
+    let count = 0;
+    if (typeof item === "string") {
+        for (const regexp of regexps) {
+            count++;
+            if (!regexp.test(item))
                 return false;
-        return true;
+        }
     }
-    return false;
+    return count ? true : false;
 }
 /**
- * Match an item matching all words in a query.
+ * Match an item any of several regular expressions.
  *
  * @param item The item to search for the query in.
- * @param query The query string to search for.
- * - Supports `"compound queries"` with quotes.
+ * @param regexps An iterable set of regular expressions.
  */
-export function MATCHES_ANY(item, regexps) {
+export function matchesAny(item, regexps) {
     if (typeof item === "string")
         for (const regexp of regexps)
-            if (MATCHES(item, regexp))
+            if (regexp.test(item))
                 return true;
     return false;
 }
-/**
- * Convert a string query to the corresponding set of case-insensitive regular expressions.
- * - Splies the query into words (respecting "quoted phrases").
- * - Return a regex for each word or quoted phrase.
- * - Unquoted words match partially (starting with a word boundary).
- * - Quoted phrases match fully (starting and ending with a word boundary).
- */
-export const toWordRegExps = (query) => toWords(query).map(toWordRegExp);
-/** Convert a string to a regular expression matching the start of a word boundary. */
-export const toWordRegExp = (word) => new RegExp(`\\b${escapeRegExp(normalizeString(word))}`, "i");
 /** Matcher that matches any words in a string. */
 export class MatchAnyWord {
     constructor(words) {
         this._regexps = toWordRegExps(words);
     }
     match(value) {
-        return MATCHES_ANY(value, this._regexps);
+        return matchesAny(value, this._regexps);
     }
 }
 /** Matcher that matches all words in a string. */
@@ -68,7 +79,7 @@ export class MatchAllWords {
         this._regexps = toWordRegExps(words);
     }
     match(value) {
-        return MATCHES_ALL(value, this._regexps);
+        return matchesAll(value, this._regexps);
     }
 }
 /** Matcher that matches an exact phrase. */
@@ -77,6 +88,6 @@ export class MatchWord {
         this._regexp = toWordRegExp(phrase);
     }
     match(value) {
-        return MATCHES(value, this._regexp);
+        return this._regexp.test(value);
     }
 }

package/util/string.d.ts

@@ -77,15 +77,6 @@ export declare const toSlug: (str: string) => string;
 export declare const toWords: (str: string) => ImmutableArray<string>;
 /** Find and iterate over the words in a string. */
 export declare function yieldWords(value: string): Generator<string, void, void>;
-/**
- * Convert a string to a regular expression that matches that string.
- *
- * @param str The input string.
- * @param flags RegExp flags that are passed into the created RegExp.
- */
-export declare const toRegExp: (str: string, flags?: string) => RegExp;
-/** Escape special characters in a string regular expression. */
-export declare const escapeRegExp: (str: string) => string;
 /** Is the first character of a string an uppercase letter? */
 export declare const isUppercaseLetter: (str: string) => boolean;
 /** Is the first character of a string a lowercase letter? */

package/util/string.js

@@ -135,16 +135,6 @@ export function* yieldWords(value) {
     }
 }
 const MATCH_WORD = /[^\s"]+|"([^"]*)"/g; // Runs of characters without spaces, or "quoted phrases"
-/**
- * Convert a string to a regular expression that matches that string.
- *
- * @param str The input string.
- * @param flags RegExp flags that are passed into the created RegExp.
- */
-export const toRegExp = (str, flags = "") => new RegExp(escapeRegExp(str), flags);
-/** Escape special characters in a string regular expression. */
-export const escapeRegExp = (str) => str.replace(REPLACE_ESCAPED, "\\$&");
-const REPLACE_ESCAPED = /[-[\]/{}()*+?.\\^$|]/g;
 /** Is the first character of a string an uppercase letter? */
 export const isUppercaseLetter = (str) => isBetween(str.charCodeAt(0), 65, 90);
 /** Is the first character of a string a lowercase letter? */