quill-delta

You can create a new Delta instance using the constructor in three ways:

1. new Delta(): Creates an empty Delta.
2. new Delta(ops): Creates a Delta from an array of operation objects.
3. new Delta(delta): Creates a Delta from an existing Delta object (which must have an ops key).

Note: No validity/sanity checks are performed during construction. The internal ops array is assigned by reference from the input without deep copying.

const delta = new Delta([
  { insert: 'Hello World' },
  { insert: '!', attributes: { bold: true }}
]);

The partition(predicate) method creates an array of two arrays: the first contains operations that passed the predicate, and the second contains those that failed.

const delta = new Delta().insert('Hello', { bold: true })
                         .insert({ image: 'https://octodex.github.com/images/labtocat.png' })
                         .insert('World!');

const results = delta.partition((op) => typeof op.insert === 'string');
const passed = results[0];  // [{ insert: 'Hello', attributes: { bold: true }}, { insert: 'World'}]
const failed = results[1];  // [{ insert: { image: 'https://octodex.github.com/images/labtocat.png' }}]

The reduce(predicate, initialValue) method applies a function against an accumulator and each operation to reduce the Delta to a single value.

const delta = new Delta().insert('Hello', { bold: true })
                         .insert({ image: 'https://octodex.github.com/images/labtocat.png' })
                         .insert('World!');

const length = delta.reduce((length, op) => (
  length + (op.insert.length || 1);
), 0);

The map(predicate) method returns a new array containing the results of calling the provided function on each operation. This is useful for extracting or transforming data from the operations.

const delta = new Delta().insert('Hello', { bold: true })
                         .insert({ image: 'https://octodex.github.com/images/labtocat.png' })
                         .insert('World!');

const text = delta
  .map((op) => {
    if (typeof op.insert === 'string') {
      return op.insert;
    } else {
      return '';
    }
  })
  .join('');

The slice([start], [end]) method returns a copy of the Delta containing a subset of its operations.

• start: The starting index (defaults to 0).
• end: The ending index (defaults to the end of the operations).

const delta = new Delta().insert('Hello', { bold: true }).insert(' World');

// Returns a full copy
const copy = delta.slice();

// Returns subset starting at index 6
const world = delta.slice(6);

// Returns subset from index 5 to 6
const space = delta.slice(5, 6);

The filter(predicate) method returns an array of operations that pass a given test function. This is useful for isolating specific types of operations, such as only text insertions.

const delta = new Delta().insert('Hello', { bold: true })
                         .insert({ image: 'https://octodex.github.com/images/labtocat.png' })
                         .insert('World!');

const text = delta
  .filter((op) => typeof op.insert === 'string')
  .map((op) => op.insert)
  .join('');

The transform(other, [priority]) method transforms the current Delta against another Delta (other).

• priority: A boolean used to break ties. If true, the current Delta (this) takes priority over other, meaning its actions are considered to happen first.

const a = new Delta().insert('a');
const b = new Delta().insert('b').retain(5).insert('c');

a.transform(b, true);  // new Delta().retain(1).insert('b').retain(5).insert('c');
a.transform(b, false); // new Delta().insert('b').retain(6).insert('c');

The length() method returns the total length of the Delta, which is calculated as the sum of the lengths of its operations.

new Delta().insert('Hello').length();  // Returns 5

new Delta().insert('A').retain(2).delete(1).length(); // Returns 4

The compose(other) method returns a new Delta that is equivalent to applying the operations of the current Delta, followed by the operations of the other Delta.

const a = new Delta().insert('abc');
const b = new Delta().retain(1).delete(1);

const composed = a.compose(b);  // composed == new Delta().insert('ac');

The invert(base) method returns an inverted Delta that has the opposite effect of the current Delta when applied against a base document Delta.

Mathematically: base.compose(delta).compose(inverted) === base.

const base = new Delta().insert('Hello\n').insert('World');
const delta = new Delta().retain(6, { bold: true }).insert('!').delete(5);

const inverted = delta.invert(base);