| [ Index ] |
PHP Cross Reference of WordPress Trunk (Updated Daily) |
[Source view] [Print] [Project Stats]
WordPress dependencies
| File Size: | 6008 lines (201 kb) |
| Included or required: | 0 times |
| Referenced: | 0 times |
| Includes or requires: | 0 files |
Listener:: (1 method):
withGlobalEvents()
Wrapper:: (53 methods):
createId()
useInstanceId()
withState()
useRefEffect()
useConstrainedTabbing()
onKeyDown()
useCopyOnClick()
useUpdatedRef()
useCopyToClipboard()
useFocusOnMount()
useFocusReturn()
isFocusNormalizedButton()
useFocusOutside()
assignRef()
useMergeRefs()
useDialog()
useDisabled()
useEvent()
useDragging()
useKeyboardShortcut()
getMediaQueryList()
useMediaQuery()
usePrevious()
undoRedoReducer()
initReducer()
useStateWithHistory()
useResizeObserver()
ResizeElement()
sizeEquals()
useLegacyResizeObserver()
use_resize_observer_useResizeObserver()
getFirstItemsPresentInState()
useAsyncList()
useWarnOnChange()
areInputsEqual()
useMemoOne()
useCallbackOne()
useDebounce()
useDebouncedInput()
useThrottle()
useFreshRef()
useDropZone()
isElementInZone()
maybeDragStart()
onDragEnter()
onDragOver()
onDragLeave()
onDrop()
maybeDragEnd()
useFocusableIframe()
checkFocus()
useFixedWindowList()
useObservableValue()
| 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: The instance id (index). param: object Object reference to create an id for. |
| useInstanceId(object, prefix, preferredId) X-Ref |
| Provides a unique instance ID. return: The 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. |
| withState(initialState = {}) 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, timeout = 4000) 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(focusOnMount = 'firstElement') 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 |
| Adds the unmount behavior of returning focus to the element which had it previously as is expected for roles like menus or dialogs. 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: Whether the element is a button element subject to focus normalization. param: 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: An object containing event handlers. Bind the event handlers to a param: 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: 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. return: {import('react').RefCallback<HTMLElement>} Element Ref. param: {Object} config Configuration object. param: {boolean=} config.isDisabled Whether the element should be disabled. |
| 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 return: {MediaQueryList|null} A new object for the media query param: {string} [query] Media Query. |
| 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. |
| undoRedoReducer(state, action) X-Ref |
| WordPress dependencies |
| initReducer(value) X-Ref |
| No description |
| useStateWithHistory(initialValue) X-Ref |
| useState with undo/redo history. return: Value, setValue, hasUndo, hasRedo, undo, redo. param: initialValue Initial value. |
| 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. return: First items present iin state. param: list New array. param: state Current 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. return: Async array. param: list Source array. param: config Configuration object. |
| 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`. return: {import('../../utils/debounce').DebouncedFunc<TFunc>} Debounced function. 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. |
| useDebouncedInput(defaultValue = '') X-Ref |
| Helper hook for input fields that need to debounce the value before using it. return: The input value, the setter and the debounced input value. param: defaultValue The default value to use. |
| 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`. return: {import('../../utils/debounce').DebouncedFunc<TFunc>} Throttled function. 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. |
| useFreshRef(value) X-Ref |
return: {import('react').MutableRefObject<T|null>} A ref with the value. param: {T} 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. return: {import('react').RefCallback<HTMLElement>} Ref callback to be passed to the drop zone element. 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. |
| 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: 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 |
| 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. return: The value corresponding to the map key requested. param: map The `ObservableMap` to observe. param: name The map key to observe. |
| mergeHistoryChanges(changes1, changes2) X-Ref |
| Merge changes for a single item into a record of changes. return: {Record< string, HistoryChange >} Merged changes param: {Record< string, HistoryChange >} changes1 Previous changes param: {Record< string, HistoryChange >} changes2 NextChanges |
| createUndoManager() X-Ref |
| Creates an undo manager. return: {UndoManager} Undo manager. |
| 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_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 return: {string} param: {Event} e |
| _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 return: {Array} param: {string} combination like "command+shift+l" |
| _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. return: Component class with generated display name assigned. param: mapComponent Function mapping component to enhanced component. param: modifierName Seed name from which to generated display name. |
| 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 |
| Generated : Sat Dec 21 08:20:01 2024 | Cross-referenced by PHPXref |