gt-sanity 0.0.5 → 1.0.0

package/src/serialization/__tests__/BaseDocumentMerger/fieldLevelMerge.test.ts

@@ -0,0 +1,142 @@
+import { createRequire } from 'module';
+import { expect, test } from 'vitest';
+import { BaseDocumentMerger } from '../../index';
+import { getDeserialized } from '../helpers';
+import { getNewFieldLevelDocument, getNewObject } from './utils';
+import clone from 'just-clone';
+
+const require = createRequire(import.meta.url);
+
+const fieldLevelArticle = require('../__fixtures__/fieldLevelArticle.json');
+const nestedLanguageFields = require('../__fixtures__/nestedLanguageFields.json');
+
+const newDocument = getNewFieldLevelDocument();
+const fieldLevelPatches = BaseDocumentMerger.fieldLevelMerge(
+  newDocument,
+  fieldLevelArticle,
+  'es_ES',
+  'en'
+);
+test('Global field level snapshot test', () => {
+  expect(fieldLevelPatches).toMatchSnapshot();
+});
+
+/*
+ * Objects
+ */
+test('Top-level string / text fields from new document patch to new field, and will be maintained in old field', () => {
+  expect(fieldLevelPatches['title.es_ES']).toEqual(newDocument.title.en);
+  expect(fieldLevelPatches['snippet.es_ES']).toEqual(newDocument.snippet.en);
+  expect(fieldLevelPatches['title.es_ES']).not.toEqual(
+    fieldLevelArticle.title.en
+  );
+  expect(fieldLevelPatches['snippet.es_ES']).not.toEqual(
+    fieldLevelArticle.snippet.en
+  );
+  expect(fieldLevelPatches['title.en']).toBeUndefined();
+  expect(fieldLevelPatches['snippet.en']).toBeUndefined();
+});
+
+test('Nested object fields override old object fields', () => {
+  expect(fieldLevelPatches['config.es_ES'].title).toEqual(
+    newDocument.config.en.title
+  );
+  expect(fieldLevelPatches['config.es_ES'].title).not.toEqual(
+    fieldLevelArticle.config.en.title
+  );
+  expect(
+    fieldLevelPatches['config.es_ES'].nestedArrayField[0].children[0].text
+  ).toEqual(newDocument.config.en.nestedArrayField[0].children[0].text);
+  expect(
+    fieldLevelPatches['config.es_ES'].nestedArrayField[0].children[0].text
+  ).not.toEqual(
+    fieldLevelArticle.config.en.nestedArrayField[0].children[0].text
+  );
+});
+
+test('Nested object merge uses old fields when not present on new object', () => {
+  expect(fieldLevelPatches['config.es_ES'].objectAsField.content).toEqual(
+    fieldLevelArticle.config.en.objectAsField.content
+  );
+});
+
+/*
+ * Arrays
+ */
+test('Arrays will use new objects when they exist', () => {
+  expect(fieldLevelPatches['content.es_ES'][0].children[0].text).toEqual(
+    newDocument.content.en[0].children[0].text
+  );
+  expect(fieldLevelPatches['content.es_ES'][0].children[0].text).not.toEqual(
+    fieldLevelArticle.content.en[0].children[0].text
+  );
+});
+
+test('Arrays will use old blocks if they do not exist on new object', () => {
+  expect(newDocument.content.en[1]).toBeUndefined();
+  expect(fieldLevelPatches['content.es_ES'][1]).toBeDefined();
+  expect(fieldLevelPatches['content.es_ES'][1]._key).toEqual(
+    fieldLevelArticle.content.en[1]._key
+  );
+});
+
+test('Arrays will merge objects in the array', () => {
+  const documentWithIncompleteObj = getNewFieldLevelDocument();
+  const incompleteObj = getNewObject();
+
+  //add a new block with some new content, but not all new content
+  documentWithIncompleteObj.content.en.push({
+    _key: fieldLevelArticle.content.en[1]._key,
+    objectAsField: incompleteObj.objectAsField,
+    title: incompleteObj.title,
+    //does not include "content" field -- we want that to be merged with the old
+  });
+
+  const fieldDocWithMergedObj = BaseDocumentMerger.fieldLevelMerge(
+    documentWithIncompleteObj,
+    fieldLevelArticle,
+    'es_ES',
+    'en'
+  );
+
+  expect(fieldDocWithMergedObj['content.es_ES'][1].title).toEqual(
+    documentWithIncompleteObj.content.en[1].title
+  );
+  expect(fieldDocWithMergedObj['content.es_ES'][1].objectAsField.title).toEqual(
+    documentWithIncompleteObj.content.en[1].objectAsField.title
+  );
+  //"content" field existed on old doc but not new, so the two coexist happily
+  expect(
+    documentWithIncompleteObj.content.en[1].objectAsField.content
+  ).toBeUndefined();
+  expect(
+    fieldDocWithMergedObj['content.es_ES'][1].objectAsField.content
+  ).toBeDefined();
+});
+
+test('nested locale fields will be merged', () => {
+  const newNestedFields = clone(nestedLanguageFields);
+  newNestedFields.pageFields.name.en = 'This is a new page field name';
+  newNestedFields.slices[0].en[0].children[0].text = 'This is new slice text';
+  const baseDocumentWithNestedFields = {
+    ...fieldLevelArticle,
+    ...nestedLanguageFields,
+  };
+  const newDocumentWithNestedFields = getDeserialized(
+    { ...fieldLevelArticle, ...newNestedFields },
+    'field'
+  );
+  const nestedFieldLevelPatches = BaseDocumentMerger.fieldLevelMerge(
+    newDocumentWithNestedFields,
+    baseDocumentWithNestedFields,
+    'es_ES',
+    'en'
+  );
+
+  expect(
+    nestedFieldLevelPatches['slices[0].es_ES'][0].children[0].text
+  ).toEqual(newDocumentWithNestedFields.slices[0].en[0].children[0].text);
+  expect(nestedFieldLevelPatches['pageFields.name.es_ES']).toEqual(
+    newDocumentWithNestedFields.pageFields.name.en
+  );
+});

package/src/serialization/__tests__/BaseDocumentMerger/utils.ts

@@ -0,0 +1,52 @@
+import { getDeserialized } from '../helpers';
+import { createRequire } from 'module';
+import clone from 'just-clone';
+
+const require = createRequire(import.meta.url);
+
+const documentLevelArticle = require('../__fixtures__/documentLevelArticle.json');
+const fieldLevelArticle = require('../__fixtures__/fieldLevelArticle.json');
+
+export const getNewObject = (): Record<string, any> => {
+  const newObject = {
+    title: 'A new title',
+    nestedArrayField: clone(documentLevelArticle.config.nestedArrayField),
+    objectAsField: { title: 'A new nested title' },
+    _key: null,
+  };
+  newObject.nestedArrayField[0].children[0].text = 'New text';
+  return newObject;
+};
+
+export const getNewDocument = (): Record<string, any> => {
+  const newDocument = getDeserialized(documentLevelArticle, 'document');
+  newDocument.title = 'A new document title';
+  newDocument.snippet = 'A new document snippet';
+  newDocument.config = getNewObject();
+  const newBlockText = newDocument.content[0];
+  newBlockText.children[0].text = 'New block text';
+  newDocument.content = [newBlockText];
+  return newDocument;
+};
+
+export const getNewFieldLevelObject = (): Record<string, any> => {
+  const newObject = {
+    title: 'A new title',
+    nestedArrayField: clone(fieldLevelArticle.config.en.nestedArrayField),
+    objectAsField: { title: 'A new nested title' },
+    _key: null,
+  };
+  newObject.nestedArrayField[0].children[0].text = 'New text';
+  return newObject;
+};
+
+export const getNewFieldLevelDocument = (): Record<string, any> => {
+  const newDocument = getDeserialized(fieldLevelArticle, 'field');
+  newDocument.title.en = 'A new document title';
+  newDocument.snippet.en = 'A new document snippet';
+  newDocument.config.en = getNewFieldLevelObject();
+  const newBlockText = newDocument.content.en[0];
+  newBlockText.children[0].text = 'New block text';
+  newDocument.content.en = [newBlockText];
+  return newDocument;
+};

package/src/serialization/__tests__/BaseDocumentSerializer/__snapshots__/documentInlineMarks.test.ts.snap

@@ -0,0 +1,39 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Global test of working doc-level functionality and snapshot match 1`] = `
+{
+  "content": "<html><head><meta name="_id" content="drafts.d8ffc675-ce86-4f60-9ac8-da164cde3b0a"><meta name="_type" content="documentLevelArticle"><meta name="_rev" content="fxcnqj-uew-gr7-v6r-z965tfm69"><meta name="version" content="3"></head><body><div class="documentLevelArticle" id="drafts.d8ffc675-ce86-4f60-9ac8-da164cde3b0a" data-type="object"><span class="title">My Document-Level Article</span><span class="snippet">This is text in my text field.</span><div class="tags" data-type="array"><span>tag 1</span><span>tag 2</span><span>tag 3</span></div><div class="content" data-type="array"><p id="a4d177e92666">This is block text with <span class="unknown__pt__mark__linkField">a website link</span> and <span class="unknown__pt__mark__linkField">a post reference</span><span class="unknown__pt__mark__linkField"> at the top level.</span></p></div></div></body></html>",
+  "name": "drafts.d8ffc675-ce86-4f60-9ac8-da164cde3b0a",
+}
+`;
+
+exports[`Test of working deserialization and snapshot match 1`] = `
+{
+  "_id": "drafts.d8ffc675-ce86-4f60-9ac8-da164cde3b0a",
+  "_rev": "fxcnqj-uew-gr7-v6r-z965tfm69",
+  "_type": "documentLevelArticle",
+  "content": [
+    {
+      "_key": "a4d177e92666",
+      "_type": "block",
+      "children": [
+        {
+          "_key": "randomKey-10",
+          "_type": "span",
+          "marks": [],
+          "text": "This is block text with a website link and a post reference at the top level.",
+        },
+      ],
+      "markDefs": [],
+      "style": "normal",
+    },
+  ],
+  "snippet": "This is text in my text field.",
+  "tags": [
+    "tag 1",
+    "tag 2",
+    "tag 3",
+  ],
+  "title": "My Document-Level Article",
+}
+`;

package/src/serialization/__tests__/BaseDocumentSerializer/__snapshots__/documentLevelSerialization.test.ts.snap

@@ -0,0 +1,8 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Global test of working doc-level functionality and snapshot match 1`] = `
+{
+  "content": "<html><head><meta name="_id" content="drafts.d8ffc675-ce86-4f60-9ac8-da164cde3b0a"><meta name="_type" content="documentLevelArticle"><meta name="_rev" content="fxcnqj-uew-gr7-v6r-z965tfm69"><meta name="version" content="3"></head><body><div class="documentLevelArticle" id="drafts.d8ffc675-ce86-4f60-9ac8-da164cde3b0a" data-type="object"><span class="title">My Document-Level Article</span><span class="snippet">This is text in my text field.</span><div class="tags" data-type="array"><span>tag 1</span><span>tag 2</span><span>tag 3</span></div><div class="config" data-level="field"><div class="objectField" data-type="object"><span class="title">This is an object nested in a document</span><div class="objectAsField" data-level="field"><div class="childObjectField" data-type="object"><span class="title">This is one level deeper</span><div class="content" data-type="array"><p id="1aa228ac848b">This is a block text 2 levels deep</p></div></div></div><div class="nestedArrayField" data-type="array"><p id="4a58adc7c507">This is block text 1 level deep</p></div></div></div><div class="content" data-type="array"><p id="a4d177e92666">This is block text at the top level.</p><div class="objectField" id="c0313627775e" data-type="object"><span class="title">This is an object in top-level block text.</span><div class="objectAsField" data-level="field"><div class="childObjectField" data-type="object"><span class="title">This is a nested object in an object in top-level block text.</span><div class="content" data-type="array"><p id="4f24f6fbfae7">This is block text in a nested object in an object in top-level block text.</p></div></div></div></div><h1 id="9e2ab13c6d63">This is h1 text</h1><h2 id="297142fbaf21">This is h2 text</h2><ul id="76e648fc3845"><li id="76e648fc3845" data-level="1">Bullet 1</li></ul><ul id="d090cd8b27d2"><li id="d090cd8b27d2" data-level="2">nested bullet a</li></ul><ul id="1cdffa5d50f5"><li id="1cdffa5d50f5" data-level="1"><h2 id="1cdffa5d50f5">Styled bullet 2</h2></li></ul><ol id="da29f5063059"><li id="da29f5063059" data-level="1"><h3 id="da29f5063059">Number 1</h3></li></ol></div></div></body></html>",
+  "name": "drafts.d8ffc675-ce86-4f60-9ac8-da164cde3b0a",
+}
+`;

package/src/serialization/__tests__/BaseDocumentSerializer/__snapshots__/fieldLevelSerialization.test.ts.snap

@@ -0,0 +1,8 @@
+// Vitest Snapshot v1, https://vitest.dev/guide/snapshot.html
+
+exports[`Global test of working field-level functionality and snapshot match 1`] = `
+{
+  "content": "<html><head><meta name="_id" content="drafts.2947533e-1ea5-4116-955b-339608d3445d"><meta name="_type" content="fieldLevelArticle"><meta name="_rev" content="l58oha-n06-1s4-f6i-74g6cuakl"><meta name="version" content="3"></head><body><div class="fieldLevelArticle" id="drafts.2947533e-1ea5-4116-955b-339608d3445d" data-type="object"><div class="title" data-level="field"><div class="" data-type="object"><span class="en">My Field-Level Article</span></div></div><div class="snippet" data-level="field"><div class="" data-type="object"><span class="en">This is text in my text field</span></div></div><div class="tags" data-level="field"><div class="" data-type="object"><div class="en" data-type="array"><span>tag 1</span><span>tag 2</span><span>tag 3</span></div></div></div><div class="config" data-level="field"><div class="" data-type="object"><div class="en" data-level="field"><div class="objectField" data-type="object"><span class="title">This is an object nested in a document</span><div class="objectAsField" data-level="field"><div class="childObjectField" data-type="object"><span class="title">This is one level deeper</span><div class="content" data-type="array"><p id="869168fe3a2a">This is block text 2 levels deep</p></div></div></div><div class="nestedArrayField" data-type="array"><p id="f49b4d7e3e51">This is block text 1 level deep</p></div></div></div></div></div><div class="content" data-level="field"><div class="" data-type="object"><div class="en" data-type="array"><p id="e2a39d768ff8">This is block text at the top level.</p><div class="objectField" id="271b0c6ee984" data-type="object"><span class="title">This is an object in top-level block text.</span><div class="objectAsField" data-level="field"><div class="childObjectField" data-type="object"><span class="title">This is a nested object in an object in top-level block text.</span><div class="content" data-type="array"><p id="4f24f6fbfae7">This is block text in a nested object in an object in top-level block text.</p></div></div></div></div></div></div></div></div></body></html>",
+  "name": "drafts.2947533e-1ea5-4116-955b-339608d3445d",
+}
+`;

package/src/serialization/__tests__/BaseDocumentSerializer/baseSerialization.test.ts

@@ -0,0 +1,345 @@
+import { PortableTextBlock } from 'sanity';
+import { describe, expect, test, vi } from 'vitest';
+import {
+  BaseDocumentSerializer,
+  customSerializers,
+  defaultStopTypes,
+} from '../../index';
+import {
+  addedCustomSerializers,
+  createCustomInnerHTML,
+  getSerialized,
+  getValidFields,
+} from '../helpers';
+import {
+  annotationAndInlineBlocks,
+  documentLevelArticle,
+  findByClass,
+  getHTMLNode,
+  inlineDocumentLevelArticle,
+  inlineSchema,
+  schema,
+} from './utils';
+
+/*
+ * METADATA PRESENCE
+ */
+describe('Has all required metadata', () => {
+  const serialized = getSerialized(documentLevelArticle, 'document');
+  const docTree = getHTMLNode(serialized);
+  test('Contains metadata field containing document id', () => {
+    const idMetaTag = Array.from(docTree.head.children).find(
+      (metaTag) => metaTag.getAttribute('name') === '_id'
+    );
+    const id = idMetaTag?.getAttribute('content');
+    expect(id).toEqual(documentLevelArticle._id);
+  });
+
+  test('Contains metadata field containing document revision', () => {
+    const revMetaTag = Array.from(docTree.head.children).find(
+      (metaTag) => metaTag.getAttribute('name') === '_rev'
+    );
+    const rev = revMetaTag?.getAttribute('content');
+    expect(rev).toEqual(documentLevelArticle._rev);
+  });
+
+  test('Contains metadata field containing document type', () => {
+    const typeMetaTag = Array.from(docTree.head.children).find(
+      (metaTag) => metaTag.getAttribute('name') === '_type'
+    );
+    const type = typeMetaTag?.getAttribute('content');
+    expect(type).toEqual(documentLevelArticle._type);
+  });
+
+  test('Contains metadata field containing version', () => {
+    const typeMetaTag = Array.from(docTree.head.children).find(
+      (metaTag) => metaTag.getAttribute('name') === 'version'
+    );
+    const version = typeMetaTag?.getAttribute('content');
+    expect(version).toEqual('3');
+  });
+});
+
+/*
+ * CUSTOM SETTINGS
+ */
+
+test('Custom serialization should manifest at all levels', () => {
+  const serializer = BaseDocumentSerializer(schema);
+  const serialized = serializer.serializeDocument(
+    documentLevelArticle,
+    'document',
+    'en',
+    defaultStopTypes,
+    addedCustomSerializers
+  );
+  const docTree = getHTMLNode(serialized).body.children[0];
+
+  const topLevelCustomSerialized = findByClass(docTree.children, 'config');
+  const requiredTopLevelTitle = documentLevelArticle.config.title;
+  expect(topLevelCustomSerialized?.innerHTML).toContain(
+    createCustomInnerHTML(requiredTopLevelTitle)
+  );
+
+  const arrayField = findByClass(docTree.children, 'content');
+  const nestedSerialized = findByClass(arrayField!.children, 'objectField');
+  const requiredNestedTitle = documentLevelArticle.content.find(
+    (b: Record<string, any>) => b._type === 'objectField'
+  ).title;
+  expect(nestedSerialized?.innerHTML).toContain(
+    createCustomInnerHTML(requiredNestedTitle)
+  );
+});
+
+test('Fields marked "localize: false" should not be serialized', () => {
+  const serialized = getSerialized(documentLevelArticle, 'document');
+  const docTree = getHTMLNode(serialized).body.children[0];
+  //"meta" is localize: false field
+  const meta = findByClass(docTree.children, 'meta');
+  expect(documentLevelArticle.meta).toBeDefined();
+  expect(meta).toBeUndefined();
+});
+
+test('Expect default stop types to be absent', () => {
+  const serialized = getSerialized(documentLevelArticle, 'document');
+  const docTree = getHTMLNode(serialized).body.children[0];
+  //"hidden" is boolean field
+  const hidden = findByClass(docTree.children, 'hidden');
+  expect(documentLevelArticle.hidden).toBeDefined();
+  expect(hidden).toBeUndefined();
+});
+
+test('Expect custom stop types to be absent at all levels', () => {
+  const customStopTypes = [...defaultStopTypes, 'objectField'];
+  const serializer = BaseDocumentSerializer(schema);
+  const serialized = serializer.serializeDocument(
+    documentLevelArticle,
+    'document',
+    'en',
+    customStopTypes,
+    customSerializers
+  );
+
+  const docTree = getHTMLNode(serialized).body.children[0];
+  const config = findByClass(docTree.children, 'config');
+  expect(documentLevelArticle.config).toBeDefined();
+  expect(config).toBeUndefined();
+
+  const arrayField = findByClass(docTree.children, 'content');
+  const nestedSerialized = findByClass(arrayField!.children, 'objectField');
+  const nestedObjField = documentLevelArticle.content.find(
+    (b: Record<string, any>) => b._type === 'objectField'
+  );
+  expect(nestedObjField).toBeDefined();
+  expect(nestedSerialized).toBeUndefined();
+});
+
+/*
+ * ANNOTATION AND INLINE BLOCK CONTENT
+ */
+
+test('Unhandled inline objects and annotations should not hinder translation flows', () => {
+  vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+  const inlineDocument = {
+    ...documentLevelArticle,
+    ...annotationAndInlineBlocks,
+  };
+  const serialized = getSerialized(inlineDocument, 'document');
+  const docTree = getHTMLNode(serialized).body.children[0];
+  const arrayField = findByClass(docTree.children, 'content');
+
+  //expect annotated object to have underlying text
+  const blockWithAnnotation = Array.from(arrayField!.children).find(
+    (node) => node.id === '0e55995095df'
+  );
+  const unhandledAnnotation = findByClass(
+    blockWithAnnotation!.children,
+    'unknown__pt__mark__annotation'
+  );
+  expect(unhandledAnnotation?.innerHTML).toContain('text');
+
+  //expect unknown inline object to be present but empty
+  //(this allows it to be merged back safely, but not sent to translation)
+  const inlineObject = findByClass(arrayField!.children, 'childObjectField');
+  expect(inlineObject?.innerHTML.length).toEqual(0);
+});
+
+test('Handled inline objects should be accurately represented per serializer', () => {
+  const inlineDocument = {
+    ...documentLevelArticle,
+    ...annotationAndInlineBlocks,
+  };
+
+  const serializer = BaseDocumentSerializer(schema);
+  const serialized = serializer.serializeDocument(
+    inlineDocument,
+    'document',
+    'en',
+    defaultStopTypes,
+    addedCustomSerializers
+  );
+  const docTree = getHTMLNode(serialized).body.children[0];
+  const arrayField = findByClass(docTree.children, 'content');
+  let inlineObject: Element | null = null;
+  let inlineObjectBlock: Record<string, any> | null = null;
+
+  Array.from(arrayField!.children).forEach((block: any) => {
+    if (!inlineObject) {
+      inlineObject =
+        findByClass(block.children, 'childObjectField') ?? inlineObject;
+    }
+  });
+
+  inlineDocument.content.forEach((block: Record<string, any>) => {
+    if (block.children) {
+      block.children.forEach((span: Record<string, any>) => {
+        if (span._type === 'childObjectField') {
+          inlineObjectBlock = span;
+        }
+      });
+    }
+  });
+
+  expect(inlineObject!.innerHTML).toContain(
+    createCustomInnerHTML(inlineObjectBlock!.title)
+  );
+});
+
+test('Handled annotations should be accurately represented per serializer', () => {
+  const inlineDocument = {
+    ...documentLevelArticle,
+    ...annotationAndInlineBlocks,
+  };
+
+  const serializer = BaseDocumentSerializer(schema);
+  const serialized = serializer.serializeDocument(
+    inlineDocument,
+    'document',
+    'en',
+    defaultStopTypes,
+    addedCustomSerializers
+  );
+  const docTree = getHTMLNode(serialized).body.children[0];
+  const arrayField = findByClass(docTree.children, 'content');
+  let annotation: Element | null = null;
+  let annotationBlock: Record<string, any> | null = null;
+
+  Array.from(arrayField!.children).forEach((block: any) => {
+    if (!annotation) {
+      annotation = findByClass(block.children, 'annotation') ?? annotation;
+    }
+  });
+
+  inlineDocument.content.forEach((block: PortableTextBlock) => {
+    if (block.children && Array.isArray(block.children)) {
+      block.children.forEach((span: Record<string, any>) => {
+        if (span.marks && span.marks.length) {
+          annotationBlock = span;
+        }
+      });
+    }
+  });
+
+  expect(annotation!.innerHTML).toEqual(annotationBlock!.text);
+});
+
+/*
+ * STYLE TAGS
+ */
+test('Serialized content should preserve style tags from Portable Text', () => {
+  const serialized = getSerialized(documentLevelArticle, 'document');
+  const docTree = getHTMLNode(serialized).body.children[0];
+  const arrayField = findByClass(docTree.children, 'content');
+  const blockH1 = documentLevelArticle.content.find(
+    (block: PortableTextBlock) => block.style === 'h1'
+  );
+  const serializedH1 = arrayField?.querySelector('h1');
+  const blockH2 = documentLevelArticle.content.find(
+    (block: PortableTextBlock) => block.style === 'h2'
+  );
+  const serializedH2 = arrayField?.querySelector('h2');
+  expect(serializedH1?.innerHTML).toEqual(blockH1.children[0].text);
+  expect(serializedH2?.innerHTML).toEqual(blockH2.children[0].text);
+});
+
+/*
+ * V2 functionality -- be able to operate without a strict schema
+ */
+
+test('Content with anonymous inline objects serializes all fields, at any depth', () => {
+  const serialized = BaseDocumentSerializer(inlineSchema).serializeDocument(
+    inlineDocumentLevelArticle,
+    'document'
+  );
+  const docTree = getHTMLNode(serialized).body.children[0];
+  const tabs = findByClass(docTree.children, 'tabs')!.children[0];
+  const config = findByClass(tabs!.children, 'config')!.children[0];
+  const fieldNames = getValidFields(inlineDocumentLevelArticle.tabs.config);
+  const foundFieldNames = Array.from(config!.children).map(
+    (child) => child.className
+  );
+  expect(foundFieldNames.sort()).toEqual(fieldNames.sort());
+  const nestedObjHTML = findByClass(config!.children, 'objectAsField')!
+    .children[0];
+  const nestedObj = inlineDocumentLevelArticle.tabs.config.objectAsField;
+  const nestedFieldNames = Array.from(nestedObjHTML!.children).map(
+    (child) => child.className
+  );
+  expect(nestedFieldNames.sort()).toEqual(getValidFields(nestedObj).sort());
+
+  const content = findByClass(tabs!.children, 'content')!;
+  const keysHTML = Array.from(content.children).map((child) => child.id);
+  const keysJSON = inlineDocumentLevelArticle.tabs.content.map(
+    (child: any) => child._key
+  );
+  expect(keysHTML.sort()).toEqual(keysJSON.sort());
+
+  const objectInArrayHTML = findByClass(content.children, 'objectField');
+  const objectInArrayHTMLFieldNames = Array.from(
+    objectInArrayHTML!.children
+  ).map((child) => child.className);
+  const objectInArray = inlineDocumentLevelArticle.tabs.content.find(
+    (obj: any) => obj._type === 'objectField'
+  );
+  expect(objectInArrayHTMLFieldNames.sort()).toEqual(
+    getValidFields(objectInArray).sort()
+  );
+});
+
+/*
+ * LIST ITEMS
+ */
+test('Serialized content should preserve list style and depth from Portable text', () => {
+  const serialized = getSerialized(documentLevelArticle, 'document');
+  const docTree = getHTMLNode(serialized).body.children[0];
+  const arrayField = findByClass(docTree.children, 'content');
+  const listItem = documentLevelArticle.content.find(
+    (block: PortableTextBlock) =>
+      block.listItem === 'bullet' && block.style === 'h2'
+  );
+
+  const serializedListItem = arrayField?.querySelectorAll('li')[2];
+  const nestedListItem = documentLevelArticle.content.find(
+    (block: PortableTextBlock) =>
+      block.listItem === 'bullet' && block.level === 2
+  );
+  const serializedNestedListItem = arrayField?.querySelectorAll('li')[1];
+  //include quote style for completeness
+  expect(serializedListItem?.innerHTML).toContain(listItem.children[0].text);
+  expect(serializedListItem?.innerHTML).toContain('h2');
+
+  expect(serializedNestedListItem?.innerHTML).toEqual(
+    nestedListItem.children[0].text
+  );
+});
+
+test('Values in a field are not repeated (indicating serializers are stateless)', () => {
+  const serialized = getSerialized(documentLevelArticle, 'document');
+  const docTree = getHTMLNode(serialized).body.children[0];
+  const HTMLList = findByClass(docTree.children, 'tags');
+  const tags = documentLevelArticle.tags;
+  expect(HTMLList?.innerHTML).toContain(tags[0]);
+  expect(HTMLList?.innerHTML).toContain(tags[1]);
+  expect(HTMLList?.innerHTML).toContain(tags[2]);
+});

package/src/serialization/__tests__/BaseDocumentSerializer/documentInlineMarks.test.ts

@@ -0,0 +1,53 @@
+import { PortableTextBlock, SanityDocument } from 'sanity';
+import { describe, expect, test } from 'vitest';
+import {
+  getSerialized,
+  getValidFields,
+  toPlainText,
+  getDeserialized,
+} from '../helpers';
+import { docWithInlineMarks, findByClass, getHTMLNode, schema } from './utils';
+import { attachGTData, BaseDocumentSerializer, customSerializers } from '../..';
+import { TranslationLevel } from '../../types';
+import { defaultStopTypes } from '../..';
+import merge from 'lodash.merge';
+import { PortableTextHtmlComponents } from '@portabletext/to-html';
+
+function serialize(document: SanityDocument, level: TranslationLevel) {
+  const serializer = BaseDocumentSerializer(schema);
+  return serializer.serializeDocument(
+    document,
+    level,
+    'en',
+    defaultStopTypes,
+    merge(customSerializers, {
+      marks: {
+        link: ({ value, children }) =>
+          attachGTData(`<a>${children}</a>`, value, 'markDef'),
+        inlineMath: ({ value, children }) =>
+          attachGTData(`<span>${children}</span>`, value, 'markDef'),
+      },
+    } satisfies Partial<PortableTextHtmlComponents>)
+  );
+}
+
+const serialized = serialize(docWithInlineMarks, 'document');
+const deserialized = getDeserialized(docWithInlineMarks, 'document');
+const docTree = getHTMLNode(serialized).body.children[0];
+
+test('Global test of working doc-level functionality and snapshot match', () => {
+  expect(serialized).toMatchSnapshot();
+});
+
+test('Test of working deserialization and snapshot match', () => {
+  expect(deserialized).toMatchSnapshot();
+});
+/*
+ * Top-level plain text
+ */
+test('String and text types get serialized correctly at top-level', () => {
+  const HTMLString = findByClass(docTree.children, 'title');
+  const HTMLText = findByClass(docTree.children, 'snippet');
+  expect(HTMLString?.innerHTML).toEqual(docWithInlineMarks.title);
+  expect(HTMLText?.innerHTML).toEqual(docWithInlineMarks.snippet);
+});