jekyll-rubin-collab-theme 0.1.0 → 0.1.1

data/_third_party/mdb-ui-kit/src/js/mdb/util/focusTrap.js

@@ -0,0 +1,97 @@
+import SelectorEngine from '../dom/selector-engine';
+import { isVisible } from './index';
+
+class FocusTrap {
+  constructor(element, options = {}, toggler) {
+    this._element = element;
+    this._toggler = toggler;
+    this._event = options.event || 'blur';
+    this._condition = options.condition || (() => true);
+    this._selector =
+      options.selector || 'button, a, input, select, textarea, [tabindex]:not([tabindex="-1"])';
+    this._onlyVisible = options.onlyVisible || false;
+    this._focusableElements = [];
+    this._firstElement = null;
+    this._lastElement = null;
+
+    this.handler = (e) => {
+      if (this._condition(e) && e.target === this._lastElement) {
+        e.preventDefault();
+        this._firstElement.focus();
+      }
+    };
+  }
+
+  trap() {
+    this._setElements();
+    this._init();
+    this._setFocusTrap();
+  }
+
+  disable() {
+    this._focusableElements.forEach((element) => {
+      element.removeEventListener(this._event, this.handler);
+    });
+
+    if (this._toggler) {
+      this._toggler.focus();
+    }
+  }
+
+  update() {
+    this._setElements();
+    this._setFocusTrap();
+  }
+
+  _init() {
+    const handler = (e) => {
+      if (!this._firstElement || e.key !== 'Tab' || this._focusableElements.includes(e.target)) {
+        return;
+      }
+
+      e.preventDefault();
+      this._firstElement.focus();
+
+      window.removeEventListener('keydown', handler);
+    };
+
+    window.addEventListener('keydown', handler);
+  }
+
+  _filterVisible(elements) {
+    return elements.filter((el) => {
+      if (!isVisible(el)) return false;
+
+      const ancestors = SelectorEngine.parents(el, '*');
+
+      for (let i = 0; i < ancestors.length; i++) {
+        const style = window.getComputedStyle(ancestors[i]);
+        if (style && (style.display === 'none' || style.visibility === 'hidden')) return false;
+      }
+      return true;
+    });
+  }
+
+  _setElements() {
+    this._focusableElements = SelectorEngine.find(this._selector, this._element);
+
+    if (this._onlyVisible) {
+      this._focusableElements = this._filterVisible(this._focusableElements);
+    }
+
+    this._firstElement = this._focusableElements[0];
+    this._lastElement = this._focusableElements[this._focusableElements.length - 1];
+  }
+
+  _setFocusTrap() {
+    this._focusableElements.forEach((element, i) => {
+      if (i === this._focusableElements.length - 1) {
+        element.addEventListener(this._event, this.handler);
+      } else {
+        element.removeEventListener(this._event, this.handler);
+      }
+    });
+  }
+}
+
+export default FocusTrap;

data/_third_party/mdb-ui-kit/src/js/mdb/util/index.js

@@ -0,0 +1,242 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.0.0-beta2): util/index.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+const MAX_UID = 1000000;
+const MILLISECONDS_MULTIPLIER = 1000;
+const TRANSITION_END = 'transitionend';
+
+// Shoutout AngusCroll (https://goo.gl/pxwQGp)
+const toType = (obj) => {
+  if (obj === null || obj === undefined) {
+    return `${obj}`;
+  }
+
+  return {}.toString
+    .call(obj)
+    .match(/\s([a-z]+)/i)[1]
+    .toLowerCase();
+};
+
+/**
+ * --------------------------------------------------------------------------
+ * Public Util Api
+ * --------------------------------------------------------------------------
+ */
+
+const getUID = (prefix) => {
+  do {
+    prefix += Math.floor(Math.random() * MAX_UID);
+  } while (document.getElementById(prefix));
+
+  return prefix;
+};
+
+const getSelector = (element) => {
+  let selector = element.getAttribute('data-mdb-target');
+
+  if (!selector || selector === '#') {
+    const hrefAttr = element.getAttribute('href');
+
+    selector = hrefAttr && hrefAttr !== '#' ? hrefAttr.trim() : null;
+  }
+
+  return selector;
+};
+
+const getSelectorFromElement = (element) => {
+  const selector = getSelector(element);
+
+  if (selector) {
+    return document.querySelector(selector) ? selector : null;
+  }
+
+  return null;
+};
+
+const getElementFromSelector = (element) => {
+  const selector = getSelector(element);
+
+  return selector ? document.querySelector(selector) : null;
+};
+
+const getTransitionDurationFromElement = (element) => {
+  if (!element) {
+    return 0;
+  }
+
+  // Get transition-duration of the element
+  let { transitionDuration, transitionDelay } = window.getComputedStyle(element);
+
+  const floatTransitionDuration = Number.parseFloat(transitionDuration);
+  const floatTransitionDelay = Number.parseFloat(transitionDelay);
+
+  // Return 0 if element or transition duration is not found
+  if (!floatTransitionDuration && !floatTransitionDelay) {
+    return 0;
+  }
+
+  // If multiple durations are defined, take the first
+  transitionDuration = transitionDuration.split(',')[0];
+  transitionDelay = transitionDelay.split(',')[0];
+
+  return (
+    (Number.parseFloat(transitionDuration) + Number.parseFloat(transitionDelay)) *
+    MILLISECONDS_MULTIPLIER
+  );
+};
+
+const triggerTransitionEnd = (element) => {
+  element.dispatchEvent(new Event(TRANSITION_END));
+};
+
+const isElement = (obj) => (obj[0] || obj).nodeType;
+
+const emulateTransitionEnd = (element, duration) => {
+  let called = false;
+  const durationPadding = 5;
+  const emulatedDuration = duration + durationPadding;
+
+  function listener() {
+    called = true;
+    element.removeEventListener(TRANSITION_END, listener);
+  }
+
+  element.addEventListener(TRANSITION_END, listener);
+  setTimeout(() => {
+    if (!called) {
+      triggerTransitionEnd(element);
+    }
+  }, emulatedDuration);
+};
+
+const typeCheckConfig = (componentName, config, configTypes) => {
+  Object.keys(configTypes).forEach((property) => {
+    const expectedTypes = configTypes[property];
+    const value = config[property];
+    const valueType = value && isElement(value) ? 'element' : toType(value);
+
+    if (!new RegExp(expectedTypes).test(valueType)) {
+      throw new Error(
+        `${componentName.toUpperCase()}: ` +
+          `Option "${property}" provided type "${valueType}" ` +
+          `but expected type "${expectedTypes}".`
+      );
+    }
+  });
+};
+
+const isVisible = (element) => {
+  if (!element) {
+    return false;
+  }
+
+  if (element.style && element.parentNode && element.parentNode.style) {
+    const elementStyle = getComputedStyle(element);
+    const parentNodeStyle = getComputedStyle(element.parentNode);
+
+    return (
+      elementStyle.display !== 'none' &&
+      parentNodeStyle.display !== 'none' &&
+      elementStyle.visibility !== 'hidden'
+    );
+  }
+
+  return false;
+};
+
+const findShadowRoot = (element) => {
+  if (!document.documentElement.attachShadow) {
+    return null;
+  }
+
+  // Can find the shadow root otherwise it'll return the document
+  if (typeof element.getRootNode === 'function') {
+    const root = element.getRootNode();
+    return root instanceof ShadowRoot ? root : null;
+  }
+
+  if (element instanceof ShadowRoot) {
+    return element;
+  }
+
+  // when we don't find a shadow root
+  if (!element.parentNode) {
+    return null;
+  }
+
+  return findShadowRoot(element.parentNode);
+};
+
+const noop = () => function () {};
+
+const reflow = (element) => element.offsetHeight;
+
+const getjQuery = () => {
+  const { jQuery } = window;
+
+  if (jQuery && !document.body.hasAttribute('data-mdb-no-jquery')) {
+    return jQuery;
+  }
+
+  return null;
+};
+
+const onDOMContentLoaded = (callback) => {
+  if (document.readyState === 'loading') {
+    document.addEventListener('DOMContentLoaded', callback);
+  } else {
+    callback();
+  }
+};
+
+const isRTL = document.documentElement.dir === 'rtl';
+
+const array = (collection) => {
+  return Array.from(collection);
+};
+
+const element = (tag) => {
+  return document.createElement(tag);
+};
+
+const defineJQueryPlugin = (name, plugin) => {
+  onDOMContentLoaded(() => {
+    const $ = getjQuery();
+    /* istanbul ignore if */
+    if ($) {
+      const JQUERY_NO_CONFLICT = $.fn[name];
+      $.fn[name] = plugin.jQueryInterface;
+      $.fn[name].Constructor = plugin;
+      $.fn[name].noConflict = () => {
+        $.fn[name] = JQUERY_NO_CONFLICT;
+        return plugin.jQueryInterface;
+      };
+    }
+  });
+};
+
+export {
+  getjQuery,
+  TRANSITION_END,
+  getUID,
+  getSelectorFromElement,
+  getElementFromSelector,
+  getTransitionDurationFromElement,
+  triggerTransitionEnd,
+  isElement,
+  emulateTransitionEnd,
+  typeCheckConfig,
+  isVisible,
+  findShadowRoot,
+  noop,
+  reflow,
+  array,
+  element,
+  onDOMContentLoaded,
+  isRTL,
+  defineJQueryPlugin,
+};

data/_third_party/mdb-ui-kit/src/js/mdb/util/keycodes.js

@@ -0,0 +1,40 @@
+export const LEFT_ARROW = 37;
+export const UP_ARROW = 38;
+export const RIGHT_ARROW = 39;
+export const DOWN_ARROW = 40;
+export const HOME = 36;
+export const END = 35;
+export const PAGE_UP = 33;
+export const PAGE_DOWN = 34;
+export const ENTER = 13;
+export const SPACE = 32;
+export const ESCAPE = 27;
+export const TAB = 9;
+export const BACKSPACE = 8;
+export const DELETE = 46;
+export const A = 65;
+export const B = 66;
+export const C = 67;
+export const D = 68;
+export const E = 69;
+export const F = 70;
+export const G = 71;
+export const H = 72;
+export const I = 73;
+export const J = 74;
+export const K = 75;
+export const L = 76;
+export const M = 77;
+export const N = 78;
+export const O = 79;
+export const P = 80;
+export const Q = 81;
+export const R = 82;
+export const S = 83;
+export const T = 84;
+export const U = 85;
+export const V = 86;
+export const W = 87;
+export const X = 88;
+export const Y = 89;
+export const Z = 90;

data/_third_party/mdb-ui-kit/src/js/mdb/util/sanitizer.js

@@ -0,0 +1,130 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.0.0-beta2): util/sanitizer.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/master/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+const uriAttrs = new Set([
+  'background',
+  'cite',
+  'href',
+  'itemtype',
+  'longdesc',
+  'poster',
+  'src',
+  'xlink:href',
+]);
+
+const ARIA_ATTRIBUTE_PATTERN = /^aria-[\w-]*$/i;
+
+/**
+ * A pattern that recognizes a commonly useful subset of URLs that are safe.
+ *
+ * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
+ */
+const SAFE_URL_PATTERN = /^(?:(?:https?|mailto|ftp|tel|file):|[^#&/:?]*(?:[#/?]|$))/gi;
+
+/**
+ * A pattern that matches safe data URLs. Only matches image, video and audio types.
+ *
+ * Shoutout to Angular 7 https://github.com/angular/angular/blob/7.2.4/packages/core/src/sanitization/url_sanitizer.ts
+ */
+const DATA_URL_PATTERN =
+  /^data:(?:image\/(?:bmp|gif|jpeg|jpg|png|tiff|webp)|video\/(?:mpeg|mp4|ogg|webm)|audio\/(?:mp3|oga|ogg|opus));base64,[\d+/a-z]+=*$/i;
+
+const allowedAttribute = (attr, allowedAttributeList) => {
+  const attrName = attr.nodeName.toLowerCase();
+
+  if (allowedAttributeList.includes(attrName)) {
+    if (uriAttrs.has(attrName)) {
+      return Boolean(
+        attr.nodeValue.match(SAFE_URL_PATTERN) || attr.nodeValue.match(DATA_URL_PATTERN)
+      );
+    }
+
+    return true;
+  }
+
+  const regExp = allowedAttributeList.filter((attrRegex) => attrRegex instanceof RegExp);
+
+  // Check if a regular expression validates the attribute.
+  for (let i = 0, len = regExp.length; i < len; i++) {
+    if (regExp[i].test(attrName)) {
+      return true;
+    }
+  }
+
+  return false;
+};
+
+export const DefaultWhitelist = {
+  // Global attributes allowed on any supplied element below.
+  '*': ['class', 'dir', 'id', 'lang', 'role', ARIA_ATTRIBUTE_PATTERN],
+  a: ['target', 'href', 'title', 'rel'],
+  area: [],
+  b: [],
+  br: [],
+  col: [],
+  code: [],
+  div: [],
+  em: [],
+  hr: [],
+  h1: [],
+  h2: [],
+  h3: [],
+  h4: [],
+  h5: [],
+  h6: [],
+  i: [],
+  img: ['src', 'srcset', 'alt', 'title', 'width', 'height'],
+  li: [],
+  ol: [],
+  p: [],
+  pre: [],
+  s: [],
+  small: [],
+  span: [],
+  sub: [],
+  sup: [],
+  strong: [],
+  u: [],
+  ul: [],
+};
+
+export function sanitizeHtml(unsafeHtml, whiteList, sanitizeFn) {
+  if (!unsafeHtml.length) {
+    return unsafeHtml;
+  }
+
+  if (sanitizeFn && typeof sanitizeFn === 'function') {
+    return sanitizeFn(unsafeHtml);
+  }
+
+  const domParser = new window.DOMParser();
+  const createdDocument = domParser.parseFromString(unsafeHtml, 'text/html');
+  const whitelistKeys = Object.keys(whiteList);
+  const elements = [].concat(...createdDocument.body.querySelectorAll('*'));
+
+  for (let i = 0, len = elements.length; i < len; i++) {
+    const el = elements[i];
+    const elName = el.nodeName.toLowerCase();
+
+    if (whitelistKeys.indexOf(elName) === -1) {
+      el.parentNode.removeChild(el);
+
+      continue;
+    }
+
+    const attributeList = [].concat(...el.attributes);
+    const whitelistedAttributes = [].concat(whiteList['*'] || [], whiteList[elName] || []);
+
+    attributeList.forEach((attr) => {
+      if (!allowedAttribute(attr, whitelistedAttributes)) {
+        el.removeAttribute(attr.nodeName);
+      }
+    });
+  }
+
+  return createdDocument.body.innerHTML;
+}

data/_third_party/mdb-ui-kit/src/js/mdb/util/scrollbar.js

@@ -0,0 +1,83 @@
+/**
+ * --------------------------------------------------------------------------
+ * Bootstrap (v5.0.0): util/scrollBar.js
+ * Licensed under MIT (https://github.com/twbs/bootstrap/blob/main/LICENSE)
+ * --------------------------------------------------------------------------
+ */
+
+import SelectorEngine from '../dom/selector-engine';
+import Manipulator from '../dom/manipulator';
+
+const SELECTOR_FIXED_CONTENT = '.fixed-top, .fixed-bottom, .is-fixed, .sticky-top';
+const SELECTOR_STICKY_CONTENT = '.sticky-top';
+
+const getWidth = () => {
+  // https://developer.mozilla.org/en-US/docs/Web/API/Window/innerWidth#usage_notes
+  const documentWidth = document.documentElement.clientWidth;
+  return Math.abs(window.innerWidth - documentWidth);
+};
+
+const hide = (width = getWidth()) => {
+  _disableOverFlow();
+  // give padding to element to balances the hidden scrollbar width
+  _setElementAttributes('body', 'paddingRight', (calculatedValue) => calculatedValue + width);
+  // trick: We adjust positive paddingRight and negative marginRight to sticky-top elements, to keep shown fullwidth
+  _setElementAttributes(
+    SELECTOR_FIXED_CONTENT,
+    'paddingRight',
+    (calculatedValue) => calculatedValue + width
+  );
+  _setElementAttributes(
+    SELECTOR_STICKY_CONTENT,
+    'marginRight',
+    (calculatedValue) => calculatedValue - width
+  );
+};
+
+const _disableOverFlow = () => {
+  const actualValue = document.body.style.overflow;
+  if (actualValue) {
+    Manipulator.setDataAttribute(document.body, 'overflow', actualValue);
+  }
+
+  document.body.style.overflow = 'hidden';
+};
+
+const _setElementAttributes = (selector, styleProp, callback) => {
+  const scrollbarWidth = getWidth();
+  SelectorEngine.find(selector).forEach((element) => {
+    if (element !== document.body && window.innerWidth > element.clientWidth + scrollbarWidth) {
+      return;
+    }
+
+    const actualValue = element.style[styleProp];
+    const calculatedValue = window.getComputedStyle(element)[styleProp];
+    Manipulator.setDataAttribute(element, styleProp, actualValue);
+    element.style[styleProp] = `${callback(Number.parseFloat(calculatedValue))}px`;
+  });
+};
+
+const reset = () => {
+  _resetElementAttributes('body', 'overflow');
+  _resetElementAttributes('body', 'paddingRight');
+  _resetElementAttributes(SELECTOR_FIXED_CONTENT, 'paddingRight');
+  _resetElementAttributes(SELECTOR_STICKY_CONTENT, 'marginRight');
+};
+
+const _resetElementAttributes = (selector, styleProp) => {
+  SelectorEngine.find(selector).forEach((element) => {
+    const value = Manipulator.getDataAttribute(element, styleProp);
+    if (typeof value === 'undefined') {
+      element.style.removeProperty(styleProp);
+    } else {
+      Manipulator.removeDataAttribute(element, styleProp);
+      element.style[styleProp] = value;
+    }
+  });
+};
+
+const isBodyOverflowing = () => {
+  return getWidth() > 0;
+};
+
+export { getWidth, hide, isBodyOverflowing, reset };

data/_third_party/mdb-ui-kit/src/js/mdb/util/stack.js

@@ -0,0 +1,105 @@
+import SelectorEngine from '../dom/selector-engine';
+import { isVisible, typeCheckConfig } from './index';
+
+const NAME = 'Stack';
+
+const DEFAULT_OPTIONS = {
+  position: 'top',
+  container: null,
+  refresh: 1000,
+  filter: (el) => {
+    return el;
+  },
+};
+
+const TYPE_OPTIONS = {
+  position: 'string',
+  container: '(undefined|null|string)',
+  refresh: 'number',
+  filter: 'function',
+};
+
+class Stack {
+  constructor(element, selector, options) {
+    this._element = element;
+    this._selector = selector;
+    this._options = this._getConfig(options);
+
+    this._offset = null;
+
+    if (this._options.container) {
+      this._parent = SelectorEngine.findOne(this._options.container);
+    }
+  }
+
+  get stackableElements() {
+    return SelectorEngine.find(this._selector)
+      .filter((el, i) => this._options.filter(el, i))
+      .map((el) => ({ el, rect: el.getBoundingClientRect() }))
+      .filter(({ el, rect }) => {
+        const basicCondition = el !== this._element && isVisible(el);
+        if (this._offset === null) {
+          return basicCondition;
+        }
+
+        return basicCondition && this._getBoundryOffset(rect) < this._offset;
+      })
+      .sort((a, b) => {
+        return this._getBoundryOffset(b.rect) - this._getBoundryOffset(a.rect);
+      });
+  }
+
+  get nextElements() {
+    return SelectorEngine.find(this._selector)
+      .filter((el) => el !== this._element)
+      .filter((el, i) => this._options.filter(el, i))
+      .filter((el) => {
+        this._offset = null;
+        return this._getBoundryOffset(el.getBoundingClientRect()) > this._offset;
+      });
+  }
+
+  _getConfig(options) {
+    const config = {
+      ...DEFAULT_OPTIONS,
+      ...options,
+    };
+
+    typeCheckConfig(NAME, config, TYPE_OPTIONS);
+
+    return config;
+  }
+
+  _getBoundryOffset(rect) {
+    const { position } = this._options;
+
+    let parentTopOffset = 0;
+    let parentBottomBoundry = window.innerHeight;
+
+    if (this._parent) {
+      const parentRect = this._parent.getBoundingClientRect();
+
+      parentTopOffset = parentRect.top;
+      parentBottomBoundry = parentRect.bottom;
+    }
+
+    if (position === 'top') {
+      return rect.top - parentTopOffset;
+    }
+    return parentBottomBoundry - rect.bottom;
+  }
+
+  calculateOffset() {
+    const [previousElement] = this.stackableElements;
+
+    if (!previousElement) {
+      this._offset = 0;
+    } else {
+      this._offset = this._getBoundryOffset(previousElement.rect) + previousElement.rect.height;
+    }
+
+    return this._offset;
+  }
+}
+
+export default Stack;