@atlaskit/adf-schema 28.1.12 → 28.1.13

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # @atlaskit/adf-schema
 
+## 28.1.13
+
+### Patch Changes
+
+- 7999d27: Add src to npmignore
+
 ## 28.1.12
 
 ### Patch Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaskit/adf-schema",
-  "version": "28.1.12",
+  "version": "28.1.13",
   "description": "Shared package that contains the ADF-schema (json) and ProseMirror node/mark specs",
   "publishConfig": {
     "registry": "https://registry.npmjs.org/"

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

@@ -1,55 +0,0 @@
-import { initialize } from 'adf-test-helpers/src/ajv';
-
-import v1SchemaFull from '../../../../json-schema/v1/full.json';
-import v1SchemaStage0 from '../../../../json-schema/v1/stage-0.json';
-
-import {
-  fullValidJsonSchema,
-  fullInvalidJsonSchema,
-  stage0ValidJsonSchema,
-  stage0InvalidJsonSchema,
-} from '@atlassian/adf-schema-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);
-
-  describe('full', () => {
-    for (const file of fullValidJsonSchema) {
-      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);
-      });
-    }
-
-    for (const file of fullInvalidJsonSchema) {
-      it(`does not validate '${file.name}'`, () => {
-        expect(validateFull(file.data)).toEqual(false);
-      });
-    }
-  });
-
-  describe('stage-0', () => {
-    for (const file of stage0ValidJsonSchema) {
-      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);
-      });
-    }
-
-    for (const file of stage0InvalidJsonSchema) {
-      it(`does not validate '${file.name}'`, () => {
-        expect(validateStage0(file.data)).toEqual(false);
-      });
-    }
-  });
-});

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

@@ -1,214 +0,0 @@
-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

@@ -1,192 +0,0 @@
-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

@@ -1,46 +0,0 @@
-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

@@ -1,76 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,44 +0,0 @@
-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);
-  });
-}