@depup/prosemirror-state 1.4.4-depup.0

package/src/state.ts

@@ -0,0 +1,266 @@
+import {Node, Mark, Schema} from "prosemirror-model"
+
+import {Selection, TextSelection} from "./selection"
+import {Transaction} from "./transaction"
+import {Plugin, StateField} from "./plugin"
+
+function bind<T extends Function>(f: T, self: any): T {
+  return !self || !f ? f : f.bind(self)
+}
+
+class FieldDesc<T> {
+  init: (config: EditorStateConfig, instance: EditorState) => T
+  apply: (tr: Transaction, value: T, oldState: EditorState, newState: EditorState) => T
+
+  constructor(readonly name: string, desc: StateField<any>, self?: any) {
+    this.init = bind(desc.init, self)
+    this.apply = bind(desc.apply, self)
+  }
+}
+
+const baseFields = [
+  new FieldDesc<Node>("doc", {
+    init(config) { return config.doc || config.schema!.topNodeType.createAndFill() },
+    apply(tr) { return tr.doc }
+  }),
+
+  new FieldDesc<Selection>("selection", {
+    init(config, instance) { return config.selection || Selection.atStart(instance.doc) },
+    apply(tr) { return tr.selection }
+  }),
+
+  new FieldDesc<readonly Mark[] | null>("storedMarks", {
+    init(config) { return config.storedMarks || null },
+    apply(tr, _marks, _old, state) { return (state.selection as TextSelection).$cursor ? tr.storedMarks : null }
+  }),
+
+  new FieldDesc<number>("scrollToSelection", {
+    init() { return 0 },
+    apply(tr, prev) { return tr.scrolledIntoView ? prev + 1 : prev }
+  })
+]
+
+// Object wrapping the part of a state object that stays the same
+// across transactions. Stored in the state's `config` property.
+class Configuration {
+  fields: FieldDesc<any>[]
+  plugins: Plugin[] = []
+  pluginsByKey: {[key: string]: Plugin} = Object.create(null)
+
+  constructor(readonly schema: Schema, plugins?: readonly Plugin[]) {
+    this.fields = baseFields.slice()
+    if (plugins) plugins.forEach(plugin => {
+      if (this.pluginsByKey[plugin.key])
+        throw new RangeError("Adding different instances of a keyed plugin (" + plugin.key + ")")
+      this.plugins.push(plugin)
+      this.pluginsByKey[plugin.key] = plugin
+      if (plugin.spec.state)
+        this.fields.push(new FieldDesc<any>(plugin.key, plugin.spec.state, plugin))
+    })
+  }
+}
+
+/// The type of object passed to
+/// [`EditorState.create`](#state.EditorState^create).
+export interface EditorStateConfig {
+  /// The schema to use (only relevant if no `doc` is specified).
+  schema?: Schema
+
+  /// The starting document. Either this or `schema` _must_ be
+  /// provided.
+  doc?: Node
+
+  /// A valid selection in the document.
+  selection?: Selection
+
+  /// The initial set of [stored marks](#state.EditorState.storedMarks).
+  storedMarks?: readonly Mark[] | null
+
+  /// The plugins that should be active in this state.
+  plugins?: readonly Plugin[]
+}
+
+/// The state of a ProseMirror editor is represented by an object of
+/// this type. A state is a persistent data structure—it isn't
+/// updated, but rather a new state value is computed from an old one
+/// using the [`apply`](#state.EditorState.apply) method.
+///
+/// A state holds a number of built-in fields, and plugins can
+/// [define](#state.PluginSpec.state) additional fields.
+export class EditorState {
+  /// @internal
+  constructor(
+    /// @internal
+    readonly config: Configuration
+  ) {}
+
+  /// The current document.
+  declare doc: Node
+
+  /// The selection.
+  declare selection: Selection
+
+  /// A set of marks to apply to the next input. Will be null when
+  /// no explicit marks have been set.
+  declare storedMarks: readonly Mark[] | null
+
+  /// The schema of the state's document.
+  get schema(): Schema {
+    return this.config.schema
+  }
+
+  /// The plugins that are active in this state.
+  get plugins(): readonly Plugin[] {
+    return this.config.plugins
+  }
+
+  /// Apply the given transaction to produce a new state.
+  apply(tr: Transaction): EditorState {
+    return this.applyTransaction(tr).state
+  }
+
+  /// @internal
+  filterTransaction(tr: Transaction, ignore = -1) {
+    for (let i = 0; i < this.config.plugins.length; i++) if (i != ignore) {
+      let plugin = this.config.plugins[i]
+      if (plugin.spec.filterTransaction && !plugin.spec.filterTransaction.call(plugin, tr, this))
+        return false
+    }
+    return true
+  }
+
+  /// Verbose variant of [`apply`](#state.EditorState.apply) that
+  /// returns the precise transactions that were applied (which might
+  /// be influenced by the [transaction
+  /// hooks](#state.PluginSpec.filterTransaction) of
+  /// plugins) along with the new state.
+  applyTransaction(rootTr: Transaction): {state: EditorState, transactions: readonly Transaction[]} {
+    if (!this.filterTransaction(rootTr)) return {state: this, transactions: []}
+
+    let trs = [rootTr], newState = this.applyInner(rootTr), seen = null
+    // This loop repeatedly gives plugins a chance to respond to
+    // transactions as new transactions are added, making sure to only
+    // pass the transactions the plugin did not see before.
+    for (;;) {
+      let haveNew = false
+      for (let i = 0; i < this.config.plugins.length; i++) {
+        let plugin = this.config.plugins[i]
+        if (plugin.spec.appendTransaction) {
+          let n = seen ? seen[i].n : 0, oldState = seen ? seen[i].state : this
+          let tr = n < trs.length &&
+              plugin.spec.appendTransaction.call(plugin, n ? trs.slice(n) : trs, oldState, newState)
+          if (tr && newState.filterTransaction(tr, i)) {
+            tr.setMeta("appendedTransaction", rootTr)
+            if (!seen) {
+              seen = []
+              for (let j = 0; j < this.config.plugins.length; j++)
+                seen.push(j < i ? {state: newState, n: trs.length} : {state: this, n: 0})
+            }
+            trs.push(tr)
+            newState = newState.applyInner(tr)
+            haveNew = true
+          }
+          if (seen) seen[i] = {state: newState, n: trs.length}
+        }
+      }
+      if (!haveNew) return {state: newState, transactions: trs}
+    }
+  }
+
+  /// @internal
+  applyInner(tr: Transaction) {
+    if (!tr.before.eq(this.doc)) throw new RangeError("Applying a mismatched transaction")
+    let newInstance = new EditorState(this.config), fields = this.config.fields
+    for (let i = 0; i < fields.length; i++) {
+      let field = fields[i]
+      ;(newInstance as any)[field.name] = field.apply(tr, (this as any)[field.name], this, newInstance)
+    }
+    return newInstance
+  }
+
+  /// Accessor that constructs and returns a new [transaction](#state.Transaction) from this state.
+  get tr(): Transaction { return new Transaction(this) }
+
+  /// Create a new state.
+  static create(config: EditorStateConfig) {
+    let $config = new Configuration(config.doc ? config.doc.type.schema : config.schema!, config.plugins)
+    let instance = new EditorState($config)
+    for (let i = 0; i < $config.fields.length; i++)
+      (instance as any)[$config.fields[i].name] = $config.fields[i].init(config, instance)
+    return instance
+  }
+
+  /// Create a new state based on this one, but with an adjusted set
+  /// of active plugins. State fields that exist in both sets of
+  /// plugins are kept unchanged. Those that no longer exist are
+  /// dropped, and those that are new are initialized using their
+  /// [`init`](#state.StateField.init) method, passing in the new
+  /// configuration object..
+  reconfigure(config: {
+    /// New set of active plugins.
+    plugins?: readonly Plugin[]    
+  }) {
+    let $config = new Configuration(this.schema, config.plugins)
+    let fields = $config.fields, instance = new EditorState($config)
+    for (let i = 0; i < fields.length; i++) {
+      let name = fields[i].name
+      ;(instance as any)[name] = this.hasOwnProperty(name) ? (this as any)[name] : fields[i].init(config, instance)
+    }
+    return instance
+  }
+
+  /// Serialize this state to JSON. If you want to serialize the state
+  /// of plugins, pass an object mapping property names to use in the
+  /// resulting JSON object to plugin objects. The argument may also be
+  /// a string or number, in which case it is ignored, to support the
+  /// way `JSON.stringify` calls `toString` methods.
+  toJSON(pluginFields?: {[propName: string]: Plugin}): any {
+    let result: any = {doc: this.doc.toJSON(), selection: this.selection.toJSON()}
+    if (this.storedMarks) result.storedMarks = this.storedMarks.map(m => m.toJSON())
+    if (pluginFields && typeof pluginFields == 'object') for (let prop in pluginFields) {
+      if (prop == "doc" || prop == "selection")
+        throw new RangeError("The JSON fields `doc` and `selection` are reserved")
+      let plugin = pluginFields[prop], state = plugin.spec.state
+      if (state && state.toJSON) result[prop] = state.toJSON.call(plugin, (this as any)[plugin.key])
+    }
+    return result
+  }
+
+  /// Deserialize a JSON representation of a state. `config` should
+  /// have at least a `schema` field, and should contain array of
+  /// plugins to initialize the state with. `pluginFields` can be used
+  /// to deserialize the state of plugins, by associating plugin
+  /// instances with the property names they use in the JSON object.
+  static fromJSON(config: {
+    /// The schema to use.
+    schema: Schema
+    /// The set of active plugins.
+    plugins?: readonly Plugin[]
+  }, json: any, pluginFields?: {[propName: string]: Plugin}) {
+    if (!json) throw new RangeError("Invalid input for EditorState.fromJSON")
+    if (!config.schema) throw new RangeError("Required config field 'schema' missing")
+    let $config = new Configuration(config.schema, config.plugins)
+    let instance = new EditorState($config)
+    $config.fields.forEach(field => {
+      if (field.name == "doc") {
+        instance.doc = Node.fromJSON(config.schema, json.doc)
+      } else if (field.name == "selection") {
+        instance.selection = Selection.fromJSON(instance.doc, json.selection)
+      } else if (field.name == "storedMarks") {
+        if (json.storedMarks) instance.storedMarks = json.storedMarks.map(config.schema.markFromJSON)
+      } else {
+        if (pluginFields) for (let prop in pluginFields) {
+          let plugin = pluginFields[prop], state = plugin.spec.state
+          if (plugin.key == field.name && state && state.fromJSON &&
+              Object.prototype.hasOwnProperty.call(json, prop)) {
+            // This field belongs to a plugin mapped to a JSON field, read it from there.
+            ;(instance as any)[field.name] = state.fromJSON.call(plugin, config, json[prop], instance)
+            return
+          }
+        }
+        ;(instance as any)[field.name] = field.init(config, instance)
+      }
+    })
+    return instance
+  }
+}

package/src/transaction.ts

@@ -0,0 +1,215 @@
+import {Transform, Step} from "prosemirror-transform"
+import {Mark, MarkType, Node, Slice} from "prosemirror-model"
+import {type EditorView} from "prosemirror-view"
+import {Selection} from "./selection"
+import {Plugin, PluginKey} from "./plugin"
+import {EditorState} from "./state"
+
+/// Commands are functions that take a state and a an optional
+/// transaction dispatch function and...
+///
+///  - determine whether they apply to this state
+///  - if not, return false
+///  - if `dispatch` was passed, perform their effect, possibly by
+///    passing a transaction to `dispatch`
+///  - return true
+///
+/// In some cases, the editor view is passed as a third argument.
+export type Command = (state: EditorState, dispatch?: (tr: Transaction) => void, view?: EditorView) => boolean
+
+const UPDATED_SEL = 1, UPDATED_MARKS = 2, UPDATED_SCROLL = 4
+
+/// An editor state transaction, which can be applied to a state to
+/// create an updated state. Use
+/// [`EditorState.tr`](#state.EditorState.tr) to create an instance.
+///
+/// Transactions track changes to the document (they are a subclass of
+/// [`Transform`](#transform.Transform)), but also other state changes,
+/// like selection updates and adjustments of the set of [stored
+/// marks](#state.EditorState.storedMarks). In addition, you can store
+/// metadata properties in a transaction, which are extra pieces of
+/// information that client code or plugins can use to describe what a
+/// transaction represents, so that they can update their [own
+/// state](#state.StateField) accordingly.
+///
+/// The [editor view](#view.EditorView) uses a few metadata
+/// properties: it will attach a property `"pointer"` with the value
+/// `true` to selection transactions directly caused by mouse or touch
+/// input, a `"composition"` property holding an ID identifying the
+/// composition that caused it to transactions caused by composed DOM
+/// input, and a `"uiEvent"` property of that may be `"paste"`,
+/// `"cut"`, or `"drop"`.
+export class Transaction extends Transform {
+  /// The timestamp associated with this transaction, in the same
+  /// format as `Date.now()`.
+  time: number
+
+  private curSelection: Selection
+  // The step count for which the current selection is valid.
+  private curSelectionFor = 0
+  // Bitfield to track which aspects of the state were updated by
+  // this transaction.
+  private updated = 0
+  // Object used to store metadata properties for the transaction.
+  private meta: {[name: string]: any} = Object.create(null)
+
+  /// The stored marks set by this transaction, if any.
+  storedMarks: readonly Mark[] | null
+
+  /// @internal
+  constructor(state: EditorState) {
+    super(state.doc)
+    this.time = Date.now()
+    this.curSelection = state.selection
+    this.storedMarks = state.storedMarks
+  }
+
+  /// The transaction's current selection. This defaults to the editor
+  /// selection [mapped](#state.Selection.map) through the steps in the
+  /// transaction, but can be overwritten with
+  /// [`setSelection`](#state.Transaction.setSelection).
+  get selection(): Selection {
+    if (this.curSelectionFor < this.steps.length) {
+      this.curSelection = this.curSelection.map(this.doc, this.mapping.slice(this.curSelectionFor))
+      this.curSelectionFor = this.steps.length
+    }
+    return this.curSelection
+  }
+
+  /// Update the transaction's current selection. Will determine the
+  /// selection that the editor gets when the transaction is applied.
+  setSelection(selection: Selection): this {
+    if (selection.$from.doc != this.doc)
+      throw new RangeError("Selection passed to setSelection must point at the current document")
+    this.curSelection = selection
+    this.curSelectionFor = this.steps.length
+    this.updated = (this.updated | UPDATED_SEL) & ~UPDATED_MARKS
+    this.storedMarks = null
+    return this
+  }
+
+  /// Whether the selection was explicitly updated by this transaction.
+  get selectionSet() {
+    return (this.updated & UPDATED_SEL) > 0
+  }
+
+  /// Set the current stored marks.
+  setStoredMarks(marks: readonly Mark[] | null): this {
+    this.storedMarks = marks
+    this.updated |= UPDATED_MARKS
+    return this
+  }
+
+  /// Make sure the current stored marks or, if that is null, the marks
+  /// at the selection, match the given set of marks. Does nothing if
+  /// this is already the case.
+  ensureMarks(marks: readonly Mark[]): this {
+    if (!Mark.sameSet(this.storedMarks || this.selection.$from.marks(), marks))
+      this.setStoredMarks(marks)
+    return this
+  }
+
+  /// Add a mark to the set of stored marks.
+  addStoredMark(mark: Mark): this {
+    return this.ensureMarks(mark.addToSet(this.storedMarks || this.selection.$head.marks()))
+  }
+
+  /// Remove a mark or mark type from the set of stored marks.
+  removeStoredMark(mark: Mark | MarkType): this {
+    return this.ensureMarks(mark.removeFromSet(this.storedMarks || this.selection.$head.marks()))
+  }
+
+  /// Whether the stored marks were explicitly set for this transaction.
+  get storedMarksSet() {
+    return (this.updated & UPDATED_MARKS) > 0
+  }
+
+  /// @internal
+  addStep(step: Step, doc: Node) {
+    super.addStep(step, doc)
+    this.updated = this.updated & ~UPDATED_MARKS
+    this.storedMarks = null
+  }
+
+  /// Update the timestamp for the transaction.
+  setTime(time: number): this {
+    this.time = time
+    return this
+  }
+
+  /// Replace the current selection with the given slice.
+  replaceSelection(slice: Slice): this {
+    this.selection.replace(this, slice)
+    return this
+  }
+
+  /// Replace the selection with the given node. When `inheritMarks` is
+  /// true and the content is inline, it inherits the marks from the
+  /// place where it is inserted.
+  replaceSelectionWith(node: Node, inheritMarks = true): this {
+    let selection = this.selection
+    if (inheritMarks)
+      node = node.mark(this.storedMarks || (selection.empty ? selection.$from.marks() : (selection.$from.marksAcross(selection.$to) || Mark.none)))
+    selection.replaceWith(this, node)
+    return this
+  }
+
+  /// Delete the selection.
+  deleteSelection(): this {
+    this.selection.replace(this)
+    return this
+  }
+
+  /// Replace the given range, or the selection if no range is given,
+  /// with a text node containing the given string.
+  insertText(text: string, from?: number, to?: number): this {
+    let schema = this.doc.type.schema
+    if (from == null) {
+      if (!text) return this.deleteSelection()
+      return this.replaceSelectionWith(schema.text(text), true)
+    } else {
+      if (to == null) to = from
+      if (!text) return this.deleteRange(from, to)
+      let marks = this.storedMarks
+      if (!marks) {
+        let $from = this.doc.resolve(from)
+        marks = to == from ? $from.marks() : $from.marksAcross(this.doc.resolve(to))
+      }
+      this.replaceRangeWith(from, to, schema.text(text, marks))
+      if (!this.selection.empty && this.selection.to == from + text.length)
+        this.setSelection(Selection.near(this.selection.$to))
+      return this
+    }
+  }
+
+  /// Store a metadata property in this transaction, keyed either by
+  /// name or by plugin.
+  setMeta(key: string | Plugin | PluginKey, value: any): this {
+    this.meta[typeof key == "string" ? key : key.key] = value
+    return this
+  }
+
+  /// Retrieve a metadata property for a given name or plugin.
+  getMeta(key: string | Plugin | PluginKey) {
+    return this.meta[typeof key == "string" ? key : key.key]
+  }
+
+  /// Returns true if this transaction doesn't contain any metadata,
+  /// and can thus safely be extended.
+  get isGeneric() {
+    for (let _ in this.meta) return false
+    return true
+  }
+
+  /// Indicate that the editor should scroll the selection into view
+  /// when updated to the state produced by this transaction.
+  scrollIntoView(): this {
+    this.updated |= UPDATED_SCROLL
+    return this
+  }
+
+  /// True when this transaction has had `scrollIntoView` called on it.
+  get scrolledIntoView() {
+    return (this.updated & UPDATED_SCROLL) > 0
+  }
+}