@league-of-foundry-developers/foundry-vtt-types 9.280.1 → 12.331.1-beta

package/src/foundry/common/prosemirror/schema/other.d.mts

@@ -0,0 +1,149 @@
+export declare const details: {
+  content: string;
+  group: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const summary: {
+  content: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const summaryBlock: {
+  content: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const dl: {
+  content: string;
+  group: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const dt: {
+  content: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const dd: {
+  content: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const fieldset: {
+  content: string;
+  group: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const legend: {
+  content: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const picture: {
+  content: string;
+  group: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const audio: {
+  content: string;
+  group: string;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const video: {
+  content: string;
+  group: string;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const track: {
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string];
+};
+
+export declare const source: {
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string];
+};
+
+export declare const object: {
+  inline: boolean;
+  group: string;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string];
+};
+
+export declare const figure: {
+  content: string;
+  group: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const figcaption: {
+  content: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const small: {
+  content: string;
+  group: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const ruby: {
+  content: string;
+  group: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const rp: {
+  content: string;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const rt: {
+  content: string;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const iframe: {
+  attrs: Record<string, unknown>;
+  managed: Record<string, unknown>;
+  group: string;
+  defining: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, unknown];
+};

package/src/foundry/common/prosemirror/schema/schema-definition.d.mts

@@ -0,0 +1,39 @@
+import { MarkSpec, Node, NodeSpec } from "prosemirror-model";
+
+export default SchemaDefinition;
+
+/**
+ * An abstract interface for a ProseMirror schema definition
+ */
+declare abstract class SchemaDefinition {
+  /**
+   * The HTML tag selector this node is associated with
+   */
+  static tag: string;
+
+  /**
+   * Schema attributes
+   * @remarks SchemaDefinition subclasses must implement the attrs getter.
+   */
+  static get attrs(): Record<string, unknown>;
+
+  /**
+   * Check if an HTML element is appropriate to represent as this node, and if so, extract its schema attributes.
+   * @param el - The HTML element
+   * @returns Returns false if the HTML element is not appropriate for this schema node, otherwise returns its attributes.
+   * @remarks SchemaDefinition subclasses must implement the getAttrs method.
+   */
+  static getAttrs(el: HTMLElement): Record<string, unknown> | boolean;
+
+  /**
+   * Convert a ProseMirror Node back into an HTML element.
+   * @param node - The ProseMirror node.
+   * @remarks SchemaDefinition subclasses must implement the toDOM method.
+   */
+  static toDOM(node: Node): unknown[];
+
+  /**
+   * Create the ProseMirror schema specification.
+   */
+  static make(): NodeSpec | MarkSpec;
+}

package/src/foundry/common/prosemirror/schema/secret-node.d.mts

@@ -0,0 +1,27 @@
+import { MarkSpec, Node, NodeSpec } from "prosemirror-model";
+import type SchemaDefinition from "./schema-definition.d.mts";
+import { EditorState, Transaction } from "prosemirror-state";
+
+export default SecretNode;
+
+/**
+ * A class responsible for encapsulating logic around secret nodes in the ProseMirror schema.
+ */
+declare class SecretNode extends SchemaDefinition {
+  static override tag: "section";
+
+  static override get attrs(): Record<string, unknown>;
+
+  static override getAttrs(el: HTMLElement): boolean | Record<string, unknown>;
+
+  static override toDOM(node: Node): [string, Record<string, unknown>, number];
+
+  static override make(): NodeSpec | MarkSpec;
+
+  /**
+   * Handle slitting a secret block in two, making sure the new block gets a unique ID.
+   * @param state    - The ProseMirror editor state.
+   * @param dispatch - The editor dispatch function.
+   */
+  static split(state: EditorState, dispatch: (tr: Transaction) => void): boolean;
+}

package/src/foundry/common/prosemirror/schema/tables.d.mts

@@ -0,0 +1,106 @@
+import { Node } from "prosemirror-model";
+
+export declare const builtInTableNodes: {
+  table: Record<string, unknown>;
+  table_cell: Record<string, unknown>;
+  table_header: Record<string, unknown>;
+  table_row: Record<string, unknown>;
+};
+
+export declare const tableComplex: {
+  content: string;
+  isolating: boolean;
+  group: string;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const colgroup: {
+  content: string;
+  isolating: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const col: {
+  tableRole: string;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string];
+};
+
+export declare const thead: {
+  content: string;
+  isolating: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const tbody: {
+  content: string;
+  isolating: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const tfoot: {
+  content: string;
+  isolating: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const caption: {
+  content: string;
+  isolating: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const captionBlock: {
+  content: string;
+  isolating: boolean;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const tableRowComplex: {
+  content: string;
+  parseDOM: Record<string, unknown>[];
+  toDOM: () => [string, number];
+};
+
+export declare const tableCellComplex: {
+  content: string;
+  attrs: Record<string, unknown>;
+  managed: Record<string, string[]>;
+  isolating: boolean;
+  parseDOM: Record<string, unknown>;
+  toDOM: (node: Node) => [string, unknown, number];
+};
+
+export declare const tableCellComplexBlock: {
+  content: string;
+  attrs: Record<string, unknown>;
+  managed: Record<string, string[]>;
+  isolating: boolean;
+  parseDOM: Record<string, unknown>;
+  toDOM: (node: Node) => [string, unknown, number];
+};
+
+export declare const tableHeaderComplex: {
+  content: string;
+  attrs: Record<string, unknown>;
+  managed: Record<string, string[]>;
+  isolating: boolean;
+  parseDOM: Record<string, unknown>;
+  toDOM: (node: Node) => [string, unknown, number];
+};
+
+export declare const tableHeaderComplexBlock: {
+  content: string;
+  attrs: Record<string, unknown>;
+  managed: Record<string, string[]>;
+  isolating: boolean;
+  parseDOM: Record<string, unknown>;
+  toDOM: (node: Node) => [string, unknown, number];
+};

package/src/foundry/common/prosemirror/schema/utils.d.mts

@@ -0,0 +1,37 @@
+/**
+ * Determine if an HTML element contains purely inline content, i.e. only text nodes and 'mark' elements.
+ * @param element - The element.
+ */
+export declare function onlyInlineContent(element: HTMLElement): boolean;
+
+/**
+ * Determine if an HTML element is empty.
+ * @param element - The element.
+ */
+export declare function isElementEmpty(element: HTMLElement): boolean;
+
+/**
+ * Convert an element's style attribute string into an object.
+ * @param str - The style string.
+ */
+export declare function stylesFromString(str: string): Record<string, unknown>;
+
+/**
+ * Merge two style attribute strings.
+ * @param a - The first style string.
+ * @param b - The second style string.
+ */
+export declare function mergeStyle(a: string, b: string): string;
+
+/**
+ * Convert an element's class attribute string into an array of class names.
+ * @param str - The class string
+ */
+export declare function classesFromString(str: string): string[];
+
+/**
+ * Merge two class attribute strings.
+ * @param a - The first class string.
+ * @param b - The second class string.
+ */
+export declare function mergeClass(a: string, b: string): string;

package/src/foundry/common/prosemirror/schema.d.mts

@@ -0,0 +1,138 @@
+import type { MarkSpec, NodeSpec, Schema } from "prosemirror-model";
+import type {
+  paragraph,
+  blockquote,
+  hr as horizontal_rule,
+  heading,
+  pre as code_block,
+  br as hard_break,
+} from "./schema/core.d.mts";
+import type {
+  ol as ordered_list,
+  ul as bullet_list,
+  li as list_item,
+  liText as list_item_text,
+} from "./schema/lists.d.mts";
+import type {
+  tableComplex as table_complex,
+  colgroup,
+  col,
+  thead,
+  tbody,
+  tfoot,
+  caption,
+  captionBlock as caption_block,
+  tableRowComplex as table_row_complex,
+  tableCellComplex as table_cell_complex,
+  tableCellComplexBlock as table_cell_complex_block,
+  tableHeaderComplex as table_header_complex,
+  tableHeaderComplexBlock as table_header_complex_block,
+} from "./schema/tables.d.mts";
+import type {
+  details,
+  summary,
+  summaryBlock as summary_block,
+  dl,
+  dt,
+  dd,
+  fieldset,
+  legend,
+  picture,
+  audio,
+  video,
+  track,
+  source,
+  object,
+  figure,
+  figcaption,
+  small,
+  ruby,
+  rp,
+  rt,
+  iframe,
+} from "./schema/other.d.mts";
+import type {
+  superscript,
+  subscript,
+  span,
+  font,
+  em,
+  strong,
+  underline,
+  strikethrough,
+  code,
+} from "./schema/marks.d.mts";
+
+export declare const nodes: {
+  doc: { content: string };
+  text: { content: string };
+  paragraph: typeof paragraph;
+  blockquote: typeof blockquote;
+  secret: NodeSpec | MarkSpec;
+  horizontal_rule: typeof horizontal_rule;
+  heading: typeof heading;
+  code_block: typeof code_block;
+  image_link: NodeSpec | MarkSpec;
+  image: NodeSpec | MarkSpec;
+  hard_break: typeof hard_break;
+
+  ordered_list: typeof ordered_list;
+  bullet_list: typeof bullet_list;
+  list_item: typeof list_item;
+  list_item_text: typeof list_item_text;
+
+  table_complex: typeof table_complex;
+  tbody: typeof tbody;
+  thead: typeof thead;
+  tfoot: typeof tfoot;
+  caption: typeof caption;
+  caption_block: typeof caption_block;
+  colgroup: typeof colgroup;
+  col: typeof col;
+  table_row_complex: typeof table_row_complex;
+  table_cell_complex: typeof table_cell_complex;
+  table_header_complex: typeof table_header_complex;
+  table_cell_complex_block: typeof table_cell_complex_block;
+  table_header_complex_block: typeof table_header_complex_block;
+  table: Record<string, unknown>;
+  table_cell: Record<string, unknown>;
+  table_header: Record<string, unknown>;
+  table_row: Record<string, unknown>;
+
+  details: typeof details;
+  summary: typeof summary;
+  summary_block: typeof summary_block;
+  dl: typeof dl;
+  dt: typeof dt;
+  dd: typeof dd;
+  fieldset: typeof fieldset;
+  legend: typeof legend;
+  picture: typeof picture;
+  audio: typeof audio;
+  video: typeof video;
+  track: typeof track;
+  source: typeof source;
+  object: typeof object;
+  figure: typeof figure;
+  figcaption: typeof figcaption;
+  small: typeof small;
+  ruby: typeof ruby;
+  rp: typeof rp;
+  rt: typeof rt;
+  iframe: typeof iframe;
+};
+
+export declare const marks: {
+  superscript: typeof superscript;
+  subscript: typeof subscript;
+  span: typeof span;
+  font: typeof font;
+  link: NodeSpec | MarkSpec;
+  em: typeof em;
+  strong: typeof strong;
+  underline: typeof underline;
+  strikethrough: typeof strikethrough;
+  code: typeof code;
+};
+
+export declare const schema: Schema;

package/src/foundry/common/prosemirror/string-serializer.d.mts

@@ -0,0 +1,120 @@
+import type { DOMOutputSpec, Fragment, Mark, Schema } from "prosemirror-model";
+
+/**
+ * @param node - The ProseMirror node.
+ * @returns The specification to build a DOM node for this ProseMirror node.
+ */
+export type ProseMirrorNodeOutput = (node: Node) => DOMOutputSpec;
+
+/**
+ * @param mark   - The ProseMirror mark.
+ * @param inline - Is the mark appearing in an inline context?
+ * @returns The specification to build a DOM node for this ProseMirror mark.
+ */
+
+export type ProseMirrorMarkOutput = (mark: Mark, inline: boolean) => DOMOutputSpec;
+
+export default StringSerializer;
+/**
+ * A class responsible for serializing a ProseMirror document into a string of HTML.
+ */
+declare class StringSerializer {
+  /**
+   * @param nodes - The node output specs.
+   * @param marks - The mark output specs.
+   */
+  constructor(nodes: Record<string, ProseMirrorNodeOutput>, marks: Record<string, ProseMirrorMarkOutput>);
+
+  /**
+   * Build a serializer for the given schema.
+   * @param schema - The ProseMirror schema.
+   */
+  static fromSchema(schema: Schema): StringSerializer;
+
+  /**
+   * Create a StringNode from a ProseMirror DOMOutputSpec.
+   * @param spec   - The specification.
+   * @param inline - Whether this is a block or inline node.
+   * @returns An object describing the outer node, and a reference to the child node where content should be appended, if applicable.
+   */
+  protected _specToStringNode(
+    spec: DOMOutputSpec | string,
+    inline: boolean,
+  ): { outer: StringNode; content?: StringNode };
+
+  /**
+   * Serialize a ProseMirror fragment into an HTML string.
+   * @param fragment - The ProseMirror fragment, a collection of ProseMirror nodes.
+   * @param target   - The target to append to. Not required for the top-level invocation. (default: `new StringNode()`)
+   * @returns A DOM tree representation as a StringNode.
+   */
+  serializeFragment(fragment: Fragment, target?: StringNode): StringNode;
+
+  /**
+   * Convert a ProseMirror node representation to a StringNode.
+   * @param node - The ProseMirror node.
+   */
+  protected _toStringNode(node: Node): StringNode;
+
+  /**
+   * Convert a ProseMirror mark representation to a StringNode.
+   * @param mark   - The ProseMirror mark.
+   * @param inline - Does the mark appear in an inline context?
+   */
+  protected _serializeMark(mark: Mark, inline: boolean): ReturnType<StringSerializer["_specToStringNode"]>;
+}
+
+/**
+ * A class that behaves like a lightweight DOM node, allowing children to be appended. Serializes to an HTML string.
+ */
+declare class StringNode {
+  /**
+   * @param tag    - The tag name. If none is provided, this node's children will not be wrapped in an outer tag.
+   * @param attrs  - The tag attributes.
+   * @param inline - Whether the node appears inline or as a block.
+   */
+  constructor(tag?: string, attrs?: Record<string, string>, inline?: boolean);
+
+  /**
+   * The tag name.
+   */
+  readonly tag: string | undefined;
+
+  /**
+   * The tag attributes.
+   */
+  readonly attrs: Record<string, string> | undefined;
+
+  /**
+   * Whether the node appears inline or as a block.
+   */
+  get inline(): boolean;
+
+  /**
+   * Append a child to this string node.
+   * @param child - The child node or string.
+   * @throws If attempting to append a child to a void element.
+   */
+  appendChild(child: StringNode | string): void;
+
+  /**
+   * Serialize the StringNode structure into a single string.
+   * @param spaces - The number of spaces to use for indentation (maximum 10). If this value is a string,
+   *                 that string is used as indentation instead (or the first 10 characters if it is
+   *                 longer). (default: `0`)
+   */
+  toString(
+    spaces?: string | number,
+    {
+      _depth,
+      _inlineParent,
+    }?: {
+      /** @internal (default: `0`) */
+      _depth?: number;
+      /** @internal (default: `false`) */
+      _inlineParent?: boolean;
+    },
+  ): string;
+}
+
+export { StringNode };

package/src/foundry/common/prosemirror/util.d.mts

@@ -0,0 +1,43 @@
+import type { Node, Schema, Slice } from "prosemirror-model";
+// Fixes VSC not finding it for the @link TSDoc directive.
+// eslint-disable-next-line @typescript-eslint/no-unused-vars
+import type { StringNode } from "./string-serializer.d.mts";
+
+/**
+ * Use the DOM and ProseMirror's DOMParser to construct a ProseMirror document state from an HTML string. This cannot be
+ * used server-side.
+ * @param htmlString - A string of HTML.
+ * @param schema     - The ProseMirror schema to use instead of the default one.
+ * @returns The document node.
+ */
+export declare function parseHTMLString(htmlString: string, schema?: Schema): Node;
+
+/**
+ * Use the StringSerializer to convert a ProseMirror document into an HTML string. This can be used server-side.
+ * @param doc     - The ProseMirror document.
+ * @param options - Additional options to configure serialization behavior.
+ * @returns
+ */
+export declare function serializeHTMLString(
+  doc: Node,
+  options?: {
+    /** The ProseMirror schema to use instead of the default one. */
+    schema?: Schema;
+    /** The number of spaces to use for indentation. See {@link StringNode#toString} for details. */
+    spaces?: string | number;
+  },
+): string;
+
+/**
+ * @param node    - The candidate node.
+ * @returns A new node to replace the candidate node, or nothing if a replacement should not be made.
+ */
+export declare type ProseMirrorSliceTransformer = (node: Node) => Node | void;
+
+/**
+ * Apply a transformation to some nodes in a slice, and return the new slice.
+ * @param slice       - The slice to transform.
+ * @param transformer - The transformation function.
+ * @returns Either the original slice if no changes were made, or the newly-transformed slice.
+ */
+export declare function transformSlice(slice: Slice, transformer: ProseMirrorSliceTransformer): Slice;