@atlaskit/adf-schema 28.1.11 → 28.1.13

package/src/schema/confluence-schema.ts

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

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

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

@@ -1,30 +0,0 @@
-// # 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';