@atlaskit/adf-schema 28.1.6 → 28.1.7

package/src/schema/nodes/expand.ts

@@ -0,0 +1,101 @@
+import { NodeSpec, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { BreakoutMarkDefinition } from '../marks';
+import { MarksObject, NoMark } from './types/mark';
+import { NonNestableBlockContent } from './types/non-nestable-block-content';
+
+/**
+ * @name expand_node
+ */
+export interface ExpandBaseDefinition {
+  type: 'expand';
+  attrs: {
+    title?: string;
+  };
+  /**
+   * @minItems 1
+   * @allowUnsupportedBlock true
+   */
+  content: Array<NonNestableBlockContent>;
+  marks?: Array<any>;
+}
+
+/**
+ * @name expand_with_no_mark_node
+ */
+export type ExpandDefinition = ExpandBaseDefinition & NoMark;
+
+/**
+ * @name expand_with_breakout_mark_node
+ */
+export type ExpandWithBreakoutDefinition = ExpandBaseDefinition &
+  MarksObject<BreakoutMarkDefinition>;
+
+function getExpandAttrs(domNode: Node | string) {
+  const dom = domNode as HTMLElement;
+  return {
+    title: dom.getAttribute('data-title'),
+    __expanded: true,
+  };
+}
+
+export const expand: NodeSpec = {
+  inline: false,
+  group: 'block',
+  marks: 'dataConsumer fragment unsupportedMark unsupportedNodeAttribute',
+  content:
+    '(paragraph | panel | blockquote | orderedList | bulletList | rule | heading | codeBlock | mediaGroup | mediaSingle | decisionList | taskList | table | blockCard | embedCard | extension | unsupportedBlock)+',
+  isolating: true,
+  selectable: true,
+  attrs: {
+    title: { default: '' },
+    __expanded: { default: true },
+  },
+  parseDOM: [
+    {
+      context: 'table//',
+      tag: 'div[data-node-type="expand"]',
+      getAttrs: getExpandAttrs,
+    },
+    {
+      context: 'expand//',
+      tag: '[data-node-type="expand"]',
+      skip: true,
+    },
+    {
+      context: 'nestedExpand//',
+      tag: '[data-node-type="expand"]',
+      skip: true,
+    },
+    {
+      tag: '[data-node-type="nestedExpand"] button',
+      ignore: true,
+    },
+    {
+      tag: '[data-node-type="expand"] button',
+      ignore: true,
+    },
+    {
+      tag: 'div[data-node-type="expand"]',
+      getAttrs: getExpandAttrs,
+    },
+  ],
+  toDOM(node: PMNode) {
+    const attrs = {
+      'data-node-type': 'expand',
+      'data-title': node.attrs.title,
+      'data-expanded': node.attrs.__expanded,
+    };
+    return ['div', attrs, 0];
+  },
+};
+
+export const toJSON = (node: PMNode) => ({
+  attrs: Object.keys(node.attrs)
+    .filter((key) => !key.startsWith('__'))
+    .reduce<typeof node.attrs>((obj, key) => {
+      return {
+        ...obj,
+        [key]: node.attrs[key],
+      };
+    }, {}),
+});

package/src/schema/nodes/extension.ts

@@ -0,0 +1,60 @@
+import { Node as PMNode, NodeSpec } from '@atlaskit/editor-prosemirror/model';
+import { ExtensionAttributes } from './types/extensions';
+import { getExtensionAttrs } from '../../utils/extensions';
+import { MarksObject } from './types/mark';
+import { DataConsumerDefinition } from '../marks/data-consumer';
+import { FragmentDefinition } from '../marks/fragment';
+
+/**
+ * @name extension_node
+ */
+export interface ExtensionBaseDefinition {
+  type: 'extension';
+  attrs: ExtensionAttributes;
+  marks?: Array<any>;
+}
+
+/**
+ * @name extension_with_marks_node
+ */
+export type ExtensionDefinition = ExtensionBaseDefinition &
+  MarksObject<DataConsumerDefinition | FragmentDefinition>;
+
+const createExtensionNodeSpec = (): NodeSpec => {
+  const nodeSpec: NodeSpec = {
+    inline: false,
+    group: 'block',
+    atom: true,
+    selectable: true,
+    attrs: {
+      extensionType: { default: '' },
+      extensionKey: { default: '' },
+      parameters: { default: null },
+      text: { default: null },
+      layout: { default: 'default' },
+      localId: { default: null },
+    },
+    parseDOM: [
+      {
+        tag: '[data-node-type="extension"]',
+        getAttrs: (domNode) => getExtensionAttrs(domNode as HTMLElement),
+      },
+    ],
+    toDOM(node: PMNode) {
+      const attrs = {
+        'data-node-type': 'extension',
+        'data-extension-type': node.attrs.extensionType,
+        'data-extension-key': node.attrs.extensionKey,
+        'data-text': node.attrs.text,
+        'data-parameters': JSON.stringify(node.attrs.parameters),
+        'data-layout': node.attrs.layout,
+        'data-local-id:': node.attrs.localId,
+      };
+      return ['div', attrs];
+    },
+  };
+
+  return nodeSpec;
+};
+
+export const extension = createExtensionNodeSpec();

package/src/schema/nodes/hard-break.ts

@@ -0,0 +1,21 @@
+import { NodeSpec } from '@atlaskit/editor-prosemirror/model';
+
+/**
+ * @name hardBreak_node
+ */
+export interface HardBreakDefinition {
+  type: 'hardBreak';
+  attrs?: {
+    text?: '\n';
+  };
+}
+
+export const hardBreak: NodeSpec = {
+  inline: true,
+  group: 'inline',
+  selectable: false,
+  parseDOM: [{ tag: 'br' }],
+  toDOM() {
+    return ['br'];
+  },
+};

package/src/schema/nodes/heading.ts

@@ -0,0 +1,64 @@
+import { NodeSpec } from '@atlaskit/editor-prosemirror/model';
+import { AlignmentMarkDefinition, IndentationMarkDefinition } from '../marks';
+import { MarksObject, NoMark } from './types/mark';
+import { Inline } from './types/inline-content';
+
+/**
+ * @name heading_node
+ */
+export interface HeadingBaseDefinition {
+  type: 'heading';
+  /**
+   * @allowUnsupportedInline true
+   */
+  content?: Array<Inline>;
+  marks?: Array<any>;
+  attrs: {
+    /**
+     * @minimum 1
+     * @maximum 6
+     */
+    level: number;
+  };
+}
+
+/**
+ * @name heading_with_no_marks_node
+ */
+export type HeadingDefinition = HeadingBaseDefinition & NoMark;
+
+// Check `paragraph` node for why we are doing things like this
+/**
+ * @name heading_with_alignment_node
+ */
+export type HeadingWithAlignmentDefinition = HeadingBaseDefinition &
+  MarksObject<AlignmentMarkDefinition>;
+
+/**
+ * @name heading_with_indentation_node
+ */
+export type HeadingWithIndentationDefinition = HeadingBaseDefinition &
+  MarksObject<IndentationMarkDefinition>;
+
+export type HeadingWithMarksDefinition =
+  | HeadingWithAlignmentDefinition
+  | HeadingWithIndentationDefinition;
+
+export const heading: NodeSpec = {
+  attrs: { level: { default: 1 } },
+  content: `inline*`,
+  group: 'block',
+  defining: true,
+  selectable: false,
+  parseDOM: [
+    { tag: 'h1', attrs: { level: 1 } },
+    { tag: 'h2', attrs: { level: 2 } },
+    { tag: 'h3', attrs: { level: 3 } },
+    { tag: 'h4', attrs: { level: 4 } },
+    { tag: 'h5', attrs: { level: 5 } },
+    { tag: 'h6', attrs: { level: 6 } },
+  ],
+  toDOM(node) {
+    return ['h' + node.attrs['level'], 0];
+  },
+};

package/src/schema/nodes/image.ts

@@ -0,0 +1,32 @@
+import { NodeSpec, Node } from '@atlaskit/editor-prosemirror/model';
+
+export const image: NodeSpec = {
+  group: 'inline',
+  inline: true,
+  attrs: {
+    src: { default: '' },
+    alt: { default: '' },
+    title: { default: null },
+  },
+  draggable: true,
+  parseDOM: [
+    {
+      tag: 'img[src^="data:image/"]',
+      ignore: true,
+    },
+    {
+      tag: 'img[src]',
+      getAttrs(domNode) {
+        const dom = domNode as HTMLElement;
+        return {
+          src: dom.getAttribute('src'),
+          alt: dom.getAttribute('alt'),
+          title: dom.getAttribute('title'),
+        };
+      },
+    },
+  ],
+  toDOM(node: Node) {
+    return ['img', node.attrs];
+  },
+};

package/src/schema/nodes/index.ts

@@ -0,0 +1,184 @@
+export { expand, toJSON as expandToJSON } from './expand';
+export type { ExpandDefinition } from './expand';
+export { confluenceJiraIssue } from './confluence-jira-issue';
+export { confluenceUnsupportedBlock } from './confluence-unsupported-block';
+export { confluenceUnsupportedInline } from './confluence-unsupported-inline';
+export { doc } from './doc';
+export type { DocNode } from './doc';
+export { blockquote } from './blockquote';
+export type { BlockQuoteDefinition } from './blockquote';
+export { bulletList, bulletListSelector } from './bullet-list';
+export type { BulletListDefinition } from './types/list';
+export { codeBlock, toJSON as codeBlockToJSON } from './code-block';
+export type {
+  CodeBlockDefinition,
+  CodeBlockAttrs,
+  CodeBlockBaseDefinition,
+  CodeBlockWithMarksDefinition,
+} from './code-block';
+export { hardBreak } from './hard-break';
+export type { HardBreakDefinition } from './hard-break';
+export { heading } from './heading';
+export type {
+  HeadingDefinition,
+  HeadingBaseDefinition,
+  HeadingWithAlignmentDefinition,
+  HeadingWithIndentationDefinition,
+  HeadingWithMarksDefinition,
+} from './heading';
+export { rule } from './rule';
+export type { RuleDefinition } from './rule';
+export {
+  orderedList,
+  orderedListSelector,
+  orderedListWithOrder,
+} from './ordered-list';
+export type { OrderedListDefinition } from './types/list';
+export { paragraph } from './paragraph';
+export type {
+  ParagraphDefinition,
+  ParagraphBaseDefinition,
+  ParagraphWithAlignmentDefinition,
+  ParagraphWithIndentationDefinition,
+  ParagraphWithMarksDefinition,
+} from './paragraph';
+export { emoji } from './emoji';
+export type { EmojiAttributes, EmojiDefinition } from './emoji';
+export { image } from './image';
+export { mention, toJSON as mentionToJSON } from './mention';
+export type {
+  MentionAttributes,
+  UserType as MentionUserType,
+  MentionDefinition,
+} from './mention';
+export { listItem } from './list-item';
+export type { ListItemArray, ListItemDefinition } from './types/list';
+export { panel, PanelType } from './panel';
+export type { PanelAttributes, PanelDefinition } from './panel';
+export { text } from './text';
+export type { TextDefinition } from './text';
+export { default as unknownBlock } from './unknown-block';
+export { caption } from './caption';
+export type { CaptionDefinition } from './caption';
+export {
+  media,
+  copyPrivateAttributes as copyPrivateMediaAttributes,
+  toJSON as mediaToJSON,
+} from './media';
+export type {
+  MediaType,
+  MediaBaseAttributes,
+  MediaAttributes,
+  ExternalMediaAttributes,
+  DisplayType as MediaDisplayType,
+  MediaDefinition,
+  MediaADFAttrs,
+} from './media';
+export { mediaGroup } from './media-group';
+export { mediaInline } from './media-inline';
+export type {
+  MediaInlineAttributes,
+  MediaInlineDefinition,
+} from './media-inline';
+export type { MediaGroupDefinition } from './media-group';
+export {
+  mediaSingle,
+  mediaSingleSpec,
+  mediaSingleWithCaption,
+  mediaSingleWithWidthType,
+  mediaSingleFull,
+  toJSON as mediaSingleToJSON,
+} from './media-single';
+export type { MediaSingleDefinition } from './media-single';
+export {
+  table,
+  tableWithCustomWidth,
+  tableToJSON,
+  tableCell,
+  toJSONTableCell,
+  tableHeader,
+  toJSONTableHeader,
+  tableRow,
+  tableBackgroundColorPalette,
+  tableBackgroundBorderColor,
+  tableBackgroundColorNames,
+  getCellAttrs,
+  getCellDomAttrs,
+  tablePrefixSelector,
+  tableCellSelector,
+  tableHeaderSelector,
+  tableCellContentWrapperSelector,
+  tableCellContentDomSelector,
+} from './tableNodes';
+export type {
+  TableAttributes,
+  CellAttributes,
+  Layout as TableLayout,
+  TableDefinition,
+  TableCell as TableCellDefinition,
+  TableHeader as TableHeaderDefinition,
+  TableRow as TableRowDefinition,
+  CellDomAttrs,
+} from './tableNodes';
+export { decisionList, decisionListSelector } from './decision-list';
+export type { DecisionListDefinition } from './decision-list';
+export { decisionItem } from './decision-item';
+export type { DecisionItemDefinition } from './decision-item';
+export { taskList, taskListSelector } from './task-list';
+export type { TaskListDefinition, TaskListContent } from './task-list';
+export { taskItem } from './task-item';
+export type { TaskItemDefinition } from './task-item';
+export { extension } from './extension';
+export type { ExtensionDefinition } from './extension';
+export { inlineExtension } from './inline-extension';
+export type { InlineExtensionDefinition } from './inline-extension';
+export { bodiedExtension } from './bodied-extension';
+export type { BodiedExtensionDefinition } from './bodied-extension';
+export { date } from './date';
+export type { DateDefinition } from './date';
+export { placeholder } from './placeholder';
+export type { PlaceholderDefinition } from './placeholder';
+export { layoutSection, layoutSectionWithSingleColumn } from './layout-section';
+export type {
+  LayoutSectionDefinition,
+  LayoutSectionBaseDefinition,
+  LayoutSectionFullDefinition,
+  LayoutSectionWithSingleColumnDefinition,
+} from './layout-section';
+export { layoutColumn } from './layout-column';
+export type { LayoutColumnDefinition } from './layout-column';
+export { inlineCard } from './inline-card';
+export type { InlineCardDefinition } from './inline-card';
+export { blockCard } from './block-card';
+export type {
+  UrlType,
+  DataType,
+  DatasourceAttributes,
+  DatasourceAttributeProperties,
+  CardAttributes,
+  BlockCardDefinition,
+} from './block-card';
+export { unsupportedBlock } from './unsupported-block';
+export { unsupportedInline } from './unsupported-inline';
+export { status } from './status';
+export type { StatusDefinition } from './status';
+export { nestedExpand } from './nested-expand';
+export type { NestedExpandDefinition } from './nested-expand';
+export type { NoMark } from './types/mark';
+export type { MarksObject } from './types/mark';
+export type { BlockContent } from './types/block-content';
+export type { NonNestableBlockContent } from './types/non-nestable-block-content';
+export type { InlineAtomic } from './types/inline-content';
+export type { InlineCode } from './types/inline-content';
+export type { InlineLinkText } from './types/inline-content';
+export type { InlineFormattedText } from './types/inline-content';
+export type { Inline } from './types/inline-content';
+export type { NestedExpandContent } from './nested-expand';
+export type { Layout as ExtensionLayout } from './types/extensions';
+export { embedCard } from './embed-card';
+export type { EmbedCardDefinition, EmbedCardAttributes } from './embed-card';
+export type {
+  RichMediaAttributes,
+  ExtendedMediaAttributes,
+  Layout as RichMediaLayout,
+} from './types/rich-media-common';

package/src/schema/nodes/inline-card.ts

@@ -0,0 +1,70 @@
+import { NodeSpec, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { CardAttributes } from './block-card';
+
+/**
+ * @name inlineCard_node
+ */
+export interface InlineCardDefinition {
+  type: 'inlineCard';
+  attrs: CardAttributes;
+}
+
+export const inlineCard: NodeSpec = {
+  inline: true,
+  group: 'inline',
+  selectable: true,
+  draggable: true,
+  attrs: {
+    url: { default: null },
+    data: { default: null },
+  },
+  parseDOM: [
+    {
+      tag: 'a[data-inline-card], span[data-inline-card]',
+
+      // bump priority higher than hyperlink
+      priority: 100,
+
+      getAttrs: (dom) => {
+        const anchor = dom as HTMLAnchorElement;
+        const data = anchor.getAttribute('data-card-data');
+
+        /* Support attrs from Editor and Renderer */
+        return {
+          url:
+            anchor.getAttribute('href') ||
+            anchor.getAttribute('data-card-url') ||
+            null,
+          data: data ? JSON.parse(data) : null,
+        };
+      },
+    },
+
+    // for renderer
+    {
+      tag: 'div[data-inline-card]',
+
+      getAttrs: (dom) => {
+        const anchor = dom as HTMLDivElement;
+        const data = anchor.getAttribute('data-card-data');
+
+        return {
+          url: anchor.getAttribute('data-card-url'),
+          data: data ? JSON.parse(data) : null,
+        };
+      },
+    },
+  ],
+  toDOM(node: PMNode) {
+    const attrs = {
+      'data-inline-card': '',
+      href: node.attrs.url || '',
+      'data-card-data': node.attrs.data ? JSON.stringify(node.attrs.data) : '',
+    };
+    if (node.attrs.url) {
+      return ['a', attrs, node.attrs.url];
+    } else {
+      return ['a', attrs];
+    }
+  },
+};

package/src/schema/nodes/inline-extension.ts

@@ -0,0 +1,57 @@
+import { NodeSpec, Node as PMNode } from '@atlaskit/editor-prosemirror/model';
+import { getExtensionAttrs } from '../../utils/extensions';
+import { InlineExtensionAttributes } from './types/extensions';
+import { MarksObject } from './types/mark';
+import { DataConsumerDefinition } from '../marks/data-consumer';
+import { FragmentDefinition } from '../marks/fragment';
+
+/**
+ * @name inlineExtension_node
+ */
+export interface InlineExtensionBaseDefinition {
+  type: 'inlineExtension';
+  attrs: InlineExtensionAttributes;
+  marks?: Array<any>;
+}
+
+/**
+ * @name inlineExtension_with_marks_node
+ */
+export type InlineExtensionDefinition = InlineExtensionBaseDefinition &
+  MarksObject<DataConsumerDefinition | FragmentDefinition>;
+
+const createInlineExtensionNodeSpec = (): NodeSpec => {
+  const nodeSpec: NodeSpec = {
+    inline: true,
+    group: 'inline',
+    selectable: true,
+    attrs: {
+      extensionType: { default: '' },
+      extensionKey: { default: '' },
+      parameters: { default: null },
+      text: { default: null },
+      localId: { default: null },
+    },
+    parseDOM: [
+      {
+        tag: 'span[data-extension-type]',
+        getAttrs: (domNode) => getExtensionAttrs(domNode as HTMLElement, true),
+      },
+    ],
+    toDOM(node: PMNode) {
+      const attrs = {
+        'data-extension-type': node.attrs.extensionType,
+        'data-extension-key': node.attrs.extensionKey,
+        'data-text': node.attrs.text,
+        'data-parameters': JSON.stringify(node.attrs.parameters),
+        'data-local-id:': node.attrs.localId,
+        contenteditable: 'false',
+      };
+      return ['span', attrs];
+    },
+  };
+
+  return nodeSpec;
+};
+
+export const inlineExtension = createInlineExtensionNodeSpec();

package/src/schema/nodes/layout-column.ts

@@ -0,0 +1,68 @@
+import { NodeSpec } from '@atlaskit/editor-prosemirror/model';
+import { BlockContent } from './types/block-content';
+
+/**
+ * @name layoutColumn_node
+ */
+export interface LayoutColumnDefinition {
+  type: 'layoutColumn';
+  attrs: {
+    /**
+     * @minimum 0
+     * @maximum 100
+     */
+    width: number;
+  };
+  /**
+   * @minItems 1
+   * @allowUnsupportedBlock true
+   */
+  content: Array<BlockContent>;
+}
+
+export const layoutColumn: NodeSpec = {
+  content: '(block|unsupportedBlock)+',
+  isolating: true,
+  marks:
+    'alignment indentation dataConsumer fragment unsupportedMark unsupportedNodeAttribute',
+  selectable: false,
+  attrs: {
+    width: {
+      default: undefined,
+    },
+  },
+  parseDOM: [
+    {
+      context: 'layoutColumn//',
+      tag: 'div[data-layout-column]',
+      skip: true,
+    },
+    {
+      tag: 'div[data-layout-column]',
+      getAttrs: (domNode) => {
+        const dom = domNode as HTMLElement;
+        return {
+          width: Number(dom.getAttribute('data-column-width')) || undefined,
+        };
+      },
+    },
+  ],
+  toDOM(node) {
+    const attrs: Record<string, string> = {
+      'data-layout-column': 'true',
+    };
+    const { width } = node.attrs;
+    if (width) {
+      attrs['style'] = `flex-basis: ${width}%`;
+      attrs['data-column-width'] = width;
+    }
+
+    // We need to apply a attribute to the inner most child to help
+    // ProseMirror identify its boundaries better.
+    const contentAttrs: Record<string, string> = {
+      'data-layout-content': 'true',
+    };
+
+    return ['div', attrs, ['div', contentAttrs, 0]];
+  },
+};