Bring projects, wikis, and teams together with AI. AppFlowy is the AI collaborative workspace where you achieve more without losing control of your data. The leading open source Notion alternative.
Dart blogconfluence-alternativecontent-managementcontent-servicesdocumentationflutternote-takingnotion-alternativeproject-managementtask-managementteam-collaborationwiki
chore: add documentation for lib-ot crate
appflowy3c5b9e6b5009
diff --git a/frontend/rust-lib/flowy-grid/src/services/field/type_options/checkbox_type_option/checkbox_tests.rs b/frontend/rust-lib/flowy-grid/src/services/field/type_options/checkbox_type_option/checkbox_tests.rsindex b9d155da7d..ddd1ba049d 100644--- a/frontend/rust-lib/flowy-grid/src/services/field/type_options/checkbox_type_option/checkbox_tests.rs+++ b/frontend/rust-lib/flowy-grid/src/services/field/type_options/checkbox_type_option/checkbox_tests.rs@@ -1,7 +1,7 @@#[cfg(test)]mod tests {use crate::entities::FieldType;- use crate::services::cell::{apply_cell_data_changeset, decode_any_cell_data, CellDataOperation};+ use crate::services::cell::CellDataOperation;use crate::services::field::type_options::checkbox_type_option::*;use crate::services::field::FieldBuilder;use flowy_grid_data_model::revision::FieldRevision;diff --git a/frontend/rust-lib/flowy-grid/src/services/field/type_options/date_type_option/date_tests.rs b/frontend/rust-lib/flowy-grid/src/services/field/type_options/date_type_option/date_tests.rsindex 74b6ee6fd8..1229a8f5e1 100644--- a/frontend/rust-lib/flowy-grid/src/services/field/type_options/date_type_option/date_tests.rs+++ b/frontend/rust-lib/flowy-grid/src/services/field/type_options/date_type_option/date_tests.rs@@ -1,7 +1,7 @@#[cfg(test)]mod tests {use crate::entities::FieldType;- use crate::services::cell::{CellDataChangeset, CellDataOperation};+ use crate::services::cell::CellDataOperation;use crate::services::field::*;// use crate::services::field::{DateCellChangeset, DateCellData, DateFormat, DateTypeOption, TimeFormat};use flowy_grid_data_model::revision::FieldRevision;diff --git a/frontend/rust-lib/flowy-text-block/tests/editor/op_test.rs b/frontend/rust-lib/flowy-text-block/tests/editor/op_test.rsindex 3f174fa3bc..47d3c5ebfe 100644--- a/frontend/rust-lib/flowy-text-block/tests/editor/op_test.rs+++ b/frontend/rust-lib/flowy-text-block/tests/editor/op_test.rs@@ -2,6 +2,7 @@use crate::editor::{Rng, TestBuilder, TestOp::*};use flowy_sync::client_document::{NewlineDoc, PlainDoc};use lib_ot::{+ core::Interval,core::*,rich_text::{AttributeBuilder, RichTextAttribute, RichTextAttributes, RichTextDelta},};@@ -39,23 +40,23 @@ fn attributes_insert_text_at_middle() {#[test]fn delta_get_ops_in_interval_1() {let mut delta = RichTextDelta::default();- let insert_a = OpBuilder::insert("123").build();- let insert_b = OpBuilder::insert("4").build();+ let insert_a = OperationBuilder::insert("123").build();+ let insert_b = OperationBuilder::insert("4").build();delta.add(insert_a.clone());delta.add(insert_b.clone());- let mut iterator = DeltaIter::from_interval(&delta, Interval::new(0, 4));+ let mut iterator = DeltaIterator::from_interval(&delta, Interval::new(0, 4));assert_eq!(iterator.ops(), delta.ops);}#[test]fn delta_get_ops_in_interval_2() {let mut delta = RichTextDelta::default();- let insert_a = OpBuilder::insert("123").build();- let insert_b = OpBuilder::insert("4").build();- let insert_c = OpBuilder::insert("5").build();- let retain_a = OpBuilder::retain(3).build();+ let insert_a = OperationBuilder::insert("123").build();+ let insert_b = OperationBuilder::insert("4").build();+ let insert_c = OperationBuilder::insert("5").build();+ let retain_a = OperationBuilder::retain(3).build();delta.add(insert_a.clone());delta.add(retain_a.clone());@@ -63,32 +64,32 @@ fn delta_get_ops_in_interval_2() {delta.add(insert_c.clone());assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(0, 2)).ops(),- vec![OpBuilder::insert("12").build()]+ DeltaIterator::from_interval(&delta, Interval::new(0, 2)).ops(),+ vec![OperationBuilder::insert("12").build()]);assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(1, 3)).ops(),- vec![OpBuilder::insert("23").build()]+ DeltaIterator::from_interval(&delta, Interval::new(1, 3)).ops(),+ vec![OperationBuilder::insert("23").build()]);assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(0, 3)).ops(),+ DeltaIterator::from_interval(&delta, Interval::new(0, 3)).ops(),vec![insert_a.clone()]);assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(0, 4)).ops(),- vec![insert_a.clone(), OpBuilder::retain(1).build()]+ DeltaIterator::from_interval(&delta, Interval::new(0, 4)).ops(),+ vec![insert_a.clone(), OperationBuilder::retain(1).build()]);assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(0, 6)).ops(),+ DeltaIterator::from_interval(&delta, Interval::new(0, 6)).ops(),vec![insert_a.clone(), retain_a.clone()]);assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(0, 7)).ops(),+ DeltaIterator::from_interval(&delta, Interval::new(0, 7)).ops(),vec![insert_a.clone(), retain_a.clone(), insert_b.clone()]);}@@ -96,54 +97,60 @@ fn delta_get_ops_in_interval_2() {#[test]fn delta_get_ops_in_interval_3() {let mut delta = RichTextDelta::default();- let insert_a = OpBuilder::insert("123456").build();+ let insert_a = OperationBuilder::insert("123456").build();delta.add(insert_a.clone());assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(3, 5)).ops(),- vec![OpBuilder::insert("45").build()]+ DeltaIterator::from_interval(&delta, Interval::new(3, 5)).ops(),+ vec![OperationBuilder::insert("45").build()]);}#[test]fn delta_get_ops_in_interval_4() {let mut delta = RichTextDelta::default();- let insert_a = OpBuilder::insert("12").build();- let insert_b = OpBuilder::insert("34").build();- let insert_c = OpBuilder::insert("56").build();+ let insert_a = OperationBuilder::insert("12").build();+ let insert_b = OperationBuilder::insert("34").build();+ let insert_c = OperationBuilder::insert("56").build();delta.ops.push(insert_a.clone());delta.ops.push(insert_b.clone());delta.ops.push(insert_c.clone());assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(0, 2)).ops(),+ DeltaIterator::from_interval(&delta, Interval::new(0, 2)).ops(),vec![insert_a]);assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(2, 4)).ops(),+ DeltaIterator::from_interval(&delta, Interval::new(2, 4)).ops(),vec![insert_b]);assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(4, 6)).ops(),+ DeltaIterator::from_interval(&delta, Interval::new(4, 6)).ops(),vec![insert_c]);assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(2, 5)).ops(),- vec![OpBuilder::insert("34").build(), OpBuilder::insert("5").build()]+ DeltaIterator::from_interval(&delta, Interval::new(2, 5)).ops(),+ vec![+ OperationBuilder::insert("34").build(),+ OperationBuilder::insert("5").build()+ ]);}#[test]fn delta_get_ops_in_interval_5() {let mut delta = RichTextDelta::default();- let insert_a = OpBuilder::insert("123456").build();- let insert_b = OpBuilder::insert("789").build();+ let insert_a = OperationBuilder::insert("123456").build();+ let insert_b = OperationBuilder::insert("789").build();delta.ops.push(insert_a.clone());delta.ops.push(insert_b.clone());assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(4, 8)).ops(),- vec![OpBuilder::insert("56").build(), OpBuilder::insert("78").build()]+ DeltaIterator::from_interval(&delta, Interval::new(4, 8)).ops(),+ vec![+ OperationBuilder::insert("56").build(),+ OperationBuilder::insert("78").build()+ ]);// assert_eq!(@@ -155,54 +162,60 @@ fn delta_get_ops_in_interval_5() {#[test]fn delta_get_ops_in_interval_6() {let mut delta = RichTextDelta::default();- let insert_a = OpBuilder::insert("12345678").build();+ let insert_a = OperationBuilder::insert("12345678").build();delta.add(insert_a.clone());assert_eq!(- DeltaIter::from_interval(&delta, Interval::new(4, 6)).ops(),- vec![OpBuilder::insert("56").build()]+ DeltaIterator::from_interval(&delta, Interval::new(4, 6)).ops(),+ vec![OperationBuilder::insert("56").build()]);}#[test]fn delta_get_ops_in_interval_7() {let mut delta = RichTextDelta::default();- let insert_a = OpBuilder::insert("12345").build();- let retain_a = OpBuilder::retain(3).build();+ let insert_a = OperationBuilder::insert("12345").build();+ let retain_a = OperationBuilder::retain(3).build();delta.add(insert_a.clone());delta.add(retain_a.clone());- let mut iter_1 = DeltaIter::from_offset(&delta, 2);- assert_eq!(iter_1.next_op().unwrap(), OpBuilder::insert("345").build());- assert_eq!(iter_1.next_op().unwrap(), OpBuilder::retain(3).build());+ let mut iter_1 = DeltaIterator::from_offset(&delta, 2);+ assert_eq!(iter_1.next_op().unwrap(), OperationBuilder::insert("345").build());+ assert_eq!(iter_1.next_op().unwrap(), OperationBuilder::retain(3).build());- let mut iter_2 = DeltaIter::new(&delta);- assert_eq!(iter_2.next_op_with_len(2).unwrap(), OpBuilder::insert("12").build());- assert_eq!(iter_2.next_op().unwrap(), OpBuilder::insert("345").build());+ let mut iter_2 = DeltaIterator::new(&delta);+ assert_eq!(+ iter_2.next_op_with_len(2).unwrap(),+ OperationBuilder::insert("12").build()+ );+ assert_eq!(iter_2.next_op().unwrap(), OperationBuilder::insert("345").build());- assert_eq!(iter_2.next_op().unwrap(), OpBuilder::retain(3).build());+ assert_eq!(iter_2.next_op().unwrap(), OperationBuilder::retain(3).build());}#[test]fn delta_op_seek() {let mut delta = RichTextDelta::default();- let insert_a = OpBuilder::insert("12345").build();- let retain_a = OpBuilder::retain(3).build();+ let insert_a = OperationBuilder::insert("12345").build();+ let retain_a = OperationBuilder::retain(3).build();delta.add(insert_a.clone());delta.add(retain_a.clone());- let mut iter = DeltaIter::new(&delta);+ let mut iter = DeltaIterator::new(&delta);iter.seek::<OpMetric>(1);- assert_eq!(iter.next_op().unwrap(), OpBuilder::retain(3).build());+ assert_eq!(iter.next_op().unwrap(), retain_a);}#[test]fn delta_utf16_code_unit_seek() {let mut delta = RichTextDelta::default();- delta.add(OpBuilder::insert("12345").build());+ delta.add(OperationBuilder::insert("12345").build());- let mut iter = DeltaIter::new(&delta);+ let mut iter = DeltaIterator::new(&delta);iter.seek::<Utf16CodeUnitMetric>(3);- assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::insert("45").build());+ assert_eq!(+ iter.next_op_with_len(2).unwrap(),+ OperationBuilder::insert("45").build()+ );}#[test]@@ -213,77 +226,92 @@ fn delta_utf16_code_unit_seek_with_attributes() {.add_attr(RichTextAttribute::Italic(true)).build();- delta.add(OpBuilder::insert("1234").attributes(attributes.clone()).build());- delta.add(OpBuilder::insert("\n").build());+ delta.add(OperationBuilder::insert("1234").attributes(attributes.clone()).build());+ delta.add(OperationBuilder::insert("\n").build());- let mut iter = DeltaIter::new(&delta);+ let mut iter = DeltaIterator::new(&delta);iter.seek::<Utf16CodeUnitMetric>(0);assert_eq!(iter.next_op_with_len(4).unwrap(),- OpBuilder::insert("1234").attributes(attributes).build(),+ OperationBuilder::insert("1234").attributes(attributes).build(),);}#[test]fn delta_next_op_len() {let mut delta = RichTextDelta::default();- delta.add(OpBuilder::insert("12345").build());- let mut iter = DeltaIter::new(&delta);- assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::insert("12").build());- assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::insert("34").build());- assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::insert("5").build());+ delta.add(OperationBuilder::insert("12345").build());+ let mut iter = DeltaIterator::new(&delta);+ assert_eq!(+ iter.next_op_with_len(2).unwrap(),+ OperationBuilder::insert("12").build()+ );+ assert_eq!(+ iter.next_op_with_len(2).unwrap(),+ OperationBuilder::insert("34").build()+ );+ assert_eq!(iter.next_op_with_len(2).unwrap(), OperationBuilder::insert("5").build());assert_eq!(iter.next_op_with_len(1), None);}#[test]fn delta_next_op_len_with_chinese() {let mut delta = RichTextDelta::default();- delta.add(OpBuilder::insert("你好").build());+ delta.add(OperationBuilder::insert("你好").build());- let mut iter = DeltaIter::new(&delta);+ let mut iter = DeltaIterator::new(&delta);assert_eq!(iter.next_op_len().unwrap(), 2);- assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::insert("你好").build());+ assert_eq!(+ iter.next_op_with_len(2).unwrap(),+ OperationBuilder::insert("你好").build()+ );}#[test]fn delta_next_op_len_with_english() {let mut delta = RichTextDelta::default();- delta.add(OpBuilder::insert("ab").build());- let mut iter = DeltaIter::new(&delta);+ delta.add(OperationBuilder::insert("ab").build());+ let mut iter = DeltaIterator::new(&delta);assert_eq!(iter.next_op_len().unwrap(), 2);- assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::insert("ab").build());+ assert_eq!(+ iter.next_op_with_len(2).unwrap(),+ OperationBuilder::insert("ab").build()+ );}#[test]fn delta_next_op_len_after_seek() {let mut delta = RichTextDelta::default();- delta.add(OpBuilder::insert("12345").build());- let mut iter = DeltaIter::new(&delta);+ delta.add(OperationBuilder::insert("12345").build());+ let mut iter = DeltaIterator::new(&delta);assert_eq!(iter.next_op_len().unwrap(), 5);iter.seek::<Utf16CodeUnitMetric>(3);assert_eq!(iter.next_op_len().unwrap(), 2);- assert_eq!(iter.next_op_with_len(1).unwrap(), OpBuilder::insert("4").build());+ assert_eq!(iter.next_op_with_len(1).unwrap(), OperationBuilder::insert("4").build());assert_eq!(iter.next_op_len().unwrap(), 1);- assert_eq!(iter.next_op().unwrap(), OpBuilder::insert("5").build());+ assert_eq!(iter.next_op().unwrap(), OperationBuilder::insert("5").build());}#[test]fn delta_next_op_len_none() {let mut delta = RichTextDelta::default();- delta.add(OpBuilder::insert("12345").build());- let mut iter = DeltaIter::new(&delta);+ delta.add(OperationBuilder::insert("12345").build());+ let mut iter = DeltaIterator::new(&delta);assert_eq!(iter.next_op_len().unwrap(), 5);- assert_eq!(iter.next_op_with_len(5).unwrap(), OpBuilder::insert("12345").build());+ assert_eq!(+ iter.next_op_with_len(5).unwrap(),+ OperationBuilder::insert("12345").build()+ );assert_eq!(iter.next_op_len(), None);}#[test]fn delta_next_op_with_len_zero() {let mut delta = RichTextDelta::default();- delta.add(OpBuilder::insert("12345").build());- let mut iter = DeltaIter::new(&delta);+ delta.add(OperationBuilder::insert("12345").build());+ let mut iter = DeltaIterator::new(&delta);assert_eq!(iter.next_op_with_len(0), None,);assert_eq!(iter.next_op_len().unwrap(), 5);}@@ -291,14 +319,14 @@ fn delta_next_op_with_len_zero() {#[test]fn delta_next_op_with_len_cross_op_return_last() {let mut delta = RichTextDelta::default();- delta.add(OpBuilder::insert("12345").build());- delta.add(OpBuilder::retain(1).build());- delta.add(OpBuilder::insert("678").build());+ delta.add(OperationBuilder::insert("12345").build());+ delta.add(OperationBuilder::retain(1).build());+ delta.add(OperationBuilder::insert("678").build());- let mut iter = DeltaIter::new(&delta);+ let mut iter = DeltaIterator::new(&delta);iter.seek::<Utf16CodeUnitMetric>(4);assert_eq!(iter.next_op_len().unwrap(), 1);- assert_eq!(iter.next_op_with_len(2).unwrap(), OpBuilder::retain(1).build());+ assert_eq!(iter.next_op_with_len(2).unwrap(), OperationBuilder::retain(1).build());}#[test]@@ -342,18 +370,17 @@ fn apply_1000() {}#[test]-fn apply() {- let s = "hello world,".to_owned();- let mut delta_a = RichTextDelta::default();- delta_a.insert(&s, RichTextAttributes::default());-- let mut delta_b = RichTextDelta::default();- delta_b.retain(s.len(), RichTextAttributes::default());- delta_b.insert("appflowy", RichTextAttributes::default());+fn apply_test() {+ let s = "hello";+ let delta_a = PlainTextDeltaBuilder::new().insert(s).build();+ let delta_b = PlainTextDeltaBuilder::new()+ .retain(s.len())+ .insert(", AppFlowy")+ .build();- let after_a = delta_a.apply("").unwrap();+ let after_a = delta_a.to_str().unwrap();let after_b = delta_b.apply(&after_a).unwrap();- assert_eq!("hello world,appflowy", &after_b);+ assert_eq!("hello, AppFlowy", &after_b);}#[test]@@ -384,6 +411,17 @@ fn invert() {}}+#[test]+fn invert_test() {+ let s = "hello world";+ let delta = PlainTextDeltaBuilder::new().insert(s).build();+ let invert_delta = delta.invert_str("");+ assert_eq!(delta.utf16_base_len, invert_delta.utf16_target_len);+ assert_eq!(delta.utf16_target_len, invert_delta.utf16_base_len);++ assert_eq!(invert_delta.apply(s).unwrap(), "")+}+#[test]fn empty_ops() {let mut delta = RichTextDelta::default();@@ -415,23 +453,24 @@ fn ops_merging() {assert_eq!(delta.ops.len(), 0);delta.retain(2, RichTextAttributes::default());assert_eq!(delta.ops.len(), 1);- assert_eq!(delta.ops.last(), Some(&OpBuilder::retain(2).build()));+ assert_eq!(delta.ops.last(), Some(&OperationBuilder::retain(2).build()));delta.retain(3, RichTextAttributes::default());assert_eq!(delta.ops.len(), 1);- assert_eq!(delta.ops.last(), Some(&OpBuilder::retain(5).build()));+ assert_eq!(delta.ops.last(), Some(&OperationBuilder::retain(5).build()));delta.insert("abc", RichTextAttributes::default());assert_eq!(delta.ops.len(), 2);- assert_eq!(delta.ops.last(), Some(&OpBuilder::insert("abc").build()));+ assert_eq!(delta.ops.last(), Some(&OperationBuilder::insert("abc").build()));delta.insert("xyz", RichTextAttributes::default());assert_eq!(delta.ops.len(), 2);- assert_eq!(delta.ops.last(), Some(&OpBuilder::insert("abcxyz").build()));+ assert_eq!(delta.ops.last(), Some(&OperationBuilder::insert("abcxyz").build()));delta.delete(1);assert_eq!(delta.ops.len(), 3);- assert_eq!(delta.ops.last(), Some(&OpBuilder::delete(1).build()));+ assert_eq!(delta.ops.last(), Some(&OperationBuilder::delete(1).build()));delta.delete(1);assert_eq!(delta.ops.len(), 3);- assert_eq!(delta.ops.last(), Some(&OpBuilder::delete(2).build()));+ assert_eq!(delta.ops.last(), Some(&OperationBuilder::delete(2).build()));}+#[test]fn is_noop() {let mut delta = RichTextDelta::default();@@ -582,11 +621,11 @@ fn transform_two_conflict_non_seq_delta() {#[test]fn delta_invert_no_attribute_delta() {let mut delta = RichTextDelta::default();- delta.add(OpBuilder::insert("123").build());+ delta.add(OperationBuilder::insert("123").build());let mut change = RichTextDelta::default();- change.add(OpBuilder::retain(3).build());- change.add(OpBuilder::insert("456").build());+ change.add(OperationBuilder::retain(3).build());+ change.add(OperationBuilder::insert("456").build());let undo = change.invert(&delta);let new_delta = delta.compose(&change).unwrap();diff --git a/frontend/rust-lib/flowy-text-block/tests/editor/serde_test.rs b/frontend/rust-lib/flowy-text-block/tests/editor/serde_test.rsindex 87d425901b..ae9e57b3c6 100644--- a/frontend/rust-lib/flowy-text-block/tests/editor/serde_test.rs+++ b/frontend/rust-lib/flowy-text-block/tests/editor/serde_test.rs@@ -11,7 +11,7 @@ fn operation_insert_serialize_test() {.add_attr(RichTextAttribute::Bold(true)).add_attr(RichTextAttribute::Italic(true)).build();- let operation = OpBuilder::insert("123").attributes(attributes).build();+ let operation = OperationBuilder::insert("123").attributes(attributes).build();let json = serde_json::to_string(&operation).unwrap();eprintln!("{}", json);@@ -42,7 +42,7 @@ fn attributes_serialize_test() {.add_attr(RichTextAttribute::Bold(true)).add_attr(RichTextAttribute::Italic(true)).build();- let retain = OpBuilder::insert("123").attributes(attributes).build();+ let retain = OperationBuilder::insert("123").attributes(attributes).build();let json = serde_json::to_string(&retain).unwrap();eprintln!("{}", json);@@ -56,7 +56,7 @@ fn delta_serialize_multi_attribute_test() {.add_attr(RichTextAttribute::Bold(true)).add_attr(RichTextAttribute::Italic(true)).build();- let retain = OpBuilder::insert("123").attributes(attributes).build();+ let retain = OperationBuilder::insert("123").attributes(attributes).build();delta.add(retain);delta.add(Operation::Retain(5.into()));diff --git a/frontend/rust-lib/flowy-text-block/tests/editor/undo_redo_test.rs b/frontend/rust-lib/flowy-text-block/tests/editor/undo_redo_test.rsindex e6ea9200ab..78aa034744 100644--- a/frontend/rust-lib/flowy-text-block/tests/editor/undo_redo_test.rs+++ b/frontend/rust-lib/flowy-text-block/tests/editor/undo_redo_test.rs@@ -108,6 +108,7 @@ fn history_bold_redo_with_lagging() {fn history_delete_undo() {let ops = vec![Insert(0, "123", 0),+ Wait(RECORD_THRESHOLD),AssertDocJson(0, r#"[{"insert":"123"}]"#),Delete(0, Interval::new(0, 3)),AssertDocJson(0, r#"[]"#),diff --git a/shared-lib/flowy-sync/src/client_document/extensions/delete/preserve_line_format_merge.rs b/shared-lib/flowy-sync/src/client_document/extensions/delete/preserve_line_format_merge.rsindex 4da15e5f06..6c7283e4c7 100644--- a/shared-lib/flowy-sync/src/client_document/extensions/delete/preserve_line_format_merge.rs+++ b/shared-lib/flowy-sync/src/client_document/extensions/delete/preserve_line_format_merge.rs@@ -1,6 +1,6 @@use crate::{client_document::DeleteExt, util::is_newline};use lib_ot::{- core::{Attributes, DeltaBuilder, DeltaIter, Interval, Utf16CodeUnitMetric, NEW_LINE},+ core::{Attributes, DeltaBuilder, DeltaIterator, Interval, Utf16CodeUnitMetric, NEW_LINE},rich_text::{plain_attributes, RichTextDelta},};@@ -16,7 +16,7 @@ impl DeleteExt for PreserveLineFormatOnMerge {}// seek to the interval start pos. e.g. You backspace enter pos- let mut iter = DeltaIter::from_offset(delta, interval.start);+ let mut iter = DeltaIterator::from_offset(delta, interval.start);// op will be the "\n"let newline_op = iter.next_op_with_len(1)?;diff --git a/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_block_format.rs b/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_block_format.rsindex 46a0e0290d..4a4c00a19d 100644--- a/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_block_format.rs+++ b/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_block_format.rs@@ -1,5 +1,5 @@use lib_ot::{- core::{DeltaBuilder, DeltaIter, Interval},+ core::{DeltaBuilder, DeltaIterator, Interval},rich_text::{plain_attributes, AttributeScope, RichTextAttribute, RichTextDelta},};@@ -20,7 +20,7 @@ impl FormatExt for ResolveBlockFormat {}let mut new_delta = DeltaBuilder::new().retain(interval.start).build();- let mut iter = DeltaIter::from_offset(delta, interval.start);+ let mut iter = DeltaIterator::from_offset(delta, interval.start);let mut start = 0;let end = interval.size();while start < end && iter.has_next() {diff --git a/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_inline_format.rs b/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_inline_format.rsindex 383b780aca..567d06d6f2 100644--- a/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_inline_format.rs+++ b/shared-lib/flowy-sync/src/client_document/extensions/format/resolve_inline_format.rs@@ -1,5 +1,5 @@use lib_ot::{- core::{DeltaBuilder, DeltaIter, Interval},+ core::{DeltaBuilder, DeltaIterator, Interval},rich_text::{AttributeScope, RichTextAttribute, RichTextDelta},};@@ -19,7 +19,7 @@ impl FormatExt for ResolveInlineFormat {return None;}let mut new_delta = DeltaBuilder::new().retain(interval.start).build();- let mut iter = DeltaIter::from_offset(delta, interval.start);+ let mut iter = DeltaIterator::from_offset(delta, interval.start);let mut start = 0;let end = interval.size();diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_exit_block.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_exit_block.rsindex e41470b9eb..253833d255 100644--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_exit_block.rs+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_exit_block.rs@@ -1,8 +1,6 @@use crate::{client_document::InsertExt, util::is_newline};-use lib_ot::{- core::{is_empty_line_at_index, DeltaBuilder, DeltaIter},- rich_text::{attributes_except_header, RichTextAttributeKey, RichTextDelta},-};+use lib_ot::core::{is_empty_line_at_index, DeltaBuilder, DeltaIterator};+use lib_ot::rich_text::{attributes_except_header, RichTextAttributeKey, RichTextDelta};pub struct AutoExitBlock {}@@ -21,7 +19,7 @@ impl InsertExt for AutoExitBlock {return None;}- let mut iter = DeltaIter::from_offset(delta, index);+ let mut iter = DeltaIterator::from_offset(delta, index);let next = iter.next_op()?;let mut attributes = next.get_attributes();diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_format.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_format.rsindex d7f1da4f89..4c7cd642c2 100644--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_format.rs+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/auto_format.rs@@ -1,6 +1,6 @@use crate::{client_document::InsertExt, util::is_whitespace};use lib_ot::{- core::{count_utf16_code_units, DeltaBuilder, DeltaIter},+ core::{count_utf16_code_units, DeltaBuilder, DeltaIterator},rich_text::{plain_attributes, RichTextAttribute, RichTextAttributes, RichTextDelta},};use std::cmp::min;@@ -17,7 +17,7 @@ impl InsertExt for AutoFormatExt {if !is_whitespace(text) {return None;}- let mut iter = DeltaIter::new(delta);+ let mut iter = DeltaIterator::new(delta);if let Some(prev) = iter.next_op_with_len(index) {match AutoFormat::parse(prev.get_data()) {None => {}diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/default_insert.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/default_insert.rsindex 628d55cb24..c165985493 100644--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/default_insert.rs+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/default_insert.rs@@ -1,6 +1,6 @@use crate::client_document::InsertExt;use lib_ot::{- core::{Attributes, DeltaBuilder, DeltaIter, NEW_LINE},+ core::{Attributes, DeltaBuilder, DeltaIterator, NEW_LINE},rich_text::{RichTextAttributeKey, RichTextAttributes, RichTextDelta},};@@ -11,7 +11,7 @@ impl InsertExt for DefaultInsertAttribute {}fn apply(&self, delta: &RichTextDelta, replace_len: usize, text: &str, index: usize) -> Option<RichTextDelta> {- let iter = DeltaIter::new(delta);+ let iter = DeltaIterator::new(delta);let mut attributes = RichTextAttributes::new();// Enable each line split by "\n" remains the block attributes. for example:diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_block_format.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_block_format.rsindex 2c0ceae111..03c9723d7b 100644--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_block_format.rs+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_block_format.rs@@ -1,6 +1,6 @@use crate::{client_document::InsertExt, util::is_newline};use lib_ot::{- core::{DeltaBuilder, DeltaIter, NEW_LINE},+ core::{DeltaBuilder, DeltaIterator, NEW_LINE},rich_text::{attributes_except_header, plain_attributes, RichTextAttribute, RichTextAttributeKey, RichTextAttributes,RichTextDelta,@@ -18,7 +18,7 @@ impl InsertExt for PreserveBlockFormatOnInsert {return None;}- let mut iter = DeltaIter::from_offset(delta, index);+ let mut iter = DeltaIterator::from_offset(delta, index);match iter.next_op_with_newline() {None => {}Some((newline_op, offset)) => {diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_inline_format.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_inline_format.rsindex 37b31e3d26..b0de6451aa 100644--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_inline_format.rs+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/preserve_inline_format.rs@@ -3,7 +3,7 @@ use crate::{util::{contain_newline, is_newline},};use lib_ot::{- core::{DeltaBuilder, DeltaIter, OpNewline, NEW_LINE},+ core::{DeltaBuilder, DeltaIterator, OpNewline, NEW_LINE},rich_text::{plain_attributes, RichTextAttributeKey, RichTextDelta},};@@ -18,7 +18,7 @@ impl InsertExt for PreserveInlineFormat {return None;}- let mut iter = DeltaIter::new(delta);+ let mut iter = DeltaIterator::new(delta);let prev = iter.next_op_with_len(index)?;if OpNewline::parse(&prev).is_contain() {return None;@@ -64,7 +64,7 @@ impl InsertExt for PreserveLineFormatOnSplit {return None;}- let mut iter = DeltaIter::new(delta);+ let mut iter = DeltaIterator::new(delta);let prev = iter.next_op_with_len(index)?;if OpNewline::parse(&prev).is_end() {return None;diff --git a/shared-lib/flowy-sync/src/client_document/extensions/insert/reset_format_on_new_line.rs b/shared-lib/flowy-sync/src/client_document/extensions/insert/reset_format_on_new_line.rsindex f63bf9bddf..8671049ee7 100644--- a/shared-lib/flowy-sync/src/client_document/extensions/insert/reset_format_on_new_line.rs+++ b/shared-lib/flowy-sync/src/client_document/extensions/insert/reset_format_on_new_line.rs@@ -1,6 +1,6 @@use crate::{client_document::InsertExt, util::is_newline};use lib_ot::{- core::{DeltaBuilder, DeltaIter, Utf16CodeUnitMetric, NEW_LINE},+ core::{DeltaBuilder, DeltaIterator, Utf16CodeUnitMetric, NEW_LINE},rich_text::{RichTextAttributeKey, RichTextAttributes, RichTextDelta},};@@ -15,7 +15,7 @@ impl InsertExt for ResetLineFormatOnNewLine {return None;}- let mut iter = DeltaIter::new(delta);+ let mut iter = DeltaIterator::new(delta);iter.seek::<Utf16CodeUnitMetric>(index);let next_op = iter.next_op()?;if !next_op.get_data().starts_with(NEW_LINE) {diff --git a/shared-lib/lib-ot/src/core/delta/builder.rs b/shared-lib/lib-ot/src/core/delta/builder.rsindex b065b645af..184284393a 100644--- a/shared-lib/lib-ot/src/core/delta/builder.rs+++ b/shared-lib/lib-ot/src/core/delta/builder.rs@@ -1,7 +1,12 @@-use crate::core::{trim, Attributes, Delta, PlainTextAttributes};+use crate::core::delta::{trim, Delta};+use crate::core::operation::{Attributes, PlainTextAttributes};pub type PlainTextDeltaBuilder = DeltaBuilder<PlainTextAttributes>;+/// A builder for creating new [Delta] objects.+///+/// Note that all edit operations must be sorted; the start point of each+/// interval must be no less than the end point of the previous one.pub struct DeltaBuilder<T: Attributes> {delta: Delta<T>,}@@ -23,6 +28,8 @@ whereDeltaBuilder::default()}+ /// Retain the 'n' characters with the attributes. Use 'retain' instead if you don't+ /// need any attributes.pub fn retain_with_attributes(mut self, n: usize, attrs: T) -> Self {self.delta.retain(n, attrs);self@@ -33,11 +40,14 @@ whereself}+ /// Deletes the given interval. Panics if interval is not properly sorted.pub fn delete(mut self, n: usize) -> Self {self.delta.delete(n);self}+ /// Insert the string with attributes. Use 'insert' instead if you don't+ /// need any attributes.pub fn insert_with_attributes(mut self, s: &str, attrs: T) -> Self {self.delta.insert(s, attrs);self@@ -53,6 +63,7 @@ whereself}+ /// Builds the `Delta`pub fn build(self) -> Delta<T> {self.delta}diff --git a/shared-lib/lib-ot/src/core/delta/cursor.rs b/shared-lib/lib-ot/src/core/delta/cursor.rsindex d6ebb8b3cc..a465d62dea 100644--- a/shared-lib/lib-ot/src/core/delta/cursor.rs+++ b/shared-lib/lib-ot/src/core/delta/cursor.rs@@ -1,33 +1,51 @@#![allow(clippy::while_let_on_iterator)]-use crate::{- core::{Attributes, Delta, Interval, Operation},- errors::{ErrorBuilder, OTError, OTErrorCode},-};+use crate::core::delta::Delta;+use crate::core::interval::Interval;+use crate::core::operation::{Attributes, Operation};+use crate::errors::{ErrorBuilder, OTError, OTErrorCode};use std::{cmp::min, iter::Enumerate, slice::Iter};+/// A [DeltaCursor] is used to iterate the delta and return the corresponding delta.#[derive(Debug)]-pub struct OpCursor<'a, T: Attributes> {+pub struct DeltaCursor<'a, T: Attributes> {pub(crate) delta: &'a Delta<T>,pub(crate) origin_iv: Interval,pub(crate) consume_iv: Interval,pub(crate) consume_count: usize,- pub(crate) op_index: usize,+ pub(crate) op_offset: usize,iter: Enumerate<Iter<'a, Operation<T>>>,next_op: Option<Operation<T>>,}-impl<'a, T> OpCursor<'a, T>+impl<'a, T> DeltaCursor<'a, T>whereT: Attributes,{- pub fn new(delta: &'a Delta<T>, interval: Interval) -> OpCursor<'a, T> {+ /// # Arguments+ ///+ /// * `delta`: The delta you want to iterate over.+ /// * `interval`: The range for the cursor movement.+ ///+ /// # Examples+ ///+ /// ```+ /// use lib_ot::core::{DeltaIterator, Interval, OperationBuilder};+ /// use lib_ot::rich_text::RichTextDelta;+ /// let mut delta = RichTextDelta::default();+ /// let op_1 = OperationBuilder::insert("123").build();+ /// let op_2 = OperationBuilder::insert("4").build();+ /// delta.add(op_1.clone());+ /// delta.add(op_2.clone());+ /// assert_eq!(DeltaIterator::from_interval(&delta, Interval::new(0, 3)).ops(), vec![op_1.clone()]);+ /// ```+ pub fn new(delta: &'a Delta<T>, interval: Interval) -> DeltaCursor<'a, T> {// debug_assert!(interval.start <= delta.target_len);let mut cursor = Self {delta,origin_iv: interval,consume_iv: interval,consume_count: 0,- op_index: 0,+ op_offset: 0,iter: delta.ops.iter().enumerate(),next_op: None,};@@ -35,17 +53,37 @@ wherecursor}- // get the next operation interval+ /// Return the next operation intervalpub fn next_iv(&self) -> Interval {self.next_iv_with_len(None).unwrap_or_else(|| Interval::new(0, 0))}- pub fn next_op(&mut self) -> Option<Operation<T>> {+ /// Return the next operation+ pub fn get_next_op(&mut self) -> Option<Operation<T>> {self.next_with_len(None)}- // get the last operation before the end.- // checkout the delta_next_op_with_len_cross_op_return_last test for more detail+ /// Return the reference of the next operation+ pub fn next_op(&self) -> Option<&Operation<T>> {+ let mut next_op = self.next_op.as_ref();+ if next_op.is_none() {+ let mut offset = 0;+ for op in &self.delta.ops {+ offset += op.len();+ if offset > self.consume_count {+ next_op = Some(op);+ break;+ }+ }+ }+ next_op+ }++ /// # Arguments+ ///+ /// * `expected_len`: Return the next operation with the specified length.+ ///+ ///pub fn next_with_len(&mut self, expected_len: Option<usize>) -> Option<Operation<T>> {let mut find_op = None;let holder = self.next_op.clone();@@ -97,17 +135,24 @@ where}pub fn has_next(&self) -> bool {- self.next_iter_op().is_some()+ self.next_op().is_some()}- fn descend(&mut self, index: usize) {- self.consume_iv.start += index;+ /// Find the op within the current offset.+ /// This function sets the start of the consume_iv to the offset, update the consume_count+ /// and the next_op reference.+ ///+ /// # Arguments+ ///+ /// * `offset`: Represents the offset of the delta string, in Utf16CodeUnit unit.+ fn descend(&mut self, offset: usize) {+ self.consume_iv.start += offset;if self.consume_count >= self.consume_iv.start {return;}while let Some((o_index, op)) = self.iter.next() {- self.op_index = o_index;+ self.op_offset = o_index;let start = self.consume_count;let end = start + op.len();let intersect = Interval::new(start, end).intersect(self.consume_iv);@@ -121,7 +166,7 @@ where}fn next_iv_with_len(&self, expected_len: Option<usize>) -> Option<Interval> {- let op = self.next_iter_op()?;+ let op = self.next_op()?;let start = self.consume_count;let end = match expected_len {None => self.consume_count + op.len(),@@ -132,31 +177,16 @@ wherelet interval = intersect.translate_neg(start);Some(interval)}-- pub fn next_iter_op(&self) -> Option<&Operation<T>> {- let mut next_op = self.next_op.as_ref();- if next_op.is_none() {- let mut offset = 0;- for op in &self.delta.ops {- offset += op.len();- if offset > self.consume_count {- next_op = Some(op);- break;- }- }- }- next_op- }}-fn find_next<'a, T>(cursor: &mut OpCursor<'a, T>) -> Option<&'a Operation<T>>+fn find_next<'a, T>(cursor: &mut DeltaCursor<'a, T>) -> Option<&'a Operation<T>>whereT: Attributes,{match cursor.iter.next() {None => None,Some((o_index, op)) => {- cursor.op_index = o_index;+ cursor.op_offset = o_index;Some(op)}}@@ -164,31 +194,34 @@ wheretype SeekResult = Result<(), OTError>;pub trait Metric {- fn seek<T: Attributes>(cursor: &mut OpCursor<T>, offset: usize) -> SeekResult;+ fn seek<T: Attributes>(cursor: &mut DeltaCursor<T>, offset: usize) -> SeekResult;}+/// [OpMetric] is used by [DeltaIterator] for seeking operations+/// The unit of the movement is Operationpub struct OpMetric();impl Metric for OpMetric {- fn seek<T: Attributes>(cursor: &mut OpCursor<T>, offset: usize) -> SeekResult {- let _ = check_bound(cursor.op_index, offset)?;- let mut seek_cursor = OpCursor::new(cursor.delta, cursor.origin_iv);- let mut cur_offset = 0;+ fn seek<T: Attributes>(cursor: &mut DeltaCursor<T>, op_offset: usize) -> SeekResult {+ let _ = check_bound(cursor.op_offset, op_offset)?;+ let mut seek_cursor = DeltaCursor::new(cursor.delta, cursor.origin_iv);+while let Some((_, op)) = seek_cursor.iter.next() {- cur_offset += op.len();- if cur_offset > offset {+ cursor.descend(op.len());+ if cursor.op_offset >= op_offset {break;}}- cursor.descend(cur_offset);Ok(())}}+/// [Utf16CodeUnitMetric] is used by [DeltaIterator] for seeking operations.+/// The unit of the movement is Utf16CodeUnitpub struct Utf16CodeUnitMetric();impl Metric for Utf16CodeUnitMetric {- fn seek<T: Attributes>(cursor: &mut OpCursor<T>, offset: usize) -> SeekResult {+ fn seek<T: Attributes>(cursor: &mut DeltaCursor<T>, offset: usize) -> SeekResult {if offset > 0 {let _ = check_bound(cursor.consume_count, offset)?;let _ = cursor.next_with_len(Some(offset));diff --git a/shared-lib/lib-ot/src/core/delta/delta.rs b/shared-lib/lib-ot/src/core/delta/delta.rsindex 29fd424dcb..6edf817bdf 100644--- a/shared-lib/lib-ot/src/core/delta/delta.rs+++ b/shared-lib/lib-ot/src/core/delta/delta.rs@@ -1,8 +1,9 @@-use crate::{- core::{operation::*, DeltaIter, FlowyStr, Interval, OperationTransformable, MAX_IV_LEN},- errors::{ErrorBuilder, OTError, OTErrorCode},-};+use crate::errors::{ErrorBuilder, OTError, OTErrorCode};+use crate::core::delta::{DeltaIterator, MAX_IV_LEN};+use crate::core::flowy_str::FlowyStr;+use crate::core::interval::Interval;+use crate::core::operation::{Attributes, Operation, OperationBuilder, OperationTransformable, PlainTextAttributes};use bytes::Bytes;use serde::de::DeserializeOwned;use std::{@@ -15,11 +16,20 @@ use std::{pub type PlainTextDelta = Delta<PlainTextAttributes>;-// TODO: optimize the memory usage with Arc::make_mut or Cow+/// A [Delta] contains list of operations that consists of 'Retain', 'Delete' and 'Insert' operation.+/// Check out the [Operation] for more details. It describes the document as a sequence of+/// operations.+///#[derive(Clone, Debug, PartialEq, Eq)]pub struct Delta<T: Attributes> {pub ops: Vec<Operation<T>>,++ /// 'Delete' and 'Retain' operation will update the [utf16_base_len]+ /// Transforming the other delta, it requires the utf16_base_len must be equal.pub utf16_base_len: usize,++ /// Represents the current len of the delta.+ /// 'Insert' and 'Retain' operation will update the [utf16_target_len]pub utf16_target_len: usize,}@@ -81,6 +91,7 @@ where}}+ /// Adding an operation. It will be added in sequence.pub fn add(&mut self, op: Operation<T>) {match op {Operation::Delete(i) => self.delete(i),@@ -89,6 +100,7 @@ where}}+ /// Creating a [Delete] operation with len [n]pub fn delete(&mut self, n: usize) {if n == 0 {return;@@ -97,10 +109,11 @@ whereif let Some(Operation::Delete(n_last)) = self.ops.last_mut() {*n_last += n;} else {- self.ops.push(OpBuilder::delete(n).build());+ self.ops.push(OperationBuilder::delete(n).build());}}+ /// Creating a [Insert] operation with string, [s].pub fn insert(&mut self, s: &str, attributes: T) {let s: FlowyStr = s.into();if s.is_empty() {@@ -119,10 +132,10 @@ where}[.., op_last @ Operation::<T>::Delete(_)] => {let new_last = op_last.clone();- *op_last = OpBuilder::<T>::insert(&s).attributes(attributes).build();+ *op_last = OperationBuilder::<T>::insert(&s).attributes(attributes).build();Some(new_last)}- _ => Some(OpBuilder::<T>::insert(&s).attributes(attributes).build()),+ _ => Some(OperationBuilder::<T>::insert(&s).attributes(attributes).build()),};match new_last {@@ -131,6 +144,7 @@ where}}+ /// Creating a [Retain] operation with len, [n].pub fn retain(&mut self, n: usize, attributes: T) {if n == 0 {return;@@ -143,24 +157,48 @@ whereself.ops.push(new_op);}} else {- self.ops.push(OpBuilder::<T>::retain(n).attributes(attributes).build());+ self.ops+ .push(OperationBuilder::<T>::retain(n).attributes(attributes).build());}}- /// Applies an operation to a string, returning a new string.- pub fn apply(&self, s: &str) -> Result<String, OTError> {- let s: FlowyStr = s.into();- if s.utf16_size() != self.utf16_base_len {+ /// Return the a new string described by this delta. The new string will contains the input string.+ /// The length of the [applied_str] must be equal to the the [utf16_base_len].+ ///+ /// # Arguments+ ///+ /// * `applied_str`: A string represents the utf16_base_len content. it will be consumed by the [retain]+ /// or [delete] operations.+ ///+ ///+ /// # Examples+ ///+ /// ```+ /// use lib_ot::core::PlainTextDeltaBuilder;+ /// let s = "hello";+ /// let delta_a = PlainTextDeltaBuilder::new().insert(s).build();+ /// let delta_b = PlainTextDeltaBuilder::new()+ /// .retain(s.len())+ /// .insert(", AppFlowy")+ /// .build();+ ///+ /// let after_a = delta_a.to_str().unwrap();+ /// let after_b = delta_b.apply(&after_a).unwrap();+ /// assert_eq!("hello, AppFlowy", &after_b);+ /// ```+ pub fn apply(&self, applied_str: &str) -> Result<String, OTError> {+ let applied_str: FlowyStr = applied_str.into();+ if applied_str.utf16_size() != self.utf16_base_len {return Err(ErrorBuilder::new(OTErrorCode::IncompatibleLength).msg(format!(- "Expected: {}, received: {}",+ "Expected: {}, but received: {}",self.utf16_base_len,- s.utf16_size()+ applied_str.utf16_size())).build());}let mut new_s = String::new();- let code_point_iter = &mut s.utf16_code_unit_iter();+ let code_point_iter = &mut applied_str.utf16_code_unit_iter();for op in &self.ops {match &op {Operation::Retain(retain) => {@@ -181,34 +219,60 @@ whereOk(new_s)}- /// Computes the inverse of an operation. The inverse of an operation is the- /// operation that reverts the effects of the operation- pub fn invert_str(&self, s: &str) -> Self {+ /// Computes the inverse [Delta]. The inverse of an operation is the+ /// operation that reverts the effects of the operation+ /// # Arguments+ ///+ /// * `inverted_s`: A string represents the utf16_base_len content. The len of [inverted_s]+ /// must equal to the [utf16_base_len], it will be consumed by the [retain] or [delete] operations.+ ///+ /// If the delta's operations just contain a insert operation. The inverted_s must be empty string.+ ///+ /// # Examples+ ///+ /// ```+ /// use lib_ot::core::PlainTextDeltaBuilder;+ /// let s = "hello world";+ /// let delta = PlainTextDeltaBuilder::new().insert(s).build();+ /// let invert_delta = delta.invert_str(s);+ /// assert_eq!(delta.utf16_base_len, invert_delta.utf16_target_len);+ /// assert_eq!(delta.utf16_target_len, invert_delta.utf16_base_len);+ ///+ /// assert_eq!(invert_delta.apply(s).unwrap(), "")+ ///+ /// ```+ ///+ pub fn invert_str(&self, inverted_s: &str) -> Self {let mut inverted = Delta::default();- let chars = &mut s.chars();+ let inverted_s: FlowyStr = inverted_s.into();+ let code_point_iter = &mut inverted_s.utf16_code_unit_iter();+for op in &self.ops {match &op {Operation::Retain(retain) => {inverted.retain(retain.n, T::default());- // TODO: use advance_by instead, but it's unstable now- // chars.advance_by(retain.num)for _ in 0..retain.n {- chars.next();+ code_point_iter.next();}}Operation::Insert(insert) => {inverted.delete(insert.utf16_size());}Operation::Delete(delete) => {- inverted.insert(&chars.take(*delete as usize).collect::<String>(), op.get_attributes());+ let bytes = code_point_iter+ .take(*delete as usize)+ .into_iter()+ .flat_map(|a| str::from_utf8(a.0).ok())+ .collect::<String>();++ inverted.insert(&bytes, op.get_attributes());}}}inverted}- /// Checks if this operation has no effect.- #[inline]+ /// Return true if the delta doesn't contain any [Insert] or [Delete] operations.pub fn is_noop(&self) -> bool {matches!(self.ops.as_slice(), [] | [Operation::Retain(_)])}@@ -231,8 +295,8 @@ whereSelf: Sized,{let mut new_delta = Delta::default();- let mut iter = DeltaIter::new(self);- let mut other_iter = DeltaIter::new(other);+ let mut iter = DeltaIterator::new(self);+ let mut other_iter = DeltaIterator::new(other);while iter.has_next() || other_iter.has_next() {if other_iter.is_next_insert() {@@ -252,10 +316,10 @@ wherelet op = iter.next_op_with_len(length)- .unwrap_or_else(|| OpBuilder::retain(length).build());+ .unwrap_or_else(|| OperationBuilder::retain(length).build());let other_op = other_iter.next_op_with_len(length)- .unwrap_or_else(|| OpBuilder::retain(length).build());+ .unwrap_or_else(|| OperationBuilder::retain(length).build());// debug_assert_eq!(op.len(), other_op.len(), "Composing delta failed,");@@ -263,12 +327,16 @@ where(Operation::Retain(retain), Operation::Retain(other_retain)) => {let composed_attrs = retain.attributes.compose(&other_retain.attributes)?;- new_delta.add(OpBuilder::retain(retain.n).attributes(composed_attrs).build())+ new_delta.add(OperationBuilder::retain(retain.n).attributes(composed_attrs).build())}(Operation::Insert(insert), Operation::Retain(other_retain)) => {let mut composed_attrs = insert.attributes.compose(&other_retain.attributes)?;composed_attrs.remove_empty();- new_delta.add(OpBuilder::insert(op.get_data()).attributes(composed_attrs).build())+ new_delta.add(+ OperationBuilder::insert(op.get_data())+ .attributes(composed_attrs)+ .build(),+ )}(Operation::Retain(_), Operation::Delete(_)) => {new_delta.add(other_op);@@ -331,7 +399,7 @@ whereOrdering::Less => {a_prime.retain(retain.n, composed_attrs.clone());b_prime.retain(retain.n, composed_attrs.clone());- next_op2 = Some(OpBuilder::retain(o_retain.n - retain.n).build());+ next_op2 = Some(OperationBuilder::retain(o_retain.n - retain.n).build());next_op1 = ops1.next();}Ordering::Equal => {@@ -343,14 +411,14 @@ whereOrdering::Greater => {a_prime.retain(o_retain.n, composed_attrs.clone());b_prime.retain(o_retain.n, composed_attrs.clone());- next_op1 = Some(OpBuilder::retain(retain.n - o_retain.n).build());+ next_op1 = Some(OperationBuilder::retain(retain.n - o_retain.n).build());next_op2 = ops2.next();}};}(Some(Operation::Delete(i)), Some(Operation::Delete(j))) => match i.cmp(j) {Ordering::Less => {- next_op2 = Some(OpBuilder::delete(*j - *i).build());+ next_op2 = Some(OperationBuilder::delete(*j - *i).build());next_op1 = ops1.next();}Ordering::Equal => {@@ -358,7 +426,7 @@ wherenext_op2 = ops2.next();}Ordering::Greater => {- next_op1 = Some(OpBuilder::delete(*i - *j).build());+ next_op1 = Some(OperationBuilder::delete(*i - *j).build());next_op2 = ops2.next();}},@@ -366,7 +434,7 @@ wherematch i.cmp(o_retain) {Ordering::Less => {a_prime.delete(*i);- next_op2 = Some(OpBuilder::retain(o_retain.n - *i).build());+ next_op2 = Some(OperationBuilder::retain(o_retain.n - *i).build());next_op1 = ops1.next();}Ordering::Equal => {@@ -376,7 +444,7 @@ where}Ordering::Greater => {a_prime.delete(o_retain.n);- next_op1 = Some(OpBuilder::delete(*i - o_retain.n).build());+ next_op1 = Some(OperationBuilder::delete(*i - o_retain.n).build());next_op2 = ops2.next();}};@@ -385,7 +453,7 @@ wherematch retain.cmp(j) {Ordering::Less => {b_prime.delete(retain.n);- next_op2 = Some(OpBuilder::delete(*j - retain.n).build());+ next_op2 = Some(OperationBuilder::delete(*j - retain.n).build());next_op1 = ops1.next();}Ordering::Equal => {@@ -395,7 +463,7 @@ where}Ordering::Greater => {b_prime.delete(*j);- next_op1 = Some(OpBuilder::retain(retain.n - *j).build());+ next_op1 = Some(OperationBuilder::retain(retain.n - *j).build());next_op2 = ops2.next();}};@@ -407,21 +475,17 @@ wherefn invert(&self, other: &Self) -> Self {let mut inverted = Delta::default();- if other.is_empty() {- return inverted;- }-let mut index = 0;for op in &self.ops {let len: usize = op.len() as usize;match op {Operation::Delete(n) => {- invert_from_other(&mut inverted, other, op, index, index + *n);+ invert_other(&mut inverted, other, op, index, index + *n);index += len;}Operation::Retain(_) => {match op.has_attribute() {- true => invert_from_other(&mut inverted, other, op, index, index + len),+ true => invert_other(&mut inverted, other, op, index, index + len),false => {// tracing::trace!("invert retain: {} by retain {} {}", op, len,// op.get_attributes());@@ -452,7 +516,7 @@ where}}-fn invert_from_other<T: Attributes>(+fn invert_other<T: Attributes>(base: &mut Delta<T>,other: &Delta<T>,operation: &Operation<T>,@@ -460,7 +524,7 @@ fn invert_from_other<T: Attributes>(end: usize,) {tracing::trace!("invert op: {} [{}:{}]", operation, start, end);- let other_ops = DeltaIter::from_interval(other, Interval::new(start, end)).ops();+ let other_ops = DeltaIterator::from_interval(other, Interval::new(start, end)).ops();other_ops.into_iter().for_each(|other_op| match operation {Operation::Delete(_n) => {// tracing::trace!("invert delete: {} by add {}", n, other_op);diff --git a/shared-lib/lib-ot/src/core/delta/delta_serde.rs b/shared-lib/lib-ot/src/core/delta/delta_serde.rsindex ceac31ee58..7dff063211 100644--- a/shared-lib/lib-ot/src/core/delta/delta_serde.rs+++ b/shared-lib/lib-ot/src/core/delta/delta_serde.rs@@ -1,4 +1,5 @@-use crate::core::{Attributes, Delta};+use crate::core::delta::Delta;+use crate::core::operation::Attributes;use serde::{de::{SeqAccess, Visitor},ser::SerializeSeq,diff --git a/shared-lib/lib-ot/src/core/delta/iterator.rs b/shared-lib/lib-ot/src/core/delta/iterator.rsindex ccad56845d..ba9db58428 100644--- a/shared-lib/lib-ot/src/core/delta/iterator.rs+++ b/shared-lib/lib-ot/src/core/delta/iterator.rs@@ -1,17 +1,17 @@use super::cursor::*;-use crate::{- core::{Attributes, Delta, Interval, Operation, NEW_LINE},- rich_text::RichTextAttributes,-};+use crate::core::delta::{Delta, NEW_LINE};+use crate::core::interval::Interval;+use crate::core::operation::{Attributes, Operation};+use crate::rich_text::RichTextAttributes;use std::ops::{Deref, DerefMut};pub(crate) const MAX_IV_LEN: usize = i32::MAX as usize;-pub struct DeltaIter<'a, T: Attributes> {- cursor: OpCursor<'a, T>,+pub struct DeltaIterator<'a, T: Attributes> {+ cursor: DeltaCursor<'a, T>,}-impl<'a, T> DeltaIter<'a, T>+impl<'a, T> DeltaIterator<'a, T>whereT: Attributes,{@@ -28,7 +28,7 @@ where}pub fn from_interval(delta: &'a Delta<T>, interval: Interval) -> Self {- let cursor = OpCursor::new(delta, interval);+ let cursor = DeltaCursor::new(delta, interval);Self { cursor }}@@ -46,7 +46,7 @@ where}pub fn next_op(&mut self) -> Option<Operation<T>> {- self.cursor.next_op()+ self.cursor.get_next_op()}pub fn next_op_with_len(&mut self, len: usize) -> Option<Operation<T>> {@@ -80,28 +80,28 @@ where}pub fn is_next_insert(&self) -> bool {- match self.cursor.next_iter_op() {+ match self.cursor.next_op() {None => false,Some(op) => op.is_insert(),}}pub fn is_next_retain(&self) -> bool {- match self.cursor.next_iter_op() {+ match self.cursor.next_op() {None => false,Some(op) => op.is_retain(),}}pub fn is_next_delete(&self) -> bool {- match self.cursor.next_iter_op() {+ match self.cursor.next_op() {None => false,Some(op) => op.is_delete(),}}}-impl<'a, T> Iterator for DeltaIter<'a, T>+impl<'a, T> Iterator for DeltaIterator<'a, T>whereT: Attributes,{@@ -112,7 +112,7 @@ where}pub fn is_empty_line_at_index(delta: &Delta<RichTextAttributes>, index: usize) -> bool {- let mut iter = DeltaIter::new(delta);+ let mut iter = DeltaIterator::new(delta);let (prev, next) = (iter.next_op_with_len(index), iter.next_op());if prev.is_none() {return true;@@ -128,7 +128,7 @@ pub fn is_empty_line_at_index(delta: &Delta<RichTextAttributes>, index: usize) -}pub struct AttributesIter<'a, T: Attributes> {- delta_iter: DeltaIter<'a, T>,+ delta_iter: DeltaIterator<'a, T>,}impl<'a, T> AttributesIter<'a, T>@@ -141,7 +141,7 @@ where}pub fn from_interval(delta: &'a Delta<T>, interval: Interval) -> Self {- let delta_iter = DeltaIter::from_interval(delta, interval);+ let delta_iter = DeltaIterator::from_interval(delta, interval);Self { delta_iter }}@@ -157,7 +157,7 @@ impl<'a, T> Deref for AttributesIter<'a, T>whereT: Attributes,{- type Target = DeltaIter<'a, T>;+ type Target = DeltaIterator<'a, T>;fn deref(&self) -> &Self::Target {&self.delta_iterdiff --git a/shared-lib/lib-ot/src/core/flowy_str.rs b/shared-lib/lib-ot/src/core/flowy_str.rsindex 95cc1735cc..9e503672eb 100644--- a/shared-lib/lib-ot/src/core/flowy_str.rs+++ b/shared-lib/lib-ot/src/core/flowy_str.rs@@ -177,7 +177,7 @@ impl<'a> FlowyUtf16CodePointIterator<'a> {}}-use crate::core::Interval;+use crate::core::interval::Interval;use std::str;impl<'a> Iterator for FlowyUtf16CodePointIterator<'a> {@@ -226,7 +226,8 @@ pub fn len_utf8_from_first_byte(b: u8) -> usize {#[cfg(test)]mod tests {- use crate::core::{FlowyStr, Interval};+ use crate::core::flowy_str::FlowyStr;+ use crate::core::interval::Interval;#[test]fn flowy_str_code_unit() {diff --git a/shared-lib/lib-ot/src/core/interval.rs b/shared-lib/lib-ot/src/core/interval.rsindex a6f3131b6a..cc907ec3ea 100644--- a/shared-lib/lib-ot/src/core/interval.rs+++ b/shared-lib/lib-ot/src/core/interval.rs@@ -157,7 +157,7 @@ impl From<RangeToInclusive<usize>> for Interval {#[cfg(test)]mod tests {- use crate::core::Interval;+ use crate::core::interval::Interval;#[test]fn contains() {diff --git a/shared-lib/lib-ot/src/core/mod.rs b/shared-lib/lib-ot/src/core/mod.rsindex b5bc594246..72a6dd9b74 100644--- a/shared-lib/lib-ot/src/core/mod.rs+++ b/shared-lib/lib-ot/src/core/mod.rs@@ -3,28 +3,7 @@ mod flowy_str;mod interval;mod operation;-use crate::errors::OTError;pub use delta::*;pub use flowy_str::*;pub use interval::*;pub use operation::*;--pub trait OperationTransformable {- /// Merges the operation with `other` into one operation while preserving- /// the changes of both.- fn compose(&self, other: &Self) -> Result<Self, OTError>- where- Self: Sized;- /// Transforms two operations a and b that happened concurrently and- /// produces two operations a' and b'.- /// (a', b') = a.transform(b)- /// a.compose(b') = b.compose(a')- fn transform(&self, other: &Self) -> Result<(Self, Self), OTError>- where- Self: Sized;- /// Inverts the operation with `other` to produces undo operation.- /// undo = a.invert(b)- /// new_b = b.compose(a)- /// b = new_b.compose(undo)- fn invert(&self, other: &Self) -> Self;-}diff --git a/shared-lib/lib-ot/src/core/operation/builder.rs b/shared-lib/lib-ot/src/core/operation/builder.rsindex dc7b6dd7d9..a42ebdecb3 100644--- a/shared-lib/lib-ot/src/core/operation/builder.rs+++ b/shared-lib/lib-ot/src/core/operation/builder.rs@@ -1,40 +1,38 @@-use crate::{- core::{Attributes, Operation, PlainTextAttributes},- rich_text::RichTextAttributes,-};+use crate::core::operation::{Attributes, Operation, PlainTextAttributes};+use crate::rich_text::RichTextAttributes;-pub type RichTextOpBuilder = OpBuilder<RichTextAttributes>;-pub type PlainTextOpBuilder = OpBuilder<PlainTextAttributes>;+pub type RichTextOpBuilder = OperationBuilder<RichTextAttributes>;+pub type PlainTextOpBuilder = OperationBuilder<PlainTextAttributes>;-pub struct OpBuilder<T: Attributes> {+pub struct OperationBuilder<T: Attributes> {ty: Operation<T>,attrs: T,}-impl<T> OpBuilder<T>+impl<T> OperationBuilder<T>whereT: Attributes,{- pub fn new(ty: Operation<T>) -> OpBuilder<T> {- OpBuilder {+ pub fn new(ty: Operation<T>) -> OperationBuilder<T> {+ OperationBuilder {ty,attrs: T::default(),}}- pub fn retain(n: usize) -> OpBuilder<T> {- OpBuilder::new(Operation::Retain(n.into()))+ pub fn retain(n: usize) -> OperationBuilder<T> {+ OperationBuilder::new(Operation::Retain(n.into()))}- pub fn delete(n: usize) -> OpBuilder<T> {- OpBuilder::new(Operation::Delete(n))+ pub fn delete(n: usize) -> OperationBuilder<T> {+ OperationBuilder::new(Operation::Delete(n))}- pub fn insert(s: &str) -> OpBuilder<T> {- OpBuilder::new(Operation::Insert(s.into()))+ pub fn insert(s: &str) -> OperationBuilder<T> {+ OperationBuilder::new(Operation::Insert(s.into()))}- pub fn attributes(mut self, attrs: T) -> OpBuilder<T> {+ pub fn attributes(mut self, attrs: T) -> OperationBuilder<T> {self.attrs = attrs;self}diff --git a/shared-lib/lib-ot/src/core/operation/operation.rs b/shared-lib/lib-ot/src/core/operation/operation.rsindex 82228c19fc..8ff47d95e8 100644--- a/shared-lib/lib-ot/src/core/operation/operation.rs+++ b/shared-lib/lib-ot/src/core/operation/operation.rs@@ -1,8 +1,9 @@-use crate::{- core::{FlowyStr, Interval, OpBuilder, OperationTransformable},- errors::OTError,-};+use crate::core::flowy_str::FlowyStr;+use crate::core::interval::Interval;+use crate::core::operation::OperationBuilder;+use crate::errors::OTError;use serde::{Deserialize, Serialize, __private::Formatter};+use std::fmt::Display;use std::{cmp::min,fmt,@@ -10,13 +11,73 @@ use std::{ops::{Deref, DerefMut},};-pub trait Attributes: fmt::Display + Eq + PartialEq + Default + Clone + Debug + OperationTransformable {- fn is_empty(&self) -> bool;+pub trait OperationTransformable {+ /// Merges the operation with `other` into one operation while preserving+ /// the changes of both.+ ///+ /// # Arguments+ ///+ /// * `other`: The delta gonna to merge.+ ///+ /// # Examples+ ///+ /// ```+ /// use lib_ot::core::{OperationTransformable, PlainTextDeltaBuilder};+ /// let document = PlainTextDeltaBuilder::new().build();+ /// let delta = PlainTextDeltaBuilder::new().insert("abc").build();+ /// let new_document = document.compose(&delta).unwrap();+ /// assert_eq!(new_document.to_str().unwrap(), "abc".to_owned());+ /// ```+ fn compose(&self, other: &Self) -> Result<Self, OTError>+ where+ Self: Sized;++ /// Transforms two operations a and b that happened concurrently and+ /// produces two operations a' and b'.+ /// (a', b') = a.transform(b)+ /// a.compose(b') = b.compose(a')+ ///+ fn transform(&self, other: &Self) -> Result<(Self, Self), OTError>+ where+ Self: Sized;++ /// Return the invert delta from the other. It can be used to do the undo operation.+ ///+ /// # Arguments+ ///+ /// * `other`: Generate the undo delta for [Other]. [Other] can compose the undo delta to return+ /// to the previous state.+ ///+ /// # Examples+ ///+ /// ```+ /// use lib_ot::core::{OperationTransformable, PlainTextDeltaBuilder};+ /// let original_document = PlainTextDeltaBuilder::new().build();+ /// let delta = PlainTextDeltaBuilder::new().insert("abc").build();+ ///+ /// let undo_delta = delta.invert(&original_document);+ /// let new_document = original_document.compose(&delta).unwrap();+ /// let document = new_document.compose(&undo_delta).unwrap();+ ///+ /// assert_eq!(original_document, document);+ ///+ /// ```+ fn invert(&self, other: &Self) -> Self;+}- // Remove the empty attribute which value is None.- fn remove_empty(&mut self);+pub trait Attributes: Default + Display + Eq + PartialEq + Clone + Debug + OperationTransformable {+ fn is_empty(&self) -> bool {+ true+ }++ /// Remove the empty attribute which value is None.+ fn remove_empty(&mut self) {+ // Do nothing+ }- fn extend_other(&mut self, other: Self);+ fn extend_other(&mut self, _other: Self) {+ // Do nothing+ }}#[derive(Debug, Clone, Eq, PartialEq)]@@ -77,22 +138,22 @@ wherelet right;match self {Operation::Delete(n) => {- left = Some(OpBuilder::<T>::delete(index).build());- right = Some(OpBuilder::<T>::delete(*n - index).build());+ left = Some(OperationBuilder::<T>::delete(index).build());+ right = Some(OperationBuilder::<T>::delete(*n - index).build());}Operation::Retain(retain) => {- left = Some(OpBuilder::<T>::delete(index).build());- right = Some(OpBuilder::<T>::delete(retain.n - index).build());+ left = Some(OperationBuilder::<T>::delete(index).build());+ right = Some(OperationBuilder::<T>::delete(retain.n - index).build());}Operation::Insert(insert) => {let attributes = self.get_attributes();left = Some(- OpBuilder::<T>::insert(&insert.s[0..index])+ OperationBuilder::<T>::insert(&insert.s[0..index]).attributes(attributes.clone()).build(),);right = Some(- OpBuilder::<T>::insert(&insert.s[index..insert.utf16_size()])+ OperationBuilder::<T>::insert(&insert.s[index..insert.utf16_size()]).attributes(attributes).build(),);@@ -104,16 +165,18 @@ wherepub fn shrink(&self, interval: Interval) -> Option<Operation<T>> {let op = match self {- Operation::Delete(n) => OpBuilder::delete(min(*n, interval.size())).build(),- Operation::Retain(retain) => OpBuilder::retain(min(retain.n, interval.size()))+ Operation::Delete(n) => OperationBuilder::delete(min(*n, interval.size())).build(),+ Operation::Retain(retain) => OperationBuilder::retain(min(retain.n, interval.size())).attributes(retain.attributes.clone()).build(),Operation::Insert(insert) => {if interval.start > insert.utf16_size() {- OpBuilder::insert("").build()+ OperationBuilder::insert("").build()} else {let s = insert.s.sub_str(interval).unwrap_or_else(|| "".to_owned());- OpBuilder::insert(&s).attributes(insert.attributes.clone()).build()+ OperationBuilder::insert(&s)+ .attributes(insert.attributes.clone())+ .build()}}};@@ -212,7 +275,7 @@ whereself.n += n;None} else {- Some(OpBuilder::retain(n).attributes(attributes).build())+ Some(OperationBuilder::retain(n).attributes(attributes).build())}}@@ -296,7 +359,7 @@ whereself.s += s;None} else {- Some(OpBuilder::<T>::insert(s).attributes(attributes).build())+ Some(OperationBuilder::<T>::insert(s).attributes(attributes).build())}}@@ -346,15 +409,7 @@ impl fmt::Display for PlainTextAttributes {}}-impl Attributes for PlainTextAttributes {- fn is_empty(&self) -> bool {- true- }-- fn remove_empty(&mut self) {}-- fn extend_other(&mut self, _other: Self) {}-}+impl Attributes for PlainTextAttributes {}impl OperationTransformable for PlainTextAttributes {fn compose(&self, _other: &Self) -> Result<Self, OTError> {diff --git a/shared-lib/lib-ot/src/core/operation/operation_serde.rs b/shared-lib/lib-ot/src/core/operation/operation_serde.rsindex aefb909d0a..d029fb0e16 100644--- a/shared-lib/lib-ot/src/core/operation/operation_serde.rs+++ b/shared-lib/lib-ot/src/core/operation/operation_serde.rs@@ -1,4 +1,5 @@-use crate::core::{Attributes, FlowyStr, Insert, Operation, Retain};+use crate::core::flowy_str::FlowyStr;+use crate::core::operation::{Attributes, Insert, Operation, Retain};use serde::{de,de::{MapAccess, SeqAccess, Visitor},diff --git a/shared-lib/lib-ot/src/rich_text/attributes.rs b/shared-lib/lib-ot/src/rich_text/attributes.rsindex d70e23228b..05d37317d2 100644--- a/shared-lib/lib-ot/src/rich_text/attributes.rs+++ b/shared-lib/lib-ot/src/rich_text/attributes.rs@@ -1,10 +1,6 @@#![allow(non_snake_case)]-use crate::{- block_attribute,- core::{Attributes, Operation, OperationTransformable},- errors::OTError,- ignore_attribute, inline_attribute, list_attribute,-};+use crate::core::{Attributes, Operation, OperationTransformable};+use crate::{block_attribute, errors::OTError, ignore_attribute, inline_attribute, list_attribute};use lazy_static::lazy_static;use std::{collections::{HashMap, HashSet},diff --git a/shared-lib/lib-ot/src/rich_text/delta.rs b/shared-lib/lib-ot/src/rich_text/delta.rsindex 99cb35f2bc..3a60cf7b02 100644--- a/shared-lib/lib-ot/src/rich_text/delta.rs+++ b/shared-lib/lib-ot/src/rich_text/delta.rs@@ -1,7 +1,5 @@-use crate::{- core::{Delta, DeltaBuilder},- rich_text::RichTextAttributes,-};+use crate::core::{Delta, DeltaBuilder};+use crate::rich_text::RichTextAttributes;pub type RichTextDelta = Delta<RichTextAttributes>;pub type RichTextDeltaBuilder = DeltaBuilder<RichTextAttributes>;