@atlaskit/adf-schema 28.1.5 → 28.1.7

package/src/utils/colors.ts

@@ -0,0 +1,171 @@
+import * as namedColors from 'css-color-names'; // eslint-disable-line import/extensions
+
+/**
+ * We're avoding importing these colors from @atlaskit/theme since we
+ * do not want to have react as a dependency of this package.
+ * TODO: Refactor this once tokenization by Core team is ready
+ * https://product-fabric.atlassian.net/browse/CS-908
+ */
+
+export const R50 = '#FFEBE6';
+export const R75 = '#FFBDAD';
+export const R100 = '#FF8F73';
+export const R300 = '#FF5630';
+export const R400 = '#DE350B';
+export const R500 = '#BF2600';
+
+export const Y50 = '#FFFAE6';
+export const Y75 = '#FFF0B3';
+export const Y200 = '#FFC400';
+export const Y400 = '#FF991F';
+export const Y500 = '#FF8B00';
+
+export const G50 = '#E3FCEF';
+export const G75 = '#ABF5D1';
+export const G200 = '#57D9A3';
+export const G300 = '#36B37E';
+export const G400 = '#00875A';
+export const G500 = '#006644';
+
+export const B50 = '#DEEBFF';
+export const B75 = '#B3D4FF';
+export const B100 = '#4C9AFF';
+export const B400 = '#0052CC';
+export const B500 = '#0747A6';
+
+export const N0 = '#FFFFFF';
+export const N20 = '#F4F5F7';
+export const N30 = '#EBECF0';
+export const N40 = '#DFE1E6';
+export const N50 = '#C1C7D0';
+export const N60 = '#B3BAC5';
+export const N80 = '#97A0AF';
+export const N90 = '#8993A4';
+export const N200 = '#6B778C';
+export const N300 = '#5E6C84';
+export const N300A = '#091E4224';
+export const N500 = '#42526E';
+export const N600 = '#758195';
+export const N800 = '#172B4D';
+export const N1000 = '#172B4D';
+
+export const P50 = '#EAE6FF';
+export const P75 = '#C0B6F2';
+export const P100 = '#998DD9';
+export const P300 = '#6554C0';
+export const P400 = '#5243AA';
+export const P500 = '#403294';
+
+export const T50 = '#E6FCFF';
+export const T75 = '#B3F5FF';
+export const T100 = '#79E2F2';
+export const T300 = '#00B8D9';
+export const T500 = '#008DA6';
+
+/**
+ * @return String with HEX-coded color.
+ */
+export function normalizeHexColor(
+  color: string | null,
+  defaultColor?: string,
+): string | null {
+  if (!color) {
+    return null;
+  }
+
+  // Normalize to hex
+  color = color.trim().toLowerCase();
+  if (isHex(color)) {
+    // Normalize 3-hex to 6-hex colours
+    if (color.length === 4) {
+      color = color
+        .split('')
+        .map((c) => (c === '#' ? '#' : `${c}${c}`))
+        .join('');
+    }
+  } else if (isRgb(color)) {
+    return rgbToHex(color);
+  } else {
+    // http://dev.w3.org/csswg/css-color/#named-colors
+    if (color === 'default') {
+      return null;
+    } else if ((namedColors).default && (namedColors as any).default[color]) {
+      color = (namedColors as any).default[color];
+    } else if (namedColors && namedColors[color]) {
+      color = namedColors[color];
+    } else {
+      return null;
+    }
+  }
+
+  if (color === defaultColor) {
+    return null;
+  }
+
+  return color;
+}
+
+/**
+ * Converts hex color format to rgb.
+ * Works well with full hex color format and shortcut as well.
+ *
+ * @param hex - hex color string (#xxx, or #xxxxxx)
+ */
+export function hexToRgb(color: string): string | null {
+  if (!isHex(color)) {
+    return null;
+  }
+
+  let colorBits = color.substring(1).split('');
+  if (colorBits.length === 3) {
+    colorBits = [
+      colorBits[0],
+      colorBits[0],
+      colorBits[1],
+      colorBits[1],
+      colorBits[2],
+      colorBits[2],
+    ];
+  }
+
+  const rgb = Number(`0x${colorBits.join('')}`);
+  // eslint-disable-next-line no-bitwise
+  return `rgb(${(rgb >> 16) & 255},${(rgb >> 8) & 255},${rgb & 255})`;
+}
+
+/**
+ * Converts hex color format to rgba.
+ *
+ * @param hex - hex color string (#xxx, or #xxxxxx)
+ */
+export function hexToRgba(rawColor: string, alpha: number): string | null {
+  let color = normalizeHexColor(rawColor);
+  if (!color) {
+    return null;
+  }
+  const hex2rgb = (color: string) =>
+    color.match(/[a-z0-9]{2}/gi)!.map((hex) => parseInt(hex, 16));
+  return `rgba(${hex2rgb(color).concat(alpha).join(',')})`;
+}
+
+export function rgbToHex(value: string): string | null {
+  const matches = value.match(/(0?\.?\d{1,3})%?\b/g);
+
+  if (matches && matches.length >= 3) {
+    const [red, green, blue] = matches.map(Number);
+    return (
+      '#' +
+      (blue | (green << 8) | (red << 16) | (1 << 24)).toString(16).slice(1) // eslint-disable-line no-bitwise
+    );
+  }
+
+  return null;
+}
+
+export function isRgb(color: string): boolean {
+  return /rgba?\(/.test(color);
+}
+
+export function isHex(color: string): boolean {
+  return /^#([A-Fa-f0-9]{3}){1,2}$/.test(color);
+}

package/src/utils/confluence/emoji.ts

@@ -0,0 +1,99 @@
+// Default emoji id for Confluence glyphs that has no match to Fabric Emoji
+const DEFAULT_EMOJI_ID = '2b50';
+
+// Default ac:name for emoticons as a fallback is `blue-star`
+const DEFAULT_EMOJI_ACNAME = 'blue-star';
+
+// ac:hipchat-emoticon prefix when converting to Emoji ID
+const HC_EMOTICON_PREFIX = 'atlassian-';
+
+/**
+ * Confluence glyphs ac:name of <ac:emoticon /> map to new emojis
+ * {
+ *   [ac:name] : ['emoji-id', 'emoji-shortName', 'emoji-fallback']
+ *   ...
+ * }
+ * Glyphs that do not map to Fabric Emoji
+ * will be mapped to Emoji Id '2b50' (:star:) with preserving ac:name as shortName attribute;
+ */
+const acNameToEmojiMap = {
+  smile: ['1f642', ':slight_smile:', '\uD83D\uDE42'],
+  sad: ['1f641', ':slight_frown:', '\uD83D\uDE41'],
+  cheeky: ['1f61b', ':stuck_out_tongue:', '\uD83D\uDE1B'],
+  laugh: ['1f600', ':grinning:', '\uD83D\uDE00'],
+  wink: ['1f609', ':wink:', '\uD83D\uDE09'],
+  information: ['2139', ':information_source:', '\u2139'],
+  tick: ['2705', ':white_check_mark:', '\u2705'],
+  cross: ['274c', ':x:', '\u274C'],
+  warning: ['26a0', ':warning:', '\u26A0'],
+  plus: ['2795', ':heavy_plus_sign:', '\u2795'],
+  minus: ['2796', ':heavy_minus_sign:', '\u2796'],
+  question: ['2753', ':question:', '\u003F'],
+  'thumbs-up': ['1f44d', ':thumbsup:', '\uD83D\uDC4D'],
+  'thumbs-down': ['1f44e', ':thumbsdown:', '\uD83D\uDC4E'],
+  'light-on': ['1f4a1', ':bulb:', '\uD83D\uDCA1'],
+  'yellow-star': ['2b50', ':star:', '\uD83D\uDC9B'],
+  'light-off': ['1f6ab', ':no_entry_sign:', '\uD83D\uDEAB'],
+  'red-star': ['2764', ':heart:', '\u2764\uFE0F'],
+  'green-star': ['1f49a', ':green_heart:', '\uD83D\uDC9A'],
+  'blue-star': ['1f499', ':blue_heart:', '\uD83D\uDC99'],
+  heart: ['2764', ':heart:', '\u2764\uFE0F'],
+  'broken-heart': ['1f494', ':broken_heart:', '\uD83D\uDC94'],
+};
+
+export type NameToEmoji = keyof typeof acNameToEmojiMap;
+
+export function acNameToEmoji(acName: NameToEmoji) {
+  const emojiData = acNameToEmojiMap[acName];
+  return emojiData
+    ? {
+        id: emojiData[0],
+        shortName: emojiData[1],
+        text: emojiData[2],
+      }
+    : {
+        id: DEFAULT_EMOJI_ID,
+        shortName: `:${acName}:`,
+        text: '',
+      };
+}
+
+export function emojiIdToAcName(emojiId: string) {
+  const filterEmojis = (acName: keyof typeof acNameToEmojiMap) =>
+    acNameToEmojiMap[acName] ? acNameToEmojiMap[acName][0] === emojiId : false;
+  return (
+    Object.keys(acNameToEmojiMap) as Array<keyof typeof acNameToEmoji>
+  ).filter(filterEmojis)[0];
+}
+
+export function acShortcutToEmoji(hipchatEmoticonShortName: string) {
+  return {
+    id: `${HC_EMOTICON_PREFIX}${hipchatEmoticonShortName}`,
+    shortName: `:${hipchatEmoticonShortName}:`,
+    text: '',
+  };
+}
+
+function getAcNameFromShortName(shortName: string) {
+  return shortName.slice(
+    shortName[0] === ':' ? 1 : 0,
+    shortName[shortName.length - 1] === ':' ? -1 : shortName.length,
+  );
+}
+
+export function getEmojiAcName({
+  id,
+  shortName,
+}: {
+  id: string;
+  shortName: string;
+}) {
+  if (DEFAULT_EMOJI_ID === id) {
+    const possibleName = getAcNameFromShortName(shortName);
+    if (possibleName in acNameToEmojiMap) {
+      return possibleName;
+    }
+  }
+
+  return emojiIdToAcName(id) || DEFAULT_EMOJI_ACNAME;
+}

package/src/utils/extensions.ts

@@ -0,0 +1,32 @@
+import { ExtensionAttributes, Layout } from '../schema/nodes/types/extensions';
+
+export const isValidLayout = (name: string | null): name is Layout => {
+  return !!name && ['default', 'wide', 'full-width'].includes(name);
+};
+
+export const getExtensionAttrs = (
+  dom: HTMLElement,
+  isInline: boolean = false,
+): ExtensionAttributes | false => {
+  const extensionType = dom.getAttribute('data-extension-type');
+  const extensionKey = dom.getAttribute('data-extension-key');
+
+  if (!extensionType || !extensionKey) {
+    return false;
+  }
+
+  const attrs: ExtensionAttributes = {
+    extensionType,
+    extensionKey,
+    text: dom.getAttribute('data-text') || undefined,
+    parameters: JSON.parse(dom.getAttribute('data-parameters') || '{}'),
+    localId: dom.getAttribute('data-local-id') || undefined,
+  };
+
+  if (!isInline) {
+    const rawLayout = dom.getAttribute('data-layout');
+    attrs.layout = isValidLayout(rawLayout) ? rawLayout : 'default';
+  }
+
+  return attrs;
+};

package/src/utils/index.ts

@@ -0,0 +1,69 @@
+export {
+  acNameToEmoji,
+  acShortcutToEmoji,
+  emojiIdToAcName,
+  getEmojiAcName,
+} from './confluence/emoji';
+export type { NameToEmoji } from './confluence/emoji';
+export { generateUuid, uuid } from './uuid';
+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,
+  hexToRgb,
+  hexToRgba,
+  isHex,
+  isRgb,
+  normalizeHexColor,
+  rgbToHex,
+} from './colors';
+export {
+  getLinkMatch,
+  isSafeUrl,
+  normalizeUrl,
+  linkify,
+  linkifyMatch,
+} from './url';
+export type { Match } from './url';

package/src/utils/parseDOM.ts

@@ -0,0 +1,2 @@
+export const isDOMElement = (maybeNode: unknown): maybeNode is Element =>
+  maybeNode instanceof Node && maybeNode.nodeType === Node.ELEMENT_NODE;

package/src/utils/url.ts

@@ -0,0 +1,173 @@
+/**
+ * This file has been partially duplicated in packages/linking-platform/linking-common/src/url.ts
+ * Any changes made here should be mirrored there.
+ * Ticket for dedeplication: https://product-fabric.atlassian.net/browse/EDM-7138
+ * Ticket for fixing linkification of filename-like urls: https://product-fabric.atlassian.net/browse/EDM-7190
+ */
+import LinkifyIt from 'linkify-it';
+
+const whitelistedURLPatterns = [
+  /^https?:\/\//im,
+  /^ftps?:\/\//im,
+  /^gopher:\/\//im,
+  /^integrity:\/\//im,
+  /^file:\/\//im,
+  /^smb:\/\//im,
+  /^dynamicsnav:\/\//im,
+  /^jamfselfservice:\/\//im,
+  /^\//im,
+  /^mailto:/im,
+  /^skype:/im,
+  /^callto:/im,
+  /^facetime:/im,
+  /^git:/im,
+  /^irc6?:/im,
+  /^news:/im,
+  /^nntp:/im,
+  /^feed:/im,
+  /^cvs:/im,
+  /^svn:/im,
+  /^mvn:/im,
+  /^ssh:/im,
+  /^scp:\/\//im,
+  /^sftp:\/\//im,
+  /^itms:/im,
+  // This is not a valid notes link, but we support this pattern for backwards compatibility
+  /^notes:/im,
+  /^notes:\/\//im,
+  /^hipchat:\/\//im,
+  // This is not a valid sourcetree link, but we support this pattern for backwards compatibility
+  /^sourcetree:/im,
+  /^sourcetree:\/\//im,
+  /^urn:/im,
+  /^tel:/im,
+  /^xmpp:/im,
+  /^telnet:/im,
+  /^vnc:/im,
+  /^rdp:/im,
+  /^whatsapp:/im,
+  /^slack:/im,
+  /^sips?:/im,
+  /^magnet:/im,
+  /^#/im,
+];
+
+/**
+ * Please notify the Editor Mobile team (Slack: #help-mobilekit) if the logic for this changes.
+ */
+export const isSafeUrl = (url: string): boolean => {
+  const urlTrimmed = url.trim();
+  if (urlTrimmed.length === 0) {
+    return true;
+  }
+  return whitelistedURLPatterns.some((p) => p.test(urlTrimmed));
+};
+
+export interface Match {
+  schema: any;
+  index: number;
+  lastIndex: number;
+  raw: string;
+  text: string;
+  url: string;
+  length?: number;
+  input?: string;
+}
+
+export const linkify = LinkifyIt();
+linkify.add('sourcetree:', 'http:');
+linkify.add('jamfselfservice:', 'http:');
+
+const urlWithoutSpacesValidator: LinkifyIt.Rule = {
+  validate: /[^\s]+/,
+};
+
+// `tel:` URI spec is https://datatracker.ietf.org/doc/html/rfc3966
+// We're not validating the phone number or separators - but if there's a space it definitely isn't a valid `tel:` URI
+linkify.add('tel:', urlWithoutSpacesValidator);
+
+// https://datatracker.ietf.org/doc/html/rfc8089
+linkify.add('file:', urlWithoutSpacesValidator);
+
+linkify.add('notes:', 'http:');
+
+const tlds =
+  'biz|com|edu|gov|net|org|pro|web|xxx|aero|asia|coop|info|museum|name|shop|рф'.split(
+    '|',
+  );
+const tlds2Char =
+  'a[cdefgilmnoqrtuwxz]|b[abdefghijmnorstvwyz]|c[acdfghiklmnoruvwxyz]|d[ejkmoz]|e[cegrstu]|f[ijkmor]|g[abdefghilmnpqrstuwy]|h[kmnrtu]|i[delmnoqrst]|j[emop]|k[eghimnprwyz]|l[abcikrstuvy]|m[acdeghklmnopqrtuvwxyz]|n[acefgilopruz]|om|p[aefghkmnrtw]|qa|r[eosuw]|s[abcdegijklmnrtuvxyz]|t[cdfghjklmnortvwz]|u[agksyz]|v[aceginu]|w[fs]|y[et]|z[amw]';
+tlds.push(tlds2Char);
+linkify.tlds(tlds, false);
+
+// linkify-it mishandles closing braces on long urls, so we preference using our own regex first:
+// https://product-fabric.atlassian.net/browse/ED-13669
+export const LINK_REGEXP =
+  /(https?|ftp|jamfselfservice|gopher|dynamicsnav|integrity|file|smb):\/\/[^\s]+/;
+
+/** Attempt to find a link match using a regex string defining a URL */
+export const linkifyMatch = (text: string): Match[] => {
+  if (!LINK_REGEXP.test(text)) {
+    return [];
+  }
+
+  const matches: Match[] = [];
+  let startpos = 0;
+  let substr;
+
+  while ((substr = text.substr(startpos))) {
+    const link = (substr.match(LINK_REGEXP) || [''])[0];
+    if (link) {
+      const index = substr.search(LINK_REGEXP);
+      const start = index >= 0 ? index + startpos : index;
+      const end = start + link.length;
+      matches.push({
+        index: start,
+        lastIndex: end,
+        raw: link,
+        url: link,
+        text: link,
+        schema: '',
+      });
+      startpos += end;
+    } else {
+      break;
+    }
+  }
+
+  return matches;
+};
+
+/**
+ * Attempt to find a link match. Tries to use our regex search first.
+ * If this doesn't match (e.g. no protocol), try using linkify-it library.
+ * Returns null if url string empty or no string given, or if no match found.
+ */
+export function getLinkMatch(str?: string): Match | null {
+  if (!str) {
+    return null;
+  }
+  // linkify-it mishandles closing braces on long urls, so we preference using our own regex first:
+  // https://product-fabric.atlassian.net/browse/ED-13669
+  let match: null | Match[] = linkifyMatch(str);
+  if (!match.length) {
+    match = linkify.match(str);
+  }
+  return match && match[0];
+}
+
+/**
+ * Adds protocol to url if needed.
+ * Returns empty string if no url given or if no link match found.
+ */
+export function normalizeUrl(url?: string) {
+  const match = getLinkMatch(url);
+  return (match && match.url) || '';
+}
+
+/**
+ * checks if root relative link
+ */
+export function isRootRelative(url: string) {
+  return url.startsWith('/');
+}

package/src/utils/uuid.ts

@@ -0,0 +1,19 @@
+/* eslint-disable no-bitwise */
+export const generateUuid = () =>
+  'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, (c) => {
+    const r = (Math.random() * 16) | 0;
+    return (c === 'x' ? r : (r & 0x3) | 0x8).toString(16);
+  });
+/* eslint-enable no-bitwise */
+
+let staticValue: string | false = false;
+
+export const uuid = {
+  setStatic(value: string | false) {
+    staticValue = value;
+  },
+
+  generate() {
+    return staticValue || generateUuid();
+  },
+};

package/src/version.json

@@ -0,0 +1,6 @@
+{
+	"name": "@atlaskit/adf-schema",
+	"version": "999.9.9",
+	"NOTE: THIS FILE": "IS ONLY USED IN DEVELOPMENT",
+	"BEFORE PUBLISH": "IT IS REGENERATED WITH ACTUAL VERSION INFO"
+}