[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

Search

title

Body

[close]

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

WordPress dependencies

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

Defines 2 classes

Listener:: (1 method):
  withGlobalEvents()

Wrapper:: (49 methods):
  createId()
  useInstanceId()
  withState()
  useRefEffect()
  useConstrainedTabbing()
  onKeyDown()
  useCopyOnClick()
  useUpdatedRef()
  useCopyToClipboard()
  useFocusOnMount()
  useFocusReturn()
  isFocusNormalizedButton()
  useFocusOutside()
  assignRef()
  useMergeRefs()
  useDialog()
  useDisabled()
  useDragging()
  useKeyboardShortcut()
  getMediaQueryList()
  useMediaQuery()
  usePrevious()
  undoRedoReducer()
  initReducer()
  useStateWithHistory()
  useResolvedElement()
  useResizeObserver()
  useResizeAware()
  getFirstItemsPresentInState()
  useAsyncList()
  useWarnOnChange()
  areInputsEqual()
  useMemoOne()
  useCallbackOne()
  useDebounce()
  useDebouncedInput()
  useThrottle()
  useFreshRef()
  useDropZone()
  isElementInZone()
  maybeDragStart()
  onDragEnter()
  onDragOver()
  onDragLeave()
  onDrop()
  maybeDragEnd()
  useFocusableIframe()
  checkFocus()
  useFixedWindowList()

Defines 49 functions

  mergeHistoryChanges()
  createUndoManager()
  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_24495__()
  _addEvent()
  _characterFromEvent()
  _modifiersMatch()
  _eventModifiers()
  _preventDefault()
  _stopPropagation()
  _isModifier()
  _getReverseMap()
  _pickBestAction()
  _keysFromString()
  _getKeyInfo()
  _belongsTo()
  Mousetrap()
  _resetSequences()
  _getMatches()
  _fireCallback()
  _handleKeyEvent()
  _resetSequenceTimer()
  _bindSequence()
  _increaseSequence()
  _callbackAndReset()
  _bindSingle()
  __webpack_require__()
  __extends()
  __()
  __rest()
  __decorate()
  __param()
  __esDecorate()
  accept()
  __runInitializers()
  __propKey()
  __setFunctionName()
  __metadata()
  __awaiter()
  adopt()
  fulfilled()
  rejected()
  step()
  __generator()
  verb()
  step()
  __exportStar()
  __values()
  __read()
  __spread()
  __spreadArrays()
  __spreadArray()
  __await()
  __asyncGenerator()
  verb()
  resume()
  step()
  fulfill()
  reject()
  settle()
  __asyncDelegator()
  verb()
  __asyncValues()
  verb()
  settle()
  __makeTemplateObject()
  __importStar()
  __importDefault()
  __classPrivateFieldGet()
  __classPrivateFieldSet()
  __classPrivateFieldIn()
  __addDisposableResource()
  __disposeResources()
  fail()
  next()
  localeLowerCase()
  lowerCase()
  noCase()
  replace()
  pascalCaseTransform()
  pascalCaseTransformMerge()
  pascalCase()
  createHigherOrderComponent()
  invokeFunc()
  startTimer()
  cancelTimer()
  leadingEdge()
  getTimeSinceLastCall()
  remainingWait()
  shouldInvoke()
  timerExpired()
  clearTimer()
  trailingEdge()
  cancel()
  flush()
  pending()
  debounced()
  ifCondition()

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.

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.

useResolvedElement(subscriber, refOrElement)   X-Ref
No description

useResizeObserver(opts = {})   X-Ref
No description

useResizeAware()   X-Ref
Hook which allows to listen the resize event of any target element when it changes sizes.
_Note: `useResizeObserver` will report `null` until after first 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, 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: {any} defaultValue The default value to use.
return: {[string, Function, string]} 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

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

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

ifCondition(predicate)   X-Ref
No description



Generated : Thu Mar 28 08:20:01 2024 Cross-referenced by PHPXref