@atlaskit/adf-schema 28.1.6 → 28.1.7

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

package/src/__tests__/unit/schema/marks/text-color.ts

@@ -0,0 +1,61 @@
+import { createSchema } from '../../../../schema/create-schema';
+import {
+  fromHTML,
+  toHTML,
+  textWithMarks,
+} from 'adf-test-helpers/src/adf-schema';
+
+const testColorObj1 = { color: '#97a0af' };
+const testColorObj2 = { color: '#97A0AF' };
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema textColor mark`, () => {
+  itMatches(
+    `<span style="color: rgb(151, 160, 175);">text</span>`,
+    'text',
+    testColorObj1,
+  );
+  itMatches(`<span style="color: #97a0af;">text</span>`, 'text', testColorObj1);
+  itMatches(`<span style="color: #97A0AF;">text</span>`, 'text', testColorObj1);
+
+  it('serializes to <span style="color: ...">', () => {
+    const schema = makeSchema();
+    const node = schema.text('foo', [
+      schema.marks.textColor.create(testColorObj1),
+    ]);
+    expect(toHTML(node, schema)).toEqual(
+      `<span class=\"fabric-text-color-mark\" style=\"--custom-palette-color: var(--ds-icon-accent-gray, #97A0AF)\" data-text-custom-color=\"#97a0af\">foo</span>`,
+    );
+  });
+
+  it('serializes to <span style="color: ..."> case preserving', () => {
+    const schema = makeSchema();
+    const node = schema.text('foo', [
+      schema.marks.textColor.create(testColorObj2),
+    ]);
+    expect(toHTML(node, schema)).toEqual(
+      `<span class=\"fabric-text-color-mark\" style=\"--custom-palette-color: var(--ds-icon-accent-gray, #97A0AF)\" data-text-custom-color=\"#97A0AF\">foo</span>`,
+    );
+  });
+});
+
+function makeSchema() {
+  return createSchema({
+    nodes: ['doc', 'paragraph', 'text'],
+    marks: ['textColor'],
+  });
+}
+
+function itMatches(
+  html: string,
+  expectedText: string,
+  attrs: { color: string },
+) {
+  it(`matches ${html}`, () => {
+    const schema = makeSchema();
+    const doc = fromHTML(`${html}`, schema);
+    const textColorNode = schema.marks.textColor.create(attrs);
+
+    expect(textWithMarks(doc, expectedText, [textColorNode])).toBe(true);
+  });
+}

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

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