@atlaskit/adf-schema 28.1.6 → 28.1.8

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

package/src/__tests__/unit/schema/marks/confluence-inline-comment.ts

@@ -0,0 +1,25 @@
+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 confluence-inline-comment mark`, () => {
+  it('serializes to <span data-reference="hash-ref-goes-here">', () => {
+    const schema = makeSchema();
+    const node = schema.text('foo', [
+      schema.marks.confluenceInlineComment.create({
+        reference: 'hash-ref-goes-here',
+      }),
+    ]);
+    expect(toHTML(node, schema)).toContain(
+      'data-reference="hash-ref-goes-here"',
+    );
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text'],
+    marks: ['confluenceInlineComment'],
+  });
+}

package/src/__tests__/unit/schema/marks/data-consumer.ts

@@ -0,0 +1,52 @@
+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 data-consumer mark`, () => {
+  let schema: Schema;
+  const firstSourceId = 'first-source-id';
+  const secondSourceId = 'second-source-id';
+  const dataSourceString = `"${firstSourceId}","${secondSourceId}"`;
+
+  beforeEach(() => {
+    schema = makeSchema();
+  });
+
+  it('serializes to the correct HTML', () => {
+    const node = schema.text('foo', [
+      schema.marks.dataConsumer.create({
+        sources: [firstSourceId, secondSourceId],
+      }),
+    ]);
+    const html = toHTML(node, schema);
+
+    expect(html).toContain(`data-sources="[${dataSourceString}]"`);
+    expect(html).toContain('data-mark-type="dataConsumer"');
+  });
+
+  it.each(['div', 'span'])(
+    'parses annotation correctly from html for %s',
+    (wrapperType) => {
+      const doc = fromHTML(
+        `<${wrapperType} data-mark-type="dataConsumer" data-sources="[${dataSourceString}]">foo</${wrapperType}>`,
+        schema,
+      );
+      const dataConsumerNode = doc.firstChild!;
+
+      expect(dataConsumerNode.marks).toHaveLength(1);
+      expect(dataConsumerNode.marks[0].type.name).toBe('dataConsumer');
+      expect(dataConsumerNode.marks[0].attrs).toEqual({
+        sources: [firstSourceId, secondSourceId],
+      });
+    },
+  );
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text'],
+    marks: ['dataConsumer'],
+  });
+}

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

@@ -0,0 +1,37 @@
+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 em mark`, () => {
+  itMatches('<em>text</em>', 'text');
+  itMatches('<i>text</i>', 'text');
+  itMatches('<span style="font-style: italic">text</span>', 'text');
+
+  it('serializes to <em>', () => {
+    const schema = makeSchema();
+    const node = schema.text('foo', [schema.marks.em.create()]);
+    expect(toHTML(node, schema)).toEqual('<em>foo</em>');
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text'],
+    marks: ['em'],
+  });
+}
+
+function itMatches(html: string, expectedText: string) {
+  it(`matches ${html}`, () => {
+    const schema = makeSchema();
+    const doc = fromHTML(`${html}`, schema);
+    const emNode = schema.marks.em.create();
+
+    expect(textWithMarks(doc, expectedText, [emNode])).toBe(true);
+  });
+}

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

@@ -0,0 +1,188 @@
+import { createSchema } from '../../../../schema/create-schema';
+import {
+  toHTML,
+  fromHTML,
+  textWithMarks,
+} from 'adf-test-helpers/src/adf-schema';
+import { Node } from '@atlaskit/editor-prosemirror/model';
+
+const href = 'http://atlassian.com';
+const href2 = 'http://atlassian.com/test';
+const href3 = 'http://atlassian.com?test=123';
+const unsafeHref = 'javascript:alert("hack")';
+const content = 'foo';
+const sampleLink = `<a href="${href}">${content}</a>`;
+const sampleBlockLink = `<a href="${href}" data-block-link="true" class="blockLink"><p>${content}</p></a>`;
+const emptyLink = `<a>${content}</a>`;
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema link mark`, () => {
+  itMatches(`<p>${sampleLink}</p>`, href, content);
+  itMatches(
+    `<p><a href="${href}" title="test" alt="hello">${content}</a></p>`,
+    href,
+    content,
+  );
+  itMatches(`<p><a href="${href2}">${content}</a></p>`, href2, content);
+  itMatches(`<p><a href="${href3}">${content}</a></p>`, href3, content);
+
+  describe('when there is a textColor mark', () => {
+    it('should not throw an error when the check() is called', () => {
+      const doc = {
+        type: 'text',
+        text: 'Foo',
+        marks: [
+          {
+            type: 'link',
+            attrs: {
+              href: 'http://example.com',
+            },
+          },
+
+          {
+            type: 'textColor',
+            attrs: {
+              color: '#ff5630',
+            },
+          },
+        ],
+      };
+
+      const textNode = Node.fromJSON(makeSchema(), doc);
+      expect(() => {
+        textNode.check();
+      }).not.toThrow();
+    });
+  });
+
+  describe('whitelist URLs', () => {
+    const schema = makeSchema();
+
+    it(`should parse links starting from http://`, () => {
+      const doc = fromHTML(
+        `<p><a href="http://www.atlassian.com">Atlassian</a></p>`,
+        schema,
+      );
+      const textNode = doc.firstChild!.firstChild!;
+
+      expect(textNode.marks).toHaveLength(1);
+    });
+
+    it(`should parse links starting from https://`, () => {
+      const doc = fromHTML(
+        `<p><a href="https://www.atlassian.com">Atlassian</a></p>`,
+        schema,
+      );
+      const textNode = doc.firstChild!.firstChild!;
+
+      expect(textNode.marks).toHaveLength(1);
+    });
+
+    it(`should parse links starting from sourcetree://`, () => {
+      const doc = fromHTML(
+        `<p><a href="sourcetree://cloneRepo/ssh://user@bitbucket.org/owner/repo.git">Clone me</a></p>`,
+        schema,
+      );
+      const textNode = doc.firstChild!.firstChild!;
+
+      expect(textNode.marks).toHaveLength(1);
+    });
+
+    it(`should parse root relative links`, () => {
+      const doc = fromHTML(`<p><a href="/TEST-100">TEST-100</a></p>`, schema);
+      const textNode = doc.firstChild!.firstChild!;
+
+      expect(textNode.marks).toHaveLength(1);
+    });
+
+    it(`should not parse links starting from javascript://`, () => {
+      const doc = fromHTML(
+        `<p><a href="javascript:alert(1)">Click me</a></p>`,
+        schema,
+      );
+      const textNode = doc.firstChild!.firstChild!;
+
+      expect(textNode.marks).toHaveLength(0);
+    });
+
+    it(`should not parse links starting from javascript://`, () => {
+      const doc = fromHTML(
+        `<p><a href="view-source:https://bitbucket.org/atlassian/atlaskit/pull-requests/3196/fix-component-prevent-javascript-links-for/diff">View source</a></p>`,
+        schema,
+      );
+      const textNode = doc.firstChild!.firstChild!;
+
+      expect(textNode.marks).toHaveLength(0);
+    });
+
+    it(`should remove unsafe link when serialize`, () => {
+      const schema = makeSchema();
+      const node = schema.text(content, [
+        schema.marks.link.create({ href: unsafeHref }),
+      ]);
+      const html: string = toHTML(node, schema);
+
+      expect(html).toContain(`${emptyLink}`);
+    });
+  });
+
+  describe('serialization', () => {
+    it(`serializes to ${sampleLink}`, () => {
+      const schema = makeSchema();
+      const node = schema.text(content, [schema.marks.link.create({ href })]);
+      const html: string = toHTML(node, schema);
+      expect(html).toContain(`${sampleLink}`);
+    });
+    it(`serializes block marked links ${sampleLink}`, () => {
+      const schema = makeSchema();
+      const node = schema.nodes.paragraph.create(null, schema.text(content), [
+        schema.marks.link.create({ href }),
+      ]);
+      const html: string = toHTML(node, schema);
+      expect(html).toContain(`${sampleBlockLink}`);
+    });
+  });
+
+  describe('confluence metadata', () => {
+    it('creates a PM node with attributes from ADF', () => {
+      const doc = {
+        type: 'text',
+        text: 'Foo',
+        marks: [
+          {
+            type: 'link',
+            attrs: {
+              href: 'http://example.com',
+              __confluenceMetadata: {
+                linkType: 'value',
+              },
+            },
+          },
+        ],
+      };
+
+      const text = Node.fromJSON(makeSchema(), doc);
+      expect(text.marks[0].attrs).toHaveProperty('__confluenceMetadata');
+      expect(text.marks[0].attrs.__confluenceMetadata).toHaveProperty(
+        'linkType',
+        'value',
+      );
+    });
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text'],
+    marks: ['link', 'textColor'],
+  });
+}
+
+function itMatches(html: string, href: string, expectedText: string) {
+  it(`matches ${html}`, () => {
+    const schema = makeSchema();
+    const doc = fromHTML(html, schema);
+    const link = schema.marks.link.create({ href });
+    expect(textWithMarks(doc, expectedText, [link])).toBe(true);
+  });
+}

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

@@ -0,0 +1,37 @@
+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 strike mark`, () => {
+  itMatches('<s>text</s>', 'text');
+  itMatches('<del>text</del>', 'text');
+  itMatches('<strike>text</strike>', 'text');
+  itMatches('<span style="text-decoration: line-through">text</span>', 'text');
+
+  it('serializes to <s>', () => {
+    const schema = makeSchema();
+    const node = schema.text('foo', [schema.marks.strike.create()]);
+    expect(toHTML(node, schema)).toEqual('<s>foo</s>');
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text'],
+    marks: ['strike'],
+  });
+}
+
+function itMatches(html: string, expectedText: string) {
+  it(`matches ${html}`, () => {
+    const schema = makeSchema();
+    const doc = fromHTML(html, schema);
+    const strike = schema.marks.strike.create();
+    expect(textWithMarks(doc, expectedText, [strike])).toBe(true);
+  });
+}

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

@@ -0,0 +1,43 @@
+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 strong mark`, () => {
+  itMatches('<strong>text</strong>', 'text');
+  itMatches('<b>text</b>', 'text');
+  itMatches('<b style="font-weight: bold">text</b>', 'text');
+  itMatches('<span style="font-weight: bold">text</span>', 'text');
+
+  it('serializes to <strong>', () => {
+    const schema = makeSchema();
+    const node = schema.text('foo', [schema.marks.strong.create()]);
+    expect(toHTML(node, schema)).toEqual('<strong>foo</strong>');
+  });
+
+  it('should not match <b style=font-weight: normal> as strong', () => {
+    const schema = makeSchema();
+    const doc = fromHTML('<b style="font-weight: normal">text</b>', schema);
+    expect(textWithMarks(doc, 'text', [])).toBe(true);
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text'],
+    marks: ['strong'],
+  });
+}
+
+function itMatches(html: string, expectedText: string) {
+  it(`matches ${html}`, () => {
+    const schema = makeSchema();
+    const doc = fromHTML(html, schema);
+    const strong = schema.marks.strong.create();
+    expect(textWithMarks(doc, expectedText, [strong])).toBe(true);
+  });
+}

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

@@ -0,0 +1,50 @@
+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 subsup mark`, () => {
+  itMatches('<sub>text</sub>', 'text', { type: 'sub' });
+  itMatches('<sup>text</sup>', 'text', { type: 'sup' });
+
+  it('serializes to <sub>', () => {
+    const schema = makeSchema();
+    const node = schema.text('foo', [
+      schema.marks.subsup.create({ type: 'sub' }),
+    ]);
+    expect(toHTML(node, schema)).toEqual('<sub>foo</sub>');
+  });
+
+  it('serializes to <sup>', () => {
+    const schema = makeSchema();
+    const node = schema.text('foo', [
+      schema.marks.subsup.create({ type: 'sup' }),
+    ]);
+    expect(toHTML(node, schema)).toEqual('<sup>foo</sup>');
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text'],
+    marks: ['subsup'],
+  });
+}
+
+function itMatches(
+  html: string,
+  expectedText: string,
+  attrs: { type: 'sub' | 'sup' },
+) {
+  it(`matches ${html}`, () => {
+    const schema = makeSchema();
+    const doc = fromHTML(`${html}`, schema);
+    const subsupNode = schema.marks.subsup.create(attrs);
+
+    expect(textWithMarks(doc, expectedText, [subsupNode])).toBe(true);
+  });
+}