@atlaskit/adf-schema 28.1.11 → 28.1.13

package/src/__tests__/unit/schema/nodes/tableNodes.ts

@@ -1,555 +0,0 @@
-import { uuid } from '../../../../utils';
-import { createSchema } from '../../../../schema/create-schema';
-import {
-  table,
-  TableAttributes,
-  CellAttributes,
-} from '../../../../schema/nodes/tableNodes';
-import { fromHTML, toHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
-
-import {
-  ATTRIBUTES_PARSE_DEFAULTS,
-  ATTRIBUTES_PARSE_NUMBERED_COLUMNS,
-  ATTRIBUTES_PARSE_WIDE_LAYOUT,
-  ATTRIBUTES_PARSE_FULLWIDTH_LAYOUT,
-  HTML_PARSE_EDITOR_2x2,
-  HTML_PARSE_EDITOR_2x2_WITH_HEADER_COLUMN,
-  HTML_PARSE_EDITOR_2x1_ONLY_HEADERS,
-  HTML_PARSE_EDITOR_2x1_PARTIAL_CELL_SELECTION,
-  HTML_PARSE_EDITOR_1x2_PARTIAL_HEADER_CELL,
-  HTML_PARSE_EDITOR_P_TABLE_P_RANGE,
-  HTML_PARSE_EDITOR_P_PARTIAL_TABLE,
-  HTML_PARSE_RENDERER_FULL_TABLE_2x2_NO_HEADERS,
-  HTML_PARSE_RENDERER_FULL_TABLE_2x2_HEADER_COLUMN,
-  HTML_PARSE_RENDERER_FULL_TABLE_2x2_HEADER_ROW,
-  HTML_PARSE_RENDERER_FULL_2x1_TABLE_ONLY_HEADERS,
-  HTML_PARSE_RENDERER_PARTIAL_TABLE_2x1_CELL_SELECTION,
-  HTML_PARSE_RENDERER_PARTIAL_TABLE_2x1_HEADER_CELL_SELECTION,
-  HTML_PARSE_RENDERER_P_TABLE_P_SELECTION_RANGE,
-  HTML_PARSE_RENDERER_P_PARTIAL_TABLE_SELECTION_RANGE,
-  HTML_PARSE_GOOGLE_SHEETS_DATA_CELLS,
-} from './_consts';
-
-const makeSchema = () =>
-  createSchema({
-    nodes: [
-      'doc',
-      'paragraph',
-      'text',
-      'table',
-      'tableRow',
-      'tableCell',
-      'tableHeader',
-    ],
-    marks: ['fragment', 'unsupportedMark', 'unsupportedNodeAttribute'],
-  });
-
-const TABLE_LOCAL_ID = 'test-table-local-id';
-const packageName = process.env._PACKAGE_NAME_ as string;
-
-describe(`${packageName}/schema table node`, () => {
-  beforeAll(() => {
-    uuid.setStatic(TABLE_LOCAL_ID);
-  });
-
-  afterAll(() => {
-    uuid.setStatic(false);
-  });
-
-  const schema = makeSchema();
-
-  it('should have isolating property to be true', () => {
-    expect(schema.nodes.table.spec.isolating).toEqual(true);
-  });
-  it('should have selectable property to be true', () => {
-    expect(schema.nodes.table.spec.selectable).toEqual(true);
-  });
-
-  describe('parse attributes', () => {
-    it('should parse with defaults if missing', () => {
-      const doc = fromHTML(ATTRIBUTES_PARSE_DEFAULTS, schema);
-
-      const parsedTable = doc.firstChild!;
-      expect(parsedTable.type.spec).toEqual(table);
-      expect(parsedTable.attrs).toEqual({
-        __autoSize: false,
-        isNumberColumnEnabled: false,
-        layout: 'default',
-        localId: TABLE_LOCAL_ID,
-      });
-    });
-
-    it('should parse numbered columns', () => {
-      const doc = fromHTML(ATTRIBUTES_PARSE_NUMBERED_COLUMNS, schema);
-
-      const parsedTable = doc.firstChild!;
-      expect(parsedTable.type.spec).toEqual(table);
-      expect(parsedTable.attrs).toEqual({
-        __autoSize: false,
-        isNumberColumnEnabled: true,
-        layout: 'default',
-        localId: TABLE_LOCAL_ID,
-      });
-    });
-
-    it('should parse wide layout', () => {
-      const doc = fromHTML(ATTRIBUTES_PARSE_WIDE_LAYOUT, schema);
-
-      const parsedTable = doc.firstChild!;
-      expect(parsedTable.type.spec).toEqual(table);
-      expect(parsedTable.attrs).toEqual({
-        __autoSize: false,
-        isNumberColumnEnabled: false,
-        layout: 'wide',
-        localId: TABLE_LOCAL_ID,
-      });
-    });
-
-    it('should parse full-width layout', () => {
-      const doc = fromHTML(ATTRIBUTES_PARSE_FULLWIDTH_LAYOUT, schema);
-
-      const parsedTable = doc.firstChild!;
-      expect(parsedTable.type.spec).toEqual(table);
-      expect(parsedTable.attrs).toEqual({
-        __autoSize: false,
-        isNumberColumnEnabled: false,
-        layout: 'full-width',
-        localId: TABLE_LOCAL_ID,
-      });
-    });
-  });
-
-  describe('parse from HTML/clipboard', () => {
-    describe('parse from editor encoded HTML', () => {
-      it('should parse from 2x2 table selection', () => {
-        const doc = fromHTML(HTML_PARSE_EDITOR_2x2, schema);
-
-        const parsedTable = doc.firstChild!;
-        // type
-        expect(parsedTable.type.spec).toEqual(table);
-        // structure
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableHeader(paragraph("B"))), tableRow(tableCell(paragraph("1")), tableCell(paragraph("2"))))',
-        );
-        // attributes
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'default',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-
-      it('should parse from 2x2 table selection with header column', () => {
-        const doc = fromHTML(HTML_PARSE_EDITOR_2x2_WITH_HEADER_COLUMN, schema);
-
-        const parsedTable = doc.firstChild!;
-        expect(parsedTable.type.spec).toEqual(table);
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableCell(paragraph("B"))), tableRow(tableHeader(paragraph("1")), tableCell(paragraph("2"))))',
-        );
-      });
-
-      it('should parse partial selection from 2x1 table header selection', () => {
-        const doc = fromHTML(HTML_PARSE_EDITOR_2x1_ONLY_HEADERS, schema);
-
-        const parsedTable = doc.firstChild!;
-        expect(parsedTable.type.spec).toEqual(table);
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableHeader(paragraph("B"))))',
-        );
-      });
-
-      it('should parse partial selection from 2x1 table cell selection', () => {
-        const doc = fromHTML(
-          HTML_PARSE_EDITOR_2x1_PARTIAL_CELL_SELECTION,
-          schema,
-        );
-
-        const parsedTable = doc.firstChild!;
-        expect(parsedTable.type.spec).toEqual(table);
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableCell(paragraph("1")), tableCell(paragraph("2"))))',
-        );
-      });
-
-      it('should parse partial selection from 1x2 table header/cell selection', () => {
-        const doc = fromHTML(HTML_PARSE_EDITOR_1x2_PARTIAL_HEADER_CELL, schema);
-
-        const parsedTable = doc.firstChild!;
-        expect(parsedTable.type.spec).toEqual(table);
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("B"))), tableRow(tableCell(paragraph("2"))))',
-        );
-      });
-
-      it('should parse paragraph/table/paragraph from range selection', () => {
-        const doc = fromHTML(HTML_PARSE_EDITOR_P_TABLE_P_RANGE, schema);
-
-        const parsedTable = doc.child(1)!;
-        expect(parsedTable.type.spec).toEqual(table);
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableHeader(paragraph("B"))), tableRow(tableCell(paragraph("1")), tableCell(paragraph("2"))))',
-        );
-      });
-
-      it('should parse paragraph and partial table selection from range selection', () => {
-        const doc = fromHTML(HTML_PARSE_EDITOR_P_PARTIAL_TABLE, schema);
-
-        const parsedTable = doc.child(1)!;
-        expect(parsedTable.type.spec).toEqual(table);
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableHeader(paragraph("B"))), tableRow(tableCell(paragraph("1"))))',
-        );
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'full-width',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-    });
-
-    /*
-     * Scenarios
-     * - a full 2x2 table selection (no headers)
-     * - a full 2x2 table selection (with column headers)
-     * - a full 2x2 table selection (with row headers)
-     * - a full 2x1 table selection (only headers)
-     * - a partial 2x1 cell selection
-     * - a partial 2x1 header/cell selection
-     * - a paragraph/full table/p selection range
-     * - a paragraph/partial table selection range
-     */
-    describe('parse from renderer encoded HTML', () => {
-      it('should parse a full 2x2 table selection (no headers)', () => {
-        const doc = fromHTML(
-          HTML_PARSE_RENDERER_FULL_TABLE_2x2_NO_HEADERS,
-          schema,
-        );
-
-        const parsedTable = doc.firstChild!;
-        // type
-        expect(parsedTable.type.spec).toEqual(table);
-        // structure
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableCell(paragraph("A")), tableCell(paragraph("B"))), tableRow(tableCell(paragraph("C")), tableCell(paragraph("D"))))',
-        );
-        // attributes
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'default',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-
-      it('should parse a full 2x2 table selection (with header column)', () => {
-        const doc = fromHTML(
-          HTML_PARSE_RENDERER_FULL_TABLE_2x2_HEADER_COLUMN,
-          schema,
-        );
-
-        const parsedTable = doc.firstChild!;
-        // type
-        expect(parsedTable.type.spec).toEqual(table);
-        // structure
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableCell(paragraph("B"))), tableRow(tableHeader(paragraph("C")), tableCell(paragraph("D"))))',
-        );
-        // attributes
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'default',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-
-      it('should parse a full 2x2 table selection (with header row)', () => {
-        const doc = fromHTML(
-          HTML_PARSE_RENDERER_FULL_TABLE_2x2_HEADER_ROW,
-          schema,
-        );
-
-        const parsedTable = doc.firstChild!;
-        // type
-        expect(parsedTable.type.spec).toEqual(table);
-        // structure
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableHeader(paragraph("B"))), tableRow(tableCell(paragraph("C")), tableCell(paragraph("D"))))',
-        );
-        // attributes
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'default',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-      it('should parse a full 2x1 table selection (only headers)', () => {
-        const doc = fromHTML(
-          HTML_PARSE_RENDERER_FULL_2x1_TABLE_ONLY_HEADERS,
-          schema,
-        );
-
-        const parsedTable = doc.firstChild!;
-        // type
-        expect(parsedTable.type.spec).toEqual(table);
-        // structure
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableHeader(paragraph("B"))), tableRow(tableHeader(paragraph("C")), tableHeader(paragraph("D"))))',
-        );
-        // attributes
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'default',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-      it('should parse a partial 2x1 cell selection', () => {
-        const doc = fromHTML(
-          HTML_PARSE_RENDERER_PARTIAL_TABLE_2x1_CELL_SELECTION,
-          schema,
-        );
-
-        const parsedTable = doc.firstChild!;
-        // type
-        expect(parsedTable.type.spec).toEqual(table);
-        // structure
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableCell(paragraph("A")), tableCell(paragraph("B"))))',
-        );
-        // attributes
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'default',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-      it('should parse a partial 2x1 header/cell selection', () => {
-        const doc = fromHTML(
-          HTML_PARSE_RENDERER_PARTIAL_TABLE_2x1_HEADER_CELL_SELECTION,
-          schema,
-        );
-
-        const parsedTable = doc.firstChild!;
-        // type
-        expect(parsedTable.type.spec).toEqual(table);
-        // structure
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableCell(paragraph("B"))))',
-        );
-        // attributes
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'default',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-      it('should parse a paragraph/full table/p selection range', () => {
-        const doc = fromHTML(
-          HTML_PARSE_RENDERER_P_TABLE_P_SELECTION_RANGE,
-          schema,
-        );
-
-        const parsedTable = doc.child(1)!;
-        // type
-        expect(parsedTable.type.spec).toEqual(table);
-        // structure
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableHeader(paragraph("B"))), tableRow(tableCell(paragraph("C")), tableCell(paragraph("D"))))',
-        );
-        // attributes
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'default',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-      it('should parse a paragraph/partial table selection range', () => {
-        const doc = fromHTML(
-          HTML_PARSE_RENDERER_P_PARTIAL_TABLE_SELECTION_RANGE,
-          schema,
-        );
-
-        const parsedTable = doc.child(1)!;
-        // type
-        expect(parsedTable.type.spec).toEqual(table);
-        // structure
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableHeader(paragraph("A")), tableHeader(paragraph("B"))), tableRow(tableCell(paragraph("C"))))',
-        );
-        // attributes
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'default',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-    });
-
-    describe('parse from Google sheets encoded HTML', () => {
-      it('should parse selected cells', () => {
-        const doc = fromHTML(HTML_PARSE_GOOGLE_SHEETS_DATA_CELLS, schema);
-
-        const parsedTable = doc.firstChild!;
-        // type
-        expect(parsedTable.type.spec).toEqual(table);
-        // structure
-        expect(parsedTable.toString()).toEqual(
-          'table(tableRow(tableCell(paragraph), tableCell(paragraph("Team members"))), tableRow(tableCell(paragraph("1")), tableCell(paragraph("Han"))), tableRow(tableCell(paragraph("2")), tableCell(paragraph("Kristina"))), tableRow(tableCell(paragraph("3")), tableCell(paragraph("Lucy"))), tableRow(tableCell(paragraph("4")), tableCell(paragraph("Mario"))), tableRow(tableCell(paragraph("5")), tableCell(paragraph("Pavlo"))), tableRow(tableCell(paragraph("6")), tableCell(paragraph("Sam"))), tableRow(tableCell(paragraph("7")), tableCell(paragraph("Twig"))), tableRow(tableCell(paragraph("8")), tableCell(paragraph("Wing"))))',
-        );
-        // attributes
-        expect(parsedTable.attrs).toEqual({
-          __autoSize: false,
-          isNumberColumnEnabled: false,
-          layout: 'default',
-          localId: TABLE_LOCAL_ID,
-        });
-      });
-    });
-  });
-
-  /*
-   * scenarios
-   * - table - default attributes
-   * - table - change each individual attribute (number col, layout, autosize)
-   * - cells - default attributes
-   * - cells - change each individual attribute (colspan, rowspan, style, colorname, colwidth, class
-   * - header - default attributes
-   * - header - change each individual attribute colspan, rowspan, style, colorname, colwidth, class)
-   */
-  describe('convert to HTML', () => {
-    const schema = makeSchema();
-
-    describe('table node', () => {
-      it('should convert default table', () => {
-        const table = schema.nodes.table.create();
-        expect(toHTML(table, schema)).toEqual(
-          '<table data-number-column="false" data-layout="default" data-autosize="false" data-table-local-id=""><tbody></tbody></table>',
-        );
-      });
-
-      it('should convert table with layout attribute', () => {
-        const attrs = { layout: 'full-width' } as TableAttributes;
-        const table = schema.nodes.table.create(attrs);
-        expect(toHTML(table, schema)).toEqual(
-          '<table data-number-column="false" data-layout="full-width" data-autosize="false" data-table-local-id=""><tbody></tbody></table>',
-        );
-      });
-
-      it('should convert table with isNumberColumnEnabled attribute', () => {
-        const attrs = { isNumberColumnEnabled: true } as TableAttributes;
-        const table = schema.nodes.table.create(attrs);
-        expect(toHTML(table, schema)).toEqual(
-          '<table data-number-column="true" data-layout="default" data-autosize="false" data-table-local-id=""><tbody></tbody></table>',
-        );
-      });
-
-      it('should convert table with __autoSize attribute', () => {
-        const attrs = { __autoSize: true } as TableAttributes;
-        const table = schema.nodes.table.create(attrs);
-        expect(toHTML(table, schema)).toEqual(
-          '<table data-number-column="false" data-layout="default" data-autosize="true" data-table-local-id=""><tbody></tbody></table>',
-        );
-      });
-    });
-
-    describe('cell node', () => {
-      it('should convert default cell', () => {
-        const cell = schema.nodes.tableCell.create();
-        expect(toHTML(cell, schema)).toEqual(
-          '<td class="pm-table-cell-content-wrap"></td>',
-        );
-      });
-      it('should convert default cell with colspan attribute', () => {
-        const attrs = { colspan: 2 } as CellAttributes;
-        const cell = schema.nodes.tableCell.create(attrs);
-        expect(toHTML(cell, schema)).toEqual(
-          '<td colspan="2" class="pm-table-cell-content-wrap"></td>',
-        );
-      });
-      it('should convert default cell with rowspan attribute', () => {
-        const attrs = { rowspan: 2 } as CellAttributes;
-        const cell = schema.nodes.tableCell.create(attrs);
-        expect(toHTML(cell, schema)).toEqual(
-          '<td rowspan="2" class="pm-table-cell-content-wrap"></td>',
-        );
-      });
-      it('should convert default cell with colwidth attribute', () => {
-        const attrs = { colwidth: [200, 300] } as CellAttributes;
-        const cell = schema.nodes.tableCell.create(attrs);
-        expect(toHTML(cell, schema)).toEqual(
-          '<td data-colwidth="200,300" class="pm-table-cell-content-wrap"></td>',
-        );
-      });
-      it('should convert default cell with background attribute', () => {
-        const attrs = { background: '#ff0000' } as CellAttributes;
-        const cell = schema.nodes.tableCell.create(attrs);
-        expect(toHTML(cell, schema)).toEqual(
-          '<td style="background-color: #ff0000;" data-cell-background="#ff0000" class="pm-table-cell-content-wrap"></td>',
-        );
-      });
-    });
-
-    describe('header node', () => {
-      it('should convert default header', () => {
-        const header = schema.nodes.tableHeader.create();
-        expect(toHTML(header, schema)).toEqual(
-          '<th class="pm-table-header-content-wrap"></th>',
-        );
-      });
-      it('should convert default header with colspan attribute', () => {
-        const attrs = { colspan: 2 } as CellAttributes;
-        const cell = schema.nodes.tableHeader.create(attrs);
-        expect(toHTML(cell, schema)).toEqual(
-          '<th colspan="2" class="pm-table-header-content-wrap"></th>',
-        );
-      });
-      it('should convert default header with rowspan attribute', () => {
-        const attrs = { rowspan: 2 } as CellAttributes;
-        const cell = schema.nodes.tableHeader.create(attrs);
-        expect(toHTML(cell, schema)).toEqual(
-          '<th rowspan="2" class="pm-table-header-content-wrap"></th>',
-        );
-      });
-      it('should convert default header with colwidth attribute', () => {
-        const attrs = { colwidth: [200, 300] } as CellAttributes;
-        const cell = schema.nodes.tableHeader.create(attrs);
-        expect(toHTML(cell, schema)).toEqual(
-          '<th data-colwidth="200,300" class="pm-table-header-content-wrap"></th>',
-        );
-      });
-      it('should convert default header with background attribute', () => {
-        const attrs = { background: '#ff0000' } as CellAttributes;
-        const cell = schema.nodes.tableHeader.create(attrs);
-        expect(toHTML(cell, schema)).toEqual(
-          '<th style="background-color: #ff0000;" data-cell-background="#ff0000" class="pm-table-header-content-wrap"></th>',
-        );
-      });
-
-      it('should strip out background style with var(--ds-background-neutral)', () => {
-        const attrs = {
-          background: 'var(--ds-background-neutral, #F4F5F7)',
-        } as CellAttributes;
-        const cell = schema.nodes.tableHeader.create(attrs);
-        expect(toHTML(cell, schema)).toEqual(
-          '<th style="" class="pm-table-header-content-wrap"></th>',
-        );
-      });
-    });
-
-    describe('row node', () => {
-      it('should convert table row', () => {
-        const row = schema.nodes.tableRow.create();
-        expect(toHTML(row, schema)).toEqual('<tr></tr>');
-      });
-    });
-  });
-});

package/src/__tests__/unit/schema/nodes/task-item.ts

@@ -1,39 +0,0 @@
-import { createSchema } from '../../../../schema/create-schema';
-import { toHTML, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
-
-const schema = makeSchema();
-const packageName = process.env._PACKAGE_NAME_ as string;
-
-describe(`${packageName}/schema taskItem node`, () => {
-  it('serializes to <div> with proper data-attributes', () => {
-    const html = toHTML(schema.nodes.taskItem.create(), schema);
-    expect(html).toContain('<div');
-    expect(html).toContain('data-task-local-id');
-    expect(html).toContain('data-task-state');
-  });
-
-  it('matches <div data-task-local-id>', () => {
-    const doc = fromHTML('<div data-task-local-id>', schema);
-    const taskItem = doc.firstChild!.firstChild!;
-    expect(taskItem.type.name).toEqual('taskItem');
-  });
-
-  it('taskItem requires defining to be true', () => {
-    expect(schema.nodes.taskItem.spec.defining).toBe(true);
-  });
-});
-
-function makeSchema() {
-  return createSchema({
-    nodes: [
-      'doc',
-      'paragraph',
-      'text',
-      'taskList',
-      'taskItem',
-      'orderedList',
-      'bulletList',
-      'listItem',
-    ],
-  });
-}

package/src/__tests__/unit/schema/nodes/task-list.ts

@@ -1,45 +0,0 @@
-import { createSchema } from '../../../../schema/create-schema';
-import { toHTML, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
-
-const schema = makeSchema();
-const packageName = process.env._PACKAGE_NAME_ as string;
-
-describe(`${packageName}/schema taskList node`, () => {
-  it('serializes to <div> with proper data-attributes', () => {
-    const html = toHTML(
-      schema.nodes.taskList.create({ localId: 'cheese' }),
-      schema,
-    );
-    expect(html).toContain('<div');
-    expect(html).toContain('data-task-list-local-id="cheese"');
-  });
-
-  it('matches <div data-task-list-local-id>', () => {
-    const doc = fromHTML(
-      '<div data-node-type="actionList" data-task-list-local-id>',
-      schema,
-    );
-    const taskList = doc.firstChild!;
-    expect(taskList.type.name).toEqual('taskList');
-    expect(taskList.attrs.localId).not.toEqual(undefined);
-  });
-
-  it('taskList requires defining to be true', () => {
-    expect(schema.nodes.taskList.spec.defining).toBe(true);
-  });
-});
-
-function makeSchema() {
-  return createSchema({
-    nodes: [
-      'doc',
-      'paragraph',
-      'text',
-      'taskList',
-      'taskItem',
-      'orderedList',
-      'bulletList',
-      'listItem',
-    ],
-  });
-}

package/src/__tests__/unit/schema/nodes/unknown-block.ts

@@ -1,42 +0,0 @@
-import { fromHTML, toHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
-import { inlineNodes } from '../../../../schema/inline-nodes';
-
-import { schema } from 'adf-test-helpers/src/adf-schema';
-
-const packageName = process.env._PACKAGE_NAME_ as string;
-
-describe(`${packageName}/schema unknownBlock node`, () => {
-  describe('should be able to parse inline node', () => {
-    inlineNodes.forEach((node) => {
-      /**
-       * It's not going to work for extension since we made extension attrs parsing more strict.
-       * Having an empty `data-extension-type` or `data-extension-key` won't be parsed as valid extension anymore.
-       */
-      if (node === 'image' || node === 'inlineExtension') {
-        return;
-      }
-      it(node, () => {
-        let element;
-
-        // schema.nodes.text.create() is not valid
-        // https://discuss.prosemirror.net/t/how-i-can-create-text-node-types/759
-        if ('text' === node) {
-          element = toHTML(schema.text('foo'), schema);
-        } else {
-          element = toHTML(schema.nodes[node].create(), schema);
-        }
-
-        const doc = fromHTML(
-          `<div data-node-type="unknownBlock">${element}</div>`,
-          schema,
-        );
-        const span = doc.firstChild!;
-        const elementNode = span.firstChild!;
-
-        expect(elementNode).toBeDefined();
-        expect(elementNode).toHaveProperty('type');
-        expect(elementNode.type).toEqual(schema.nodes[node]);
-      });
-    });
-  });
-});