@thomasfosterau/effect-richtext 0.0.0-stage → 0.1.0

package/dist/compat/transform.d.ts

@@ -0,0 +1,458 @@
+import { MapResult, Mappable, Mapping as Mapping$1, StepMap } from "../transform/map.js";
+import { Step as Step$1, StepResult as StepResult$1 } from "../transform/step.js";
+import { AttrStep as AttrStep$1, DocAttrStep as DocAttrStep$1 } from "../transform/attr_step.js";
+import { AddMarkStep as AddMarkStep$1, AddNodeMarkStep as AddNodeMarkStep$1, RemoveMarkStep as RemoveMarkStep$1, RemoveNodeMarkStep as RemoveNodeMarkStep$1 } from "../transform/mark_step.js";
+import { Transform as Transform$1 } from "../transform/transform.js";
+import { ReplaceAroundStep as ReplaceAroundStep$1, ReplaceStep as ReplaceStep$1 } from "../transform/replace_step.js";
+import "../transform.js";
+import { CORE, TransformError } from "./internal/core.js";
+import { Attrs, ContentMatch, Fragment, Mark, MarkType, Node, NodeRange, NodeType, Schema, Slice } from "./model.js";
+/**
+ * A mapping represents a pipeline of zero or more step maps.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Mapping implements Mappable {
+  /** @internal */
+  readonly [CORE]: Mapping$1;
+  /** Create a new mapping with the given position maps. */
+  constructor(maps?: ReadonlyArray<StepMap>, mirror?: Array<number>, from?: number, to?: number);
+  /** The step maps in this mapping. */
+  get maps(): ReadonlyArray<StepMap>;
+  /** @internal */
+  get mirror(): Array<number> | undefined;
+  set mirror(value: Array<number> | undefined);
+  /** The starting position in the `maps` array, used when `map` or `mapResult` is called. */
+  get from(): number;
+  set from(value: number);
+  /** The end position in the `maps` array. */
+  get to(): number;
+  set to(value: number);
+  /** Create a mapping that maps only through a part of this one. */
+  slice(from?: number, to?: number): Mapping;
+  /** Add a step map to the end of this mapping. */
+  appendMap(map: StepMap, mirrors?: number): void;
+  /** Add all the step maps in a given mapping to this one (preserving mirroring information). */
+  appendMapping(mapping: Mapping): void;
+  /** Finds the offset of the step map that mirrors the map at the given offset, in this mapping. */
+  getMirror(n: number): number | undefined;
+  /** @internal */
+  setMirror(n: number, m: number): void;
+  /** Append the inverse of the given mapping to this one. */
+  appendMappingInverted(mapping: Mapping): void;
+  /** Create an inverted version of this mapping. */
+  invert(): Mapping;
+  /** Map a position through this mapping. */
+  map(pos: number, assoc?: number): number;
+  /** Map a position through this mapping, returning a mapping result. */
+  mapResult(pos: number, assoc?: number): MapResult;
+}
+/**
+ * The result of applying a step.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class StepResult {
+  /** The transformed document, if successful. */
+  readonly doc: Node | null;
+  /** The failure message, if unsuccessful. */
+  readonly failed: string | null;
+  /** @internal */
+  constructor(
+  /** The transformed document, if successful. */
+  doc: Node | null,
+  /** The failure message, if unsuccessful. */
+  failed: string | null);
+  /** Create a successful step result. */
+  static ok(doc: Node): StepResult;
+  /** Create a failed step result. */
+  static fail(message: string): StepResult;
+  /** Call `Node.replace` with the given arguments. Create a successful result if it succeeds, and a failed one if it throws a `ReplaceError`. */
+  static fromReplace(doc: Node, from: number, to: number, slice: Slice): StepResult;
+}
+/**
+ * A step object represents an atomic change. Subclass it to define
+ * custom steps: subclasses are adapted into core steps automatically.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare abstract class Step {
+  /** @internal */
+  readonly [CORE]: Step$1;
+  constructor();
+  /** Applies this step to the given document, returning a result object. */
+  abstract apply(doc: Node): StepResult;
+  /** Get the step map that represents the changes made by this step. */
+  getMap(): StepMap;
+  /** Create an inverted version of this step. */
+  abstract invert(doc: Node): Step;
+  /** Map this step through a mappable thing, returning either a version of that step with its positions adjusted, or `null` if the step was entirely deleted by the mapping. */
+  abstract map(mapping: Mappable): Step | null;
+  /** Try to merge this step with another one, to be applied directly after it. */
+  merge(_other: Step): Step | null;
+  /** Create a JSON-serializeable representation of this step. */
+  abstract toJSON(): any;
+  /** Deserialize a step from its JSON representation. */
+  static fromJSON(schema: Schema, json: any): Step;
+  /** To be able to serialize steps to JSON, each step needs a string ID to attach to its JSON representation. */
+  static jsonID(id: string, stepClass: {
+    fromJSON(schema: any, json: any): Step;
+  }): any;
+}
+/** Base class of the facades for the core's built-in steps. @internal */
+declare abstract class CoreStep extends Step {
+  apply(doc: Node): StepResult;
+  getMap(): StepMap;
+  invert(doc: Node): Step;
+  map(mapping: Mappable): Step | null;
+  merge(other: Step): Step | null;
+  toJSON(): any;
+}
+/**
+ * Replace a part of the document with a slice of new content.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class ReplaceStep extends CoreStep {
+  /** @internal */
+  readonly [CORE]: ReplaceStep$1;
+  /** The given `slice` should fit the 'gap' between `from` and `to`. */
+  constructor(from: number, to: number, slice: Slice, structure?: boolean);
+  /** The start position of the replaced range. */
+  get from(): number;
+  /** The end position of the replaced range. */
+  get to(): number;
+  /** The slice to insert. */
+  get slice(): Slice;
+  /** @internal */
+  get structure(): boolean;
+  /** @internal */
+  static fromJSON(schema: Schema, json: any): ReplaceStep;
+}
+/**
+ * Replace a part of the document with a slice of content, but preserve
+ * a range of the replaced content by moving it into the slice.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class ReplaceAroundStep extends CoreStep {
+  /** @internal */
+  readonly [CORE]: ReplaceAroundStep$1;
+  /** Create a replace-around step with the given range and gap. */
+  constructor(from: number, to: number, gapFrom: number, gapTo: number, slice: Slice, insert: number, structure?: boolean);
+  /** The start position of the replaced range. */
+  get from(): number;
+  /** The end position of the replaced range. */
+  get to(): number;
+  /** The start of preserved range. */
+  get gapFrom(): number;
+  /** The end of preserved range. */
+  get gapTo(): number;
+  /** The slice to insert. */
+  get slice(): Slice;
+  /** The position in the slice where the preserved range should be inserted. */
+  get insert(): number;
+  /** @internal */
+  get structure(): boolean;
+  /** @internal */
+  static fromJSON(schema: Schema, json: any): ReplaceAroundStep;
+}
+/**
+ * Add a mark to all inline content between two positions.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class AddMarkStep extends CoreStep {
+  /** @internal */
+  readonly [CORE]: AddMarkStep$1;
+  /** Create a mark step. */
+  constructor(from: number, to: number, mark: Mark);
+  /** The start of the marked range. */
+  get from(): number;
+  /** The end of the marked range. */
+  get to(): number;
+  /** The mark to add. */
+  get mark(): Mark;
+  /** @internal */
+  static fromJSON(schema: Schema, json: any): AddMarkStep;
+}
+/**
+ * Remove a mark from all inline content between two positions.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class RemoveMarkStep extends CoreStep {
+  /** @internal */
+  readonly [CORE]: RemoveMarkStep$1;
+  /** Create a mark-removing step. */
+  constructor(from: number, to: number, mark: Mark);
+  /** The start of the unmarked range. */
+  get from(): number;
+  /** The end of the unmarked range. */
+  get to(): number;
+  /** The mark to remove. */
+  get mark(): Mark;
+  /** @internal */
+  static fromJSON(schema: Schema, json: any): RemoveMarkStep;
+}
+/**
+ * Add a mark to a specific node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class AddNodeMarkStep extends CoreStep {
+  /** @internal */
+  readonly [CORE]: AddNodeMarkStep$1;
+  /** Create a node mark step. */
+  constructor(pos: number, mark: Mark);
+  /** The position of the target node. */
+  get pos(): number;
+  /** The mark to add. */
+  get mark(): Mark;
+  /** @internal */
+  static fromJSON(schema: Schema, json: any): AddNodeMarkStep;
+}
+/**
+ * Remove a mark from a specific node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class RemoveNodeMarkStep extends CoreStep {
+  /** @internal */
+  readonly [CORE]: RemoveNodeMarkStep$1;
+  /** Create a mark-removing step. */
+  constructor(pos: number, mark: Mark);
+  /** The position of the target node. */
+  get pos(): number;
+  /** The mark to remove. */
+  get mark(): Mark;
+  /** @internal */
+  static fromJSON(schema: Schema, json: any): RemoveNodeMarkStep;
+}
+/**
+ * Update an attribute in a specific node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class AttrStep extends CoreStep {
+  /** @internal */
+  readonly [CORE]: AttrStep$1;
+  /** Construct an attribute step. */
+  constructor(pos: number, attr: string, value: any);
+  /** The position of the target node. */
+  get pos(): number;
+  /** The attribute to set. */
+  get attr(): string;
+  /** The attribute's new value. */
+  get value(): any;
+  /** @internal */
+  static fromJSON(schema: Schema, json: any): AttrStep;
+}
+/**
+ * Update an attribute in the doc node.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class DocAttrStep extends CoreStep {
+  /** @internal */
+  readonly [CORE]: DocAttrStep$1;
+  /** Construct an attribute step. */
+  constructor(attr: string, value: any);
+  /** The attribute to set. */
+  get attr(): string;
+  /** The attribute's new value. */
+  get value(): any;
+  /** @internal */
+  static fromJSON(schema: Schema, json: any): DocAttrStep;
+}
+/**
+ * A node type with attributes, as used by `findWrapping` and
+ * `Transform.wrap`.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export interface NodeTypeWithAttrs {
+  type: NodeType;
+  attrs?: Attrs | null;
+}
+/**
+ * Try to find a target depth to which the content in the given range
+ * can be lifted.
+ *
+ * @since 0.1.0
+ * @category structure
+ */
+export declare const liftTarget: (range: NodeRange) => number | null;
+/**
+ * Try to find a valid way to wrap the content in the given range in a
+ * node of the given type.
+ *
+ * @since 0.1.0
+ * @category structure
+ */
+export declare const findWrapping: (range: NodeRange, nodeType: NodeType, attrs?: Attrs | null, innerRange?: NodeRange) => Array<{
+  type: NodeType;
+  attrs: Attrs | null;
+}> | null;
+/**
+ * Check whether splitting at the given position is allowed.
+ *
+ * @since 0.1.0
+ * @category structure
+ */
+export declare const canSplit: (doc: Node, pos: number, depth?: number, typesAfter?: ReadonlyArray<NodeTypeWithAttrs | null | undefined>) => boolean;
+/**
+ * Test whether the blocks before and after a given position can be
+ * joined.
+ *
+ * @since 0.1.0
+ * @category structure
+ */
+export declare const canJoin: (doc: Node, pos: number) => boolean;
+/**
+ * Find an ancestor of the given position that can be joined to the
+ * block before (or after if `dir` is positive).
+ *
+ * @since 0.1.0
+ * @category structure
+ */
+export declare const joinPoint: (doc: Node, pos: number, dir?: number) => number | null;
+/**
+ * Try to find a point where a node of the given type can be inserted
+ * near `pos`, by searching up the node hierarchy when `pos` itself
+ * isn't a valid place but is at the start or end of a node.
+ *
+ * @since 0.1.0
+ * @category structure
+ */
+export declare const insertPoint: (doc: Node, pos: number, nodeType: NodeType) => number | null;
+/**
+ * Finds a position at or around the given position where the given
+ * slice can be inserted.
+ *
+ * @since 0.1.0
+ * @category structure
+ */
+export declare const dropPoint: (doc: Node, pos: number, slice: Slice) => number | null;
+/**
+ * 'Fit' a slice into a given position in the document, producing a
+ * step that inserts it. Will return null if there's no meaningful way
+ * to insert the slice here, or inserting it would be a no-op.
+ *
+ * @since 0.1.0
+ * @category structure
+ */
+export declare const replaceStep: (doc: Node, from: number, to?: number, slice?: Slice) => Step | null;
+/**
+ * Abstraction to build up and track an array of steps representing a
+ * document transformation.
+ *
+ * @since 0.1.0
+ * @category models
+ */
+export declare class Transform {
+  /** @internal */
+  readonly [CORE]: Transform$1;
+  /** Create a transform that starts with the given document. */
+  constructor(doc: Node);
+  /** The steps in this transform. */
+  get steps(): Array<Step>;
+  /** The documents before each of the steps. */
+  get docs(): Array<Node>;
+  /** A mapping with the maps for each of the steps in this transform. */
+  get mapping(): Mapping;
+  /** The current document (the result of applying the steps in the transform). */
+  get doc(): Node;
+  /** The starting document. */
+  get before(): Node;
+  /** Apply a new step in this transform, saving the result. Throws an error when the step fails. */
+  step(step: Step): this;
+  /** Try to apply a step in this transformation, ignoring it if it fails. Returns the step result. */
+  maybeStep(step: Step): StepResult;
+  /** True when the document has been changed (when there are any steps). */
+  get docChanged(): boolean;
+  /** Return a single range, in post-transform document positions, that covers all content changed by this transform. */
+  changedRange(): {
+    from: number;
+    to: number;
+  } | null;
+  /** @internal */
+  addStep(step: Step, doc: Node): void;
+  /** Replace the part of the document between `from` and `to` with the given `slice`. */
+  replace(from: number, to?: number, slice?: Slice): this;
+  /** Replace the given range with the given content, which may be a fragment, node, or array of nodes. */
+  replaceWith(from: number, to: number, content: Fragment | Node | ReadonlyArray<Node>): this;
+  /** Delete the content between the given positions. */
+  delete(from: number, to: number): this;
+  /** Insert the given content at the given position. */
+  insert(pos: number, content: Fragment | Node | ReadonlyArray<Node>): this;
+  /** Replace a range of the document with a given slice, using `from`, `to`, and the slice's `openStart` property as hints, rather than fixed start and end points. */
+  replaceRange(from: number, to: number, slice: Slice): this;
+  /** Replace the given range with a node, but use `from` and `to` as hints, rather than precise positions. */
+  replaceRangeWith(from: number, to: number, node: Node): this;
+  /** Delete the given range, expanding it to cover fully covered parent nodes until a valid replace is found. */
+  deleteRange(from: number, to: number): this;
+  /** Split the content in the given range off from its parent, if there is sibling content before or after it, and move it up the tree to the depth specified by `target`. */
+  lift(range: NodeRange, target: number): this;
+  /** Join the blocks around the given position. */
+  join(pos: number, depth?: number): this;
+  /** Wrap the given range in the given set of wrappers. */
+  wrap(range: NodeRange, wrappers: ReadonlyArray<NodeTypeWithAttrs>): this;
+  /** Set the type of all textblocks (partly) between `from` and `to` to the given node type with the given attributes. */
+  setBlockType(from: number, to: number | undefined, type: NodeType, attrs?: Attrs | null | ((oldNode: Node) => Attrs)): this;
+  /** Change the type, attributes, and/or marks of the node at `pos`. */
+  setNodeMarkup(pos: number, type?: NodeType | null, attrs?: Attrs | null, marks?: ReadonlyArray<Mark>): this;
+  /** Set a single attribute on a given node to a new value. */
+  setNodeAttribute(pos: number, attr: string, value: any): this;
+  /** Set a single attribute on the document to a new value. */
+  setDocAttribute(attr: string, value: any): this;
+  /** Add a mark to the node at position `pos`. */
+  addNodeMark(pos: number, mark: Mark): this;
+  /** Remove a mark (or all marks of the given type) from the node at position `pos`. */
+  removeNodeMark(pos: number, mark: Mark | MarkType): this;
+  /** Split the node at the given position, and optionally, if `depth` is greater than one, any number of nodes above that. */
+  split(pos: number, depth?: number, typesAfter?: ReadonlyArray<NodeTypeWithAttrs | null | undefined>): this;
+  /** Add the given mark to the inline content between `from` and `to`. */
+  addMark(from: number, to: number, mark: Mark): this;
+  /** Remove marks from inline nodes between `from` and `to`. */
+  removeMark(from: number, to: number, mark?: Mark | MarkType | null): this;
+  /** Removes all marks and nodes from the content of the node at `pos` that don't match the given new parent node type. */
+  clearIncompatible(pos: number, parentType: NodeType, match?: ContentMatch): this;
+}
+/**
+ * Get the core (Effect API) object behind a facade. For a user-defined
+ * `Step` subclass, this is a core step that delegates to it.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare function toCore(step: ReplaceStep): ReplaceStep$1;
+export declare function toCore(step: ReplaceAroundStep): ReplaceAroundStep$1;
+export declare function toCore(step: Step): Step$1;
+export declare function toCore(mapping: Mapping): Mapping$1;
+export declare function toCore(tr: Transform): Transform$1;
+/**
+ * Get the facade for a core (Effect API) object.
+ *
+ * @since 0.1.0
+ * @category conversions
+ */
+export declare function fromCore(step: ReplaceStep$1<any>): ReplaceStep;
+export declare function fromCore(step: ReplaceAroundStep$1<any>): ReplaceAroundStep;
+export declare function fromCore(step: Step$1<any>): Step;
+export declare function fromCore(mapping: Mapping$1): Mapping;
+export declare function fromCore(result: StepResult$1<any>): StepResult;
+export declare function fromCore(tr: Transform$1<any>): Transform;
+export { MapResult, type Mappable, StepMap, TransformError };