129 lines
4.1 KiB
Plaintext
129 lines
4.1 KiB
Plaintext
import type LinkedList from '../../collection/linked-list.js';
|
|
import type LinkedNode from '../../collection/linked-node.js';
|
|
import type { RegistryDefinition } from '../../registry.js';
|
|
import Scope from '../../scope.js';
|
|
|
|
export interface BlotConstructor {
|
|
new (...args: any[]): Blot;
|
|
/**
|
|
* Creates corresponding DOM node
|
|
*/
|
|
create(value?: any): Node;
|
|
|
|
blotName: string;
|
|
tagName: string | string[];
|
|
scope: Scope;
|
|
className?: string;
|
|
|
|
requiredContainer?: BlotConstructor;
|
|
allowedChildren?: BlotConstructor[];
|
|
defaultChild?: BlotConstructor;
|
|
}
|
|
|
|
/**
|
|
* Blots are the basic building blocks of a Parchment document.
|
|
*
|
|
* Several basic implementations such as Block, Inline, and Embed are provided.
|
|
* In general you will want to extend one of these, instead of building from scratch.
|
|
* After implementation, blots need to be registered before usage.
|
|
*
|
|
* At the very minimum a Blot must be named with a static blotName and associated with either a tagName or className.
|
|
* If a Blot is defined with both a tag and class, the class takes precedence, but the tag may be used as a fallback.
|
|
* Blots must also have a scope, which determine if it is inline or block.
|
|
*/
|
|
export interface Blot extends LinkedNode {
|
|
scroll: Root;
|
|
parent: Parent;
|
|
prev: Blot | null;
|
|
next: Blot | null;
|
|
domNode: Node;
|
|
|
|
statics: BlotConstructor;
|
|
|
|
attach(): void;
|
|
clone(): Blot;
|
|
detach(): void;
|
|
isolate(index: number, length: number): Blot;
|
|
|
|
/**
|
|
* For leaves, length of blot's value()
|
|
* For parents, sum of children's values
|
|
*/
|
|
length(): number;
|
|
|
|
/**
|
|
* Returns offset between this blot and an ancestor's
|
|
*/
|
|
offset(root?: Blot): number;
|
|
remove(): void;
|
|
replaceWith(name: string, value: any): Blot;
|
|
replaceWith(replacement: Blot): Blot;
|
|
split(index: number, force?: boolean): Blot | null;
|
|
wrap(name: string, value?: any): Parent;
|
|
wrap(wrapper: Parent): Parent;
|
|
|
|
deleteAt(index: number, length: number): void;
|
|
formatAt(index: number, length: number, name: string, value: any): void;
|
|
insertAt(index: number, value: string, def?: any): void;
|
|
|
|
/**
|
|
* Called after update cycle completes. Cannot change the value or length
|
|
* of the document, and any DOM operation must reduce complexity of the DOM
|
|
* tree. A shared context object is passed through all blots.
|
|
*/
|
|
optimize(context: { [key: string]: any }): void;
|
|
optimize(mutations: MutationRecord[], context: { [key: string]: any }): void;
|
|
|
|
/**
|
|
* Called when blot changes, with the mutation records of its change.
|
|
* Internal records of the blot values can be updated, and modifications of
|
|
* the blot itself is permitted. Can be trigger from user change or API call.
|
|
* A shared context object is passed through all blots.
|
|
*/
|
|
update(mutations: MutationRecord[], context: { [key: string]: any }): void;
|
|
}
|
|
|
|
export interface Parent extends Blot {
|
|
children: LinkedList<Blot>;
|
|
domNode: HTMLElement;
|
|
|
|
appendChild(child: Blot): void;
|
|
descendant<T>(type: new () => T, index: number): [T, number];
|
|
descendant<T>(matcher: (blot: Blot) => boolean, index: number): [T, number];
|
|
descendants<T>(type: new () => T, index: number, length: number): T[];
|
|
descendants<T>(
|
|
matcher: (blot: Blot) => boolean,
|
|
index: number,
|
|
length: number,
|
|
): T[];
|
|
insertBefore(child: Blot, refNode?: Blot | null): void;
|
|
moveChildren(parent: Parent, refNode?: Blot | null): void;
|
|
path(index: number, inclusive?: boolean): [Blot, number][];
|
|
removeChild(child: Blot): void;
|
|
unwrap(): void;
|
|
}
|
|
|
|
export interface Root extends Parent {
|
|
create(input: Node | string | Scope, value?: any): Blot;
|
|
find(node: Node | null, bubble?: boolean): Blot | null;
|
|
query(query: string | Node | Scope, scope?: Scope): RegistryDefinition | null;
|
|
}
|
|
|
|
export interface Formattable extends Blot {
|
|
/**
|
|
* Apply format to blot. Should not pass onto child or other blot.
|
|
*/
|
|
format(name: string, value: any): void;
|
|
|
|
/**
|
|
* Return formats represented by blot, including from Attributors.
|
|
*/
|
|
formats(): { [index: string]: any };
|
|
}
|
|
|
|
export interface Leaf extends Blot {
|
|
index(node: Node, offset: number): number;
|
|
position(index: number, inclusive: boolean): [Node, number];
|
|
value(): any;
|
|
}
|