feat: Added bootsrap utils full files - array and dom

woothu · woothu · commit f8867075aa2f · 2018-12-13T10:01:10.000+01:00
diff --git a/src/utils/array.js b/src/utils/array.js
@@ -1,5 +1,140 @@
+// Production steps of ECMA-262, Edition 6, 22.1.2.1
+// es6-ified by @alexsasharegan
+if (!Array.from) {
+  Array.from = (function () {
+    const toStr = Object.prototype.toString
+    const isCallable = fn => typeof fn === 'function' || toStr.call(fn) === '[object Function]'
+    const toInteger = value => {
+      const number = Number(value)
+      if (isNaN(number)) {
+        return 0
+      }
+      if (number === 0 || !isFinite(number)) {
+        return number
+      }
+      return (number > 0 ? 1 : -1) * Math.floor(Math.abs(number))
+    }
+    const maxSafeInteger = Math.pow(2, 53) - 1
+    const toLength = value => Math.min(Math.max(toInteger(value), 0), maxSafeInteger)
+
+    // The length property of the from method is 1.
+    return function from (arrayLike /*, mapFn, thisArg */) {
+      // 1. Let C be the this value.
+      const C = this
+
+      // 2. Let items be ToObject(arrayLike).
+      const items = Object(arrayLike)
+
+      // 3. ReturnIfAbrupt(items).
+      if (arrayLike == null) {
+        throw new TypeError('Array.from requires an array-like object - not null or undefined')
+      }
+
+      // 4. If mapfn is undefined, then let mapping be false.
+      const mapFn = arguments.length > 1 ? arguments[1] : void undefined
+      let T
+
+      if (typeof mapFn !== 'undefined') {
+        // 5. else
+        // 5. a If IsCallable(mapfn) is false, throw a TypeError exception.
+        if (!isCallable(mapFn)) {
+          throw new TypeError('Array.from: when provided, the second argument must be a function')
+        }
+
+        // 5. b. If thisArg was supplied, let T be thisArg; else let T be undefined.
+        if (arguments.length > 2) {
+          T = arguments[2]
+        }
+      }
+
+      // 10. Let lenValue be Get(items, "length").
+      // 11. Let len be ToLength(lenValue).
+      const len = toLength(items.length)
+
+      // 13. If IsConstructor(C) is true, then
+      // 13. a. Let A be the result of calling the [[Construct]] internal method
+      // of C with an argument list containing the single item len.
+      // 14. a. Else, Let A be ArrayCreate(len).
+      let A = isCallable(C) ? Object(new C(len)) : new Array(len)
+
+      // 16. Let k be 0.
+      let k = 0
+      // 17. Repeat, while k < len… (also steps a - h)
+      let kValue
+      while (k < len) {
+        kValue = items[k]
+        if (mapFn) {
+          A[k] = typeof T === 'undefined' ? mapFn(kValue, k) : mapFn.call(T, kValue, k)
+        } else {
+          A[k] = kValue
+        }
+        k += 1
+      }
+      // 18. Let putStatus be Put(A, "length", len, true).
+      A.length = len
+      // 20. Return A.
+      return A
+    }
+  })()
+}
+
+// https://tc39.github.io/ecma262/#sec-array.prototype.find
+// Needed for IE support
+if (!Array.prototype.find) {
+  // eslint-disable-next-line no-extend-native
+  Object.defineProperty(Array.prototype, 'find', {
+    value: function (predicate) {
+      // 1. Let O be ? ToObject(this value).
+      if (this == null) {
+        throw new TypeError('"this" is null or not defined')
+      }
+
+      const o = Object(this)
+
+      // 2. Let len be ? ToLength(? Get(O, "length")).
+      const len = o.length >>> 0
+
+      // 3. If IsCallable(predicate) is false, throw a TypeError exception.
+      if (typeof predicate !== 'function') {
+        throw new TypeError('predicate must be a function')
+      }
+
+      // 4. If thisArg was supplied, let T be thisArg; else let T be undefined.
+      const thisArg = arguments[1]
+
+      // 5. Let k be 0.
+      let k = 0
+
+      // 6. Repeat, while k < len
+      while (k < len) {
+        // a. Let Pk be ! ToString(k).
+        // b. Let kValue be ? Get(O, Pk).
+        // c. Let testResult be ToBoolean(? Call(predicate, T, « kValue, k, O »)).
+        // d. If testResult is true, return kValue.
+        const kValue = o[k]
+        if (predicate.call(thisArg, kValue, k, o)) {
+          return kValue
+        }
+        // e. Increase k by 1.
+        k++
+      }
+
+      // 7. Return undefined.
+      return undefined
+    }
+  })
+}
+
+if (!Array.isArray) {
+  Array.isArray = arg => Object.prototype.toString.call(arg) === '[object Array]'
+}
+
+// Static
+export const from = Array.from
+export const isArray = Array.isArray
+
+// Instance
 export const arrayIncludes = (array, value) => array.indexOf(value) !== -1
 export function concat () {
   return Array.prototype.concat.apply([], arguments)
 }
-export const isArray = Array.isArray
diff --git a/src/utils/dom.js b/src/utils/dom.js
@@ -1,11 +1,246 @@
+import { from as arrayFrom } from './array'
+
+// Determine if an element is an HTML Element
+export const isElement = el => {
+  return el && el.nodeType === Node.ELEMENT_NODE
+}
+
+// Determine if an HTML element is visible - Faster than CSS check
+export const isVisible = el => {
+  /* istanbul ignore next: getBoundingClientRect not avaiable in JSDOM */
+  return isElement(el) &&
+           document.body.contains(el) &&
+           el.getBoundingClientRect().height > 0 &&
+           el.getBoundingClientRect().width > 0
+}
+
+// Determine if an element is disabled
+export const isDisabled = el => {
+  return !isElement(el) ||
+           el.disabled ||
+           el.classList.contains('disabled') ||
+           Boolean(el.getAttribute('disabled'))
+}
+
+// Cause/wait-for an element to reflow it's content (adjusting it's height/width)
+export const reflow = el => {
+  // requsting an elements offsetHight will trigger a reflow of the element content
+  /* istanbul ignore next: reflow doesnt happen in JSDOM */
+  return isElement(el) && el.offsetHeight
+}
+
+// Select all elements matching selector. Returns [] if none found
+export const selectAll = (selector, root) => {
+  if (!isElement(root)) {
+    root = document
+  }
+  return arrayFrom(root.querySelectorAll(selector))
+}
+
+// Select a single element, returns null if not found
+export const select = (selector, root) => {
+  if (!isElement(root)) {
+    root = document
+  }
+  return root.querySelector(selector) || null
+}
+
+// Determine if an element matches a selector
+export const matches = (el, selector) => {
+  if (!isElement(el)) {
+    return false
+  }
+
+  // https://developer.mozilla.org/en-US/docs/Web/API/Element/matches#Polyfill
+  // Prefer native implementations over polyfill function
+  const proto = Element.prototype
+  /* istanbul ignore next */
+  const Matches = proto.matches ||
+        proto.matchesSelector ||
+        proto.mozMatchesSelector ||
+        proto.msMatchesSelector ||
+        proto.oMatchesSelector ||
+        proto.webkitMatchesSelector ||
+        function (sel) /* istanbul ignore next */ {
+          const element = this
+          const m = selectAll(sel, element.document || element.ownerDocument)
+          let i = m.length
+          // eslint-disable-next-line no-empty
+          while (--i >= 0 && m.item(i) !== element) {}
+          return i > -1
+        }
+
+  return Matches.call(el, selector)
+}
+
+// Finds closest element matching selector. Returns null if not found
+export const closest = (selector, root) => {
+  if (!isElement(root)) {
+    return null
+  }
+
+  // https://developer.mozilla.org/en-US/docs/Web/API/Element/closest
+  // Since we dont support IE < 10, we can use the "Matches" version of the polyfill for speed
+  // Prefer native implementation over polyfill function
+  /* istanbul ignore next */
+  const Closest = Element.prototype.closest ||
+                  function (sel) {
+                    let element = this
+                    if (!document.documentElement.contains(element)) {
+                      return null
+                    }
+                    do {
+                      // Use our "patched" matches function
+                      if (matches(element, sel)) {
+                        return element
+                      }
+                      element = element.parentElement
+                    } while (element !== null)
+                    return null
+                  }
+
+  const el = Closest.call(root, selector)
+  // Emulate jQuery closest and return null if match is the passed in element (root)
+  return el === root ? null : el
+}
+
+// Returns true if the parent element contains the child element
+export const contains = (parent, child) => {
+  if (!parent || typeof parent.contains !== 'function') {
+    return false
+  }
+  return parent.contains(child)
+}
+
+// Get an element given an ID
+export const getById = id => {
+  return document.getElementById(/^#/.test(id) ? id.slice(1) : id) || null
+}
+
+// Add a class to an element
 export const addClass = (el, className) => {
   if (className && isElement(el)) {
     el.classList.add(className)
   }
 }
 
+// Remove a class from an element
 export const removeClass = (el, className) => {
   if (className && isElement(el)) {
     el.classList.remove(className)
   }
 }
+
+// Test if an element has a class
+export const hasClass = (el, className) => {
+  if (className && isElement(el)) {
+    return el.classList.contains(className)
+  }
+  return false
+}
+
+// Set an attribute on an element
+export const setAttr = (el, attr, value) => {
+  if (attr && isElement(el)) {
+    el.setAttribute(attr, value)
+  }
+}
+
+// Remove an attribute from an element
+export const removeAttr = (el, attr) => {
+  if (attr && isElement(el)) {
+    el.removeAttribute(attr)
+  }
+}
+
+// Get an attribute value from an element (returns null if not found)
+export const getAttr = (el, attr) => {
+  if (attr && isElement(el)) {
+    return el.getAttribute(attr)
+  }
+  return null
+}
+
+// Determine if an attribute exists on an element (returns true or false, or null if element not found)
+export const hasAttr = (el, attr) => {
+  if (attr && isElement(el)) {
+    return el.hasAttribute(attr)
+  }
+  return null
+}
+
+// Return the Bounding Client Rec of an element. Retruns null if not an element
+/* istanbul ignore next: getBoundingClientRect() doesnt work in JSDOM */
+export const getBCR = el => {
+  return isElement(el) ? el.getBoundingClientRect() : null
+}
+
+// Get computed style object for an element
+/* istanbul ignore next: getComputedStyle() doesnt work in JSDOM */
+export const getCS = el => {
+  return isElement(el) ? window.getComputedStyle(el) : {}
+}
+
+// Return an element's offset wrt document element
+// https://j11y.io/jquery/#v=git&fn=jQuery.fn.offset
+/* istanbul ignore next: getBoundingClientRect(), getClientRects() doesnt work in JSDOM */
+export const offset = el => {
+  if (isElement(el)) {
+    if (!el.getClientRects().length) {
+      return { top: 0, left: 0 }
+    }
+    const bcr = getBCR(el)
+    const win = el.ownerDocument.defaultView
+    return {
+      top: bcr.top + win.pageYOffset,
+      left: bcr.left + win.pageXOffset
+    }
+  }
+}
+
+// Return an element's offset wrt to it's offsetParent
+// https://j11y.io/jquery/#v=git&fn=jQuery.fn.position
+/* istanbul ignore next: getBoundingClientRect(), getClientRects() doesnt work in JSDOM */
+export const position = el => {
+  if (!isElement(el)) {
+    return
+  }
+  let parentOffset = { top: 0, left: 0 }
+  let offsetSelf
+  let offsetParent
+  if (getCS(el).position === 'fixed') {
+    offsetSelf = getBCR(el)
+  } else {
+    offsetSelf = offset(el)
+    const doc = el.ownerDocument
+    offsetParent = el.offsetParent || doc.documentElement
+    while (offsetParent &&
+                (offsetParent === doc.body || offsetParent === doc.documentElement) &&
+                getCS(offsetParent).position === 'static') {
+      offsetParent = offsetParent.parentNode
+    }
+    if (offsetParent && offsetParent !== el && offsetParent.nodeType === Node.ELEMENT_NODE) {
+      parentOffset = offset(offsetParent)
+      parentOffset.top += parseFloat(getCS(offsetParent).borderTopWidth)
+      parentOffset.left += parseFloat(getCS(offsetParent).borderLeftWidth)
+    }
+  }
+  return {
+    top: offsetSelf.top - parentOffset.top - parseFloat(getCS(el).marginTop),
+    left: offsetSelf.left - parentOffset.left - parseFloat(getCS(el).marginLeft)
+  }
+}
+
+// Attach an event listener to an element
+export const eventOn = (el, evtName, handler, options) => {
+  if (el && el.addEventListener) {
+    el.addEventListener(evtName, handler, options)
+  }
+}
+
+// Remove an event listener from an element
+export const eventOff = (el, evtName, handler, options) => {
+  if (el && el.removeEventListener) {
+    el.removeEventListener(evtName, handler, options)
+  }
+}
