npm - gt-sanity - Versions diffs - 0.0.6 → 1.0.1 - Mend

gt-sanity 0.0.6 → 1.0.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (88) hide show

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

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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 ADDED Viewed

@@ -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);
+});

package/src/serialization/__tests__/BaseDocumentSerializer/documentLevelSerialization.test.ts ADDED Viewed

@@ -0,0 +1,120 @@
+import { PortableTextBlock } from 'sanity';
+import { describe, expect, test } from 'vitest';
+import { getSerialized, getValidFields, toPlainText } from '../helpers';
+import { documentLevelArticle, findByClass, getHTMLNode } from './utils';
+const serialized = getSerialized(documentLevelArticle, 'document');
+const docTree = getHTMLNode(serialized).body.children[0];
+test('Global test of working doc-level functionality and snapshot match', () => {
+  expect(serialized).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(documentLevelArticle.title);
+  expect(HTMLText?.innerHTML).toEqual(documentLevelArticle.snippet);
+});
+/*
+ * Presence and accuracy of fields
+ */
+describe('Presence and accuracy of fields in "vanilla" deserialization -- objects', () => {
+  //parent node is always div with classname of field with a nested div
+  //that has classname of obj type
+  const configObj = findByClass(docTree.children, 'config');
+  const objectField = configObj!.children[0];
+  test('Top-level nested objects contain all serializable fields -- document level', () => {
+    const fieldNames = getValidFields(documentLevelArticle.config);
+    const foundFieldNames = Array.from(objectField!.children).map(
+      (child) => child.className
+    );
+    expect(foundFieldNames.sort()).toEqual(fieldNames.sort());
+  });
+  test('Nested object in object contains all serializable fields -- document level', () => {
+    const nestedObject = findByClass(objectField!.children, 'objectAsField')!
+      .children[0];
+    const fieldNames = getValidFields(
+      documentLevelArticle.config.objectAsField
+    );
+    const foundFieldNames = Array.from(nestedObject!.children).map(
+      (child) => child.className
+    );
+    expect(foundFieldNames.sort()).toEqual(fieldNames.sort());
+  });
+  test('Nested object contains accurate values -- document level', () => {
+    const title = documentLevelArticle.config.title;
+    const blockText = toPlainText(documentLevelArticle.config.nestedArrayField);
+    expect(objectField?.innerHTML).toContain(title);
+    expect(objectField?.innerHTML).toContain(blockText);
+  });
+  test('Nested object in an object contains accurate values -- document level', () => {
+    const nestedObject = findByClass(objectField!.children, 'objectAsField')!
+      .children[0];
+    const title = documentLevelArticle.config.objectAsField.title;
+    const blockText = toPlainText(
+      documentLevelArticle.config.objectAsField.content
+    );
+    expect(nestedObject.innerHTML).toContain(title);
+    expect(nestedObject.innerHTML).toContain(blockText);
+  });
+});
+describe('Presence and accuracy of fields in vanilla deserialization -- arrays', () => {
+  const arrayField = findByClass(docTree.children, 'content');
+  test('Array contains all serializable blocks with keys, in order -- document level', () => {
+    const origKeys = documentLevelArticle.content.map(
+      (block: PortableTextBlock) => block._key
+    );
+    const serializedKeys = Array.from(arrayField!.children).map(
+      (block) => block.id
+    );
+    expect(serializedKeys).toEqual(origKeys);
+  });
+  test('Array contains top-level block text -- document level', () => {
+    const blockText = toPlainText(documentLevelArticle.content).trim();
+    const blockStrings = blockText.split('\n\n');
+    blockStrings.forEach((substring: string) =>
+      expect(arrayField?.innerHTML).toContain(substring)
+    );
+  });
+  test('Object in array contains all serializable fields -- document level', () => {
+    const objectInArray = findByClass(arrayField!.children, 'objectField');
+    const fieldNames = getValidFields(
+      documentLevelArticle.content.find(
+        (block: Record<string, any>) => block._type === 'objectField'
+      )
+    );
+    const foundFieldNames = Array.from(objectInArray!.children).map(
+      (child) => child.className
+    );
+    expect(foundFieldNames.sort()).toEqual(fieldNames.sort());
+  });
+  test('Object in array contains accurate values in nested object -- document level', () => {
+    const objectInArray = findByClass(arrayField!.children, 'objectField');
+    const nestedObject = findByClass(objectInArray!.children, 'objectAsField');
+    const title = documentLevelArticle.content.find(
+      (block: Record<string, any>) => block._type === 'objectField'
+    ).objectAsField.title;
+    const blockText = toPlainText(
+      documentLevelArticle.content.find(
+        (block: Record<string, any>) => block._type === 'objectField'
+      ).objectAsField.content
+    ).trim();
+    expect(nestedObject?.innerHTML).toContain(title);
+    expect(nestedObject?.innerHTML).toContain(blockText);
+  });
+});