[ Index ]

PHP Cross Reference of WordPress

title

Body

[close]

/wp-includes/js/dist/ -> compose.js (summary)

(no description)

File Size: 4725 lines (152 kb)
Included or required:0 times
Referenced: 0 times
Includes or requires: 0 files

Defines 2 classes

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()

Defines 42 functions

  command()
  createFakeElement()
  _typeof()
  clipboard_typeof()
  _classCallCheck()
  _defineProperties()
  _createClass()
  _inherits()
  _setPrototypeOf()
  _createSuper()
  _possibleConstructorReturn()
  _assertThisInitialized()
  _isNativeReflectConstruct()
  _getPrototypeOf()
  getAttributeValue()
  Clipboard()
  closest()
  _delegate()
  delegate()
  listener()
  listen()
  listenNode()
  listenNodeList()
  listenSelector()
  select()
  E()
  listener()
  __nested_webpack_require_23879__()
  _addEvent()
  _characterFromEvent()
  _modifiersMatch()
  _eventModifiers()
  _preventDefault()
  _stopPropagation()
  _isModifier()
  _getReverseMap()
  _pickBestAction()
  _keysFromString()
  _getKeyInfo()
  _belongsTo()
  Mousetrap()
  _resetSequences()
  _getMatches()
  _fireCallback()
  _handleKeyEvent()
  _resetSequenceTimer()
  _bindSequence()
  _increaseSequence()
  _callbackAndReset()
  _bindSingle()
  __webpack_require__()
  createHigherOrderComponent()
  _extends()

Class: Listener  - X-Ref

Class responsible for orchestrating event handling on the global window,
binding a single event to be shared across all handling instances, and
removing the handler when no instances are listening for the event.

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.

param: {Record<keyof GlobalEventHandlersEventMap, string>} eventTypesToHandlers Object with keys of DOM
return: {any} Higher-order component.

Class: Wrapper  - X-Ref

createId(object)   X-Ref
Creates a new id for a given object.

param: {object} object Object reference to create an id for.
return: {number} The instance id (index).

useInstanceId(object, prefix)   X-Ref
Provides a 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.
return: {string | number} The unique instance id.

withState()   X-Ref
A Higher Order Component used to provide and manage internal component state
via props.

param: {any} initialState Optional initial state of the component.
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.

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.

param: callback     Callback with ref as argument.
param: dependencies Dependencies of the callback.
return: Ref 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.

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
return: {boolean} Whether or not the text has been copied. Resets after the

useUpdatedRef(value)   X-Ref

param: {T} value
return: {import('react').RefObject<T>} The updated ref

useCopyToClipboard(text, onSuccess)   X-Ref
Copies the given text to the clipboard when the element is clicked.

param: {string | (() => string)} text      The text to copy. Use a function if not
param: {Function}                onSuccess Called when to text is copied.
return: {import('react').Ref<TElementType>} A ref to assign to the target element.

useFocusOnMount()   X-Ref
Hook used to focus the first tabbable element on mount.

param: {boolean | 'firstElement'} focusOnMount Focus on mount mode.
return: {import('react').RefCallback<HTMLElement>} Ref callback.

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.

param: {() => void} [onFocusReturn] Overrides the default return behavior.
return: {import('react').RefCallback<HTMLElement>} Element Ref.

isFocusNormalizedButton(eventTarget)   X-Ref
Returns true if the given element is a button element subject to focus
normalization, or false otherwise.

param: {EventTarget} eventTarget The target from a mouse or touch event.
return: {eventTarget is FocusNormalizedButton} Whether element is a button.

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.

param: {EventCallback} onFocusOutside A callback triggered when focus moves outside
return: {FocusOutsideReturnValue} An object containing event handlers. Bind the event handlers

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 } />;
```

param: {Array<TRef>} refs The refs to be merged.
return: {import('react').RefCallback<TypeFromRef<TRef>>} The merged ref callback.

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.

param: {Window} [_window] window object by default; used for DI testing.
return: {boolean} True if MacOS; false otherwise.

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.

param: {string} [query] Media Query.
return: {boolean} return value of the media query.

usePrevious(value)   X-Ref
Use something's value from the previous render.
Based on https://usehooks.com/usePrevious/.

param: value The value to track.
return: The value from the previous render.

getFirstItemsPresentInState(list, state)   X-Ref
Returns the first items from list that are present on state.

param: list  New array.
param: state Current state.
return: First items present iin 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.

param: list   Source array.
param: config Configuration object.
return: Async array.

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`.

param: {TFunc}                             fn        The function to debounce.
param: {number}                            [wait]    The number of milliseconds to delay.
param: {import('lodash').DebounceSettings} [options] The options object.
return: {import('lodash').DebouncedFunc<TFunc>} Debounced function.

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`.

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.
return: {import('lodash').DebouncedFunc<TFunc>} Throttled function.

useFreshRef(value)   X-Ref

param: {T} value
return: {import('react').MutableRefObject<T|null>} A ref with the value.

useDropZone(_ref)   X-Ref
A hook to facilitate drag and drop handling.

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.
return: {import('react').RefCallback<HTMLElement>} Ref callback to be passed to the drop zone element.

isElementInZone(targetToCheck)   X-Ref
Checks if an element is in the drop zone.

param: {EventTarget|null} targetToCheck
return: {boolean} True if in drop zone, false if not.

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

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
return: {[ WPFixedWindowList, setFixedListWindow:(nextWindow:WPFixedWindowList)=>void]} Array with the fixed window list and setter

Functions
Functions that are not part of a class:

command(type)   X-Ref
Executes a given operation type.

param: {String} type
return: {Boolean}

createFakeElement(value)   X-Ref
Creates a fake textarea element with a value.

param: {String} value
return: {HTMLElement}

_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.

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

_delegate(element, selector, type, callback, useCapture)   X-Ref
Delegates event to a selector.

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

delegate(elements, selector, type, callback, useCapture)   X-Ref
Delegates event to a selector.

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

listener(element, selector, type, callback)   X-Ref
Finds closest match and invokes callback.

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

listen(target, type, callback)   X-Ref
Validates all params and calls the right
listener function based on its target type.

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

listenNode(node, type, callback)   X-Ref
Adds an event listener to a HTML element
and returns a remove listener function.

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

listenNodeList(nodeList, type, callback)   X-Ref
Add an event listener to a list of HTML elements
and returns a remove listener function.

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

listenSelector(selector, type, callback)   X-Ref
Add an event listener to a selector
and returns a remove listener function.

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

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

param: {Event} e
return: {string}

_modifiersMatch(modifiers1, modifiers2)   X-Ref
checks if two arrays are equal

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

_eventModifiers(e)   X-Ref
takes a key event and figures out what the modifiers are

param: {Event} e
returns: {Array}

_preventDefault(e)   X-Ref
prevents default for this event

param: {Event} e
returns: void

_stopPropagation(e)   X-Ref
stops propogation for this event

param: {Event} e
returns: void

_isModifier(key)   X-Ref
determines if the keycode specified is a modifier key or not

param: {string} key
returns: {boolean}

_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

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

_getKeyInfo(combination, action)   X-Ref
Gets info for a specific key combination

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

_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

param: {Object} doNotReset
returns: void

_getMatches(character, modifiers, e, sequenceName, combination, level)   X-Ref
finds all callbacks that match based on the keycode, modifiers,
and action

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
returns: {Array}

_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

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

_handleKeyEvent(e)   X-Ref
handles a keydown event

param: {Event} e
returns: void

_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

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

_increaseSequence(nextAction)   X-Ref
callback to increase the sequence level for this sequence and reset
all other sequences that were active

param: {string} nextAction
returns: {Function}

_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

param: {Event} e
returns: void

_bindSingle(combination, callback, action, sequenceName, level)   X-Ref
binds a single keyboard combination

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
returns: void

__webpack_require__(moduleId)   X-Ref
No description

createHigherOrderComponent(mapComponent, modifierName)   X-Ref
No description

_extends()   X-Ref
No description



Generated: Sun May 22 01:00:03 2022 Cross-referenced by PHPXref 0.7.1