| [ Index ] |
PHP Cross Reference of WordPress |
[Source view] [Print] [Project Stats]
(no description)
| File Size: | 4725 lines (152 kb) |
| Included or required: | 0 times |
| Referenced: | 0 times |
| Includes or requires: | 0 files |
Listener:: (1 method):
withGlobalEvents()
Wrapper:: (42 methods):
createId()
useInstanceId()
withState()
useRefEffect()
useConstrainedTabbing()
onKeyDown()
useCopyOnClick()
useUpdatedRef()
useCopyToClipboard()
useFocusOnMount()
useFocusReturn()
isFocusNormalizedButton()
useFocusOutside()
assignRef()
useMergeRefs()
useDialog()
useDisabled()
useDragging()
isAppleOS()
useKeyboardShortcut()
useMediaQuery()
usePrevious()
getFirstItemsPresentInState()
useAsyncList()
useWarnOnChange()
areInputsEqual()
useMemoOne()
useCallbackOne()
useDebounce()
useThrottle()
useFreshRef()
useDropZone()
isElementInZone()
maybeDragStart()
onDragEnter()
onDragOver()
onDragLeave()
onDrop()
maybeDragEnd()
useFocusableIframe()
checkFocus()
useFixedWindowList()
| withGlobalEvents(eventTypesToHandlers) X-Ref |
| Higher-order component creator which, given an object of DOM event types and values corresponding to a callback function name on the component, will create or update a window event handler to invoke the callback when an event occurs. On behalf of the consuming developer, the higher-order component manages unbinding when the component unmounts, and binding at most a single event handler for the entire application. return: {any} Higher-order component. param: {Record<keyof GlobalEventHandlersEventMap, string>} eventTypesToHandlers Object with keys of DOM |
| createId(object) X-Ref |
| Creates a new id for a given object. return: {number} The instance id (index). param: {object} object Object reference to create an id for. |
| useInstanceId(object, prefix) X-Ref |
| Provides a unique instance ID. return: {string | number} The unique instance id. param: {object} object Object reference to create an id for. param: {string} [prefix] Prefix for the unique id. param: {string | number} [preferredId=''] Default ID to use. |
| withState() X-Ref |
| A Higher Order Component used to provide and manage internal component state via props. return: {any} A higher order component wrapper accepting a component that takes the state props + its own props + `setState` and returning a component that only accepts the own props. param: {any} initialState Optional initial state of the component. |
| useRefEffect(callback, dependencies) X-Ref |
| Effect-like ref callback. Just like with `useEffect`, this allows you to return a cleanup function to be run if the ref changes or one of the dependencies changes. The ref is provided as an argument to the callback functions. The main difference between this and `useEffect` is that the `useEffect` callback is not called when the ref changes, but this is. Pass the returned ref callback as the component's ref and merge multiple refs with `useMergeRefs`. It's worth noting that if the dependencies array is empty, there's not strictly a need to clean up event handlers for example, because the node is to be removed. It *is* necessary if you add dependencies because the ref callback will be called multiple times for the same node. return: Ref callback. param: callback Callback with ref as argument. param: dependencies Dependencies of the callback. |
| useConstrainedTabbing() X-Ref |
| In Dialogs/modals, the tabbing must be constrained to the content of the wrapper element. This hook adds the behavior to the returned ref. return: {import('react').RefCallback<Element>} Element Ref. |
| onKeyDown(event) X-Ref |
| No description |
| useCopyOnClick(ref, text) X-Ref |
| Copies the text to the clipboard when the element is clicked. return: {boolean} Whether or not the text has been copied. Resets after the param: {import('react').RefObject<string | Element | NodeListOf<Element>>} ref Reference with the element. param: {string|Function} text The text to copy. param: {number} [timeout] Optional timeout to reset the returned |
| useUpdatedRef(value) X-Ref |
return: {import('react').RefObject<T>} The updated ref param: {T} value |
| useCopyToClipboard(text, onSuccess) X-Ref |
| Copies the given text to the clipboard when the element is clicked. return: {import('react').Ref<TElementType>} A ref to assign to the target element. param: {string | (() => string)} text The text to copy. Use a function if not param: {Function} onSuccess Called when to text is copied. |
| useFocusOnMount() X-Ref |
| Hook used to focus the first tabbable element on mount. return: {import('react').RefCallback<HTMLElement>} Ref callback. param: {boolean | 'firstElement'} focusOnMount Focus on mount mode. |
| useFocusReturn(onFocusReturn) X-Ref |
| When opening modals/sidebars/dialogs, the focus must move to the opened area and return to the previously focused element when closed. The current hook implements the returning behavior. return: {import('react').RefCallback<HTMLElement>} Element Ref. param: {() => void} [onFocusReturn] Overrides the default return behavior. |
| isFocusNormalizedButton(eventTarget) X-Ref |
| Returns true if the given element is a button element subject to focus normalization, or false otherwise. return: {eventTarget is FocusNormalizedButton} Whether element is a button. param: {EventTarget} eventTarget The target from a mouse or touch event. |
| useFocusOutside(onFocusOutside) X-Ref |
| A react hook that can be used to check whether focus has moved outside the element the event handlers are bound to. return: {FocusOutsideReturnValue} An object containing event handlers. Bind the event handlers param: {EventCallback} onFocusOutside A callback triggered when focus moves outside |
| assignRef(ref, value) X-Ref |
param: {import('react').Ref<T>} ref param: {T} value |
| useMergeRefs(refs) X-Ref |
| Merges refs into one ref callback. It also ensures that the merged ref callbacks are only called when they change (as a result of a `useCallback` dependency update) OR when the ref value changes, just as React does when passing a single ref callback to the component. As expected, if you pass a new function on every render, the ref callback will be called after every render. If you don't wish a ref callback to be called after every render, wrap it with `useCallback( callback, dependencies )`. When a dependency changes, the old ref callback will be called with `null` and the new ref callback will be called with the same value. To make ref callbacks easier to use, you can also pass the result of `useRefEffect`, which makes cleanup easier by allowing you to return a cleanup function instead of handling `null`. It's also possible to _disable_ a ref (and its behaviour) by simply not passing the ref. ```jsx const ref = useRefEffect( ( node ) => { node.addEventListener( ... ); return () => { node.removeEventListener( ... ); }; }, [ ...dependencies ] ); const otherRef = useRef(); const mergedRefs useMergeRefs( [ enabled && ref, otherRef, ] ); return <div ref={ mergedRefs } />; ``` return: {import('react').RefCallback<TypeFromRef<TRef>>} The merged ref callback. param: {Array<TRef>} refs The refs to be merged. |
| useDialog(options) X-Ref |
| Returns a ref and props to apply to a dialog wrapper to enable the following behaviors: - constrained tabbing. - focus on mount. - return focus on unmount. - focus outside. param: {DialogOptions} options Dialog Options. |
| useDisabled() X-Ref |
| In some circumstances, such as block previews, all focusable DOM elements (input fields, links, buttons, etc.) need to be disabled. This hook adds the behavior to disable nested DOM elements to the returned ref. return: {import('react').RefObject<HTMLElement>} Element Ref. |
| useDragging(_ref) X-Ref |
param: {Object} props param: {(e: MouseEvent) => void} props.onDragStart param: {(e: MouseEvent) => void} props.onDragMove param: {(e: MouseEvent) => void} props.onDragEnd |
| isAppleOS() X-Ref |
| Return true if platform is MacOS. return: {boolean} True if MacOS; false otherwise. param: {Window} [_window] window object by default; used for DI testing. |
| useKeyboardShortcut(shortcuts, callback) X-Ref |
| Attach a keyboard shortcut handler. param: {string[]|string} shortcuts Keyboard Shortcuts. param: {(e: import('mousetrap').ExtendedKeyboardEvent, combo: string) => void} callback Shortcut callback. param: {WPKeyboardShortcutConfig} options Shortcut options. |
| useMediaQuery(query) X-Ref |
| Runs a media query and returns its value when it changes. return: {boolean} return value of the media query. param: {string} [query] Media Query. |
| usePrevious(value) X-Ref |
| Use something's value from the previous render. Based on https://usehooks.com/usePrevious/. return: The value from the previous render. param: value The value to track. |
| getFirstItemsPresentInState(list, state) X-Ref |
| Returns the first items from list that are present on state. return: First items present iin state. param: list New array. param: state Current state. |
| useAsyncList(list) X-Ref |
| React hook returns an array which items get asynchronously appended from a source array. This behavior is useful if we want to render a list of items asynchronously for performance reasons. return: Async array. param: list Source array. param: config Configuration object. |
| useWarnOnChange(object) X-Ref |
| Hook that performs a shallow comparison between the preview value of an object and the new one, if there's a difference, it prints it to the console. this is useful in performance related work, to check why a component re-renders. param: {object} object Object which changes to compare. param: {string} prefix Just a prefix to show when console logging. |
| areInputsEqual(newInputs, lastInputs) X-Ref |
| No description |
| useMemoOne(getResult, inputs) X-Ref |
| No description |
| useCallbackOne(callback, inputs) X-Ref |
| No description |
| useDebounce(fn, wait, options) X-Ref |
| Debounces a function with Lodash's `debounce`. A new debounced function will be returned and any scheduled calls cancelled if any of the arguments change, including the function to debounce, so please wrap functions created on render in components in `useCallback`. return: {import('lodash').DebouncedFunc<TFunc>} Debounced function. param: {TFunc} fn The function to debounce. param: {number} [wait] The number of milliseconds to delay. param: {import('lodash').DebounceSettings} [options] The options object. |
| useThrottle(fn, wait, options) X-Ref |
| Throttles a function with Lodash's `throttle`. A new throttled function will be returned and any scheduled calls cancelled if any of the arguments change, including the function to throttle, so please wrap functions created on render in components in `useCallback`. return: {import('lodash').DebouncedFunc<TFunc>} Throttled function. param: {TFunc} fn The function to throttle. param: {number} [wait] The number of milliseconds to throttle invocations to. param: {import('lodash').ThrottleSettings} [options] The options object. See linked documentation for details. |
| useFreshRef(value) X-Ref |
return: {import('react').MutableRefObject<T|null>} A ref with the value. param: {T} value |
| useDropZone(_ref) X-Ref |
| A hook to facilitate drag and drop handling. return: {import('react').RefCallback<HTMLElement>} Ref callback to be passed to the drop zone element. param: {Object} props Named parameters. param: {boolean} props.isDisabled Whether or not to disable the drop zone. param: {(e: DragEvent) => void} props.onDragStart Called when dragging has started. param: {(e: DragEvent) => void} props.onDragEnter Called when the zone is entered. param: {(e: DragEvent) => void} props.onDragOver Called when the zone is moved within. param: {(e: DragEvent) => void} props.onDragLeave Called when the zone is left. param: {(e: MouseEvent) => void} props.onDragEnd Called when dragging has ended. param: {(e: DragEvent) => void} props.onDrop Called when dropping in the zone. |
| isElementInZone(targetToCheck) X-Ref |
| Checks if an element is in the drop zone. return: {boolean} True if in drop zone, false if not. param: {EventTarget|null} targetToCheck |
| maybeDragStart(event) X-Ref |
| No description |
| onDragEnter(event) X-Ref |
| No description |
| onDragOver(event) X-Ref |
| No description |
| onDragLeave(event) X-Ref |
| No description |
| onDrop(event) X-Ref |
| No description |
| maybeDragEnd(event) X-Ref |
| No description |
| useFocusableIframe() X-Ref |
| Dispatches a bubbling focus event when the iframe receives focus. Use `onFocus` as usual on the iframe or a parent element. return: {Object} Ref to pass to the iframe. |
| checkFocus() X-Ref |
| Checks whether the iframe is the activeElement, inferring that it has then received focus, and dispatches a focus event. |
| useFixedWindowList(elementRef, itemHeight, totalItems, options) X-Ref |
return: {[ WPFixedWindowList, setFixedListWindow:(nextWindow:WPFixedWindowList)=>void]} Array with the fixed window list and setter param: {import('react').RefObject<HTMLElement>} elementRef Used to find the closest scroll container that contains element. param: { number } itemHeight Fixed item height in pixels param: { number } totalItems Total items in list param: { WPFixedWindowListOptions } [options] Options object |
| command(type) X-Ref |
| Executes a given operation type. return: {Boolean} param: {String} type |
| createFakeElement(value) X-Ref |
| Creates a fake textarea element with a value. return: {HTMLElement} param: {String} value |
| _typeof(obj) X-Ref |
| No description |
| clipboard_typeof(obj) X-Ref |
| No description |
| _classCallCheck(instance, Constructor) X-Ref |
| No description |
| _defineProperties(target, props) X-Ref |
| No description |
| _createClass(Constructor, protoProps, staticProps) X-Ref |
| No description |
| _inherits(subClass, superClass) X-Ref |
| No description |
| _setPrototypeOf(o, p) X-Ref |
| No description |
| _createSuper(Derived) X-Ref |
| No description |
| _possibleConstructorReturn(self, call) X-Ref |
| No description |
| _assertThisInitialized(self) X-Ref |
| No description |
| _isNativeReflectConstruct() X-Ref |
| No description |
| _getPrototypeOf(o) X-Ref |
| No description |
| getAttributeValue(suffix, element) X-Ref |
| Helper function to retrieve attribute value. param: {String} suffix param: {Element} element |
| Clipboard(trigger, options) X-Ref |
param: {String|HTMLElement|HTMLCollection|NodeList} trigger param: {Object} options |
| 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 |
| 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 |
| select(element) X-Ref |
| No description |
| E() X-Ref |
| No description |
| listener() X-Ref |
| No description |
| __nested_webpack_require_23879__(moduleId) X-Ref |
| No description |
| _addEvent(object, type, callback) X-Ref |
| No description |
| _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 |
| __webpack_require__(moduleId) X-Ref |
| No description |
| createHigherOrderComponent(mapComponent, modifierName) X-Ref |
| No description |
| _extends() X-Ref |
| No description |
| Generated: Tue Dec 24 01:00:02 2024 | Cross-referenced by PHPXref 0.7.1 |