npm - @onereach/ui-components - Versions diffs - 8.4.0-beta.3653.0 → 8.4.0 - Mend

@onereach/ui-components 8.4.0-beta.3653.0 → 8.4.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (1795) hide show

package/dist/bundled/v3/dom-cec392f3.js ADDED Viewed

@@ -0,0 +1,260 @@
+import { c as _baseGetTag, b as isObjectLike_1 } from './isObject-b7415fc1.js';
+import { d as _overArg, g as get_1 } from './get-34aa21f4.js';
+var overArg = _overArg;
+/** Built-in value references. */
+var getPrototype$1 = overArg(Object.getPrototypeOf, Object);
+var _getPrototype = getPrototype$1;
+var baseGetTag = _baseGetTag,
+  getPrototype = _getPrototype,
+  isObjectLike$1 = isObjectLike_1;
+/** `Object#toString` result references. */
+var objectTag = '[object Object]';
+/** Used for built-in method references. */
+var funcProto = Function.prototype,
+  objectProto = Object.prototype;
+/** Used to resolve the decompiled source of functions. */
+var funcToString = funcProto.toString;
+/** Used to check objects for own properties. */
+var hasOwnProperty = objectProto.hasOwnProperty;
+/** Used to infer the `Object` constructor. */
+var objectCtorString = funcToString.call(Object);
+/**
+ * Checks if `value` is a plain object, that is, an object created by the
+ * `Object` constructor or one with a `[[Prototype]]` of `null`.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.8.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a plain object, else `false`.
+ * @example
+ *
+ * function Foo() {
+ *   this.a = 1;
+ * }
+ *
+ * _.isPlainObject(new Foo);
+ * // => false
+ *
+ * _.isPlainObject([1, 2, 3]);
+ * // => false
+ *
+ * _.isPlainObject({ 'x': 0, 'y': 0 });
+ * // => true
+ *
+ * _.isPlainObject(Object.create(null));
+ * // => true
+ */
+function isPlainObject$1(value) {
+  if (!isObjectLike$1(value) || baseGetTag(value) != objectTag) {
+    return false;
+  }
+  var proto = getPrototype(value);
+  if (proto === null) {
+    return true;
+  }
+  var Ctor = hasOwnProperty.call(proto, 'constructor') && proto.constructor;
+  return typeof Ctor == 'function' && Ctor instanceof Ctor && funcToString.call(Ctor) == objectCtorString;
+}
+var isPlainObject_1 = isPlainObject$1;
+var isObjectLike = isObjectLike_1,
+  isPlainObject = isPlainObject_1;
+/**
+ * Checks if `value` is likely a DOM element.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a DOM element, else `false`.
+ * @example
+ *
+ * _.isElement(document.body);
+ * // => true
+ *
+ * _.isElement('<body>');
+ * // => false
+ */
+function isElement(value) {
+  return isObjectLike(value) && value.nodeType === 1 && !isPlainObject(value);
+}
+var isElement_1 = isElement;
+const WINDOW = typeof window !== 'undefined' ? window : null;
+const MutationObs = (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.MutationObserver) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.WebKitMutationObserver) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.MozMutationObserver) || null;
+const requestAF = ((WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.requestAnimationFrame) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.webkitRequestAnimationFrame) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.mozRequestAnimationFrame) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.msRequestAnimationFrame) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.oRequestAnimationFrame) || (
+// Fallback, but not a true polyfill
+// Only needed for Opera Mini
+cb => setTimeout(cb, 16))).bind(WINDOW);
+// eslint-disable-next-line no-unsafe-optional-chaining
+const cancelAF = ((WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.cancelAnimationFrame) || (WINDOW === null || WINDOW === void 0 ? void 0 : WINDOW.mozCancelAnimationFrame)).bind(WINDOW);
+// Remove a node from DOM
+const removeNode = el => {
+  el && el.parentNode && el.parentNode.removeChild(el);
+};
+// Determine if an HTML element is visible - Faster than CSS check
+const isVisible = el => {
+  if (!isElement_1(el) || !el.parentNode || !contains(document.body, el)) {
+    // Note this can fail for shadow dom elements since they
+    // are not a direct descendant of document.body
+    return false;
+  }
+  if (getStyle(el, 'display') === 'none') {
+    // We do this check to help with vue-test-utils when using v-show
+    return false;
+  }
+  // All browsers support getBoundingClientRect(), except JSDOM as it returns all 0's for values :(
+  // So any tests that need isVisible will fail in JSDOM
+  // Except when we override the getBCR prototype in some tests
+  const bcr = getBCR(el);
+  return !!(bcr && bcr.height > 0 && bcr.width > 0);
+};
+// Cause/wait-for an element to reflow its content (adjusting its height/width)
+const reflow = el => {
+  // Requesting an elements offsetHeight will trigger a reflow of the element content
+  return get_1(el, ['offsetHeight'], null);
+};
+// Select all elements matching selector. Returns `[]` if none found
+const selectAll = (selector, root) => [...(root && isElement_1(root) ? root : document).querySelectorAll(selector)];
+// Select a single element, returns `null` if not found
+const select = (selector, root) => (root && isElement_1(root) ? root : document).querySelector(selector) || null;
+// Returns true if the parent element contains the child element
+const contains = (parent, child) => parent && typeof parent.contains === 'function' ? parent.contains(child) : false;
+// Get an element given an ID
+const getById = id => document.getElementById(/^#/.test(id) ? id.slice(1) : id) || null;
+// Add a class to an element
+const addClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  if (className && isElement_1(el) && el.classList) {
+    el.classList.add(className);
+  }
+};
+// Remove a class from an element
+const removeClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  if (className && isElement_1(el) && el.classList) el.classList.remove(className);
+};
+// Test if an element has a class
+const hasClass = (el, className) => {
+  // We are checking for `el.classList` existence here since IE 11
+  // returns `undefined` for some elements (e.g. SVG elements)
+  if (className && isElement_1(el) && el.classList) return el.classList.contains(className);
+  return false;
+};
+// Set an attribute on an element
+const setAttr = (el, attr, value) => {
+  if (attr && isElement_1(el)) {
+    el.setAttribute(attr, value);
+  }
+};
+// Remove an attribute from an element
+const removeAttr = (el, attr) => {
+  if (attr && isElement_1(el)) {
+    el.removeAttribute(attr);
+  }
+};
+// Get an attribute value from an element
+const getAttr = (el, attr) => attr && isElement_1(el) ? el.getAttribute(attr) : null;
+// Determine if an attribute exists on an element
+// Returns `true` or `false`, or `null` if element not found
+const hasAttr = (el, attr) => attr && isElement_1(el) ? el.hasAttribute(attr) : null;
+// Set an style property on an element
+const setStyle = (el, prop, value) => {
+  if (prop && isElement_1(el)) {
+    el.style[prop] = value;
+  }
+};
+// Remove an style property from an element
+const removeStyle = (el, prop) => {
+  if (prop && isElement_1(el)) {
+    el.style[prop] = '';
+  }
+};
+// Get an style property value from an element
+// Returns `null` if not found
+const getStyle = (el, prop) => prop && isElement_1(el) ? el.style[prop] || null : null;
+// Return the Bounding Client Rect of an element
+const getBCR = el => isElement_1(el) ? el.getBoundingClientRect() : null;
+// Get computed style object for an element
+const getCS = el => get_1(WINDOW, 'getComputedStyle', null) && isElement_1(el) ? getComputedStyle(el) : {};
+// Return an element's offset with respect to document element
+const offset = el => {
+  const _offset = {
+    top: 0,
+    left: 0
+  };
+  if (!isElement_1(el) || el.getClientRects().length === 0) {
+    return _offset;
+  }
+  const bcr = getBCR(el);
+  if (bcr) {
+    const win = el.ownerDocument.defaultView;
+    _offset.top = bcr.top + get_1(win, 'pageYOffset', 0);
+    _offset.left = bcr.left + get_1(win, 'pageXOffset', 0);
+  }
+  return _offset;
+};
+// Return an element's offset with respect to to its offsetParent
+const position = el => {
+  let _offset = {
+    top: 0,
+    left: 0
+  };
+  if (!isElement_1(el)) {
+    return _offset;
+  }
+  let parentOffset = {
+    top: 0,
+    left: 0
+  };
+  const elStyles = getCS(el);
+  if (elStyles.position === 'fixed') {
+    _offset = getBCR(el) || _offset;
+  } else {
+    _offset = offset(el);
+    const doc = el.ownerDocument;
+    let 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);
+      const offsetParentStyles = getCS(offsetParent);
+      parentOffset.top += parseFloat(offsetParentStyles.borderTopWidth);
+      parentOffset.left += parseFloat(offsetParentStyles.borderLeftWidth);
+    }
+  }
+  return {
+    top: _offset.top - parentOffset.top - parseFloat(elStyles.marginTop),
+    left: _offset.left - parentOffset.left - parseFloat(elStyles.marginLeft)
+  };
+};
+const getMaxZIndex = element => {
+  let maxZIndex = 0;
+  while (element) {
+    const cs = getCS(element);
+    const zIndex = cs.zIndex;
+    if (zIndex !== 'auto') {
+      maxZIndex = +zIndex > maxZIndex ? +zIndex : maxZIndex;
+    }
+    element = element.parentElement;
+  }
+  return maxZIndex;
+};
+export { MutationObs as M, _getPrototype as _, removeNode as a, reflow as b, cancelAF as c, select as d, contains as e, addClass as f, getById as g, removeClass as h, isVisible as i, hasClass as j, setAttr as k, removeAttr as l, getAttr as m, hasAttr as n, setStyle as o, removeStyle as p, getStyle as q, requestAF as r, selectAll as s, getBCR as t, getCS as u, offset as v, position as w, getMaxZIndex as x };

package/dist/bundled/v3/eq-44ea4d70.js ADDED Viewed

@@ -0,0 +1,77 @@
+import { c as _baseGetTag, i as isObject_1 } from './isObject-b7415fc1.js';
+var baseGetTag = _baseGetTag,
+  isObject = isObject_1;
+/** `Object#toString` result references. */
+var asyncTag = '[object AsyncFunction]',
+  funcTag = '[object Function]',
+  genTag = '[object GeneratorFunction]',
+  proxyTag = '[object Proxy]';
+/**
+ * Checks if `value` is classified as a `Function` object.
+ *
+ * @static
+ * @memberOf _
+ * @since 0.1.0
+ * @category Lang
+ * @param {*} value The value to check.
+ * @returns {boolean} Returns `true` if `value` is a function, else `false`.
+ * @example
+ *
+ * _.isFunction(_);
+ * // => true
+ *
+ * _.isFunction(/abc/);
+ * // => false
+ */
+function isFunction(value) {
+  if (!isObject(value)) {
+    return false;
+  }
+  // The use of `Object#toString` avoids issues with the `typeof` operator
+  // in Safari 9 which returns 'object' for typed arrays and other constructors.
+  var tag = baseGetTag(value);
+  return tag == funcTag || tag == genTag || tag == asyncTag || tag == proxyTag;
+}
+var isFunction_1 = isFunction;
+/**
+ * Performs a
+ * [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
+ * comparison between two values to determine if they are equivalent.
+ *
+ * @static
+ * @memberOf _
+ * @since 4.0.0
+ * @category Lang
+ * @param {*} value The value to compare.
+ * @param {*} other The other value to compare.
+ * @returns {boolean} Returns `true` if the values are equivalent, else `false`.
+ * @example
+ *
+ * var object = { 'a': 1 };
+ * var other = { 'a': 1 };
+ *
+ * _.eq(object, object);
+ * // => true
+ *
+ * _.eq(object, other);
+ * // => false
+ *
+ * _.eq('a', 'a');
+ * // => true
+ *
+ * _.eq('a', Object('a'));
+ * // => false
+ *
+ * _.eq(NaN, NaN);
+ * // => true
+ */
+function eq(value, other) {
+  return value === other || value !== value && other !== other;
+}
+var eq_1 = eq;
+export { eq_1 as e, isFunction_1 as i };