PHPXRef 0.7.1 : WordPress : Detail view of components.js

Creates a higher-order component which adds filtering capability to the
wrapped component. Filters get applied when the original component is about
to be mounted. When a filter is added or removed that matches the hook name,
the wrapped component re-renders.

return: {Function} Higher-order component factory.
param: {string} hookName Hook name exposed to be used by filters.

FilteredComponent(props) X-Ref

No description

isFocusNormalizedButton(element) X-Ref

Returns true if the given element is a button element subject to focus
normalization, or false otherwise.

return: {boolean} Whether element is a button.
param: {Element} element Element to test.

_class() X-Ref

No description

_class() X-Ref

No description

WrappedBlockEdit() X-Ref

No description

_class() X-Ref

No description

IconButton() X-Ref

No description

KeyboardShortcuts() X-Ref

No description

MenuGroup(_ref) X-Ref

Internal dependencies

MenuItem(_ref) X-Ref

Renders a generic menu item for use inside the more menu.

return: {WPElement} More menu item.

MenuItemsChoice(_ref) X-Ref

Internal dependencies

hideApp(unhiddenElement) X-Ref

Hides all elements in the body element from screen-readers except
the provided element and elements that should not be hidden from
screen-readers.

The reason we do this is because `aria-modal="true"` currently is bugged
in Safari, and support is spotty in other browsers overall. In the future
we should consider removing these helper functions in favor of
`aria-modal="true"`.

param: {Element} unhiddenElement The element that should not be hidden.

elementShouldBeHidden(element) X-Ref

Determines if the passed element should not be hidden from screen readers.

return: {boolean} Whether the element should not be hidden from screen-readers.
param: {HTMLElement} element The element that should be checked.

showApp() X-Ref

Makes all elements in the body that have been hidden by `hideApp`
visible again to screen-readers.

ModalFrame() X-Ref

No description

Modal(props) X-Ref

No description

cycleValue(value, total, offset) X-Ref

No description

NavigableContainer() X-Ref

No description

NavigableMenu() X-Ref

No description

TabbableContainer() X-Ref

No description

Notice(_ref) X-Ref

No description

NoticeList(_ref) X-Ref

Renders a list of notices.

return: {Object}                The rendered notices list.
param: {Object}   $0           Props passed to the component.
param: {Array}    $0.notices   Array of notices to render.
param: {Function} $0.onRemove  Function called when a notice should be removed / dismissed.
param: {Object}   $0.className Name of the class used by the component.
param: {Object}   $0.children  Array of children to be rendered inside the notice list.

PanelBody(props) X-Ref

No description

PanelColor(_ref) X-Ref

No description

PanelHeader(_ref) X-Ref

No description

Panel(_ref) X-Ref

No description

PanelRow(_ref) X-Ref

External dependencies

Placeholder(_ref) X-Ref

Renders a placeholder. Normally used by blocks to render their empty state.

return: {Object} The rendered placeholder.
param: {Object} props The component props.

PopoverDetectOutside() X-Ref

No description

Popover() X-Ref

No description

computePopoverXAxisPosition(anchorRect, contentSize, xAxis, chosenYAxis) X-Ref

Utility used to compute the popover position over the xAxis

return: {Object} Popover xAxis position and constraints.
param: {Object} anchorRect       Anchor Rect.
param: {Object} contentSize      Content Size.
param: {string} xAxis            Desired xAxis.
param: {string} chosenYAxis      yAxis to be used.
param: {boolean} expandOnMobile  Whether to expand the popover on mobile or not.

computePopoverYAxisPosition(anchorRect, contentSize, yAxis) X-Ref

Utility used to compute the popover position over the yAxis

return: {Object} Popover xAxis position and constraints.
param: {Object} anchorRect       Anchor Rect.
param: {Object} contentSize      Content Size.
param: {string} yAxis            Desired yAxis.
param: {boolean} expandOnMobile  Whether to expand the popover on mobile or not.

computePopoverPosition(anchorRect, contentSize) X-Ref

Utility used to compute the popover position and the content max width/height for a popover
given its anchor rect and its content size.

return: {Object} Popover position and constraints.
param: {Object} anchorRect       Anchor Rect.
param: {Object} contentSize      Content Size.
param: {string} position         Position.
param: {boolean} expandOnMobile  Whether to expand the popover on mobile or not.

CategorySelect(_ref) X-Ref

Internal dependencies

QueryControls(_ref) X-Ref

No description

buildTermsTree(flatTerms) X-Ref

Returns terms in a tree form.

return: {Array} Array of terms in tree format.
param: {Array} flatTerms Array of terms in flat format.

RadioControl(_ref) X-Ref

No description

RangeControl(_ref) X-Ref

No description

ResizableBox(_ref) X-Ref

No description

ResponsiveWrapper(_ref) X-Ref

No description

Sandbox() X-Ref

No description

createScrollLockComponent() X-Ref

Creates a ScrollLock component bound to the specified document.

This function creates a ScrollLock component for the specified document
and is exposed so we can create an isolated component for unit testing.

return: {Component} The bound ScrollLock component.
param: {Object} args Keyword args.
param: {HTMLDocument} args.htmlDocument The document to lock the scroll for.
param: {string} args.className The name of the class used to lock scrolling.

setLocked(locked) X-Ref

Locks and unlocks scroll depending on the boolean argument.

param: {boolean} locked Whether or not scroll should be locked.

requestLock() X-Ref

Requests scroll lock.

This function tracks requests for scroll lock. It locks scroll on the first
request and counts each request so `releaseLock` can unlock scroll when
all requests have been released.

releaseLock() X-Ref

Releases a request for scroll lock.

This function tracks released requests for scroll lock. When all requests
have been released, it unlocks scroll.

ScrollLock() X-Ref

No description

SelectControl(_ref) X-Ref

No description

rendererPath(block) X-Ref

No description

ServerSideRender(props) X-Ref

No description

Shortcut(_ref) X-Ref

External dependencies

Fill() X-Ref

No description

createSlotFill(name) X-Ref

No description

SlotFillProvider() X-Ref

No description

Slot() X-Ref

No description

TabPanel() X-Ref

No description

TextControl(_ref) X-Ref

No description

TextareaControl(_ref) X-Ref

No description

ToggleControl() X-Ref

No description

Toolbar(_ref) X-Ref

Renders a toolbar with controls.

The `controls` prop accepts an array of sets. A set is an array of controls.
Controls have the following shape:

```
{
icon: string,
title: string,
subscript: string,
onClick: Function,
isActive: boolean,
isDisabled: boolean
}
```

For convenience it is also possible to pass only an array of controls. It is
then assumed this is the only set.

Either `controls` or `children` is required, otherwise this components
renders nothing.

return: {ReactElement} The rendered toolbar.
param: {?Array}        controls  The controls to render in this toolbar.
param: {?ReactElement} children  Any other things to render inside the
param: {?string}       className Class to set on the container div.

Tooltip() X-Ref

No description

getSelectOptions(tree) X-Ref

No description

TreeSelect(_ref) X-Ref

No description

classNames() X-Ref

No description

_interopRequireDefault(obj) X-Ref

No description

_classCallCheck(instance, Constructor) X-Ref

No description

defineProperties(target, props) X-Ref

No description

ClipboardAction(options) X-Ref

param: {Object} options

_interopRequireDefault(obj) X-Ref

No description

_classCallCheck(instance, Constructor) X-Ref

No description

defineProperties(target, props) X-Ref

No description

_possibleConstructorReturn(self, call) X-Ref

No description

_inherits(subClass, superClass) X-Ref

No description

Clipboard(trigger, options) X-Ref

param: {String|HTMLElement|HTMLCollection|NodeList} trigger
param: {Object} options

getAttributeValue(suffix, element) X-Ref

Helper function to retrieve attribute value.

param: {String} suffix
param: {Element} element

_interopRequireDefault(obj) X-Ref

No description

_classCallCheck(instance, Constructor) X-Ref

No description

_possibleConstructorReturn(self, call) X-Ref

No description

_inherits(subClass, superClass) X-Ref

No description

objectIs(x, y) X-Ref

No description

createEventEmitter(value) X-Ref

No description

onlyChild(children) X-Ref

No description

createReactContext(defaultValue, calculateChangedBits) X-Ref

No description

Provider() X-Ref

No description

Consumer() X-Ref

No description

_interopRequireDefault(obj) X-Ref

No description

closest(element, selector) X-Ref

Finds the closest parent that matches a selector.

return: {Function}
param: {Element} element
param: {String} selector

_delegate(element, selector, type, callback, useCapture) X-Ref

Delegates event to a selector.

return: {Object}
param: {Element} element
param: {String} selector
param: {String} type
param: {Function} callback
param: {Boolean} useCapture

delegate(elements, selector, type, callback, useCapture) X-Ref

Delegates event to a selector.

return: {Object}
param: {Element|String|Array} [elements]
param: {String} selector
param: {String} type
param: {Function} callback
param: {Boolean} useCapture

listener(element, selector, type, callback) X-Ref

Finds closest match and invokes callback.

return: {Function}
param: {Element} element
param: {String} selector
param: {String} type
param: {Function} callback

scrollIntoView(elem, container, config) X-Ref

No description

getClientPosition(elem) X-Ref

No description

getScroll(w, top) X-Ref

No description

getScrollLeft(w) X-Ref

No description

getScrollTop(w) X-Ref

No description

getOffset(el) X-Ref

No description

_getComputedStyle(elem, name, computedStyle_) X-Ref

No description

_getComputedStyleIE(elem, name) X-Ref

No description

each(arr, fn) X-Ref

No description

isBorderBoxFn(elem) X-Ref

No description

swap(elem, options, callback) X-Ref

No description

getPBMWidth(elem, props, which) X-Ref

No description

isWindow(obj) X-Ref

A crude way of determining if an object is a window

getWH(elem, name, extra) X-Ref

No description

getWHIgnoreDisplay(elem) X-Ref

No description

css(el, name, v) X-Ref

No description

setOffset(elem, offset) X-Ref

No description

makeEmptyFunction(arg) X-Ref

Copyright (c) 2013-present, Facebook, Inc.

This source code is licensed under the MIT license found in the
LICENSE file in the root directory of this source tree.

listen(target, type, callback) X-Ref

Validates all params and calls the right
listener function based on its target type.

return: {Object}
param: {String|HTMLElement|HTMLCollection|NodeList} target
param: {String} type
param: {Function} callback

listenNode(node, type, callback) X-Ref

Adds an event listener to a HTML element
and returns a remove listener function.

return: {Object}
param: {HTMLElement} node
param: {String} type
param: {Function} callback

listenNodeList(nodeList, type, callback) X-Ref

Add an event listener to a list of HTML elements
and returns a remove listener function.

return: {Object}
param: {NodeList|HTMLCollection} nodeList
param: {String} type
param: {Function} callback

listenSelector(selector, type, callback) X-Ref

Add an event listener to a selector
and returns a remove listener function.

return: {Object}
param: {String} selector
param: {String} type
param: {Function} callback

Hash(entries) X-Ref

Creates a hash object.

param: {Array} [entries] The key-value pairs to cache.

ListCache(entries) X-Ref

Creates an list cache object.

param: {Array} [entries] The key-value pairs to cache.

MapCache(entries) X-Ref

Creates a map cache object to store key-value pairs.

param: {Array} [entries] The key-value pairs to cache.

SetCache(values) X-Ref

Creates an array cache object to store unique values.

param: {Array} [values] The values to cache.

Stack(entries) X-Ref

Creates a stack cache object to store key-value pairs.

param: {Array} [entries] The key-value pairs to cache.

arrayEach(array, iteratee) X-Ref

A specialized version of `_.forEach` for arrays without support for
iteratee shorthands.

returns: {Array} Returns `array`.
param: {Array} [array] The array to iterate over.
param: {Function} iteratee The function invoked per iteration.

arrayFilter(array, predicate) X-Ref

A specialized version of `_.filter` for arrays without support for
iteratee shorthands.

returns: {Array} Returns the new filtered array.
param: {Array} [array] The array to iterate over.
param: {Function} predicate The function invoked per iteration.

arrayLikeKeys(value, inherited) X-Ref

Creates an array of the enumerable property names of the array-like `value`.

returns: {Array} Returns the array of property names.
param: {*} value The value to query.
param: {boolean} inherited Specify returning inherited property names.

arrayMap(array, iteratee) X-Ref

A specialized version of `_.map` for arrays without support for iteratee
shorthands.

returns: {Array} Returns the new mapped array.
param: {Array} [array] The array to iterate over.
param: {Function} iteratee The function invoked per iteration.

arrayPush(array, values) X-Ref

Appends the elements of `values` to `array`.

returns: {Array} Returns `array`.
param: {Array} array The array to modify.
param: {Array} values The values to append.

arraySome(array, predicate) X-Ref

A specialized version of `_.some` for arrays without support for iteratee
shorthands.

returns: {boolean} Returns `true` if any element passes the predicate check,
param: {Array} [array] The array to iterate over.
param: {Function} predicate The function invoked per iteration.

assignValue(object, key, value) X-Ref

Assigns `value` to `key` of `object` if the existing value is not equivalent
using [`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
for equality comparisons.

param: {Object} object The object to modify.
param: {string} key The key of the property to assign.
param: {*} value The value to assign.

assocIndexOf(array, key) X-Ref

Gets the index at which the `key` is found in `array` of key-value pairs.

returns: {number} Returns the index of the matched value, else `-1`.
param: {Array} array The array to inspect.
param: {*} key The key to search for.

baseAssign(object, source) X-Ref

The base implementation of `_.assign` without support for multiple sources
or `customizer` functions.

returns: {Object} Returns `object`.
param: {Object} object The destination object.
param: {Object} source The source object.

baseAssignIn(object, source) X-Ref

The base implementation of `_.assignIn` without support for multiple sources
or `customizer` functions.

returns: {Object} Returns `object`.
param: {Object} object The destination object.
param: {Object} source The source object.

baseAssignValue(object, key, value) X-Ref

The base implementation of `assignValue` and `assignMergeValue` without
value checks.

param: {Object} object The object to modify.
param: {string} key The key of the property to assign.
param: {*} value The value to assign.

baseClone(value, bitmask, customizer, key, object, stack) X-Ref

The base implementation of `_.clone` and `_.cloneDeep` which tracks
traversed objects.

returns: {*} Returns the cloned value.
param: {*} value The value to clone.
param: {boolean} bitmask The bitmask flags.
param: {Function} [customizer] The function to customize cloning.
param: {string} [key] The key of `value`.
param: {Object} [object] The parent object of `value`.
param: {Object} [stack] Tracks traversed objects and their clone counterparts.

object() X-Ref

The base implementation of `_.create` without support for assigning
properties to the created object.

returns: {Object} Returns the new object.
param: {Object} proto The object to inherit from.

baseForOwn(object, iteratee) X-Ref

The base implementation of `_.forOwn` without support for iteratee shorthands.

returns: {Object} Returns `object`.
param: {Object} object The object to iterate over.
param: {Function} iteratee The function invoked per iteration.

baseGet(object, path) X-Ref

The base implementation of `_.get` without support for default values.

returns: {*} Returns the resolved value.
param: {Object} object The object to query.
param: {Array|string} path The path of the property to get.

baseGetAllKeys(object, keysFunc, symbolsFunc) X-Ref

The base implementation of `getAllKeys` and `getAllKeysIn` which uses
`keysFunc` and `symbolsFunc` to get the enumerable property names and
symbols of `object`.

returns: {Array} Returns the array of property names and symbols.
param: {Object} object The object to query.
param: {Function} keysFunc The function to get the keys of `object`.
param: {Function} symbolsFunc The function to get the symbols of `object`.

baseGetTag(value) X-Ref

The base implementation of `getTag` without fallbacks for buggy environments.

returns: {string} Returns the `toStringTag`.
param: {*} value The value to query.

baseHasIn(object, key) X-Ref

The base implementation of `_.hasIn` without support for deep paths.

returns: {boolean} Returns `true` if `key` exists, else `false`.
param: {Object} [object] The object to query.
param: {Array|string} key The key to check.

baseIsArguments(value) X-Ref

The base implementation of `_.isArguments`.

returns: {boolean} Returns `true` if `value` is an `arguments` object,
param: {*} value The value to check.

baseIsEqual(value, other, bitmask, customizer, stack) X-Ref

The base implementation of `_.isEqual` which supports partial comparisons
and tracks traversed objects.

returns: {boolean} Returns `true` if the values are equivalent, else `false`.
param: {*} value The value to compare.
param: {*} other The other value to compare.
param: {boolean} bitmask The bitmask flags.
param: {Function} [customizer] The function to customize comparisons.
param: {Object} [stack] Tracks traversed `value` and `other` objects.

baseIsEqualDeep(object, other, bitmask, customizer, equalFunc, stack) X-Ref

A specialized version of `baseIsEqual` for arrays and objects which performs
deep comparisons and tracks traversed objects enabling objects with circular
references to be compared.

returns: {boolean} Returns `true` if the objects are equivalent, else `false`.
param: {Object} object The object to compare.
param: {Object} other The other object to compare.
param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
param: {Function} customizer The function to customize comparisons.
param: {Function} equalFunc The function to determine equivalents of values.
param: {Object} [stack] Tracks traversed `object` and `other` objects.

baseIsMap(value) X-Ref

The base implementation of `_.isMap` without Node.js optimizations.

returns: {boolean} Returns `true` if `value` is a map, else `false`.
param: {*} value The value to check.

baseIsMatch(object, source, matchData, customizer) X-Ref

The base implementation of `_.isMatch` without support for iteratee shorthands.

returns: {boolean} Returns `true` if `object` is a match, else `false`.
param: {Object} object The object to inspect.
param: {Object} source The object of property values to match.
param: {Array} matchData The property names, values, and compare flags to match.
param: {Function} [customizer] The function to customize comparisons.

baseIsNative(value) X-Ref

The base implementation of `_.isNative` without bad shim checks.

returns: {boolean} Returns `true` if `value` is a native function,
param: {*} value The value to check.

baseIsSet(value) X-Ref

The base implementation of `_.isSet` without Node.js optimizations.

returns: {boolean} Returns `true` if `value` is a set, else `false`.
param: {*} value The value to check.

baseIsTypedArray(value) X-Ref

The base implementation of `_.isTypedArray` without Node.js optimizations.

returns: {boolean} Returns `true` if `value` is a typed array, else `false`.
param: {*} value The value to check.

baseIteratee(value) X-Ref

The base implementation of `_.iteratee`.

returns: {Function} Returns the iteratee.
param: {*} [value=_.identity] The value to convert to an iteratee.

baseKeys(object) X-Ref

The base implementation of `_.keys` which doesn't treat sparse arrays as dense.

returns: {Array} Returns the array of property names.
param: {Object} object The object to query.

baseKeysIn(object) X-Ref

The base implementation of `_.keysIn` which doesn't treat sparse arrays as dense.

returns: {Array} Returns the array of property names.
param: {Object} object The object to query.

baseMap(collection, iteratee) X-Ref

The base implementation of `_.map` without support for iteratee shorthands.

returns: {Array} Returns the new mapped array.
param: {Array|Object} collection The collection to iterate over.
param: {Function} iteratee The function invoked per iteration.

baseMatches(source) X-Ref

The base implementation of `_.matches` which doesn't clone `source`.

returns: {Function} Returns the new spec function.
param: {Object} source The object of property values to match.

baseMatchesProperty(path, srcValue) X-Ref

The base implementation of `_.matchesProperty` which doesn't clone `srcValue`.

returns: {Function} Returns the new spec function.
param: {string} path The path of the property to get.
param: {*} srcValue The value to match.

baseProperty(key) X-Ref

The base implementation of `_.property` without support for deep paths.

returns: {Function} Returns the new accessor function.
param: {string} key The key of the property to get.

basePropertyDeep(path) X-Ref

A specialized version of `baseProperty` which supports deep paths.

returns: {Function} Returns the new accessor function.
param: {Array|string} path The path of the property to get.

baseTimes(n, iteratee) X-Ref

The base implementation of `_.times` without support for iteratee shorthands
or max array length checks.

returns: {Array} Returns the array of results.
param: {number} n The number of times to invoke `iteratee`.
param: {Function} iteratee The function invoked per iteration.

baseToString(value) X-Ref

The base implementation of `_.toString` which doesn't convert nullish
values to empty strings.

returns: {string} Returns the string.
param: {*} value The value to process.

baseUnary(func) X-Ref

The base implementation of `_.unary` without support for storing metadata.

returns: {Function} Returns the new capped function.
param: {Function} func The function to cap arguments for.

cacheHas(cache, key) X-Ref

Checks if a `cache` value for `key` exists.

returns: {boolean} Returns `true` if an entry for `key` exists, else `false`.
param: {Object} cache The cache to query.
param: {string} key The key of the entry to check.

castFunction(value) X-Ref

Casts `value` to `identity` if it's not a function.

returns: {Function} Returns cast function.
param: {*} value The value to inspect.

castPath(value, object) X-Ref

Casts `value` to a path array if it's not one.

returns: {Array} Returns the cast property path array.
param: {*} value The value to inspect.
param: {Object} [object] The object to query keys on.

cloneArrayBuffer(arrayBuffer) X-Ref

Creates a clone of `arrayBuffer`.

returns: {ArrayBuffer} Returns the cloned array buffer.
param: {ArrayBuffer} arrayBuffer The array buffer to clone.

cloneBuffer(buffer, isDeep) X-Ref

Creates a clone of `buffer`.

returns: {Buffer} Returns the cloned buffer.
param: {Buffer} buffer The buffer to clone.
param: {boolean} [isDeep] Specify a deep clone.

cloneDataView(dataView, isDeep) X-Ref

Creates a clone of `dataView`.

returns: {Object} Returns the cloned data view.
param: {Object} dataView The data view to clone.
param: {boolean} [isDeep] Specify a deep clone.

cloneRegExp(regexp) X-Ref

Creates a clone of `regexp`.

returns: {Object} Returns the cloned regexp.
param: {Object} regexp The regexp to clone.

cloneSymbol(symbol) X-Ref

Creates a clone of the `symbol` object.

returns: {Object} Returns the cloned symbol object.
param: {Object} symbol The symbol object to clone.

cloneTypedArray(typedArray, isDeep) X-Ref

Creates a clone of `typedArray`.

returns: {Object} Returns the cloned typed array.
param: {Object} typedArray The typed array to clone.
param: {boolean} [isDeep] Specify a deep clone.

copyArray(source, array) X-Ref

Copies the values of `source` to `array`.

returns: {Array} Returns `array`.
param: {Array} source The array to copy values from.
param: {Array} [array=[]] The array to copy values to.

copyObject(source, props, object, customizer) X-Ref

Copies properties of `source` to `object`.

returns: {Object} Returns `object`.
param: {Object} source The object to copy properties from.
param: {Array} props The property identifiers to copy.
param: {Object} [object={}] The object to copy properties to.
param: {Function} [customizer] The function to customize copied values.

copySymbols(source, object) X-Ref

Copies own symbols of `source` to `object`.

returns: {Object} Returns `object`.
param: {Object} source The object to copy symbols from.
param: {Object} [object={}] The object to copy symbols to.

copySymbolsIn(source, object) X-Ref

Copies own and inherited symbols of `source` to `object`.

returns: {Object} Returns `object`.
param: {Object} source The object to copy symbols from.
param: {Object} [object={}] The object to copy symbols to.

createBaseEach(eachFunc, fromRight) X-Ref

Creates a `baseEach` or `baseEachRight` function.

returns: {Function} Returns the new base function.
param: {Function} eachFunc The function to iterate over a collection.
param: {boolean} [fromRight] Specify iterating from right to left.

createBaseFor(fromRight) X-Ref

Creates a base function for methods like `_.forIn` and `_.forOwn`.

returns: {Function} Returns the new base function.
param: {boolean} [fromRight] Specify iterating from right to left.

equalArrays(array, other, bitmask, customizer, equalFunc, stack) X-Ref

A specialized version of `baseIsEqualDeep` for arrays with support for
partial deep comparisons.

returns: {boolean} Returns `true` if the arrays are equivalent, else `false`.
param: {Array} array The array to compare.
param: {Array} other The other array to compare.
param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
param: {Function} customizer The function to customize comparisons.
param: {Function} equalFunc The function to determine equivalents of values.
param: {Object} stack Tracks traversed `array` and `other` objects.

equalByTag(object, other, tag, bitmask, customizer, equalFunc, stack) X-Ref

A specialized version of `baseIsEqualDeep` for comparing objects of
the same `toStringTag`.

**Note:** This function only supports comparing values with tags of
`Boolean`, `Date`, `Error`, `Number`, `RegExp`, or `String`.

returns: {boolean} Returns `true` if the objects are equivalent, else `false`.
param: {Object} object The object to compare.
param: {Object} other The other object to compare.
param: {string} tag The `toStringTag` of the objects to compare.
param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
param: {Function} customizer The function to customize comparisons.
param: {Function} equalFunc The function to determine equivalents of values.
param: {Object} stack Tracks traversed `object` and `other` objects.

equalObjects(object, other, bitmask, customizer, equalFunc, stack) X-Ref

A specialized version of `baseIsEqualDeep` for objects with support for
partial deep comparisons.

returns: {boolean} Returns `true` if the objects are equivalent, else `false`.
param: {Object} object The object to compare.
param: {Object} other The other object to compare.
param: {number} bitmask The bitmask flags. See `baseIsEqual` for more details.
param: {Function} customizer The function to customize comparisons.
param: {Function} equalFunc The function to determine equivalents of values.
param: {Object} stack Tracks traversed `object` and `other` objects.

getAllKeys(object) X-Ref

Creates an array of own enumerable property names and symbols of `object`.

returns: {Array} Returns the array of property names and symbols.
param: {Object} object The object to query.

getAllKeysIn(object) X-Ref

Creates an array of own and inherited enumerable property names and
symbols of `object`.

returns: {Array} Returns the array of property names and symbols.
param: {Object} object The object to query.

getMapData(map, key) X-Ref

Gets the data for `map`.

returns: {*} Returns the map data.
param: {Object} map The map to query.
param: {string} key The reference key.

getMatchData(object) X-Ref

Gets the property names, values, and compare flags of `object`.

returns: {Array} Returns the match data of `object`.
param: {Object} object The object to query.

getNative(object, key) X-Ref

Gets the native function at `key` of `object`.

returns: {*} Returns the function if it's native, else `undefined`.
param: {Object} object The object to query.
param: {string} key The key of the method to get.

getRawTag(value) X-Ref

A specialized version of `baseGetTag` which ignores `Symbol.toStringTag` values.

returns: {string} Returns the raw `toStringTag`.
param: {*} value The value to query.

getValue(object, key) X-Ref

Gets the value at `key` of `object`.

returns: {*} Returns the property value.
param: {Object} [object] The object to query.
param: {string} key The key of the property to get.

hasPath(object, path, hasFunc) X-Ref

Checks if `path` exists on `object`.

returns: {boolean} Returns `true` if `path` exists, else `false`.
param: {Object} object The object to query.
param: {Array|string} path The path to check.
param: {Function} hasFunc The function to check properties.

hashClear() X-Ref

Removes all key-value entries from the hash.

hashDelete(key) X-Ref

Removes `key` and its value from the hash.

returns: {boolean} Returns `true` if the entry was removed, else `false`.
param: {Object} hash The hash to modify.
param: {string} key The key of the value to remove.

hashGet(key) X-Ref

Gets the hash value for `key`.

returns: {*} Returns the entry value.
param: {string} key The key of the value to get.

hashHas(key) X-Ref

Checks if a hash value for `key` exists.

returns: {boolean} Returns `true` if an entry for `key` exists, else `false`.
param: {string} key The key of the entry to check.

hashSet(key, value) X-Ref

Sets the hash `key` to `value`.

returns: {Object} Returns the hash instance.
param: {string} key The key of the value to set.
param: {*} value The value to set.

initCloneArray(array) X-Ref

Initializes an array clone.

returns: {Array} Returns the initialized clone.
param: {Array} array The array to clone.

initCloneByTag(object, tag, isDeep) X-Ref

Initializes an object clone based on its `toStringTag`.

**Note:** This function only supports cloning values with tags of
`Boolean`, `Date`, `Error`, `Map`, `Number`, `RegExp`, `Set`, or `String`.

returns: {Object} Returns the initialized clone.
param: {Object} object The object to clone.
param: {string} tag The `toStringTag` of the object to clone.
param: {boolean} [isDeep] Specify a deep clone.

initCloneObject(object) X-Ref

Initializes an object clone.

returns: {Object} Returns the initialized clone.
param: {Object} object The object to clone.

isIndex(value, length) X-Ref

Checks if `value` is a valid array-like index.

returns: {boolean} Returns `true` if `value` is a valid index, else `false`.
param: {*} value The value to check.
param: {number} [length=MAX_SAFE_INTEGER] The upper bounds of a valid index.

isKey(value, object) X-Ref

Checks if `value` is a property name and not a property path.

returns: {boolean} Returns `true` if `value` is a property name, else `false`.
param: {*} value The value to check.
param: {Object} [object] The object to query keys on.

isKeyable(value) X-Ref

Checks if `value` is suitable for use as unique object key.

returns: {boolean} Returns `true` if `value` is suitable, else `false`.
param: {*} value The value to check.

isMasked(func) X-Ref

Checks if `func` has its source masked.

returns: {boolean} Returns `true` if `func` is masked, else `false`.
param: {Function} func The function to check.

isPrototype(value) X-Ref

Checks if `value` is likely a prototype object.

returns: {boolean} Returns `true` if `value` is a prototype, else `false`.
param: {*} value The value to check.

isStrictComparable(value) X-Ref

Checks if `value` is suitable for strict equality comparisons, i.e. `===`.

returns: {boolean} Returns `true` if `value` if suitable for strict
param: {*} value The value to check.

listCacheClear() X-Ref

Removes all key-value entries from the list cache.

listCacheDelete(key) X-Ref

Removes `key` and its value from the list cache.

returns: {boolean} Returns `true` if the entry was removed, else `false`.
param: {string} key The key of the value to remove.

listCacheGet(key) X-Ref

Gets the list cache value for `key`.

returns: {*} Returns the entry value.
param: {string} key The key of the value to get.

listCacheHas(key) X-Ref

Checks if a list cache value for `key` exists.

returns: {boolean} Returns `true` if an entry for `key` exists, else `false`.
param: {string} key The key of the entry to check.

listCacheSet(key, value) X-Ref

Sets the list cache `key` to `value`.

returns: {Object} Returns the list cache instance.
param: {string} key The key of the value to set.
param: {*} value The value to set.

mapCacheClear() X-Ref

Removes all key-value entries from the map.

mapCacheDelete(key) X-Ref

Removes `key` and its value from the map.

returns: {boolean} Returns `true` if the entry was removed, else `false`.
param: {string} key The key of the value to remove.

mapCacheGet(key) X-Ref

Gets the map value for `key`.

returns: {*} Returns the entry value.
param: {string} key The key of the value to get.

mapCacheHas(key) X-Ref

Checks if a map value for `key` exists.

returns: {boolean} Returns `true` if an entry for `key` exists, else `false`.
param: {string} key The key of the entry to check.

mapCacheSet(key, value) X-Ref

Sets the map `key` to `value`.

returns: {Object} Returns the map cache instance.
param: {string} key The key of the value to set.
param: {*} value The value to set.

mapToArray(map) X-Ref

Converts `map` to its key-value pairs.

returns: {Array} Returns the key-value pairs.
param: {Object} map The map to convert.

matchesStrictComparable(key, srcValue) X-Ref

A specialized version of `matchesProperty` for source values suitable
for strict equality comparisons, i.e. `===`.

returns: {Function} Returns the new spec function.
param: {string} key The key of the property to get.
param: {*} srcValue The value to match.

memoizeCapped(func) X-Ref

A specialized version of `_.memoize` which clears the memoized function's
cache when it exceeds `MAX_MEMOIZE_SIZE`.

returns: {Function} Returns the new memoized function.
param: {Function} func The function to have its output memoized.

nativeKeysIn(object) X-Ref

This function is like
[`Object.keys`](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
except that it includes inherited enumerable properties.

returns: {Array} Returns the array of property names.
param: {Object} object The object to query.

objectToString(value) X-Ref

Converts `value` to a string using `Object.prototype.toString`.

returns: {string} Returns the converted string.
param: {*} value The value to convert.

overArg(func, transform) X-Ref

Creates a unary function that invokes `func` with its argument transformed.

returns: {Function} Returns the new function.
param: {Function} func The function to wrap.
param: {Function} transform The argument transform.

setCacheAdd(value) X-Ref

Adds `value` to the array cache.

returns: {Object} Returns the cache instance.
param: {*} value The value to cache.

setCacheHas(value) X-Ref

Checks if `value` is in the array cache.

returns: {number} Returns `true` if `value` is found, else `false`.
param: {*} value The value to search for.

setToArray(set) X-Ref

Converts `set` to an array of its values.

returns: {Array} Returns the values.
param: {Object} set The set to convert.

stackClear() X-Ref

Removes all key-value entries from the stack.

stackDelete(key) X-Ref

Removes `key` and its value from the stack.

returns: {boolean} Returns `true` if the entry was removed, else `false`.
param: {string} key The key of the value to remove.

stackGet(key) X-Ref

Gets the stack value for `key`.

returns: {*} Returns the entry value.
param: {string} key The key of the value to get.

stackHas(key) X-Ref

Checks if a stack value for `key` exists.

returns: {boolean} Returns `true` if an entry for `key` exists, else `false`.
param: {string} key The key of the entry to check.

stackSet(key, value) X-Ref

Sets the stack `key` to `value`.

returns: {Object} Returns the stack cache instance.
param: {string} key The key of the value to set.
param: {*} value The value to set.

toKey(value) X-Ref

Converts `value` to a string key if it's not a string or symbol.

returns: {string|symbol} Returns the key.
param: {*} value The value to inspect.

toSource(func) X-Ref

Converts `func` to its source code.

returns: {string} Returns the source code.
param: {Function} func The function to convert.

cloneDeep(value) X-Ref

This method is like `_.clone` except that it recursively clones `value`.

returns: {*} Returns the deep cloned value.
param: {*} value The value to recursively clone.
since: 1.0.0

debounce(func, wait, options) X-Ref

Creates a debounced function that delays invoking `func` until after `wait`
milliseconds have elapsed since the last time the debounced function was
invoked. The debounced function comes with a `cancel` method to cancel
delayed `func` invocations and a `flush` method to immediately invoke them.
Provide `options` to indicate whether `func` should be invoked on the
leading and/or trailing edge of the `wait` timeout. The `func` is invoked
with the last arguments provided to the debounced function. Subsequent
calls to the debounced function return the result of the last `func`
invocation.

**Note:** If `leading` and `trailing` options are `true`, `func` is
invoked on the trailing edge of the timeout only if the debounced function
is invoked more than once during the `wait` timeout.

If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
until to the next tick, similar to `setTimeout` with a timeout of `0`.

See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
for details over the differences between `_.debounce` and `_.throttle`.

returns: {Function} Returns the new debounced function.
param: {Function} func The function to debounce.
param: {number} [wait=0] The number of milliseconds to delay.
param: {Object} [options={}] The options object.
param: {boolean} [options.leading=false]
param: {number} [options.maxWait]
param: {boolean} [options.trailing=true]
since: 0.1.0

invokeFunc(time) X-Ref

No description

leadingEdge(time) X-Ref

No description

remainingWait(time) X-Ref

No description

shouldInvoke(time) X-Ref

No description

timerExpired() X-Ref

No description

trailingEdge(time) X-Ref

No description

cancel() X-Ref

No description

flush() X-Ref

No description

debounced() X-Ref

No description

eq(value, other) X-Ref

Performs a
[`SameValueZero`](http://ecma-international.org/ecma-262/7.0/#sec-samevaluezero)
comparison between two values to determine if they are equivalent.

returns: {boolean} Returns `true` if the values are equivalent, else `false`.
param: {*} value The value to compare.
param: {*} other The other value to compare.
since: 4.0.0

forEach(collection, iteratee) X-Ref

Iterates over elements of `collection` and invokes `iteratee` for each element.
The iteratee is invoked with three arguments: (value, index|key, collection).
Iteratee functions may exit iteration early by explicitly returning `false`.

**Note:** As with other "Collections" methods, objects with a "length"
property are iterated like arrays. To avoid this behavior use `_.forIn`
or `_.forOwn` for object iteration.

returns: {Array|Object} Returns `collection`.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.
since: 0.1.0

forOwn(object, iteratee) X-Ref

Iterates over own enumerable string keyed properties of an object and
invokes `iteratee` for each property. The iteratee is invoked with three
arguments: (value, key, object). Iteratee functions may exit iteration
early by explicitly returning `false`.

returns: {Object} Returns `object`.
param: {Object} object The object to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.
since: 0.3.0

get(object, path, defaultValue) X-Ref

Gets the value at `path` of `object`. If the resolved value is
`undefined`, the `defaultValue` is returned in its place.

returns: {*} Returns the resolved value.
param: {Object} object The object to query.
param: {Array|string} path The path of the property to get.
param: {*} [defaultValue] The value returned for `undefined` resolved values.
since: 3.7.0

hasIn(object, path) X-Ref

Checks if `path` is a direct or inherited property of `object`.

returns: {boolean} Returns `true` if `path` exists, else `false`.
param: {Object} object The object to query.
param: {Array|string} path The path to check.
since: 4.0.0

identity(value) X-Ref

This method returns the first argument it receives.

returns: {*} Returns `value`.
param: {*} value Any value.
since: 0.1.0

isArrayLike(value) X-Ref

Checks if `value` is array-like. A value is considered array-like if it's
not a function and has a `value.length` that's an integer greater than or
equal to `0` and less than or equal to `Number.MAX_SAFE_INTEGER`.

returns: {boolean} Returns `true` if `value` is array-like, else `false`.
param: {*} value The value to check.
since: 4.0.0

isFunction(value) X-Ref

Checks if `value` is classified as a `Function` object.

returns: {boolean} Returns `true` if `value` is a function, else `false`.
param: {*} value The value to check.
since: 0.1.0

isLength(value) X-Ref

Checks if `value` is a valid array-like length.

**Note:** This method is loosely based on
[`ToLength`](http://ecma-international.org/ecma-262/7.0/#sec-tolength).

returns: {boolean} Returns `true` if `value` is a valid length, else `false`.
param: {*} value The value to check.
since: 4.0.0

isObject(value) X-Ref

Checks if `value` is the
[language type](http://www.ecma-international.org/ecma-262/7.0/#sec-ecmascript-language-types)
of `Object`. (e.g. arrays, functions, objects, regexes, `new Number(0)`, and `new String('')`)

returns: {boolean} Returns `true` if `value` is an object, else `false`.
param: {*} value The value to check.
since: 0.1.0

isObjectLike(value) X-Ref

Checks if `value` is object-like. A value is object-like if it's not `null`
and has a `typeof` result of "object".

returns: {boolean} Returns `true` if `value` is object-like, else `false`.
param: {*} value The value to check.
since: 4.0.0

isPlainObject(value) X-Ref

Checks if `value` is a plain object, that is, an object created by the
`Object` constructor or one with a `[[Prototype]]` of `null`.

returns: {boolean} Returns `true` if `value` is a plain object, else `false`.
param: {*} value The value to check.
since: 0.8.0

isString(value) X-Ref

Checks if `value` is classified as a `String` primitive or object.

returns: {boolean} Returns `true` if `value` is a string, else `false`.
param: {*} value The value to check.
since: 0.1.0

isSymbol(value) X-Ref

Checks if `value` is classified as a `Symbol` primitive or object.

returns: {boolean} Returns `true` if `value` is a symbol, else `false`.
param: {*} value The value to check.
since: 4.0.0

keys(object) X-Ref

Creates an array of the own enumerable property names of `object`.

**Note:** Non-object values are coerced to objects. See the
[ES spec](http://ecma-international.org/ecma-262/7.0/#sec-object.keys)
for more details.

returns: {Array} Returns the array of property names.
param: {Object} object The object to query.
since: 0.1.0

keysIn(object) X-Ref

Creates an array of the own and inherited enumerable property names of `object`.

**Note:** Non-object values are coerced to objects.

returns: {Array} Returns the array of property names.
param: {Object} object The object to query.
since: 3.0.0

map(collection, iteratee) X-Ref

Creates an array of values by running each element in `collection` thru
`iteratee`. The iteratee is invoked with three arguments:
(value, index|key, collection).

Many lodash methods are guarded to work as iteratees for methods like
`_.every`, `_.filter`, `_.map`, `_.mapValues`, `_.reject`, and `_.some`.

The guarded methods are:
`ary`, `chunk`, `curry`, `curryRight`, `drop`, `dropRight`, `every`,
`fill`, `invert`, `parseInt`, `random`, `range`, `rangeRight`, `repeat`,
`sampleSize`, `slice`, `some`, `sortBy`, `split`, `take`, `takeRight`,
`template`, `trim`, `trimEnd`, `trimStart`, and `words`

returns: {Array} Returns the new mapped array.
param: {Array|Object} collection The collection to iterate over.
param: {Function} [iteratee=_.identity] The function invoked per iteration.
since: 0.1.0

memoize(func, resolver) X-Ref

Creates a function that memoizes the result of `func`. If `resolver` is
provided, it determines the cache key for storing the result based on the
arguments provided to the memoized function. By default, the first argument
provided to the memoized function is used as the map cache key. The `func`
is invoked with the `this` binding of the memoized function.

**Note:** The cache is exposed as the `cache` property on the memoized
function. Its creation may be customized by replacing the `_.memoize.Cache`
constructor with one whose instances implement the
[`Map`](http://ecma-international.org/ecma-262/7.0/#sec-properties-of-the-map-prototype-object)
method interface of `clear`, `delete`, `get`, `has`, and `set`.

returns: {Function} Returns the new memoized function.
param: {Function} func The function to have its output memoized.
param: {Function} [resolver] The function to resolve the cache key.
since: 0.1.0

property(path) X-Ref

Creates a function that returns the value at `path` of a given object.

returns: {Function} Returns the new accessor function.
param: {Array|string} path The path of the property to get.
since: 2.4.0

stubArray() X-Ref

This method returns a new empty array.

returns: {Array} Returns the new empty array.
since: 4.13.0

stubFalse() X-Ref

This method returns `false`.

returns: {boolean} Returns `false`.
since: 4.13.0

throttle(func, wait, options) X-Ref

Creates a throttled function that only invokes `func` at most once per
every `wait` milliseconds. The throttled function comes with a `cancel`
method to cancel delayed `func` invocations and a `flush` method to
immediately invoke them. Provide `options` to indicate whether `func`
should be invoked on the leading and/or trailing edge of the `wait`
timeout. The `func` is invoked with the last arguments provided to the
throttled function. Subsequent calls to the throttled function return the
result of the last `func` invocation.

**Note:** If `leading` and `trailing` options are `true`, `func` is
invoked on the trailing edge of the timeout only if the throttled function
is invoked more than once during the `wait` timeout.

If `wait` is `0` and `leading` is `false`, `func` invocation is deferred
until to the next tick, similar to `setTimeout` with a timeout of `0`.

See [David Corbacho's article](https://css-tricks.com/debouncing-throttling-explained-examples/)
for details over the differences between `_.throttle` and `_.debounce`.

returns: {Function} Returns the new throttled function.
param: {Function} func The function to throttle.
param: {number} [wait=0] The number of milliseconds to throttle invocations to.
param: {Object} [options={}] The options object.
param: {boolean} [options.leading=true]
param: {boolean} [options.trailing=true]
since: 0.1.0

toNumber(value) X-Ref

Converts `value` to a number.

returns: {number} Returns the number.
param: {*} value The value to process.
since: 4.0.0

toString(value) X-Ref

Converts `value` to a string. An empty string is returned for `null`
and `undefined` values. The sign of `-0` is preserved.

returns: {string} Returns the converted string.
param: {*} value The value to convert.
since: 4.0.0

_addEvent(object, type, callback) X-Ref

cross browser add event method

returns: void
param: {Element|HTMLDocument} object
param: {string} type
param: {Function} callback

_characterFromEvent(e) X-Ref

takes the event and returns the key character

return: {string}
param: {Event} e

_modifiersMatch(modifiers1, modifiers2) X-Ref

checks if two arrays are equal

returns: {boolean}
param: {Array} modifiers1
param: {Array} modifiers2

_eventModifiers(e) X-Ref

takes a key event and figures out what the modifiers are

returns: {Array}
param: {Event} e

_preventDefault(e) X-Ref

prevents default for this event

returns: void
param: {Event} e

_stopPropagation(e) X-Ref

stops propogation for this event

returns: void
param: {Event} e

_isModifier(key) X-Ref

determines if the keycode specified is a modifier key or not

returns: {boolean}
param: {string} key

_getReverseMap() X-Ref

reverses the map lookup so that we can look for specific keys
to see what can and can't use keypress

return: {Object}

_pickBestAction(key, modifiers, action) X-Ref

picks the best action based on the key combination

param: {string} key - character for key
param: {Array} modifiers
param: {string=} action passed in

_keysFromString(combination) X-Ref

Converts from a string key combination to an array

return: {Array}
param: {string} combination like "command+shift+l"

_getKeyInfo(combination, action) X-Ref

Gets info for a specific key combination

returns: {Object}
param: {string} combination key combination ("command+s" or "a" or "*")
param: {string=} action

_belongsTo(element, ancestor) X-Ref

No description

Mousetrap(targetElement) X-Ref

No description

_resetSequences(doNotReset) X-Ref

resets all sequence counters except for the ones passed in

returns: void
param: {Object} doNotReset

_getMatches(character, modifiers, e, sequenceName, combination, level) X-Ref

finds all callbacks that match based on the keycode, modifiers,
and action

returns: {Array}
param: {string} character
param: {Array} modifiers
param: {Event|Object} e
param: {string=} sequenceName - name of the sequence we are looking for
param: {string=} combination
param: {number=} level

_fireCallback(callback, e, combo, sequence) X-Ref

actually calls the callback function

if your callback function returns false this will use the jquery
convention - prevent default and stop propogation on the event

returns: void
param: {Function} callback
param: {Event} e

_handleKeyEvent(e) X-Ref

handles a keydown event

returns: void
param: {Event} e

_resetSequenceTimer() X-Ref

called to set a 1 second timeout on the specified sequence

this is so after each key press in the sequence you have 1 second
to press the next key before you have to start over

returns: void

_bindSequence(combo, keys, callback, action) X-Ref

binds a key sequence to an event

returns: void
param: {string} combo - combo specified in bind call
param: {Array} keys
param: {Function} callback
param: {string=} action

_increaseSequence(nextAction) X-Ref

callback to increase the sequence level for this sequence and reset
all other sequences that were active

returns: {Function}
param: {string} nextAction

_callbackAndReset(e) X-Ref

wraps the specified callback inside of another function in order
to reset all sequence counters as soon as this sequence is done

returns: void
param: {Event} e

_bindSingle(combination, callback, action, sequenceName, level) X-Ref

binds a single keyboard combination

returns: void
param: {string} combination
param: {Function} callback
param: {string=} action
param: {string=} sequenceName - name of sequence if part of sequence
param: {number=} level - what part of the sequence the command is

toObject(val) X-Ref

No description

shouldUseNative() X-Ref

No description

microtaskDebounce(fn) X-Ref

No description

taskDebounce(fn) X-Ref

No description

isFunction(functionToCheck) X-Ref

Check if the given variable is a function

returns: {Boolean} answer to: is a function?

getStyleComputedProperty(element, property) X-Ref

Get CSS computed property of the given element

getParentNode(element) X-Ref

Returns the parentNode or the host of the element

returns: {Element} parent

getScrollParent(element) X-Ref

Returns the scrolling parent of the given element

returns: {Element} scroll parent

isIE(version) X-Ref

Determines if the browser is Internet Explorer

returns: {Boolean} isIE
param: {Number} version to check

getOffsetParent(element) X-Ref

Returns the offset parent of the given element

returns: {Element} offset parent

isOffsetContainer(element) X-Ref

No description

getRoot(node) X-Ref

Finds the root node (document, shadowDOM root) of the given element

returns: {Element} root node

findCommonOffsetParent(element1, element2) X-Ref

Finds the offset parent common to the two provided nodes

returns: {Element} common offset parent

getScroll(element) X-Ref

Gets the scroll value of the given element in the given side (top and left)

returns: {number} amount of scrolled pixels

includeScroll(rect, element) X-Ref

No description

getBordersSize(styles, axis) X-Ref

No description

getSize(axis, body, html, computedStyle) X-Ref

No description

getWindowSizes(document) X-Ref

No description

defineProperties(target, props) X-Ref

No description

getClientRect(offsets) X-Ref

Given element offsets, generate an output similar to getBoundingClientRect

returns: {Object} ClientRect like output

getBoundingClientRect(element) X-Ref

Get bounding client rect of given element

return: {Object} client rect
param: {HTMLElement} element

getOffsetRectRelativeToArbitraryNode(children, parent) X-Ref

No description

getViewportOffsetRectRelativeToArtbitraryNode(element) X-Ref

No description

isFixed(element) X-Ref

Check if the given element is fixed or is inside a fixed parent

returns: {Boolean} answer to "isFixed?"

getFixedPositionOffsetParent(element) X-Ref

Finds the first parent of an element that has a transformed property defined

returns: {Element} first transformed parent or documentElement

getBoundaries(popper, reference, padding, boundariesElement) X-Ref

Computed the boundaries limits and return them

returns: {Object} Coordinates of the boundaries
param: {HTMLElement} popper
param: {HTMLElement} reference
param: {number} padding
param: {HTMLElement} boundariesElement - Element used to define the boundaries
param: {Boolean} fixedPosition - Is in fixed position mode

getArea(_ref) X-Ref

No description

computeAutoPlacement(placement, refRect, popper, reference, boundariesElement) X-Ref

Utility used to transform the `auto` placement to the placement with more
available space.

returns: {Object} The data object, properly modified

getReferenceOffsets(state, popper, reference) X-Ref

Get offsets to the reference element

returns: {Object} An object containing the offsets which will be applied to the popper
param: {Object} state
param: {Element} popper - the popper element
param: {Element} reference - the reference element (the popper will be relative to this)
param: {Element} fixedPosition - is in fixed position mode

getOuterSizes(element) X-Ref

Get the outer sizes of the given element (offset size + margins)

returns: {Object} object containing width and height properties

getOppositePlacement(placement) X-Ref

Get the opposite placement of the given one

returns: {String} flipped placement

getPopperOffsets(popper, referenceOffsets, placement) X-Ref

Get offsets to the popper

returns: {Object} popperOffsets - An object containing the offsets which will be applied to the popper
param: {Object} position - CSS position the Popper will get applied
param: {HTMLElement} popper - the popper element
param: {Object} referenceOffsets - the reference offsets (the popper will be relative to this)
param: {String} placement - one of the valid placement options

find(arr, check) X-Ref

Mimics the `find` method of Array

returns: index or -1

findIndex(arr, prop, value) X-Ref

Return the index of the matching object

returns: index or -1

runModifiers(modifiers, data, ends) X-Ref

Loop trough the list of modifiers and run them in order,
each of them will then edit the data object.

returns: {dataObject}
param: {dataObject} data
param: {Array} modifiers
param: {String} ends - Optional modifier name used as stopper

update() X-Ref

Updates the position of the popper, computing the new offsets and applying
the new style.<br />
Prefer `scheduleUpdate` over `update` because of performance reasons.

isModifierEnabled(modifiers, modifierName) X-Ref

Helper used to know if the given modifier is enabled.

returns: {Boolean}

getSupportedPropertyName(property) X-Ref

Get the prefixed supported property name

returns: {String} prefixed property (camelCase or PascalCase, depending on the vendor prefix)

destroy() X-Ref

Destroys the popper.

getWindow(element) X-Ref

Get the window associated with the element

returns: {Window}

attachToScrollParents(scrollParent, event, callback, scrollParents) X-Ref

No description

setupEventListeners(reference, options, state, updateBound) X-Ref

Setup needed event listeners used to update the popper position

enableEventListeners() X-Ref

It will add resize/scroll events and start recalculating
position of the popper element when they are triggered.

removeEventListeners(reference, state) X-Ref

Remove event listeners used to update the popper position

disableEventListeners() X-Ref

It will remove resize/scroll events and won't recalculate popper position
when they are triggered. It also won't trigger `onUpdate` callback anymore,
unless you call `update` method manually.

isNumeric(n) X-Ref

Tells if a given input is a number

return: {Boolean}
param: {*} input to check

setStyles(element, styles) X-Ref

Set the style to the given popper

setAttributes(element, attributes) X-Ref

Set the attributes to the given popper

applyStyle(data) X-Ref

returns: {Object} The same data object

applyStyleOnLoad(reference, popper, options, modifierOptions, state) X-Ref

Set the x-placement attribute before everything else because it could be used
to add margins to the popper margins needs to be calculated to get the
correct popper offsets.

param: {HTMLElement} reference - The reference element used to position the popper
param: {HTMLElement} popper - The HTML element used as popper
param: {Object} options - Popper.js options

getRoundedOffsets(data, shouldRound) X-Ref

returns: {Object} The popper's position offsets rounded

computeStyle(data, options) X-Ref

returns: {Object} The data object, properly modified

isModifierRequired(modifiers, requestingName, requestedName) X-Ref

Helper used to know if the given modifier depends from another one.<br />
It checks if the needed modifier is listed and enabled.

returns: {Boolean}
param: {Array} modifiers - list of modifiers
param: {String} requestingName - name of requesting modifier
param: {String} requestedName - name of requested modifier

arrow(data, options) X-Ref

returns: {Object} The data object, properly modified

getOppositeVariation(variation) X-Ref

Get the opposite placement variation of the given one

returns: {String} flipped placement variation

clockwise(placement) X-Ref

Given an initial placement, returns all the subsequent placements
clockwise (or counter-clockwise).

returns: {Array} placements including their variations

flip(data, options) X-Ref

returns: {Object} The data object, properly modified

keepTogether(data) X-Ref

returns: {Object} The data object, properly modified

toValue(str, measurement, popperOffsets, referenceOffsets) X-Ref

Converts a string containing value + unit into a px value number

returns: {Number|String}

parseOffset(offset, popperOffsets, referenceOffsets, basePlacement) X-Ref

Parse an `offset` string to extrapolate `x` and `y` numeric offsets.

returns: {Array} a two cells array with x and y offsets in numbers

offset(data, _ref) X-Ref

returns: {Object} The data object, properly modified

preventOverflow(data, options) X-Ref

returns: {Object} The data object, properly modified

shift(data) X-Ref

returns: {Object} The data object, properly modified

hide(data) X-Ref

returns: {Object} The data object, properly modified

inner(data) X-Ref

returns: {Object} The data object, properly modified

Popper(reference, popper) X-Ref

Creates a new Popper.js instance.

return: {Object} instance - The generated Popper.js instance
param: {HTMLElement|referenceObject} reference - The reference element used to position the popper
param: {HTMLElement} popper - The HTML element used as the popper
param: {Object} options - Your custom options to override the ones defined in [Defaults](#defaults)

checkPropTypes(typeSpecs, values, location, componentName, getStack) X-Ref

Assert that the values match with the type specs.
Error messages are memorized and will only be shown once.

param: {object} typeSpecs Map of name to a ReactPropType
param: {object} values Runtime values that need to be type-checked
param: {string} location e.g. "prop", "context", "child context"
param: {string} componentName Name of the component for error messages.
param: {?Function} getStack Returns the component stack.

emptyFunctionThatReturnsNull() X-Ref

No description

getIteratorFn(maybeIterable) X-Ref

Returns the iterator method function contained on the iterable object.

Be sure to invoke the function with the iterable as context:

var iteratorFn = getIteratorFn(myIterable);
if (iteratorFn) {
var iterator = iteratorFn.call(myIterable);
...
}

return: {?function}
param: {?object} maybeIterable

is(x, y) X-Ref

inlined Object.is polyfill to avoid requiring consumers ship their own
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is

PropTypeError(message) X-Ref

We use an Error-like object for backward compatibility as people may call
PropTypes directly and inspect their output. However, we don't use real
Errors anymore. We don't inspect their stack anyway, and creating them
is prohibitively expensive if they are created too often, such as what
happens in oneOfType() for any type before the one that matched.

createChainableTypeChecker(validate) X-Ref

No description

checkType(isRequired, props, propName, componentName, location, propFullName, secret) X-Ref

No description

createPrimitiveTypeChecker(expectedType) X-Ref

No description

validate(props, propName, componentName, location, propFullName, secret) X-Ref

No description

createAnyTypeChecker() X-Ref

No description

createArrayOfTypeChecker(typeChecker) X-Ref

No description