@atlaskit/adf-schema 28.1.6 → 28.1.8

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

@@ -0,0 +1,42 @@
+import { toDOM, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+
+import { schema } from 'adf-test-helpers/src/adf-schema'
+
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema unsupportedBlock node`, () => {
+  const originalValue = {
+    type: 'invalidNode',
+    content: [
+      {
+        type: 'text',
+        text: 'foo',
+      },
+    ],
+  };
+
+  it('should parse unsupported block nodes', () => {
+    const doc = fromHTML(
+      `<div
+        data-node-type="unsupportedBlock"
+        data-original-value='${JSON.stringify(originalValue)}'
+      />`,
+      schema,
+    );
+    const unsupportedBlockNode = doc.firstChild!;
+    expect(unsupportedBlockNode.type).toEqual(schema.nodes.unsupportedBlock);
+    expect(unsupportedBlockNode.attrs.originalValue).toEqual(originalValue);
+  });
+
+  it('should encode unsupported block nodes to html', () => {
+    const unsupportedBlockNode = schema.nodes.unsupportedBlock.create({
+      originalValue,
+    });
+    const domNode = toDOM(unsupportedBlockNode, schema)
+      .firstChild as HTMLElement;
+
+    expect(domNode.getAttribute('data-original-value')).toEqual(
+      JSON.stringify(originalValue),
+    );
+  });
+});

package/src/__tests__/unit/schema/nodes/unsupported-inline.ts

@@ -0,0 +1,38 @@
+import { toDOM, fromHTML } from 'adf-test-helpers/src/adf-schema/html-helpers';
+
+import { schema } from 'adf-test-helpers/src/adf-schema'
+
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/schema unsupportedInline node`, () => {
+  const originalValue = {
+    type: 'invalidInlineNode',
+  };
+
+  it('should parse unsupported inline nodes', () => {
+    const doc = fromHTML(
+      `<span
+        data-node-type="unsupportedInline"
+        data-original-value='${JSON.stringify(originalValue)}'
+      />`,
+      schema,
+    );
+    const paragraph = doc.firstChild!;
+    const unsupportedInlineNode = paragraph.firstChild!;
+
+    expect(unsupportedInlineNode.type).toEqual(schema.nodes.unsupportedInline);
+    expect(unsupportedInlineNode.attrs.originalValue).toEqual(originalValue);
+  });
+
+  it('should encode unsupported inline nodes to html', () => {
+    const unsupportedInlineNode = schema.nodes.unsupportedInline.create({
+      originalValue,
+    });
+    const domNode = toDOM(unsupportedInlineNode, schema)
+      .firstChild as HTMLElement;
+
+    expect(domNode.getAttribute('data-original-value')).toEqual(
+      JSON.stringify(originalValue),
+    );
+  });
+});

package/src/__tests__/unit/utils/colors.ts

@@ -0,0 +1,42 @@
+import { hexToRgba, isRgb, normalizeHexColor } from '../../../utils/colors';
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/colors color utils`, () => {
+  describe('hex2rgba', () => {
+    it('converts short hex to rgba', () => {
+      expect(hexToRgba('#fab', 0.5)).toEqual('rgba(255,170,187,0.5)');
+    });
+
+    it('converts long hex to rgba', () => {
+      expect(hexToRgba('#ffaabb', 0.5)).toEqual('rgba(255,170,187,0.5)');
+    });
+  });
+
+  describe('isRgb', () => {
+    it('returns truthy for rgb', () => {
+      expect(isRgb('rgb(0, 0, 0)')).toBeTruthy();
+    });
+
+    it('returns truthy for rgba', () => {
+      expect(isRgb('rgba(0, 0, 0, 0)')).toBeTruthy();
+    });
+
+    it('returns falsy for hex', () => {
+      expect(isRgb('#FFFFFF')).toBeFalsy();
+    });
+
+    it('returns falsy for random string', () => {
+      expect(isRgb('rgab(00')).toBeFalsy();
+    });
+  });
+
+  describe('normalizeHexColor', () => {
+    it('return hex color of a color name', () => {
+      expect(normalizeHexColor('red')).toEqual('#ff0000');
+    });
+
+    it('should return null when passed `default`', () => {
+      expect(normalizeHexColor('default')).toBe(null);
+    });
+  });
+});

package/src/__tests__/unit/utils/url.ts

@@ -0,0 +1,209 @@
+import { getLinkMatch, isRootRelative, normalizeUrl } from '../../../utils/url';
+const packageName = process.env._PACKAGE_NAME_ as string;
+
+describe(`${packageName}/url url utils`, () => {
+  describe('normalizeUrl', () => {
+    const examples = [
+      ['prettyandsimple@example.com', 'mailto:prettyandsimple@example.com'],
+      ['gopher://go.com', 'gopher://go.com'],
+      ['dynamicsnav://go.com', 'dynamicsnav://go.com'],
+      ['integrity://go.com', 'integrity://go.com'],
+      ['file://go.pdf', 'file://go.pdf'],
+      ['smb://go.com', 'smb://go.com'],
+      [
+        'mailto:prettyandsimple@example.com',
+        'mailto:prettyandsimple@example.com',
+      ],
+      ['tel:1234', 'tel:1234'],
+      ['tel:1234', 'tel:1234'],
+
+      // Examples from https://datatracker.ietf.org/doc/html/rfc3966#section-6
+      ['tel:+1-201-555-0123', 'tel:+1-201-555-0123'],
+      ['tel:+1-201-555-0123', 'tel:+1-201-555-0123'],
+      ['tel:+1(800)555-0123', 'tel:+1(800)555-0123'],
+
+      // adf-schema didn't previously support notes:, even though linking-common does.
+      // This isn't a valid scheme, so we're not adding support
+      ['notes:somenoteurl', ''],
+      ['notes://somenoteurl', 'notes://somenoteurl'],
+
+      ['example.com', 'http://example.com'],
+      ['http://example.com', 'http://example.com'],
+      ['', ''],
+      [undefined, ''],
+      ['javascript:alert(1)', ''],
+      [
+        `https://test.blah.com/something#/search?_filter=(filters:!(),var:(x:!t,value:0),time:(from:now-1h,to:now))&_query=(fields:!(field.name,field.message),filters:!(('$state':(store:appState)),sort:!())`,
+        `https://test.blah.com/something#/search?_filter=(filters:!(),var:(x:!t,value:0),time:(from:now-1h,to:now))&_query=(fields:!(field.name,field.message),filters:!(('$state':(store:appState)),sort:!())`,
+        'handles links with nested parentheses',
+      ],
+      [
+        'jamfselfservice://content?entity=policy&id=551&action=view',
+        'jamfselfservice://content?entity=policy&id=551&action=view',
+      ],
+    ];
+    examples.forEach(([actual, expected, message]) => {
+      const testCase =
+        message || `should convert from "${actual}" -> "${expected}"`;
+      it(testCase, () => {
+        expect(normalizeUrl(actual)).toEqual(expected);
+      });
+    });
+  });
+
+  describe('getLinkMatch', () => {
+    const noise = (url: string) =>
+      `some text before ${url} and some more text after`;
+    it('should match web URLs', () => {
+      expect(getLinkMatch('http://localhost:1988')).not.toBe(undefined);
+      expect(getLinkMatch('http://www.atlassian.com')).not.toBe(undefined);
+      expect(getLinkMatch('http://www.atlassian.com/')).not.toBe(undefined);
+      expect(getLinkMatch('https://atlassian.com')).not.toBe(undefined);
+      expect(getLinkMatch('https://atlassian.com/')).not.toBe(undefined);
+      expect(getLinkMatch('www.atlassian.com')).not.toBe(undefined);
+      expect(getLinkMatch('www.atlassian.com/')).not.toBe(undefined);
+      expect(getLinkMatch('www.atlassian.com/foo/bar')).not.toBe(undefined);
+      expect(getLinkMatch('www.atlassian.com:12313/foo/bar')).not.toBe(
+        undefined,
+      );
+      expect(getLinkMatch('www.atlassian.com/foo/bar#foo')).not.toBe(undefined);
+      expect(getLinkMatch('www.atlassian.com/foo/bar?foo#bar')).not.toBe(
+        undefined,
+      );
+    });
+
+    it('should match only the link when surrounded with text', () => {
+      expect(getLinkMatch(noise('http://localhost:1988'))!.raw).toEqual(
+        'http://localhost:1988',
+      );
+      expect(getLinkMatch(noise('http://www.atlassian.com'))!.raw).toEqual(
+        'http://www.atlassian.com',
+      );
+      expect(getLinkMatch(noise('http://www.atlassian.com/'))!.raw).toEqual(
+        'http://www.atlassian.com/',
+      );
+      expect(getLinkMatch(noise('https://atlassian.com'))!.raw).toEqual(
+        'https://atlassian.com',
+      );
+      expect(getLinkMatch(noise('https://atlassian.com/'))!.raw).toEqual(
+        'https://atlassian.com/',
+      );
+      expect(getLinkMatch(noise('www.atlassian.com'))!.raw).toEqual(
+        'www.atlassian.com',
+      );
+      expect(getLinkMatch(noise('www.atlassian.com/'))!.raw).toEqual(
+        'www.atlassian.com/',
+      );
+      expect(getLinkMatch(noise('www.atlassian.com/foo/bar'))!.raw).toEqual(
+        'www.atlassian.com/foo/bar',
+      );
+      expect(
+        getLinkMatch(noise('www.atlassian.com:12313/foo/bar'))!.raw,
+      ).toEqual('www.atlassian.com:12313/foo/bar');
+      expect(getLinkMatch(noise('www.atlassian.com/foo/bar#foo'))!.raw).toEqual(
+        'www.atlassian.com/foo/bar#foo',
+      );
+      expect(
+        getLinkMatch(noise('www.atlassian.com/foo/bar?foo#bar'))!.raw,
+      ).toEqual('www.atlassian.com/foo/bar?foo#bar');
+    });
+
+    it('should not match filepaths', () => {
+      expect(getLinkMatch('./index.php')).toEqual(null);
+      expect(getLinkMatch('/index.php')).toEqual(null);
+    });
+    it('should not match markdown headings', () => {
+      expect(getLinkMatch('#hello')).toEqual(null);
+      expect(getLinkMatch('# hello')).toEqual(null);
+    });
+    it('should not match javascript', () => {
+      expect(getLinkMatch('javascript:alert(1);')).toEqual(null);
+    });
+    it('should not match app: or tcp: schemes', () => {
+      expect(getLinkMatch('app://atlassian.com')).toEqual(null);
+      expect(getLinkMatch('tcp://173.123.21.12')).toEqual(null);
+    });
+
+    it('should not match special characters', () => {
+      expect(getLinkMatch('[www.atlassian.com?hello=there]')!.raw).toEqual(
+        'www.atlassian.com?hello=there',
+      );
+      expect(getLinkMatch('(www.atlassian.com#hello>')!.raw).toEqual(
+        'www.atlassian.com#hello',
+      );
+      expect(getLinkMatch('(www.atlassian.com/hello<')!.raw).toEqual(
+        'www.atlassian.com/hello',
+      );
+      expect(getLinkMatch('(www.atlassian.com/hello?foo=bar^)')!.raw).toEqual(
+        'www.atlassian.com/hello?foo=bar^',
+      );
+    });
+    it('should match EMAILs', () => {
+      expect(getLinkMatch('prettyandsimple@example.com')).not.toBe(undefined);
+      expect(getLinkMatch('very.common@example.com')).not.toBe(undefined);
+      expect(
+        getLinkMatch('disposable.style.email.with+symbol@example.com'),
+      ).not.toBe(undefined);
+      expect(getLinkMatch('other.email-with-dash@example.com')).not.toBe(
+        undefined,
+      );
+      expect(getLinkMatch('x@example.com')).not.toBe(undefined);
+      expect(getLinkMatch('example-indeed@strange-example.com')).not.toBe(
+        undefined,
+      );
+      expect(getLinkMatch('example@s.solutions')).not.toBe(undefined);
+    });
+
+    it('should not match invalid EMAILs', () => {
+      expect(getLinkMatch('john.doe@example..com')).toEqual(null);
+    });
+
+    it('should match only the EMAIL when surrounded with text', () => {
+      expect(getLinkMatch(noise('http://localhost:1988'))!.raw).toEqual(
+        'http://localhost:1988',
+      );
+      expect(getLinkMatch(noise('prettyandsimple@example.com'))!.raw).toEqual(
+        'prettyandsimple@example.com',
+      );
+      expect(getLinkMatch(noise('very.common@example.com'))!.raw).toEqual(
+        'very.common@example.com',
+      );
+      expect(
+        getLinkMatch(noise('disposable.style.email.with+symbol@example.com'))!
+          .raw,
+      ).toEqual('disposable.style.email.with+symbol@example.com');
+      expect(
+        getLinkMatch(noise('other.email-with-dash@example.com'))!.raw,
+      ).toEqual('other.email-with-dash@example.com');
+      expect(getLinkMatch(noise('x@example.com'))!.raw).toEqual(
+        'x@example.com',
+      );
+      expect(
+        getLinkMatch(noise('example-indeed@strange-example.com'))!.raw,
+      ).toEqual('example-indeed@strange-example.com');
+    });
+
+    it('should not match filename extensions', () => {
+      expect(getLinkMatch('test.sh')).toEqual(null);
+      expect(getLinkMatch('test.as')).toEqual(null);
+      expect(getLinkMatch('test.ms')).toEqual(null);
+      expect(getLinkMatch('test.py')).toEqual(null);
+      expect(getLinkMatch('test.ps')).toEqual(null);
+      expect(getLinkMatch('test.so')).toEqual(null);
+      expect(getLinkMatch('test.pl')).toEqual(null);
+    });
+  });
+
+  describe('isRootRelative', () => {
+    it('should return true', () => {
+      expect(isRootRelative('/test')).toEqual(true);
+      expect(isRootRelative('/home/test')).toEqual(true);
+    });
+    it('should return false', () => {
+      expect(isRootRelative('www.atlassian.com')).toEqual(false);
+      expect(isRootRelative('https://www.atlassian.com')).toEqual(false);
+      expect(isRootRelative('test/')).toEqual(false);
+      expect(isRootRelative('  /test')).toEqual(false);
+    });
+  });
+});

package/src/index.ts

@@ -0,0 +1,297 @@
+export {
+  PanelType,
+  AnnotationTypes,
+  alignment,
+  alignmentPositionMap,
+  annotation,
+  blockCard,
+  blockquote,
+  bodiedExtension,
+  breakout,
+  bulletList,
+  bulletListSelector,
+  caption,
+  code,
+  codeBlock,
+  codeBlockToJSON,
+  colorPalette,
+  /** @deprecated [ED-15849] The extended palette is now rolled into the main one. Use `colorPalette` instead. */
+  colorPaletteExtended,
+  confluenceInlineComment,
+  confluenceJiraIssue,
+  confluenceUnsupportedBlock,
+  confluenceUnsupportedInline,
+  copyPrivateMediaAttributes,
+  createSchema,
+  dataConsumer,
+  dataConsumerToJSON,
+  date,
+  decisionItem,
+  decisionList,
+  decisionListSelector,
+  doc,
+  em,
+  embedCard,
+  emoji,
+  expand,
+  expandToJSON,
+  extension,
+  fragment,
+  fragmentToJSON,
+  hardBreak,
+  heading,
+  image,
+  indentation,
+  inlineCard,
+  inlineExtension,
+  inlineNodes,
+  layoutColumn,
+  layoutSection,
+  link,
+  linkToJSON,
+  listItem,
+  media,
+  mediaGroup,
+  mediaSingle,
+  mediaSingleWithCaption,
+  mediaSingleWithWidthType,
+  mediaSingleFull,
+  mediaSingleSpec,
+  mediaInline,
+  mediaSingleToJSON,
+  mediaToJSON,
+  mention,
+  mentionToJSON,
+  nestedExpand,
+  orderedList,
+  orderedListSelector,
+  orderedListWithOrder,
+  panel,
+  paragraph,
+  placeholder,
+  rule,
+  sanitizeNodes,
+  getCellAttrs,
+  getCellDomAttrs,
+  status,
+  strike,
+  strong,
+  subsup,
+  table,
+  tableWithCustomWidth,
+  tableBackgroundBorderColor,
+  tableBackgroundColorNames,
+  tableBackgroundColorPalette,
+  tableCell,
+  tableCellContentDomSelector,
+  tableCellContentWrapperSelector,
+  tableCellSelector,
+  tableHeader,
+  tableHeaderSelector,
+  tablePrefixSelector,
+  tableRow,
+  tableToJSON,
+  taskItem,
+  taskList,
+  taskListSelector,
+  text,
+  textColor,
+  toJSONTableCell,
+  toJSONTableHeader,
+  typeAheadQuery,
+  underline,
+  unknownBlock,
+  unsupportedBlock,
+  unsupportedInline,
+  unsupportedNodeTypesForMediaCards,
+  buildAnnotationMarkDataAttributes,
+  AnnotationMarkStates,
+  unsupportedMark,
+  unsupportedNodeAttribute,
+  border,
+  borderColorPalette,
+} from './schema';
+export type {
+  AlignmentAttributes,
+  AlignmentMarkDefinition,
+  AnnotationMarkAttributes,
+  AnnotationMarkDefinition,
+  BlockCardDefinition,
+  BlockContent,
+  BlockQuoteDefinition,
+  BodiedExtensionDefinition,
+  BreakoutMarkAttrs,
+  BreakoutMarkDefinition,
+  BulletListDefinition,
+  CaptionDefinition,
+  CardAttributes,
+  CellAttributes,
+  CodeBlockAttrs,
+  CodeBlockBaseDefinition,
+  CodeBlockDefinition,
+  CodeBlockWithMarksDefinition,
+  CodeDefinition,
+  DatasourceAttributes,
+  DataConsumerAttributes,
+  DataConsumerDefinition,
+  DataType,
+  DateDefinition,
+  DecisionItemDefinition,
+  DecisionListDefinition,
+  DocNode,
+  EmbedCardDefinition,
+  EmbedCardAttributes,
+  EmDefinition,
+  EmojiAttributes,
+  EmojiDefinition,
+  ExpandDefinition,
+  ExtensionDefinition,
+  ExtensionLayout,
+  ExternalMediaAttributes,
+  FragmentAttributes,
+  FragmentDefinition,
+  HardBreakDefinition,
+  HeadingBaseDefinition,
+  HeadingDefinition,
+  HeadingWithAlignmentDefinition,
+  HeadingWithIndentationDefinition,
+  HeadingWithMarksDefinition,
+  IndentationMarkAttributes,
+  IndentationMarkDefinition,
+  Inline,
+  InlineAtomic,
+  InlineCardDefinition,
+  InlineCode,
+  InlineExtensionDefinition,
+  InlineFormattedText,
+  InlineLinkText,
+  LayoutColumnDefinition,
+  LayoutSectionDefinition,
+  LayoutSectionFullDefinition,
+  LayoutSectionWithSingleColumnDefinition,
+  LinkAttributes,
+  LinkDefinition,
+  ListItemArray,
+  ListItemDefinition,
+  MarksObject,
+  MediaADFAttrs,
+  MediaAttributes,
+  MediaInlineAttributes,
+  MediaInlineDefinition,
+  MediaBaseAttributes,
+  MediaDefinition,
+  MediaDisplayType,
+  MediaGroupDefinition,
+  MediaSingleDefinition,
+  MediaType,
+  MentionAttributes,
+  MentionDefinition,
+  MentionUserType,
+  NestedExpandContent,
+  NestedExpandDefinition,
+  NoMark,
+  NonNestableBlockContent,
+  OrderedListDefinition,
+  PanelAttributes,
+  PanelDefinition,
+  ParagraphBaseDefinition,
+  ParagraphDefinition,
+  ParagraphWithAlignmentDefinition,
+  ParagraphWithIndentationDefinition,
+  ParagraphWithMarksDefinition,
+  PlaceholderDefinition,
+  RuleDefinition,
+  StatusDefinition,
+  StrikeDefinition,
+  StrongDefinition,
+  SubSupAttributes,
+  SubSupDefinition,
+  TableAttributes,
+  TableCellDefinition,
+  TableDefinition,
+  TableHeaderDefinition,
+  TableLayout,
+  TableRowDefinition,
+  TaskItemDefinition,
+  TaskListContent,
+  TaskListDefinition,
+  TextColorAttributes,
+  TextColorDefinition,
+  TextDefinition,
+  UnderlineDefinition,
+  UrlType,
+  AnnotationId,
+  RichMediaAttributes,
+  ExtendedMediaAttributes,
+  RichMediaLayout,
+  AnnotationDataAttributes,
+  CellDomAttrs,
+  BorderMarkAttributes,
+  BorderMarkDefinition,
+} from './schema';
+export {
+  B100,
+  B400,
+  B50,
+  B500,
+  B75,
+  G200,
+  G300,
+  G400,
+  G50,
+  G500,
+  G75,
+  N0,
+  N20,
+  N200,
+  N30,
+  N300,
+  N40,
+  N50,
+  N500,
+  N60,
+  N80,
+  N800,
+  N90,
+  P100,
+  P300,
+  P400,
+  P50,
+  P500,
+  P75,
+  R100,
+  R300,
+  R400,
+  R50,
+  R500,
+  R75,
+  T100,
+  T300,
+  T50,
+  T500,
+  T75,
+  Y200,
+  Y400,
+  Y50,
+  Y500,
+  Y75,
+  acNameToEmoji,
+  acShortcutToEmoji,
+  emojiIdToAcName,
+  generateUuid,
+  getEmojiAcName,
+  getLinkMatch,
+  hexToRgb,
+  hexToRgba,
+  isHex,
+  isRgb,
+  isSafeUrl,
+  linkify,
+  linkifyMatch,
+  normalizeHexColor,
+  normalizeUrl,
+  rgbToHex,
+  uuid,
+} from './utils';
+
+export type { Match, NameToEmoji } from './utils';

package/src/json-schema/index.ts

@@ -0,0 +1,2 @@
+export { default as fullSchema } from '../../json-schema/v1/full.json';
+export { default as stageZeroSchema } from '../../json-schema/v1/stage-0.json';

package/src/schema/bitbucket-schema.ts

@@ -0,0 +1,43 @@
+import { Schema } from '@atlaskit/editor-prosemirror/model';
+import { createSchema } from './create-schema';
+
+/**
+ * @deprecated [ED-15676] We have stopped supporting product specific schemas. Use `@atlaskit/adf-schema/schema-default` instead.
+ **/
+export const bitbucketSchema: Schema = createSchema({
+  nodes: [
+    'doc',
+    'caption',
+    'paragraph',
+    'text',
+    'bulletList',
+    'orderedList',
+    'listItem',
+    'heading',
+    'blockquote',
+    'codeBlock',
+    'hardBreak',
+    'rule',
+    'image',
+    'media',
+    'mediaSingle',
+    'mention',
+    'emoji',
+    'table',
+    'tableCell',
+    'tableHeader',
+    'tableRow',
+    'inlineCard',
+    'unsupportedBlock',
+    'unsupportedInline',
+  ],
+  marks: [
+    'em',
+    'strong',
+    'strike',
+    'link',
+    'code',
+    'unsupportedMark',
+    'unsupportedNodeAttribute',
+  ],
+});