@atlaskit/adf-schema 28.1.6 → 28.1.7

package/src/__tests__/unit/json-schema/v1-reference/stage-0/valid/table-with-width.json

@@ -0,0 +1,32 @@
+{
+  "version": 1,
+  "type": "doc",
+  "content": [
+    {
+      "type": "table",
+      "attrs": {
+        "width": 123
+      },
+      "content": [
+        {
+          "type": "tableRow",
+          "content": [
+            {
+              "type": "tableCell",
+              "attrs": {
+                "colspan": 1,
+                "rowspan": 1
+              },
+              "content": [
+                {
+                  "type": "paragraph",
+                  "content": []
+                }
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

package/src/__tests__/unit/json-schema/v1.ts

@@ -0,0 +1,53 @@
+import { initialize } from 'adf-test-helpers/src/ajv';
+
+import { readFilesSync } from 'adf-test-helpers/src/adf-schema';
+import v1SchemaFull from '../../../../json-schema/v1/full.json';
+import v1SchemaStage0 from '../../../../json-schema/v1/stage-0.json';
+
+const ajv = initialize();
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName} json-schema v1`, () => {
+  const validateFull = ajv.compile(v1SchemaFull);
+  const validateStage0 = ajv.compile(v1SchemaStage0);
+
+  const valid = readFilesSync(`${__dirname}/v1-reference/full/valid`);
+  describe('full', () => {
+    for (const file of valid) {
+      it(`validates '${file.name}'`, () => {
+        validateFull(file.data);
+        expect(validateFull.errors).toEqual(null);
+        // Valid `full` use cases should be valid against `stage-0` schema
+        validateStage0(file.data);
+        expect(validateStage0.errors).toEqual(null);
+      });
+    }
+
+    const invalid = readFilesSync(`${__dirname}/v1-reference/full/invalid`);
+    for (const file of invalid) {
+      it(`does not validate '${file.name}'`, () => {
+        expect(validateFull(file.data)).toEqual(false);
+      });
+    }
+  });
+
+  describe('stage-0', () => {
+    const valid = readFilesSync(`${__dirname}/v1-reference/stage-0/valid`);
+    for (const file of valid) {
+      it(`validates '${file.name}'`, () => {
+        validateStage0(file.data);
+        expect(validateStage0.errors).toEqual(null);
+
+        // Valid `stage-0` use cases should be invalid against `full` schema
+        expect(validateFull(file.data)).toEqual(false);
+      });
+    }
+
+    const invalid = readFilesSync(`${__dirname}/v1-reference/stage-0/invalid`);
+    for (const file of invalid) {
+      it(`does not validate '${file.name}'`, () => {
+        expect(validateStage0(file.data)).toEqual(false);
+      });
+    }
+  });
+});

package/src/__tests__/unit/schema/create-schema.ts

@@ -0,0 +1,214 @@
+const packageName = process.env._PACKAGE_NAME_ as string;
+import { code as codeBase, createSchema, sanitizeNodes } from '../../..';
+import { sanitizeNodeSpecContent } from '../../../schema/create-schema';
+const filterGroupDecMark = (marks: Array<string>) =>
+  marks.filter((mark) => mark[0] !== '_' || mark[1] !== '_');
+
+describe(`${packageName}/schema createSchema helper`, () => {
+  it('should add only defined marks and nodes to the schema', () => {
+    const nodesConfig = ['doc', 'paragraph', 'text'];
+    const marksConfig = ['em', 'strong', 'strike'];
+    const schema = createSchema({ nodes: nodesConfig, marks: marksConfig });
+    const nodes = Object.keys(schema.nodes);
+    const marks = filterGroupDecMark(Object.keys(schema.marks));
+    expect(nodes).toEqual(['doc', 'paragraph', 'text']);
+    expect(marks).toEqual(['em', 'strong', 'strike']);
+  });
+
+  it('should preserv order for marks and nodes in the schema', () => {
+    const nodesConfig = ['text', 'doc', 'paragraph'];
+    const marksConfig = ['strong', 'strike', 'em'];
+    const schema = createSchema({ nodes: nodesConfig, marks: marksConfig });
+    const nodes = Object.keys(schema.nodes);
+    const marks = filterGroupDecMark(Object.keys(schema.marks));
+    expect(nodes).toEqual(['doc', 'paragraph', 'text']);
+    expect(marks).toEqual(['em', 'strong', 'strike']);
+  });
+
+  it('should allow custom node spec for built-in node type', () => {
+    const listItem = {
+      content: 'paragraph block*',
+      parseDOM: [{ tag: 'div' }],
+    };
+    const nodesConfig = ['doc', 'paragraph', 'text'];
+    const schema = createSchema({
+      nodes: nodesConfig,
+      customNodeSpecs: { listItem },
+    });
+    const nodes = Object.keys(schema.nodes);
+    expect(nodes).toEqual(['doc', 'paragraph', 'text', 'listItem']);
+    expect(schema.nodes.listItem.spec).toEqual(listItem);
+  });
+
+  it('should allow custom node spec', () => {
+    const jiraIssue = {
+      content: 'paragraph block*',
+      parseDOM: [{ tag: 'div' }],
+    };
+    const nodesConfig = ['doc', 'paragraph', 'text'];
+    const schema = createSchema({
+      nodes: nodesConfig,
+      customNodeSpecs: { jiraIssue },
+    });
+    const nodes = Object.keys(schema.nodes);
+    expect(nodes).toEqual(['doc', 'paragraph', 'text', 'jiraIssue']);
+  });
+
+  it('should allow custom mark spec for built-in mark type', () => {
+    const code = { ...codeBase, excludes: 'em' };
+    const nodesConfig = ['doc', 'paragraph', 'text'];
+    const marksConfig = ['em'];
+    const schema = createSchema({
+      nodes: nodesConfig,
+      marks: marksConfig,
+      customMarkSpecs: { code },
+    });
+    const marks = filterGroupDecMark(Object.keys(schema.marks));
+    expect(marks).toEqual(['em', 'code']);
+    expect(schema.marks.code.spec).toEqual(code);
+  });
+
+  it('should allow custom mark spec', () => {
+    const monospace = { ...codeBase, excludes: 'em' };
+    const nodesConfig = ['doc', 'paragraph', 'text'];
+    const marksConfig = ['em'];
+    const schema = createSchema({
+      nodes: nodesConfig,
+      marks: marksConfig,
+      customMarkSpecs: { monospace },
+    });
+    const marks = filterGroupDecMark(Object.keys(schema.marks));
+    expect(marks).toEqual(['em', 'monospace']);
+    expect(schema.marks.monospace.spec).toEqual(monospace);
+  });
+
+  it('should allow only custom mark spec', () => {
+    const code = { ...codeBase, excludes: '' };
+    const nodesConfig = ['doc', 'paragraph', 'text'];
+    const schema = createSchema({
+      nodes: nodesConfig,
+      customMarkSpecs: { code },
+    });
+    expect(schema.marks.code.spec).toEqual(code);
+  });
+
+  describe('fixNodeContentSchema', () => {
+    it('excludes unsupported nodes in node content', () => {
+      const nodes = {
+        node1: {
+          content: 'node1 | nodeDoesNotExist | node2 | anotherNodeDoesNotExist',
+        },
+        node2: {
+          content: 'node2',
+        },
+      };
+      const sanitizedNodes = sanitizeNodes(nodes, {});
+
+      expect(sanitizedNodes).toEqual({
+        node1: {
+          content: 'node1 | node2',
+        },
+        node2: {
+          content: 'node2',
+        },
+      });
+    });
+
+    it('excludes unsupported nodes in node content - 2', () => {
+      const nodes = {
+        node1: {
+          content:
+            '(node1 | nodeDoesNotExist | anotherNodeDoesNotExist | node2)*',
+        },
+        node2: {
+          content: 'node2',
+        },
+      };
+      const sanitizedNodes = sanitizeNodes(nodes, {});
+
+      expect(sanitizedNodes).toEqual({
+        node1: {
+          content: '(node1 | node2)*',
+        },
+        node2: {
+          content: 'node2',
+        },
+      });
+    });
+
+    it('does not generate invalid content', () => {
+      const nodes = {
+        node1: {
+          content: 'nodeDoesNotExist | anotherNodeDoesNotExist',
+        },
+        node2: {
+          content: 'node2 | nodeDoesNotExist',
+        },
+      };
+      const sanitizedNodes = sanitizeNodes(nodes, {});
+
+      expect(sanitizedNodes).toEqual({
+        node1: {
+          content: '',
+        },
+        node2: {
+          content: 'node2',
+        },
+      });
+    });
+
+    it('should remove unsupported block from content', () => {
+      const nodes = {
+        node1: {
+          content: '(node2 | unsupportedBlock){2,3} unsupportedBlock*',
+        },
+        node2: { content: 'node2' },
+      };
+      const content = '(node2 | unsupportedBlock){2,3} unsupportedBlock*';
+      expect(sanitizeNodeSpecContent(nodes, content)).toEqual('(node2 ){2,3}');
+    });
+
+    it('modifies node immutably', () => {
+      const nodeSpec = {
+        content: 'nodeDoesNotExist',
+      };
+      const nodes = {
+        node: nodeSpec,
+      };
+      const sanitizedNodes = sanitizeNodes(nodes, {});
+
+      expect(sanitizedNodes).toEqual({
+        node: {
+          content: '',
+        },
+      });
+
+      expect(nodeSpec).toEqual({
+        content: 'nodeDoesNotExist',
+      });
+    });
+
+    it('recognizes node from group', () => {
+      const nodes = {
+        node1: {
+          content: 'inline+',
+          group: 'block',
+        },
+        node2: {
+          group: 'inline',
+        },
+      };
+      const sanitizedNodes = sanitizeNodes(nodes, {});
+
+      expect(sanitizedNodes).toEqual({
+        node1: {
+          content: 'inline+',
+          group: 'block',
+        },
+        node2: {
+          group: 'inline',
+        },
+      });
+    });
+  });
+});

package/src/__tests__/unit/schema/default-schema.ts

@@ -0,0 +1,192 @@
+import {
+  defaultSchema,
+  getSchemaBasedOnStage,
+} from '../../../schema/default-schema';
+
+describe('Default Schema', () => {
+  describe('Nodes', () => {
+    it('should contain the `mediaInline` node', () => {
+      expect(defaultSchema.nodes.mediaInline).toBeDefined();
+    });
+  });
+
+  describe('Marks', () => {
+    it('should contain the `typeAheadQuery` mark', () => {
+      expect(defaultSchema.marks.typeAheadQuery).toBeDefined();
+    });
+
+    it('should contain the `fragment` mark', () => {
+      expect(defaultSchema.marks.fragment).toBeDefined();
+    });
+  });
+});
+
+describe('Get Schema Based On Stage', () => {
+  describe('Default / Full Schema', () => {
+    it('should contain the nodes', () => {
+      const schema = getSchemaBasedOnStage();
+      expect(Object.keys(schema.nodes)).toEqual([
+        'doc',
+        'paragraph',
+        'text',
+        'bulletList',
+        'orderedList',
+        'listItem',
+        'heading',
+        'blockquote',
+        'codeBlock',
+        'panel',
+        'rule',
+        'image',
+        'mention',
+        'caption',
+        'media',
+        'mediaGroup',
+        'mediaSingle',
+        'mediaInline',
+        'placeholder',
+        'layoutSection',
+        'layoutColumn',
+        'hardBreak',
+        'emoji',
+        'table',
+        'tableCell',
+        'tableRow',
+        'tableHeader',
+        'confluenceJiraIssue',
+        'confluenceUnsupportedInline',
+        'confluenceUnsupportedBlock',
+        'decisionList',
+        'decisionItem',
+        'taskList',
+        'taskItem',
+        'date',
+        'status',
+        'expand',
+        'nestedExpand',
+        'extension',
+        'inlineExtension',
+        'bodiedExtension',
+        'inlineCard',
+        'blockCard',
+        'embedCard',
+        'unknownBlock',
+        'unsupportedBlock',
+        'unsupportedInline',
+      ]);
+    });
+
+    it('should contain the marks', () => {
+      const schema = getSchemaBasedOnStage();
+      expect(Object.keys(schema.marks)).toEqual([
+        'link',
+        'em',
+        'strong',
+        'textColor',
+        'strike',
+        'subsup',
+        'underline',
+        'code',
+        'typeAheadQuery',
+        'alignment',
+        'annotation',
+        'confluenceInlineComment',
+        '__colorGroupDeclaration',
+        '__fontStyleGroupDeclaration',
+        '__searchQueryGroupDeclaration',
+        '__linkGroupDeclaration',
+        'breakout',
+        'dataConsumer',
+        'fragment',
+        'indentation',
+        'border',
+        'unsupportedMark',
+        'unsupportedNodeAttribute',
+      ]);
+    });
+  });
+
+  describe('Stage-0', () => {
+    it('should contain the nodes', () => {
+      const schema = getSchemaBasedOnStage('stage0');
+      expect(Object.keys(schema.nodes)).toEqual([
+        'doc',
+        'paragraph',
+        'text',
+        'bulletList',
+        'orderedList',
+        'listItem',
+        'heading',
+        'blockquote',
+        'codeBlock',
+        'panel',
+        'rule',
+        'image',
+        'mention',
+        'caption',
+        'media',
+        'mediaGroup',
+        'mediaSingle',
+        'mediaInline',
+        'placeholder',
+        'layoutSection',
+        'layoutColumn',
+        'hardBreak',
+        'emoji',
+        'table',
+        'tableCell',
+        'tableRow',
+        'tableHeader',
+        'confluenceJiraIssue',
+        'confluenceUnsupportedInline',
+        'confluenceUnsupportedBlock',
+        'decisionList',
+        'decisionItem',
+        'taskList',
+        'taskItem',
+        'date',
+        'status',
+        'expand',
+        'nestedExpand',
+        'extension',
+        'inlineExtension',
+        'bodiedExtension',
+        'inlineCard',
+        'blockCard',
+        'embedCard',
+        'unknownBlock',
+        'unsupportedBlock',
+        'unsupportedInline',
+      ]);
+    });
+
+    it('should contain the marks', () => {
+      const schema = getSchemaBasedOnStage('stage0');
+      expect(Object.keys(schema.marks)).toEqual([
+        'link',
+        'em',
+        'strong',
+        'textColor',
+        'strike',
+        'subsup',
+        'underline',
+        'code',
+        'typeAheadQuery',
+        'alignment',
+        'annotation',
+        'confluenceInlineComment',
+        '__colorGroupDeclaration',
+        '__fontStyleGroupDeclaration',
+        '__searchQueryGroupDeclaration',
+        '__linkGroupDeclaration',
+        'breakout',
+        'dataConsumer',
+        'fragment',
+        'indentation',
+        'border',
+        'unsupportedMark',
+        'unsupportedNodeAttribute',
+      ]);
+    });
+  });
+});

package/src/__tests__/unit/schema/marks/annotation.ts

@@ -0,0 +1,46 @@
+import { createSchema } from '../../../../schema/create-schema';
+import { toHTML, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+import { Schema } from '@atlaskit/editor-prosemirror/model';
+
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema confluence-inline-comment mark`, () => {
+  let schema: Schema;
+  beforeEach(() => {
+    schema = makeSchema();
+  });
+
+  it('serializes to the correct HTML', () => {
+    const node = schema.text('foo', [
+      schema.marks.annotation.create({
+        id: 'hash-ref-goes-here',
+      }),
+    ]);
+
+    const html = toHTML(node, schema);
+    expect(html).toContain('data-id="hash-ref-goes-here"');
+    expect(html).toContain('data-mark-type="annotation"');
+    expect(html).toContain('data-mark-annotation-type="inlineComment"');
+  });
+
+  it('parses annotation correctly from html', () => {
+    const doc = fromHTML(
+      `<p><span data-mark-type="annotation" data-mark-annotation-type="inlineComment" data-id="comment-id" >annotated text</span></p>`,
+      schema,
+    );
+    const annotationNode = doc.firstChild!.firstChild!;
+    expect(annotationNode.marks).toHaveLength(1);
+    expect(annotationNode.marks[0].type.name).toBe('annotation');
+    expect(annotationNode.marks[0].attrs).toEqual({
+      id: 'comment-id',
+      annotationType: 'inlineComment',
+    });
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text'],
+    marks: ['annotation'],
+  });
+}

package/src/__tests__/unit/schema/marks/border.ts

@@ -0,0 +1,76 @@
+import { createSchema } from '../../../../schema/create-schema';
+import { fromHTML, toHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+
+const testAttr = { color: '#172B4D', size: 1 };
+const testAttrFalse = { color: '#12345', size: 0 };
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema border mark`, () => {
+  it('serializes to the correct HTML', () => {
+    const schema = makeSchema();
+    const node = schema.nodes.media.create(
+      {},
+      [],
+      [schema.marks.border.create(testAttr)],
+    );
+    const html = toHTML(node, schema);
+    expect(html).toContain(
+      `data-mark-type="border" data-color="#172B4D" data-size="1" style="--custom-palette-color: var(--ds-text, #172B4D)"`,
+    );
+  });
+});
+
+it('should parse border with color in lower case', () => {
+  const schema = makeSchema();
+  const doc = fromHTML(
+    `<div data-mark-type="border" data-color="${testAttr.color}" data-size="${testAttr.size}"><div data-node-type="media" data-type="file" data-id="dummy-id"></div></div>`,
+    schema,
+  );
+  const dataConsumerNode = doc.firstChild!.firstChild!;
+
+  expect(dataConsumerNode.marks).toHaveLength(1);
+  expect(dataConsumerNode.marks[0].type.name).toBe('border');
+  expect(dataConsumerNode.marks[0].attrs).toEqual({
+    size: testAttr.size,
+    color: '#172b4d',
+  });
+});
+
+it('should parse border with attributes as false if size and color are not expected values', () => {
+  const schema = makeSchema();
+  const doc = fromHTML(
+    `<div data-mark-type="border" data-color="${testAttrFalse.color}" data-size="${testAttrFalse.size}"><div data-node-type="media" data-type="file" data-id="dummy-id"></div></div>`,
+    schema,
+  );
+  const dataConsumerNode = doc.firstChild!.firstChild!;
+
+  expect(dataConsumerNode.marks).toHaveLength(1);
+  expect(dataConsumerNode.marks[0].type.name).toBe('border');
+  expect(dataConsumerNode.marks[0].attrs).toEqual({
+    size: false,
+    color: false,
+  });
+});
+
+it('should parse maximum size as 3', () => {
+  const schema = makeSchema();
+  const doc = fromHTML(
+    `<div data-mark-type="border" data-color="${testAttr.color}" data-size=5><div data-node-type="media" data-type="file" data-id="dummy-id"></div></div>`,
+    schema,
+  );
+  const dataConsumerNode = doc.firstChild!.firstChild!;
+
+  expect(dataConsumerNode.marks).toHaveLength(1);
+  expect(dataConsumerNode.marks[0].type.name).toBe('border');
+  expect(dataConsumerNode.marks[0].attrs).toEqual({
+    size: 3,
+    color: '#172b4d',
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text', 'mediaSingle', 'media', 'caption'],
+    marks: ['border'],
+  });
+}

package/src/__tests__/unit/schema/marks/breakout.ts

@@ -0,0 +1,24 @@
+import { createSchema } from '../../../../schema/create-schema';
+import { toHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema breakout mark`, () => {
+  it('serializes to the correct HTML', () => {
+    const schema = makeSchema();
+    const node = schema.nodes.codeBlock.create(
+      {},
+      [],
+      [schema.marks.breakout.create({ mode: 'wide' })],
+    );
+    const html = toHTML(node, schema);
+    expect(html).toContain('data-mode="wide"');
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text', 'codeBlock'],
+    marks: ['breakout'],
+  });
+}

package/src/__tests__/unit/schema/marks/code.ts

@@ -0,0 +1,44 @@
+import { createSchema } from '../../../../schema/create-schema';
+import {
+  fromHTML,
+  toHTML,
+  textWithMarks,
+} from 'adf-test-helpers/src/adf-schema';
+
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema code mark`, () => {
+  itMatches('<span class="code">text</span>', 'text');
+  itMatches('<code>text</code>', 'text');
+  itMatches('<tt>text</tt>', 'text');
+  itMatches(
+    `<span style="font-family: Menlo, Monaco, 'Courier New', monospace;">text</span>`,
+    'text',
+  );
+  itMatches(`<span style="white-space: pre;">text</span>`, 'text');
+
+  it('serializes to <span class="code">', () => {
+    const schema = makeSchema();
+    const node = schema.text('foo', [schema.marks.code.create()]);
+    expect(toHTML(node, schema)).toEqual(
+      '<span class="code" spellcheck="false">foo</span>',
+    );
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text'],
+    marks: ['code'],
+  });
+}
+
+function itMatches(html: string, expectedText: string) {
+  it(`matches ${html}`, () => {
+    const schema = makeSchema();
+    const doc = fromHTML(`${html}`, schema);
+    const codeNode = schema.marks.code.create();
+
+    expect(textWithMarks(doc, expectedText, [codeNode])).toBe(true);
+  });
+}