@atlaskit/adf-schema 28.1.6 → 28.1.7

package/src/schema/confluence-schema.ts

@@ -0,0 +1,76 @@
+import { createSchema } from './create-schema';
+import { Schema } from '@atlaskit/editor-prosemirror/model';
+
+const nodes = [
+  'doc',
+  'paragraph',
+  'blockquote',
+  'codeBlock',
+  'panel',
+  'hardBreak',
+  'orderedList',
+  'bulletList',
+  'heading',
+  'mediaInline',
+  'mediaGroup',
+  'mediaSingle',
+  'media',
+  'caption',
+  'confluenceUnsupportedBlock',
+  'confluenceJiraIssue',
+  'expand',
+  'nestedExpand',
+  'extension',
+  'inlineExtension',
+  'bodiedExtension',
+  'listItem',
+  'mention',
+  'text',
+  'confluenceUnsupportedInline',
+  'media',
+  'rule',
+  'table',
+  'tableCell',
+  'tableHeader',
+  'tableRow',
+  'emoji',
+  'taskList',
+  'taskItem',
+  'date',
+  'placeholder',
+  'decisionList',
+  'decisionItem',
+  'layoutSection',
+  'layoutColumn',
+  'inlineCard',
+  'unsupportedBlock',
+  'unsupportedInline',
+];
+
+const marks = [
+  'link',
+  'em',
+  'strong',
+  'strike',
+  'subsup',
+  'underline',
+  'mentionQuery',
+  'code',
+  'textColor',
+  'confluenceInlineComment',
+  'annotation',
+  'unsupportedMark',
+  'unsupportedNodeAttribute',
+];
+
+/**
+ * @deprecated [ED-15676] We have stopped supporting product specific schemas. Use `@atlaskit/adf-schema/schema-default` instead.
+ **/
+export const confluenceSchema: Schema = createSchema({ nodes, marks });
+/**
+ * @deprecated [ED-15676] We have stopped supporting product specific schemas. Use `@atlaskit/adf-schema/schema-default` instead.
+ **/
+export const confluenceSchemaWithMediaSingle: Schema = createSchema({
+  nodes: nodes.concat('mediaSingle'),
+  marks,
+});

package/src/schema/create-schema.ts

@@ -0,0 +1,337 @@
+import { NodeSpec, MarkSpec, Schema } from '@atlaskit/editor-prosemirror/model';
+import { COLOR, FONT_STYLE, SEARCH_QUERY, LINK } from './groups';
+
+import {
+  link,
+  em,
+  strong,
+  textColor,
+  strike,
+  subsup,
+  underline,
+  code,
+  typeAheadQuery,
+  confluenceInlineComment,
+  breakout,
+  alignment,
+  indentation,
+  annotation,
+  unsupportedMark,
+  unsupportedNodeAttribute,
+  dataConsumer,
+  fragment,
+  border,
+} from './marks';
+
+import {
+  confluenceJiraIssue,
+  confluenceUnsupportedBlock,
+  confluenceUnsupportedInline,
+  doc,
+  paragraph,
+  text,
+  bulletList,
+  orderedListWithOrder,
+  listItem,
+  heading,
+  blockquote,
+  codeBlock,
+  panel,
+  rule,
+  image,
+  mention,
+  media,
+  mediaInline,
+  mediaSingleWithCaption,
+  mediaGroup,
+  hardBreak,
+  emoji,
+  table,
+  tableCell,
+  tableHeader,
+  tableRow,
+  decisionList,
+  decisionItem,
+  taskList,
+  taskItem,
+  unknownBlock,
+  extension,
+  inlineExtension,
+  bodiedExtension,
+  date,
+  placeholder,
+  layoutSection,
+  layoutColumn,
+  inlineCard,
+  blockCard,
+  unsupportedBlock,
+  unsupportedInline,
+  status,
+  expand,
+  nestedExpand,
+  embedCard,
+  caption,
+} from './nodes';
+
+function addItems(
+  builtInItems: SchemaBuiltInItem[],
+  config: string[],
+  customSpecs: SchemaCustomNodeSpecs | SchemaCustomMarkSpecs = {},
+) {
+  if (!config) {
+    return {};
+  }
+
+  /**
+   * Add built-in Node / Mark specs
+   */
+  const items = builtInItems.reduce<Record<string, NodeSpec | MarkSpec>>(
+    (items, { name, spec }) => {
+      if (config.indexOf(name) !== -1) {
+        items[name] = customSpecs[name] || spec;
+      }
+
+      return items;
+    },
+    {},
+  );
+
+  /**
+   * Add Custom Node / Mark specs
+   */
+  return Object.keys(customSpecs).reduce((items, name) => {
+    if (items[name]) {
+      return items;
+    }
+
+    items[name] = customSpecs[name];
+
+    return items;
+  }, items);
+}
+
+// We use groups to allow schemas to be constructed in different shapes without changing node/mark
+// specs, but this means nodes/marks are defined with groups that might never be used in the schema.
+// In this scenario ProseMirror will complain and prevent the schema from being constructed.
+//
+// To avoid the problem, we include items that serve to "declare" the groups in the schema. This
+// approach unfortunately leaves unused items in the schema, but has the benefit of avoiding the
+// need to manipulate `exclude` or content expression values for potentially every schema item.
+function groupDeclaration(name: string) {
+  return {
+    name: `__${name}GroupDeclaration`,
+    spec: {
+      group: name,
+    },
+  };
+}
+
+const markGroupDeclarations = [
+  groupDeclaration(COLOR),
+  groupDeclaration(FONT_STYLE),
+  groupDeclaration(SEARCH_QUERY),
+  groupDeclaration(LINK),
+];
+
+const markGroupDeclarationsNames = markGroupDeclarations.map(
+  (groupMark) => groupMark.name,
+);
+
+const nodesInOrder: SchemaBuiltInItem[] = [
+  { name: 'doc', spec: doc },
+  { name: 'paragraph', spec: paragraph },
+  { name: 'text', spec: text },
+  { name: 'bulletList', spec: bulletList },
+  { name: 'orderedList', spec: orderedListWithOrder },
+  { name: 'listItem', spec: listItem },
+  { name: 'heading', spec: heading },
+  { name: 'blockquote', spec: blockquote },
+  { name: 'codeBlock', spec: codeBlock },
+  { name: 'panel', spec: panel(true) },
+  { name: 'rule', spec: rule },
+  { name: 'image', spec: image },
+  { name: 'mention', spec: mention },
+  { name: 'caption', spec: caption },
+  { name: 'media', spec: media },
+  { name: 'mediaGroup', spec: mediaGroup },
+  { name: 'mediaSingle', spec: mediaSingleWithCaption },
+  { name: 'mediaInline', spec: mediaInline },
+  { name: 'placeholder', spec: placeholder },
+  { name: 'layoutSection', spec: layoutSection },
+  { name: 'layoutColumn', spec: layoutColumn },
+  { name: 'hardBreak', spec: hardBreak },
+  { name: 'emoji', spec: emoji },
+  { name: 'table', spec: table },
+  { name: 'tableCell', spec: tableCell },
+  { name: 'tableRow', spec: tableRow },
+  { name: 'tableHeader', spec: tableHeader },
+  { name: 'confluenceJiraIssue', spec: confluenceJiraIssue },
+  { name: 'confluenceUnsupportedInline', spec: confluenceUnsupportedInline },
+  { name: 'confluenceUnsupportedBlock', spec: confluenceUnsupportedBlock },
+  { name: 'decisionList', spec: decisionList },
+  { name: 'decisionItem', spec: decisionItem },
+  { name: 'taskList', spec: taskList },
+  { name: 'taskItem', spec: taskItem },
+  { name: 'date', spec: date },
+  { name: 'status', spec: status },
+  { name: 'expand', spec: expand },
+  { name: 'nestedExpand', spec: nestedExpand },
+  { name: 'extension', spec: extension },
+  { name: 'inlineExtension', spec: inlineExtension },
+  { name: 'bodiedExtension', spec: bodiedExtension },
+  { name: 'inlineCard', spec: inlineCard },
+  { name: 'blockCard', spec: blockCard },
+  { name: 'embedCard', spec: embedCard },
+  { name: 'unknownBlock', spec: unknownBlock },
+  { name: 'unsupportedBlock', spec: unsupportedBlock },
+  { name: 'unsupportedInline', spec: unsupportedInline },
+];
+
+const marksInOrder: SchemaBuiltInItem[] = [
+  { name: 'link', spec: link },
+  { name: 'em', spec: em },
+  { name: 'strong', spec: strong },
+  { name: 'textColor', spec: textColor },
+  { name: 'strike', spec: strike },
+  { name: 'subsup', spec: subsup },
+  { name: 'underline', spec: underline },
+  { name: 'code', spec: code },
+  { name: 'typeAheadQuery', spec: typeAheadQuery },
+  { name: 'alignment', spec: alignment },
+  { name: 'annotation', spec: annotation },
+  { name: 'confluenceInlineComment', spec: confluenceInlineComment },
+  ...markGroupDeclarations,
+  { name: 'breakout', spec: breakout },
+  { name: 'dataConsumer', spec: dataConsumer },
+  { name: 'fragment', spec: fragment },
+  { name: 'indentation', spec: indentation },
+  { name: 'border', spec: border },
+  { name: 'unsupportedMark', spec: unsupportedMark },
+  { name: 'unsupportedNodeAttribute', spec: unsupportedNodeAttribute },
+];
+
+/**
+ * Creates a schema preserving order of marks and nodes.
+ */
+export function createSchema<
+  N extends string = string,
+  M extends string = string,
+>(config: SchemaConfig<N, M>): Schema<N, M> {
+  const { customNodeSpecs, customMarkSpecs } = config;
+  const nodesConfig = Object.keys(customNodeSpecs || {}).concat(config.nodes);
+  const marksConfig = Object.keys(customMarkSpecs || {})
+    .concat(config.marks || [])
+    .concat(markGroupDeclarationsNames);
+
+  let nodes = addItems(nodesInOrder, nodesConfig, customNodeSpecs) as Record<
+    string,
+    NodeSpec
+  >;
+  let marks = addItems(marksInOrder, marksConfig, customMarkSpecs) as Record<
+    string,
+    MarkSpec
+  >;
+  nodes = sanitizeNodes(nodes, marks);
+  return new Schema<string, string>({
+    nodes,
+    marks,
+  });
+}
+
+export function sanitizeNodes(
+  nodes: { [key: string]: NodeSpec },
+  supportedMarks: { [key: string]: MarkSpec },
+): { [key: string]: NodeSpec } {
+  const nodeNames = Object.keys(nodes);
+  nodeNames.forEach((nodeKey) => {
+    const nodeSpec = { ...nodes[nodeKey] };
+    if (nodeSpec.marks && nodeSpec.marks !== '_') {
+      nodeSpec.marks = nodeSpec.marks
+        .split(' ')
+        .filter((mark) => !!supportedMarks[mark])
+        .join(' ');
+    }
+    if (nodeSpec.content) {
+      nodeSpec.content = sanitizeNodeSpecContent(nodes, nodeSpec.content);
+    }
+    nodes[nodeKey] = nodeSpec;
+  });
+  return nodes;
+}
+
+export function sanitizeNodeSpecContent(
+  nodes: { [key: string]: NodeSpec },
+  rawContent: string,
+): string {
+  const content = rawContent.replace(/\W/g, ' ');
+  const contentKeys = content.split(' ');
+  const unsupportedContentKeys = contentKeys.filter(
+    (contentKey) => !isContentSupported(nodes, contentKey),
+  );
+  return unsupportedContentKeys.reduce(
+    (newContent, nodeName) => sanitizedContent(newContent, nodeName),
+    rawContent,
+  );
+}
+
+function sanitizedContent(
+  content: string | undefined,
+  invalidContent: string,
+): string {
+  if (!invalidContent.length) {
+    return content || '';
+  }
+
+  if (!content || !content.match(/\w/)) {
+    return '';
+  }
+
+  const pattern = `(${invalidContent}((\\s)*\\|)+)|((\\|(\\s)*)+${invalidContent})|(${invalidContent}$)|(${invalidContent}(\\+|\\*))`;
+  return content
+    .replace(new RegExp(pattern, 'g'), '')
+    .replace('  ', ' ')
+    .trim();
+}
+
+function isContentSupported(
+  nodes: { [key: string]: NodeSpec },
+  contentKey: string,
+): boolean {
+  const nodeKeys = Object.keys(nodes);
+
+  // content is with valid node
+  if (nodeKeys.indexOf(contentKey) > -1) {
+    return true;
+  }
+
+  // content is with valid group
+  for (const supportedKey in nodes) {
+    const nodeSpec = nodes[supportedKey];
+    if (nodeSpec && nodeSpec.group === contentKey) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+export interface SchemaConfig<N = string, M = string> {
+  nodes: N[];
+  customNodeSpecs?: SchemaCustomNodeSpecs;
+  marks?: M[];
+  customMarkSpecs?: SchemaCustomMarkSpecs;
+}
+
+export interface SchemaBuiltInItem {
+  name: string;
+  spec: NodeSpec | MarkSpec;
+}
+
+export interface SchemaCustomNodeSpecs {
+  [name: string]: NodeSpec;
+}
+export interface SchemaCustomMarkSpecs {
+  [name: string]: MarkSpec;
+}
+
+export const allowCustomPanel: boolean = true;

package/src/schema/default-schema.ts

@@ -0,0 +1,180 @@
+import memoizeOne from 'memoize-one';
+
+import {
+  mediaSingleFull,
+  layoutSectionWithSingleColumn,
+  tableWithCustomWidth,
+} from './nodes';
+import { createSchema, SchemaConfig } from './create-schema';
+
+type DefaultSchemaNodes =
+  | 'doc'
+  | 'paragraph'
+  | 'text'
+  | 'bulletList'
+  | 'orderedList'
+  | 'listItem'
+  | 'heading'
+  | 'blockquote'
+  | 'codeBlock'
+  | 'panel'
+  | 'rule'
+  | 'image'
+  | 'mention'
+  | 'media'
+  | 'caption'
+  | 'mediaGroup'
+  | 'mediaSingle'
+  | 'mediaInline'
+  | 'confluenceUnsupportedBlock'
+  | 'confluenceUnsupportedInline'
+  | 'confluenceJiraIssue'
+  | 'expand'
+  | 'nestedExpand'
+  | 'extension'
+  | 'inlineExtension'
+  | 'bodiedExtension'
+  | 'hardBreak'
+  | 'emoji'
+  | 'table'
+  | 'tableCell'
+  | 'tableHeader'
+  | 'tableRow'
+  | 'decisionList'
+  | 'decisionItem'
+  | 'taskList'
+  | 'taskItem'
+  | 'unknownBlock'
+  | 'date'
+  | 'status'
+  | 'placeholder'
+  | 'layoutSection'
+  | 'layoutColumn'
+  | 'inlineCard'
+  | 'blockCard'
+  | 'embedCard'
+  | 'unsupportedBlock'
+  | 'unsupportedInline';
+
+type DefaultSchemaMarks =
+  | 'link'
+  | 'em'
+  | 'strong'
+  | 'strike'
+  | 'subsup'
+  | 'underline'
+  | 'code'
+  | 'textColor'
+  | 'confluenceInlineComment'
+  | 'breakout'
+  | 'alignment'
+  | 'indentation'
+  | 'annotation'
+  | 'border'
+  | 'unsupportedMark'
+  | 'unsupportedNodeAttribute'
+  | 'typeAheadQuery'
+  | 'dataConsumer'
+  | 'fragment';
+
+const getDefaultSchemaConfig = (): SchemaConfig<
+  DefaultSchemaNodes,
+  DefaultSchemaMarks
+> => {
+  let defaultSchemaConfig: SchemaConfig<
+    DefaultSchemaNodes,
+    DefaultSchemaMarks
+  > = {
+    nodes: [
+      'doc',
+      'paragraph',
+      'text',
+      'bulletList',
+      'orderedList',
+      'listItem',
+      'heading',
+      'blockquote',
+      'codeBlock',
+      'panel',
+      'rule',
+      'image',
+      'caption',
+      'mention',
+      'media',
+      'mediaGroup',
+      'mediaSingle',
+      'mediaInline',
+      'confluenceUnsupportedBlock',
+      'confluenceUnsupportedInline',
+      'confluenceJiraIssue',
+      'expand',
+      'nestedExpand',
+      'extension',
+      'inlineExtension',
+      'bodiedExtension',
+      'hardBreak',
+      'emoji',
+      'table',
+      'tableCell',
+      'tableHeader',
+      'tableRow',
+      'decisionList',
+      'decisionItem',
+      'taskList',
+      'taskItem',
+      'unknownBlock',
+      'date',
+      'status',
+      'placeholder',
+      'layoutSection',
+      'layoutColumn',
+      'inlineCard',
+      'blockCard',
+      'embedCard',
+      'unsupportedBlock',
+      'unsupportedInline',
+    ],
+    marks: [
+      'link',
+      'em',
+      'strong',
+      'strike',
+      'subsup',
+      'underline',
+      'code',
+      'textColor',
+      'confluenceInlineComment',
+      'breakout',
+      'alignment',
+      'indentation',
+      'annotation',
+      'dataConsumer',
+      'border',
+      'unsupportedMark',
+      'unsupportedNodeAttribute',
+      'typeAheadQuery', // https://product-fabric.atlassian.net/browse/ED-10214,
+      'fragment',
+    ],
+  };
+  return defaultSchemaConfig;
+};
+
+export const defaultSchemaConfig: SchemaConfig<
+  DefaultSchemaNodes,
+  DefaultSchemaMarks
+> = getDefaultSchemaConfig();
+
+export const getSchemaBasedOnStage = memoizeOne((stage = 'final') => {
+  const defaultSchemaConfig = getDefaultSchemaConfig();
+  if (stage === 'stage0') {
+    defaultSchemaConfig.customNodeSpecs = {
+      layoutSection: layoutSectionWithSingleColumn,
+      table: tableWithCustomWidth,
+      mediaSingle: mediaSingleFull,
+    };
+  }
+
+  return createSchema(defaultSchemaConfig);
+});
+
+export const defaultSchema = getSchemaBasedOnStage();

package/src/schema/groups.ts

@@ -0,0 +1,30 @@
+// # What do marks exist?
+//
+// Marks are categorised into different groups. One motivation for this was to allow the `code` mark
+// to exclude other marks, without needing to explicitly name them. Explicit naming requires the
+// named mark to exist in the schema. This is undesirable because we want to construct different
+// schemas that have different sets of nodes/marks.
+//
+// Groups provide a level of indirection, and solve this problem. For the immediate use-case, one
+// group called "not_code" would have sufficed, but this an ultra-specialised to code.
+
+// Mark group for font styling (e.g. bold, italic, underline, superscript).
+export const FONT_STYLE = 'fontStyle';
+
+// Marks group for search queries.
+export const SEARCH_QUERY = 'searchQuery';
+
+// Marks group for links.
+export const LINK = 'link';
+
+// Marks group for colors (text-color, background-color, etc).
+export const COLOR = 'color';
+
+// They need to be on their own group so that they can exclude each other
+// and also work when one of them is disabled.
+
+// Marks group for alignment.
+export const ALIGNMENT = 'alignment';
+
+// Marks group for indentation.
+export const INDENTATION = 'indentation';