shelving 1.86.1 → 1.86.2

package/constraint/Constraints.js

@@ -1,3 +1,4 @@
+import { getPrototype } from "../util/object.js";
 import { withArrayItems, omitArrayItems } from "../util/array.js";
 import { Constraint } from "./Constraint.js";
 /** Type of Rule that is powered by several sub-constraints (e.g. `Filters` and `Sorts` and `Query` itself extend this). */
@@ -21,12 +22,12 @@ export class Constraints extends Constraint {
     /** Clone this set of constraints but add additional constraints. */
     with(...constraints) {
         const _constraints = withArrayItems(this._constraints, ...constraints);
-        return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
+        return _constraints !== this._constraints ? { __proto__: getPrototype(this), ...this, _constraints: _constraints } : this;
     }
     /** Clone this set of constraints but remove specific constraints. */
     omit(...constraints) {
         const _constraints = omitArrayItems(this._constraints, ...constraints);
-        return _constraints !== this._constraints ? { __proto__: Object.getPrototypeOf(this), ...this, _constraints: _constraints } : this;
+        return _constraints !== this._constraints ? { __proto__: getPrototype(this), ...this, _constraints: _constraints } : this;
     }
     /** Iterate over the constraints. */
     [Symbol.iterator]() {

package/constraint/QueryConstraints.d.ts

@@ -31,7 +31,7 @@ export declare class QueryConstraints<T extends Data = Data> extends Constraint<
     readonly filters: FilterConstraints<T>;
     readonly sorts: SortConstraints<T>;
     readonly limit: number | null;
-    constructor(filters?: FilterList<Partial<T>>, sorts?: SortList<Partial<T>>, limit?: number | null);
+    constructor(filters?: FilterList<Partial<T>> | FilterConstraints<T>, sorts?: SortList<Partial<T>> | SortConstraints<T>, limit?: number | null);
     filter(...filters: FilterList<Partial<T>>[]): this;
     get unfilter(): this;
     match(item: T): boolean;

package/constraint/QueryConstraints.js

@@ -1,4 +1,4 @@
-import { getProp } from "../util/object.js";
+import { getProp, getPrototype } from "../util/object.js";
 import { assert } from "../util/assert.js";
 import { limitArray } from "../util/array.js";
 import { FilterConstraints } from "./FilterConstraints.js";
@@ -19,7 +19,7 @@ export class QueryConstraints extends Constraint {
     // Implement `Filterable`
     filter(...filters) {
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             filters: this.filters.filter(...filters),
         };
@@ -28,7 +28,7 @@ export class QueryConstraints extends Constraint {
         if (!this.filters.size)
             return this;
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             filters: EMPTY_FILTERS,
         };
@@ -39,7 +39,7 @@ export class QueryConstraints extends Constraint {
     // Implement `Sortable`
     sort(...sorts) {
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             sorts: this.sorts.sort(...sorts),
         };
@@ -48,7 +48,7 @@ export class QueryConstraints extends Constraint {
         if (!this.sorts.size)
             return this;
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             sorts: EMPTY_SORTS,
         };
@@ -59,14 +59,14 @@ export class QueryConstraints extends Constraint {
     // Implement `Queryable`
     after(item) {
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             filters: this.filters.with(..._getAfterFilters(this.sorts, item)),
         };
     }
     before(item) {
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             filters: this.filters.with(..._getBeforeFilters(this.sorts, item)),
         };
@@ -75,7 +75,7 @@ export class QueryConstraints extends Constraint {
         if (this.limit === limit)
             return this;
         return {
-            __proto__: Object.getPrototypeOf(this),
+            __proto__: getPrototype(this),
             ...this,
             limit,
         };

package/error/ThroughError.js

@@ -7,7 +7,7 @@ export class ThroughError extends Error {
     constructor(message, cause) {
         super(message);
         this.cause = cause;
-        this.stack = `${this.stack}\nCause: ${cause instanceof Error ? cause.stack : debug(cause)}`;
+        this.stack = `${this.stack || ""}\nCause: ${cause instanceof Error ? cause.stack || "" : debug(cause)}`;
     }
 }
 ThroughError.prototype.name = "ThroughError";

package/markup/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./options.js";
+export * from "./rule.js";
 export * from "./rules.js";
 export * from "./render.js";
 export * from "./regexp.js";

package/markup/index.js

@@ -1,4 +1,5 @@
 export * from "./options.js";
+export * from "./rule.js";
 export * from "./rules.js";
 export * from "./render.js";
 export * from "./regexp.js";

package/markup/options.d.ts

@@ -1,4 +1,4 @@
-import { MarkupRules } from "./rules.js";
+import type { MarkupRules } from "./rule.js";
 /** The current parsing options (represents the current state of the parsing). */
 export type MarkupOptions = {
     /** The active list of parsing rules. */

package/markup/regexp.d.ts

@@ -2,13 +2,13 @@ import type { Data } from "../util/data.js";
 import { NamedRegExp, NamedRegExpData, PossibleRegExp } from "../util/regexp.js";
 import type { MarkupOptions } from "./options.js";
 /** Subset of `NamedRegExpArray<T>` that are the only things we're required return from a `MarkupMatcher` function. */
-export type MarkupMatch<T extends Data | undefined = Data | undefined> = {
+export type MarkupMatch<T extends Data | undefined> = {
     0: string;
     index: number;
     groups: T;
 };
 /** Function that matches a string and returns a `MarkupMatch` or `null` or `void` */
-export type MarkupMatcher<T extends Data | undefined = Data | undefined> = (input: string, options: MarkupOptions) => MarkupMatch<T> | null | void;
+export type MarkupMatcher<T extends Data> = (input: string, options: MarkupOptions) => MarkupMatch<T> | null | void;
 export declare const LINE_REGEXP: RegExp;
 export declare const LINE_START_REGEXP: RegExp;
 export declare const LINE_END_REGEXP: RegExp;

package/markup/render.js

@@ -77,49 +77,48 @@ function _renderElement(element, options, context) {
  */
 function* _parseString(input, options, context, offset = 0) {
     let matchedRule = undefined;
-    let matchedPriority = Number.MIN_SAFE_INTEGER;
-    let matchedIndex = Number.MIN_SAFE_INTEGER;
-    let matchedLength = 0;
-    let matchedGroups = undefined;
+    let matchedResult = undefined;
+    let highPriority = Number.MIN_SAFE_INTEGER;
+    let lowIndex = Number.MIN_SAFE_INTEGER;
     // Loop through all rules in the list and see if any match.
     for (const rule of options.rules) {
         // Only apply this rule if both:
         // 1. The priority is equal or higher to the current priority.
         // 2. The rule is allowed in the current context.
-        const { priority = 0, match, contexts } = rule;
-        if (priority >= matchedPriority && contexts.includes(context)) {
-            const result = typeof match === "function" ? match(input, options) : match.exec(input);
+        const { priority } = rule;
+        if (rule.priority >= highPriority && rule.contexts.includes(context)) {
+            const result = rule.match(input, options);
             if (result) {
                 // Use the match if it has length and is earlier in the string or is higher priority.
-                const { 0: { length } = "", index, groups } = result;
-                if (length && (index < matchedIndex || priority > matchedPriority)) {
+                const { 0: { length } = "", index } = result;
+                if (length && (index < lowIndex || rule.priority > highPriority)) {
                     matchedRule = rule;
-                    matchedPriority = priority;
-                    matchedIndex = index;
-                    matchedLength = length;
-                    matchedGroups = groups;
+                    matchedResult = result;
+                    highPriority = priority;
+                    lowIndex = index;
                 }
             }
         }
     }
     // Did at least one rule match?
-    if (matchedRule && matchedLength) {
+    if (matchedRule && matchedResult) {
         // If index is more than zero, then the string before the match may match another rule at lower priority.
-        const prefix = input.slice(0, matchedIndex);
+        const prefix = input.slice(0, lowIndex);
         if (prefix.length)
             yield* _parseString(prefix, options, context, offset);
         // Call the rule's `render()` function to generate the node.
         // React gets annoyed if we don't set a `key:` property on lists of elements.
         // We use the string offset as the `.key` property in the element because it's cheap to calculate and guaranteed to be unique within the string.
         // Trying to generate an incrementing number would require tracking the number and passing it back and forth through `_parseString()`
-        const { render, subcontext } = matchedRule;
-        const element = render(matchedGroups, options);
-        element.key = offset + matchedIndex;
+        const { 0: { length } = "", groups, index } = matchedResult;
+        const element = matchedRule.render(groups, options);
+        element.key = offset + index;
+        const { subcontext } = matchedRule;
         yield subcontext ? _renderElement(element, options, subcontext) : element;
         // Decrement the content.
-        const suffix = input.slice(matchedIndex + matchedLength);
+        const suffix = input.slice(index + length);
         if (suffix.length)
-            yield* _parseString(suffix, options, context, offset + matchedIndex + matchedLength);
+            yield* _parseString(suffix, options, context, offset + index + length);
     }
     else {
         // If nothing matched return the entire string..

package/markup/rule.d.ts

@@ -0,0 +1,80 @@
+import { NamedRegExp, NamedRegExpArray, NamedRegExpData } from "../util/regexp.js";
+import { Data } from "../util/data.js";
+import { JSXElement } from "../util/jsx.js";
+import { ImmutableArray } from "../util/array.js";
+import { MarkupOptions } from "./options.js";
+export type MarkupRuleMatch<T extends Data = Data> = {
+    0: string;
+    index: number;
+    groups?: T;
+};
+export declare abstract class MarkupRule {
+    /**
+     * Contexts this rule should be applied in,
+     *
+     * @example `["block", "inline", "list"]`
+     */
+    readonly contexts: ImmutableArray<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 | null;
+    /**
+     * 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;
+    constructor(contexts: ImmutableArray<string>, //
+    subcontext?: string | null, priority?: number);
+    /** Match an input string against this  */
+    abstract match(input: string, options: MarkupOptions): MarkupRuleMatch | null;
+    /** Render the JSX element for this rule using the props matched by `.match` */
+    abstract render(props: Data | undefined, options: MarkupOptions): JSXElement;
+}
+export declare class RegExpMarkupRule extends MarkupRule {
+    private readonly _regexp;
+    private readonly _render;
+    constructor(_regexp: RegExp, //
+    _render: (props: Data, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
+    match(input: string): MarkupRuleMatch | null;
+    render(props: Data, options: MarkupOptions): JSXElement;
+}
+export declare class NamedRegExpMarkupRule<T extends NamedRegExpData> extends MarkupRule {
+    private readonly _regexp;
+    private readonly _render;
+    constructor(_regexp: NamedRegExp<T>, //
+    _render: (props: T, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
+    match(input: string): NamedRegExpArray<T> | null;
+    render(props: T, options: MarkupOptions): JSXElement;
+}
+export declare class LinkRegExpMarkupRule extends MarkupRule {
+    readonly _regexp: NamedRegExp<{
+        title?: string;
+        href: string;
+    }>;
+    readonly _render: (props: {
+        title: string;
+        href: string;
+    }, options: MarkupOptions) => JSXElement;
+    constructor(_regexp: NamedRegExp<{
+        title?: string;
+        href: string;
+    }>, //
+    _render: (props: {
+        title: string;
+        href: string;
+    }, options: MarkupOptions) => JSXElement, contexts: ImmutableArray<string>, subcontext?: string | null, priority?: number);
+    match(input: string, { schemes, url: base }: MarkupOptions): MarkupRuleMatch<{
+        title: string;
+        href: string;
+    }> | null;
+    render(props: {
+        title: string;
+        href: string;
+    }, options: MarkupOptions): JSXElement<import("../util/jsx.js").JSXProps>;
+}
+export type MarkupRules = MarkupRule[];

package/markup/rule.js

@@ -0,0 +1,63 @@
+import { formatURL, getOptionalURL } from "../util/url.js";
+export class MarkupRule {
+    constructor(contexts, //
+    subcontext = null, priority = 0) {
+        this.contexts = contexts;
+        this.subcontext = subcontext;
+        this.priority = priority;
+    }
+}
+export class RegExpMarkupRule extends MarkupRule {
+    constructor(_regexp, //
+    _render, contexts, subcontext, priority) {
+        super(contexts, subcontext, priority);
+        this._regexp = _regexp;
+        this._render = _render;
+    }
+    match(input) {
+        return this._regexp.exec(input);
+    }
+    render(props, options) {
+        return this._render(props, options);
+    }
+}
+export class NamedRegExpMarkupRule extends MarkupRule {
+    constructor(_regexp, //
+    _render, contexts, subcontext, priority) {
+        super(contexts, subcontext, priority);
+        this._regexp = _regexp;
+        this._render = _render;
+    }
+    match(input) {
+        return this._regexp.exec(input);
+    }
+    render(props, options) {
+        return this._render(props, options);
+    }
+}
+export class LinkRegExpMarkupRule extends MarkupRule {
+    constructor(_regexp, //
+    _render, contexts, subcontext, priority) {
+        super(contexts, subcontext, priority);
+        this._regexp = _regexp;
+        this._render = _render;
+    }
+    // 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`).
+    match(input, { schemes, url: base }) {
+        const match = this._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) } };
+            }
+        }
+        return null;
+    }
+    render(props, options) {
+        return this._render(props, options);
+    }
+}

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 type AnyMarkupRule = MarkupRule<any>;
-/** A set of markup rules (as an object or array). */
-export 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).