@7h3laughingman/foundry-types 13.351.0

package/src/common/primitives/number.d.mts

@@ -0,0 +1,79 @@
+export {};
+
+declare global {
+    interface Number {
+        /**
+         * Test for near-equivalence of two numbers within some permitted epsilon
+         * @param n Some other number
+         * @param e Some permitted epsilon, by default 1e-8
+         * @returns Are the numbers almost equal?
+         */
+        almostEqual(n: number, e?: number): boolean;
+
+        /**
+         * Transform a number to an ordinal string representation. i.e.
+         * 1 => 1st
+         * 2 => 2nd
+         * 3 => 3rd
+         */
+        ordinalString(): string;
+
+        /**
+         * Return a string front-padded by zeroes to reach a certain number of numeral characters
+         * @param digits The number of characters desired
+         * @returns The zero-padded number
+         */
+        paddedString(digits: number): string;
+
+        /**
+         * Return a string prefaced by the sign of the number (+) or (-)
+         * @returns The signed number as a string
+         */
+        signedString(): string;
+
+        /**
+         * Round a number to the nearest number which is a multiple of a given interval
+         * @param interval       The interval to round the number to the nearest multiple of
+         * @param [method=round] The rounding method in: round, ceil, floor
+         * @returns The rounded number
+         *
+         * @example Round a number to the nearest step interval
+         * ```js
+         * let n = 17.18;
+         * n.toNearest(5); // 15
+         * n.toNearest(10); // 20
+         * n.toNearest(10, "floor"); // 10
+         * n.toNearest(10, "ceil"); // 20
+         * n.toNearest(0.25); // 17.25
+         * ```
+         */
+        toNearest(interval?: number, method?: "round" | "ceil" | "floor"): number;
+
+        /**
+         * A faster numeric between check which avoids type coercion to the Number object.
+         * Since this avoids coercion, if non-numbers are passed in unpredictable results will occur. Use with caution.
+         * @param a                The lower-bound
+         * @param b                The upper-bound
+         * @param [inclusive=true] Include the bounding values as a true result?
+         * @return Is the number between the two bounds?
+         */
+        between(a: number, b: number, inclusive?: boolean): boolean;
+    }
+
+    interface NumberConstructor {
+        /**
+         * Test whether a value is numeric.
+         * This is the highest performing algorithm currently available, per https://jsperf.com/isnan-vs-typeof/5
+         * @param n A value to test
+         * @return Is it a number?
+         */
+        isNumeric(n: unknown): boolean;
+
+        /**
+         * Attempt to create a number from a user-provided string.
+         * @param  n The value to convert; typically a string, but may already be a number.
+         * @return The number that the string represents, or NaN if no number could be determined.
+         */
+        fromString(n: string | number): Number;
+    }
+}

package/src/common/primitives/regexp.d.mts

@@ -0,0 +1,12 @@
+export {};
+
+declare global {
+    interface RegExpConstructor {
+        /**
+         * Escape a given input string, prefacing special characters with backslashes for use in a regular expression
+         * @param string The un-escaped input string
+         * @returns The escaped string, suitable for use in regular expression
+         */
+        escape(string: string): string;
+    }
+}

package/src/common/primitives/set.d.mts

@@ -0,0 +1,129 @@
+export {};
+
+declare global {
+    interface Set<T> {
+        /**
+         * Return the difference of two sets.
+         * @param other Some other set to compare against
+         * @returns The difference defined as objects in this which are not present in other
+         */
+        difference(other: Set<T>): Set<T>;
+        difference<U>(other: Set<U>): Set<T | U>;
+
+        /**
+         * Return the symmetric difference of two sets.
+         * @param other Another set.
+         * @returns The set of elements that exist in this or other, but not both.
+         */
+        symmetricDifference(other: Set<T>): Set<T>;
+        symmetricDifference<U>(other: Set<U>): Set<T | U>;
+
+        /**
+         * Test whether this set is equal to some other set.
+         * Sets are equal if they share the same members, independent of order
+         * @param other Some other set to compare against
+         * @returns Are the sets equal?
+         */
+        equals(other: Set<unknown>): boolean;
+
+        /**
+         * Return the first value from the set.
+         * @returns The first element in the set, or undefined
+         */
+        first(): T | undefined;
+
+        /**
+         * Return the intersection of two sets.
+         * @param other Some other set to compare against
+         * @returns The intersection of both sets
+         */
+        intersection(other: Set<T>): Set<T>;
+        intersection<U>(other: Set<U>): Set<T | U>;
+
+        /**
+         * Test whether this set has an intersection with another set.
+         * @param other Another set to compare against
+         * @returns Do the sets intersect?
+         */
+        intersects(other: Set<unknown>): boolean;
+
+        /**
+         * Return the union of two sets.
+         * @param other  The other set.
+         */
+        union(other: Set<T>): Set<T>;
+        union<U>(other: Set<U>): Set<T | U>;
+
+        /**
+         * Test whether this set is a subset of some other set.
+         * A set is a subset if all its members are also present in the other set.
+         * @param other Some other set that may be a subset of this one
+         * @returns Is the other set a subset of this one?
+         */
+        isSubset(other: Set<unknown>): boolean;
+
+        /**
+         * Convert a set to a JSON object by mapping its contents to an array
+         * @returns The set elements as an array.
+         */
+        toObject(): T[];
+
+        /**
+         * Test whether every element in this Set satisfies a certain test criterion.
+         * @see Array#every
+         * @param test The test criterion to apply. Positional arguments are the value,
+         * the index of iteration, and the set being tested.
+         * @returns {boolean}  Does every element in the set satisfy the test criterion?
+         */
+        every<U extends T = T>(test: (value: T, index: number, set: Set<T>) => value is U): this is Set<U>;
+        every(test: (value: T, index: number, set: Set<T>) => boolean): boolean;
+
+        /**
+         * Filter this set to create a subset of elements which satisfy a certain test criterion.
+         * @see Array#filter
+         * @param {function(*,number,Set): boolean} test  The test criterion to apply. Positional arguments are the value,
+         * the index of iteration, and the set being filtered.
+         * @returns {Set}  A new Set containing only elements which satisfy the test criterion.
+         */
+        filter<U extends T = T>(test: (value: T, index: number, set: Set<T>) => value is U): Set<U>;
+        filter(test: (value: T, index: number, set: Set<T>) => boolean): Set<T>;
+
+        /**
+         * Find the first element in this set which satisfies a certain test criterion.
+         * @see Array#find
+         * @param test The test criterion to apply. Positional arguments are the value, the index of iteration, and the set being searched.
+         * @returns The first element in the set which satisfies the test criterion, or undefined.
+         */
+        find<U extends T = T>(test: (value: T, index: number, obj: Set<T>) => value is U): U | undefined;
+        find(test: (value: T, index: number, obj: Set<T>) => boolean): T | undefined;
+
+        /**
+         * Create a new Set where every element is modified by a provided transformation function.
+         * @see Array#map
+         * @param transform The transformation function to apply.Positional arguments are the value, the index of iteration,
+         *                  and the set being transformed.
+         * @returns A new Set of equal size containing transformed elements.
+         */
+        map<U>(transform: (value: T, index: number, set: Set<T>) => U): Set<U>;
+
+        /**
+         * Create a new Set with elements that are filtered and transformed by a provided reducer function.
+         * @see Array#reduce
+         * @param reducer     A reducer function applied to each value. Positional arguments are the accumulator, the value,
+         *                    the index of iteration, and the set being reduced.
+         * @param accumulator The initial value of the returned accumulator.
+         * @returns The final value of the accumulator.
+         */
+        reduce<U>(reducer: (previousValue: U, currentValue: T, currentIndex: number, set: Set<T>) => U, accumulator: U): U;
+        reduce(reducer: (previousValue: T, currentValue: T, currentIndex: number, set: Set<T>) => T, accumulator: T): T;
+
+        /**
+         * Test whether any element in this Set satisfies a certain test criterion.
+         * @see Array#some
+         * @param test The test criterion to apply. Positional arguments are the value, the index of iteration, and the set
+         *             being tested.
+         * @returns Does any element in the set satisfy the test criterion?
+         */
+        some(test: (value: T, index: number, set: Set<T>) => boolean): boolean;
+    }
+}

package/src/common/primitives/string.d.mts

@@ -0,0 +1,24 @@
+export {};
+
+declare global {
+    interface String {
+        /** Capitalize a string, transforming its first character to a capital letter. */
+        capitalize(): string;
+
+        /** Convert a string to Title Case where the first letter of each word is capitalized. */
+        titleCase(): string;
+
+        /** Strip any <script> tags which were included within a provided string */
+        stripScripts(): string;
+
+        /**
+         * Transform any string into an url-viable slug string
+         * @param options Optional arguments which customize how the slugify operation is performed
+         * @param options.replacement The replacement character to separate terms, default is '-'
+         * @param options.strict Replace all non-alphanumeric characters, or allow them? Default false
+         * @param options.lowercase Lowercase the string.
+         * @returns The slugified input string
+         */
+        slugify(options?: { replacement?: string; strict?: boolean; lowercase?: boolean }): string;
+    }
+}

package/src/common/primitives/url.d.mts

@@ -0,0 +1,12 @@
+export {};
+
+// Not able to augment URL constructor
+
+// declare interface URL {
+//     /**
+//      * Attempt to parse a URL without throwing an error.
+//      * @param url The string to parse.
+//      * @returns The parsed URL if successful, otherwise null.
+//      */
+//     parseSafe(url: string): URL | null;
+// }

package/src/common/prosemirror/_module.d.mts

@@ -0,0 +1,77 @@
+/** @module prosemirror */
+
+import * as collab from "prosemirror-collab";
+import { keymap } from "prosemirror-keymap";
+import { DOMSerializer, Schema } from "prosemirror-model";
+import { AllSelection, EditorState, Plugin, PluginKey, TextSelection } from "prosemirror-state";
+import { Step } from "prosemirror-transform";
+import { EditorView } from "prosemirror-view";
+import ProseMirrorClickHandler from "./click-handler.mjs";
+import ProseMirrorContentLinkPlugin from "./content-link-plugin.mjs";
+import ProseMirrorDirtyPlugin from "./dirty-plugin.mjs";
+import DOMParser from "./dom-parser.mjs";
+import "./extensions.mjs";
+import ProseMirrorHighlightMatchesPlugin from "./highlight-matches-plugin.mjs";
+import ProseMirrorImagePlugin from "./image-plugin.mjs";
+import ProseMirrorInputRules from "./input-rules.mjs";
+import ProseMirrorKeyMaps from "./keymaps.mjs";
+import ProseMirrorMenu from "./menu.mjs";
+import ProseMirrorPlugin from "./plugin.mjs";
+import { schema as defaultSchema } from "./schema.mjs";
+import { parseHTMLString, serializeHTMLString } from "./util.mjs";
+
+declare const dom: {
+    parser: DOMParser;
+    serializer: DOMSerializer;
+    parseString: typeof parseHTMLString;
+    serializeString: typeof serializeHTMLString;
+};
+
+declare const defaultPlugins: {
+    inputRules: Plugin;
+    keyMaps: Plugin;
+    menu: Plugin;
+    isDirty: Plugin;
+    clickHandler: Plugin;
+    pasteTransformer: Plugin;
+    baseKeyMap: Plugin;
+    dropCursor: Plugin;
+    gapCursor: Plugin;
+    history: Plugin;
+    columnResizing: Plugin;
+    tables: Plugin;
+};
+
+export * as commands from "prosemirror-commands";
+export * as input from "prosemirror-inputrules";
+export * as list from "prosemirror-schema-list";
+export * as state from "prosemirror-state";
+export * as tables from "prosemirror-tables";
+export * as transform from "prosemirror-transform";
+
+export {
+    AllSelection,
+    collab,
+    defaultPlugins,
+    defaultSchema,
+    dom,
+    DOMParser,
+    DOMSerializer,
+    EditorState,
+    EditorView,
+    keymap,
+    Plugin,
+    PluginKey,
+    ProseMirrorClickHandler,
+    ProseMirrorContentLinkPlugin,
+    ProseMirrorDirtyPlugin,
+    ProseMirrorHighlightMatchesPlugin,
+    ProseMirrorImagePlugin,
+    ProseMirrorInputRules,
+    ProseMirrorKeyMaps,
+    ProseMirrorMenu,
+    ProseMirrorPlugin,
+    Schema,
+    Step,
+    TextSelection,
+};

package/src/common/prosemirror/_types.d.mts

@@ -0,0 +1,75 @@
+import { DOMOutputSpec, Mark, MarkType, Node, NodeType } from "prosemirror-model";
+import { EditorState } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import Document from "./../abstract/document.mjs";
+
+interface ProseMirrorContentLinkOptions {
+    /** The parent document housing this editor. */
+    document?: Document;
+    /** Whether to generate links relative to the parent document. */
+    relativeLinks?: boolean;
+}
+
+interface ProseMirrorMenuOptions {
+    /** A function to call when the save button is pressed. */
+    onSave?: Function;
+    /** Whether this editor instance is intended to be destroyed when saved. */
+    destroyOnSave?: boolean;
+    /** Whether to display a more compact version of the menu. */
+    compact?: boolean;
+}
+
+interface ProseMirrorMenuItem {
+    /** A string identifier for this menu item. */
+    action: string;
+    /** The description of the menu item. */
+    title: string;
+    /** An optional class to apply to the menu item. */
+    class?: string;
+    /** An optional style to apply to the title text. */
+    style?: string;
+    /** The menu item's icon HTML. */
+    icon?: string;
+    /** The mark to apply to the selected text. */
+    mark?: MarkType;
+    /** The node to wrap the selected text in. */
+    node?: NodeType;
+    /** An object of attributes for the node or mark. */
+    attrs?: object;
+    /**
+     * Entries with the same group number will be grouped together in the drop-down. Lower-numbered groups appear higher
+     * in the list.
+     */
+    group?: number;
+    /**
+     * A numeric priority which determines whether this item is displayed as the dropdown title. Lower priority takes
+     * precedence.
+     */
+    priority?: number;
+    /** The command to run when the menu item is clicked. */
+    cmd?: ProseMirrorCommand;
+    /** Whether the current item is active under the given selection or cursor. */
+    active?: boolean;
+}
+
+export interface ProseMirrorDropDownEntry extends ProseMirrorMenuItem {
+    /** Any child entries. */
+    children?: ProseMirrorDropDownEntry[];
+}
+
+interface ProseMirrorDropDownConfig {
+    /** The default title of the drop-down. */
+    title: string;
+    /** The menu CSS class. */
+    cssClass: string;
+    /** An optional icon to use instead of a text label. */
+    icon?: string;
+    /** The drop-down entries. */
+    entries: ProseMirrorDropDownEntry[];
+}
+
+export type ProseMirrorCommand = (state: EditorState, dispatch: Function, view: EditorView) => boolean;
+export type MenuToggleBlockWrapCommand = (node: NodeType, attrs?: object) => ProseMirrorCommand;
+export type ProseMirrorNodeOutput = (node: Node) => DOMOutputSpec;
+export type ProseMirrorMarkOutput = (mark: Mark, inline: boolean) => DOMOutputSpec;
+export type ProseMirrorSliceTransformer = (node: Node) => Node | void;

package/src/common/prosemirror/click-handler.d.mts

@@ -0,0 +1,24 @@
+import { Schema } from "prosemirror-model";
+import { Plugin } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import ProseMirrorPlugin from "./plugin.mjs";
+
+/**
+ * A class responsible for managing click events inside a ProseMirror editor.
+ */
+export default class ProseMirrorClickHandler extends ProseMirrorPlugin {
+    static override build(schema: Schema, options?: object): Plugin;
+
+    /**
+     * Handle a click on the editor.
+     * @param view The ProseMirror editor view.
+     * @param pos The position in the ProseMirror document that the click occurred at.
+     * @param node The current ProseMirror Node that the click has bubbled to.
+     * @param nodePos The position of the click within this Node.
+     * @param event The click event.
+     * @param direct Whether this Node is the one that was directly clicked on.
+     * @returns A return value of true indicates the event has been handled, it will not propagate to other plugins, and
+     *          ProseMirror will call preventDefault on it.
+     */
+    protected _onClick(view: EditorView, pos: number, node: Node, nodePos: number, event: PointerEvent, direct: boolean): boolean | void;
+}

package/src/common/prosemirror/content-link-plugin.d.mts

@@ -0,0 +1,34 @@
+import { Schema, Slice } from "prosemirror-model";
+import { Plugin } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { ClientDocument } from "./../../client/documents/abstract/client-document.mjs";
+import { ProseMirrorContentLinkOptions } from "./_types.mjs";
+import ProseMirrorPlugin from "./plugin.mjs";
+
+/**
+ * A class responsible for handling the dropping of Documents onto the editor and creating content links for them.
+ */
+export default class ProseMirrorContentLinkPlugin extends ProseMirrorPlugin {
+    /** The parent document housing this editor. */
+    document: Readonly<ClientDocument>;
+
+    /** Whether to generate links relative to the parent document. */
+    relativeLinks: boolean;
+
+    /**
+     * @param schema  The ProseMirror schema.
+     * @param options Additional options to configure the plugin's behaviour.
+     */
+    constructor(schema: Schema, options?: ProseMirrorContentLinkOptions);
+
+    static override build(schema: Schema, options?: object): Plugin;
+
+    /**
+     * Handle a drop onto the editor.
+     * @param view  The ProseMirror editor view.
+     * @param event The drop event.
+     * @param slice A slice of editor content.
+     * @param moved Whether the slice has been moved from a different part of the editor.
+     */
+    protected _onDrop(view: EditorView, event: DragEvent, slice: Slice, moved: boolean): boolean | void;
+}

package/src/common/prosemirror/dirty-plugin.d.mts

@@ -0,0 +1,10 @@
+import { Schema } from "prosemirror-model";
+import { Plugin } from "prosemirror-state";
+import ProseMirrorPlugin from "./plugin.mjs";
+
+/**
+ * A simple plugin that records the dirty state of the editor.
+ */
+export default class ProseMirrorDirtyPlugin extends ProseMirrorPlugin {
+    static override build(schema: Schema, options?: object): Plugin;
+}

package/src/common/prosemirror/dom-parser.d.mts

@@ -0,0 +1,7 @@
+import { DOMParser as BaseDOMParser, ParseOptions, Node as ProseMirrorNode, Schema } from "prosemirror-model";
+
+export default class DOMParser extends BaseDOMParser {
+    override parse(dom: Node, options?: ParseOptions): ProseMirrorNode;
+
+    static override fromSchema(schema: Schema): DOMParser;
+}

package/src/common/prosemirror/dropdown.d.mts

@@ -0,0 +1,50 @@
+export class ProseMirrorDropDown {
+    /** The default title for this drop-down.  */
+    title: string;
+
+    /** The items configured for this drop-down. */
+    items: ProseMirrorMenuItem[];
+
+    /**
+     * A class responsible for rendering a menu drop-down.
+     * @param title                             The default title.
+     * @param items                             The configured menu items.
+     * @param [options]
+     * @param [options.cssClass]                The menu CSS class name. Required if providing an action.
+     * @param [options.icon]                    Use an icon for the dropdown rather than a text label.
+     * @param [options.onAction]                A callback to fire when a menu item is clicked.
+     */
+    constructor(title: string, items: ProseMirrorMenuItem[], options?: { cssClass?: string; icon: string; onAction?: (event: PointerEvent) => void });
+
+    /** Attach event listeners. */
+    activateListeners(html: HTMLElement): void;
+
+    /**
+     * Construct the drop-down menu's HTML.
+     * @returns HTML contents as a string.
+     */
+    render(): string;
+
+    /**
+     * Recurse through the menu structure and apply a function to each item in it.
+     * @param fn  The function to call on each item. Return false to prevent
+     *            iterating over any further items.
+     */
+    forEachItem(fn: (item: ProseMirrorMenuItem) => boolean): void;
+
+    /**
+     * Render a list of drop-down menu items.
+     * @param   entries  The menu items.
+     * @returns          HTML contents as a string.
+     */
+    protected static _renderMenu(entries: ProseMirrorMenuItem[]): string;
+
+    /* -------------------------------------------- */
+
+    /**
+     * Render an individual drop-down menu item.
+     * @param   item  The menu item.
+     * @returns       HTML contents as a string.
+     */
+    protected static _renderMenuItem(item: ProseMirrorMenuItem): string;
+}

package/src/common/prosemirror/highlight-matches-plugin.d.mts

@@ -0,0 +1,38 @@
+import { Schema } from "prosemirror-model";
+import { EditorState, Plugin } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import ProseMirrorPlugin from "./plugin.mjs";
+
+/**
+ * A class responsible for handling the display of automated link recommendations when a user highlights text in a
+ * ProseMirror editor.
+ */
+export class PossibleMatchesTooltip {
+    /**
+     * @param view The editor view.
+     */
+    constructor(view: EditorView);
+
+    /** A reference to any existing tooltip that has been generated as part of a highlight match. */
+    tooltip: HTMLElement;
+
+    /**
+     * Update the tooltip based on changes to the selected text.
+     * @param view      The editor view.
+     * @param lastState The previous state of the document.
+     */
+    update(view: EditorView, lastState: EditorState): Promise<void>;
+}
+
+/**
+ * A ProseMirrorPlugin wrapper around the PossibleMatchesTooltip class.
+ */
+export default class ProseMirrorHighlightMatchesPlugin extends ProseMirrorPlugin {
+    /**
+     * @param schema    The ProseMirror schema.
+     * @param [options] Additional options to configure the plugin's behaviour.
+     */
+    constructor(schema: Schema, options?: ProseMirrorMenuOptions);
+
+    static override build(schema: Schema, options?: object): Plugin;
+}

package/src/common/prosemirror/image-plugin.d.mts

@@ -0,0 +1,70 @@
+import { Schema, Slice } from "prosemirror-model";
+import { Plugin } from "prosemirror-state";
+import { EditorView } from "prosemirror-view";
+import { ClientDocument } from "./../../client/documents/abstract/client-document.mjs";
+import ProseMirrorPlugin from "./plugin.mjs";
+
+/**
+ * A class responsible for handle drag-and-drop and pasting of image content. Ensuring no base64 data is injected
+ * directly into the journal content and it is instead uploaded to the user's data directory.
+ */
+export default class ProseMirrorImagePlugin extends ProseMirrorPlugin {
+    /** The related Document to store extracted base64 images for. */
+    document: Readonly<ClientDocument>;
+
+    /**
+     * @param schema           The ProseMirror schema.
+     * @param options          Additional options to configure the plugin's behaviour.
+     * @param options.document A related Document to store extract base64 images for.
+     */
+    constructor(schema: Schema, options: { document: ClientDocument });
+
+    static override build(schema: Schema, options?: object): Plugin;
+
+    /**
+     * Handle a drop onto the editor.
+     * @param view  The ProseMirror editor view.
+     * @param event The drop event.
+     * @param slice A slice of editor content.
+     * @param moved Whether the slice has been moved from a different part of the editor.
+     */
+    protected _onDrop(view: EditorView, event: DragEvent, slice: Slice, moved: boolean): boolean | void;
+
+    /**
+     * Handle a paste into the editor.
+     * @param view  The ProseMirror editor view.
+     * @param event The paste event.
+     */
+    protected _onPaste(view: EditorView, event: ClipboardEvent): boolean | void;
+
+    /**
+     * Upload any image files encountered in the drop.
+     * @param view  The ProseMirror editor view.
+     * @param files The files to upload.
+     * @param [pos] The position in the document to insert at. If not provided, the current selection will be
+     *              replaced instead.
+     */
+    protected _uploadImages(view: EditorView, files: FileList, pos?: number): Promise<void>;
+
+    /**
+     * Capture any base64-encoded images embedded in the rich text paste and upload them.
+     * @param view   The ProseMirror editor view.
+     * @param html   The HTML data as a string.
+     * @param images An array of extracted base64 image data.
+     */
+    protected _replaceBase64Images(view: EditorView, html: string, images: [string, string, string][]): Promise<void>;
+
+    /**
+     * Detect base64 image data embedded in an HTML string and extract it.
+     * @param html The HTML data as a string.
+     */
+    protected _extractBase64Images(html: string): [string, string, string][];
+
+    /**
+     * Convert a base64 string into a File object.
+     * @param data     Base64 encoded data.
+     * @param filename The filename.
+     * @param mimetype The file's mimetype.
+     */
+    static base64ToFile(data: string, filename: string, mimetype: string): File;
+}