prosemirror-rs 0.3.4 → 0.3.5

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "prosemirror-rs-node"
-version = "0.3.4"
+version = "0.3.5"
 authors = [
     "Johannes Wilm <johannes@fiduswriter.org>",
     "Daniel Seiler <me@dseiler.eu>",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prosemirror-rs",
-  "version": "0.3.4",
+  "version": "0.3.5",
   "description": "Node.js bindings for prosemirror-rs: a Rust implementation of ProseMirror's document model and transform pipeline",
   "main": "index.js",
   "types": "index.d.ts",

package/src/lib.rs

@@ -268,10 +268,15 @@ impl Editor {
     /// document directly to a database without creating any intermediate
     /// JS objects.
     ///
+    /// When `skipDefaults` is `true`, attributes whose value matches the
+    /// schema-defined default are omitted from the output ("mini" JSON).
+    ///
+    /// @param skipDefaults If true, omit attributes that have default values.
     /// @returns The document as a compact JSON string.
     #[napi]
-    pub fn doc_json(&self) -> napi::Result<String> {
-        serde_json::to_string(&self.doc)
+    pub fn doc_json(&self, skip_defaults: Option<bool>) -> napi::Result<String> {
+        let val = self.schema.with_types(|| self.doc.to_json(skip_defaults.unwrap_or(false)));
+        serde_json::to_string(&val)
             .map_err(|e| napi::Error::new(Status::GenericFailure, format!("Serialization error: {e}")))
     }
 

package/tests/editor.test.js

@@ -81,16 +81,96 @@ test('constructor throws when doc JSON is not a node object', () => {
 });
 
 // ---------------------------------------------------------------------------
-// docJson
+// docJson with skipDefaults
 // ---------------------------------------------------------------------------
 
-test('docJson returns a valid JSON string containing the initial text', () => {
-    const editor = new Editor(SCHEMA, DOC);
-    const raw = editor.docJson();
-    assert.equal(typeof raw, 'string');
-    const doc = JSON.parse(raw);
-    assert.equal(doc.type, 'doc');
-    assert.ok(raw.includes('hello'), `Expected "hello" in: ${raw}`);
+test('docJson() without argument includes all attributes', () => {
+    // Schema with attributes that have defaults
+    const schemaWithAttrs = JSON.stringify({
+        nodes: {
+            doc:       { content: 'paragraph+' },
+            paragraph: {
+                content: 'text*',
+                group: 'block',
+                attrs: { align: { default: 'left' }, indent: { default: 0 } },
+            },
+            text: { group: 'inline' },
+        },
+        marks: { strong: { attrs: { level: { default: 1 } } }, em: {} },
+    });
+
+    // Document with default attributes (should be included in regular serialization)
+    const docDefault = JSON.stringify({
+        type: 'doc',
+        content: [{
+            type: 'paragraph',
+            attrs: { align: 'left', indent: 0 },
+            content: [{
+                type: 'text',
+                text: 'hello',
+                marks: [{ type: 'strong', attrs: { level: 1 } }],
+            }],
+        }],
+    });
+
+    const editorDefault = new Editor(schemaWithAttrs, docDefault);
+
+    // Regular serialization should include all attrs
+    const fullRaw = editorDefault.docJson();
+    const full = JSON.parse(fullRaw);
+    assert.ok(fullRaw.includes('"attrs"'), `Expected attrs in full serialization: ${fullRaw}`);
+    assert.equal(full.content[0].attrs.align, 'left');
+    assert.equal(full.content[0].attrs.indent, 0);
+    assert.equal(full.content[0].content[0].marks[0].attrs.level, 1);
+
+    // Mini serialization should skip all default attributes
+    const miniRaw = editorDefault.docJson(true);
+    const mini = JSON.parse(miniRaw);
+    assert.ok(!miniRaw.includes('"attrs"'), `Expected no attrs in mini serialization: ${miniRaw}`);
+    assert.ok(!('attrs' in mini.content[0]), 'paragraph should have no attrs');
+    assert.ok(!('attrs' in mini.content[0].content[0].marks[0]), 'mark should have no attrs');
+
+    // Document with non-default attributes
+    const docCustom = JSON.stringify({
+        type: 'doc',
+        content: [{
+            type: 'paragraph',
+            attrs: { align: 'right', indent: 2 },
+            content: [{ type: 'text', text: 'world' }],
+        }],
+    });
+
+    const editorCustom = new Editor(schemaWithAttrs, docCustom);
+    const miniCustomRaw = editorCustom.docJson(true);
+    const miniCustom = JSON.parse(miniCustomRaw);
+    // Non-default attrs should still appear
+    assert.ok(miniCustomRaw.includes('"attrs"'), `Expected attrs for non-default values: ${miniCustomRaw}`);
+    assert.equal(miniCustom.content[0].attrs.align, 'right');
+    assert.equal(miniCustom.content[0].attrs.indent, 2);
+
+    // Mix of default and non-default
+    const docMixed = JSON.stringify({
+        type: 'doc',
+        content: [{
+            type: 'paragraph',
+            attrs: { align: 'center', indent: 0 },
+            content: [{ type: 'text', text: 'mixed' }],
+        }],
+    });
+
+    const editorMixed = new Editor(schemaWithAttrs, docMixed);
+    const miniMixedRaw = editorMixed.docJson(true);
+    const miniMixed = JSON.parse(miniMixedRaw);
+    // Only 'align' should be present (indent is default 0)
+    assert.ok(miniMixedRaw.includes('"attrs"'), `Expected attrs for partial non-default: ${miniMixedRaw}`);
+    assert.equal(miniMixed.content[0].attrs.align, 'center');
+    assert.ok(!('indent' in miniMixed.content[0].attrs), 'indent should be omitted (default value)');
+
+    // Verify backwards compatibility: no argument == false
+    const editorBC = new Editor(SCHEMA, DOC);
+    const noArg = editorBC.docJson();
+    const falseArg = editorBC.docJson(false);
+    assert.equal(noArg, falseArg, 'docJson() and docJson(false) should be identical');
 });
 
 // ---------------------------------------------------------------------------