PHPXRef 0.7.1 : WordPress Trunk (Updated Daily) : Detail view of compose.js

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 reference to create an id for.
return: The instance id (index).

useInstanceId(object, prefix, preferredId) X-Ref

Provides a unique instance ID.

param: object Object reference to create an id for.
param: [prefix] Prefix for the unique id.
param: [preferredId] Default ID to use.
return: The unique instance id.

withState(initialState = {}) 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, timeout = 4000) 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(focusOnMount = 'firstElement') 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

Adds the unmount behavior of returning focus to the element which had it
previously as is expected for roles like menus or dialogs.

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 The target from a mouse or touch event.
return: Whether the element is a button element subject to focus normalization.

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: onFocusOutside A callback triggered when focus moves outside
return: An object containing event handlers. Bind the event handlers to a

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: options Dialog Options.

useDisabled({isDisabled: isDisabledProp = false} = {}) 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.

If you can, prefer the use of the inert HTML attribute.

param: {Object} config Configuration object.
param: {boolean=} config.isDisabled Whether the element should be disabled.
return: {import('react').RefCallback<HTMLElement>} Element Ref.

useEvent(/*** The callback function to wrap.*/callback) X-Ref

Creates a stable callback function that has access to the latest state and
can be used within event handlers and effect callbacks. Throws when used in
the render phase.

param: callback The callback function to wrap.

useDragging({onDragStart,onDragMove,onDragEnd}) X-Ref

param: {Object}                                  props
param: {(e: import('react').MouseEvent) => void} props.onDragStart
param: {(e: MouseEvent) => void}                 props.onDragMove
param: {(e?: MouseEvent) => void}                props.onDragEnd

useKeyboardShortcut( shortcuts, callback, {bindGlobal = false,eventName = 'keydown',isDisabled = false,target} = {}) 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.

getMediaQueryList(query) X-Ref

A new MediaQueryList object for the media query

param: {string} [query] Media Query.
return: {MediaQueryList|null} A new object for the media query

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.

undoRedoReducer(state, action) X-Ref

WordPress dependencies

initReducer(value) X-Ref

No description

useStateWithHistory(initialValue) X-Ref

useState with undo/redo history.

param: initialValue Initial value.
return: Value, setValue, hasUndo, hasRedo, undo, redo.

useResizeObserver(callback, resizeObserverOptions = {}) X-Ref

No description

ResizeElement({onResize}) X-Ref

No description

sizeEquals(a, b) X-Ref

No description

useLegacyResizeObserver() X-Ref

Hook which allows to listen to the resize event of any target element when it changes size.
_Note: `useResizeObserver` will report `null` sizes until after first render.

use_resize_observer_useResizeObserver(callback, options = {}) X-Ref

**This is a legacy API and should not be used.**

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, config = {step: 1}) 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, prefix = 'Change detection') 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 similar to 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('../../utils/debounce').DebounceOptions} [options] The options object.
return: {import('../../utils/debounce').DebouncedFunc<TFunc>} Debounced function.

useDebouncedInput(defaultValue = '') X-Ref

Helper hook for input fields that need to debounce the value before using it.

param: defaultValue The default value to use.
return: The input value, the setter and the debounced input value.

useThrottle(fn, wait, options) X-Ref

Throttles a function similar to 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('../../utils/throttle').ThrottleOptions} [options] The options object. See linked documentation for details.
return: {import('../../utils/debounce').DebouncedFunc<TFunc>} Throttled function.

useFreshRef(value) X-Ref

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

useDropZone({dropZoneElement,isDisabled,onDrop: _onDrop,onDragStart: _onDragStart,onDragEnter: _onDragEnter,onDragLeave: _onDragLeave,onDragEnd: _onDragEnd,onDragOver: _onDragOver}) X-Ref

A hook to facilitate drag and drop handling.

param: {Object}                  props                   Named parameters.
param: {?HTMLElement}            [props.dropZoneElement] Optional element to be used as the drop zone.
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: 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

useObservableValue(map, name) X-Ref

React hook that lets you observe an entry in an `ObservableMap`. The hook returns the
current value corresponding to the key, or `undefined` when there is no value stored.
It also observes changes to the value and triggers an update of the calling component
in case the value changes.

param: map The `ObservableMap` to observe.
param: name The map key to observe.
return: The value corresponding to the map key requested.

Functions

Functions that are not part of a class:

mergeHistoryChanges(changes1, changes2) X-Ref

Merge changes for a single item into a record of changes.

param: {Record< string, HistoryChange >} changes1 Previous changes
param: {Record< string, HistoryChange >} changes2 NextChanges
return: {Record< string, HistoryChange >} Merged changes

createUndoManager() X-Ref

Creates an undo manager.

return: {UndoManager} Undo manager.

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

__extends(d, b) X-Ref

No description

__() X-Ref

No description

__rest(s, e) X-Ref

No description

__decorate(decorators, target, key, desc) X-Ref

No description

__param(paramIndex, decorator) X-Ref

No description

__esDecorate(ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) X-Ref

No description

accept(f) X-Ref

No description

__runInitializers(thisArg, initializers, value) X-Ref

No description

__propKey(x) X-Ref

No description

__setFunctionName(f, name, prefix) X-Ref

No description

__metadata(metadataKey, metadataValue) X-Ref

No description

__awaiter(thisArg, _arguments, P, generator) X-Ref

No description

adopt(value) X-Ref

No description

fulfilled(value) X-Ref

No description

rejected(value) X-Ref

No description

step(result) X-Ref

No description

__generator(thisArg, body) X-Ref

No description

verb(n) X-Ref

No description

step(op) X-Ref

No description

__exportStar(m, o) X-Ref

No description

__values(o) X-Ref

No description

__read(o, n) X-Ref

No description

__spread() X-Ref

No description

__spreadArrays() X-Ref

No description

__spreadArray(to, from, pack) X-Ref

No description

__await(v) X-Ref

No description

__asyncGenerator(thisArg, _arguments, generator) X-Ref

No description

awaitReturn(f) X-Ref

No description

verb(n, f) X-Ref

No description

resume(n, v) X-Ref

No description

step(r) X-Ref

No description

fulfill(value) X-Ref

No description

reject(value) X-Ref

No description

settle(f, v) X-Ref

No description

__asyncDelegator(o) X-Ref

No description

verb(n, f) X-Ref

No description

__asyncValues(o) X-Ref

No description

verb(n) X-Ref

No description

settle(resolve, reject, d, v) X-Ref

No description

__makeTemplateObject(cooked, raw) X-Ref

No description

__importStar(mod) X-Ref

No description

__importDefault(mod) X-Ref

No description

__classPrivateFieldGet(receiver, state, kind, f) X-Ref

No description

__classPrivateFieldSet(receiver, state, value, kind, f) X-Ref

No description

__classPrivateFieldIn(state, receiver) X-Ref

No description

__addDisposableResource(env, value, async) X-Ref

No description

__disposeResources(env) X-Ref

No description

fail(e) X-Ref

No description

next() X-Ref

No description

localeLowerCase(str, locale) X-Ref

Localized lower case.

lowerCase(str) X-Ref

Lower case as a function.

noCase(input, options) X-Ref

Normalize the string into something other libraries can manipulate easier.

replace(input, re, value) X-Ref

Replace `re` in the input string with the replacement value.

pascalCaseTransform(input, index) X-Ref

No description

pascalCaseTransformMerge(input) X-Ref

No description

pascalCase(input, options) X-Ref

No description

createHigherOrderComponent(mapComponent, modifierName) X-Ref

Given a function mapping a component to an enhanced component and modifier
name, returns the enhanced component augmented with a generated displayName.

param: mapComponent Function mapping component to enhanced component.
param: modifierName Seed name from which to generated display name.
return: Component class with generated display name assigned.

invokeFunc(time) X-Ref

No description

startTimer(pendingFunc, waitTime) X-Ref

No description

cancelTimer() X-Ref

No description

leadingEdge(time) X-Ref

No description

getTimeSinceLastCall(time) X-Ref

No description

remainingWait(time) X-Ref

No description

shouldInvoke(time) X-Ref

No description

timerExpired() X-Ref

No description

clearTimer() X-Ref

No description

trailingEdge(time) X-Ref

No description

cancel() X-Ref

No description

flush() X-Ref

No description

pending() X-Ref

No description

debounced(...args) X-Ref

No description

observableMap() X-Ref

A constructor (factory) for `ObservableMap`, a map-like key/value data structure
where the individual entries are observable: using the `subscribe` method, you can
subscribe to updates for a particular keys. Each subscriber always observes one
specific key and is not notified about any unrelated changes (for different keys)
in the `ObservableMap`.

return: A new instance of the `ObservableMap` type.

callListeners(name) X-Ref

No description

ifCondition(predicate) X-Ref

No description

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

PHP Cross Reference of WordPress Trunk (Updated Daily)

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

Defines 2 classes

Defines 53 functions