PHPXRef 0.7.1 : WordPress : Detail view of data.js

Given an instance of EquivalentKeyMap, returns its internal value pair tuple
for a key, if one exists. The tuple members consist of the last reference
value for the key (used in efficient subsequent lookups) and the value
assigned for the key at the leaf node.

return: {?Array} Value pair, if exists.
param: {EquivalentKeyMap} instance EquivalentKeyMap instance.
param: {*} key The key for which to return value pair.

EquivalentKeyMap(iterable) X-Ref

No description

isPromise(obj) X-Ref

No description

areInputsEqual(newInputs, lastInputs) X-Ref

No description

useMemoOne(getResult, inputs) X-Ref

No description

useCallbackOne(callback, inputs) X-Ref

No description

_defineProperty(obj, key, value) X-Ref

No description

ownKeys(object, enumerableOnly) X-Ref

No description

_objectSpread2(target) X-Ref

No description

formatProdErrorMessage(code) X-Ref

Adapted from React: https://github.com/facebook/react/blob/master/packages/shared/formatProdErrorMessage.js

Do not require this module directly! Use normal throw error calls. These messages will be replaced with error codes
during build.
param: {number} code

isPlainObject(obj) X-Ref

param: {any} obj The object to inspect.
returns: {boolean} True if the argument appears to be a plain object.

miniKindOf(val) X-Ref

No description

ctorName(val) X-Ref

No description

isError(val) X-Ref

No description

isDate(val) X-Ref

No description

kindOf(val) X-Ref

No description

redux_createStore(reducer, preloadedState, enhancer) X-Ref

Creates a Redux store that holds the state tree.
The only way to change the data in the store is to call `dispatch()` on it.

There should only be a single store in your app. To specify how different
parts of the state tree respond to actions, you may combine several reducers
into a single reducer function by using `combineReducers`.

param: {Function} reducer A function that returns the next state tree, given
param: {any} [preloadedState] The initial state. You may optionally specify it
param: {Function} [enhancer] The store enhancer. You may optionally specify it
returns: {Store} A Redux store that lets you read the state, dispatch actions

ensureCanMutateNextListeners() X-Ref

This makes a shallow copy of currentListeners so we can use
nextListeners as a temporary list while dispatching.

This prevents any bugs around consumers calling
subscribe/unsubscribe in the middle of a dispatch.

getState() X-Ref

Reads the state tree managed by the store.

returns: {any} The current state tree of your application.

subscribe(listener) X-Ref

Adds a change listener. It will be called any time an action is dispatched,
and some part of the state tree may potentially have changed. You may then
call `getState()` to read the current state tree inside the callback.

You may call `dispatch()` from a change listener, with the following
caveats:

1. The subscriptions are snapshotted just before every `dispatch()` call.
If you subscribe or unsubscribe while the listeners are being invoked, this
will not have any effect on the `dispatch()` that is currently in progress.
However, the next `dispatch()` call, whether nested or not, will use a more
recent snapshot of the subscription list.

2. The listener should not expect to see all state changes, as the state
might have been updated multiple times during a nested `dispatch()` before
the listener is called. It is, however, guaranteed that all subscribers
registered before the `dispatch()` started will be called with the latest
state by the time it exits.

param: {Function} listener A callback to be invoked on every dispatch.
returns: {Function} A function to remove this change listener.

dispatch(action) X-Ref

Dispatches an action. It is the only way to trigger a state change.

The `reducer` function, used to create the store, will be called with the
current state tree and the given `action`. Its return value will
be considered the **next** state of the tree, and the change listeners
will be notified.

The base implementation only supports plain object actions. If you want to
dispatch a Promise, an Observable, a thunk, or something else, you need to
wrap your store creating function into the corresponding middleware. For
example, see the documentation for the `redux-thunk` package. Even the
middleware will eventually dispatch plain object actions using this method.

param: {Object} action A plain object representing “what changed”. It is
returns: {Object} For convenience, the same action object you dispatched.

replaceReducer(nextReducer) X-Ref

Replaces the reducer currently used by the store to calculate the state.

You might need this if your app implements code splitting and you want to
load some of the reducers dynamically. You might also need this if you
implement a hot reloading mechanism for Redux.

param: {Function} nextReducer The reducer for the store to use instead.
returns: {void}

observable() X-Ref

Interoperability point for observable/reactive libraries.

returns: {observable} A minimal observable of state changes.

observeState() X-Ref

No description

warning(message) X-Ref

Prints a warning in the console if it exists.

param: {String} message The warning message.
returns: {void}

getUnexpectedStateShapeWarningMessage(inputState, reducers, action, unexpectedKeyCache) X-Ref

No description

assertReducerShape(reducers) X-Ref

No description

combineReducers(reducers) X-Ref

Turns an object whose values are different reducer functions, into a single
reducer function. It will call every child reducer, and gather their results
into a single state object, whose keys correspond to the keys of the passed
reducer functions.

param: {Object} reducers An object whose values correspond to different
returns: {Function} A reducer function that invokes every reducer inside the

bindActionCreator(actionCreator, dispatch) X-Ref

No description

bindActionCreators(actionCreators, dispatch) X-Ref

Turns an object whose values are action creators, into an object with the
same keys, but with every function wrapped into a `dispatch` call so they
may be invoked directly. This is just a convenience method, as you can call
`store.dispatch(MyActionCreators.doSomething())` yourself just fine.

For convenience, you can also pass an action creator as the first argument,
and get a dispatch wrapped function in return.

param: {Function|Object} actionCreators An object whose values are action
param: {Function} dispatch The `dispatch` function available on your Redux
returns: {Function|Object} The object mimicking the original object, but with

compose() X-Ref

Composes single-argument functions from right to left. The rightmost
function can take multiple arguments as it provides the signature for
the resulting composite function.

param: {...Function} funcs The functions to compose.
returns: {Function} A function obtained by composing the argument functions

applyMiddleware() X-Ref

Creates a store enhancer that applies middleware to the dispatch method
of the Redux store. This is handy for a variety of tasks, such as expressing
asynchronous actions in a concise manner, or logging every action payload.

See `redux-thunk` package as an example of the Redux middleware.

Because middleware is potentially asynchronous, this should be the first
store enhancer in the composition chain.

Note that each middleware will be given the `dispatch` and `getState` functions
as named arguments.

param: {...Function} middlewares The middleware chain to be applied.
returns: {Function} A store enhancer applying the middleware.

isCrushed() X-Ref

No description

createRegistrySelector(registrySelector) X-Ref

Creates a selector function that takes additional curried argument with the
registry `select` function. While a regular selector has signature
```js
( state, ...selectorArgs ) => ( result )
```
that allows to select data from the store's `state`, a registry selector
has signature:
```js
( select ) => ( state, ...selectorArgs ) => ( result )
```
that supports also selecting from other registered stores.

return: {Function} Registry selector that can be registered with a store.
param: {Function} registrySelector Function receiving a registry `select`

createRegistryControl(registryControl) X-Ref

Creates a control function that takes additional curried argument with the `registry` object.
While a regular control has signature
```js
( action ) => ( iteratorOrPromise )
```
where the control works with the `action` that it's bound to, a registry control has signature:
```js
( registry ) => ( action ) => ( iteratorOrPromise )
```
A registry control is typically used to select data or dispatch an action to a registered
store.

When registering a control created with `createRegistryControl` with a store, the store
knows which calling convention to use when executing the control.

return: {Function} Registry control that can be registered with a store.
param: {Function} registryControl Function receiving a registry object and returning a control.

controls_select(storeKey, selectorName, ...args) X-Ref

Dispatches a control action for triggering a synchronous registry select.

Note: This control synchronously returns the current selector value, triggering the
resolution, but not waiting for it.

return: {Object} The control descriptor.
param: {string} storeKey The key for the store the selector belongs to.
param: {string} selectorName The name of the selector.
param: {Array} args Arguments for the selector.

controls_resolveSelect(storeKey, selectorName, ...args) X-Ref

Dispatches a control action for triggering and resolving a registry select.

Note: when this control action is handled, it automatically considers
selectors that may have a resolver. In such case, it will return a `Promise` that resolves
after the selector finishes resolving, with the final result value.

return: {Object} The control descriptor.
param: {string} storeKey      The key for the store the selector belongs to
param: {string} selectorName  The name of the selector
param: {Array}  args          Arguments for the selector.

controls_dispatch(storeKey, actionName, ...args) X-Ref

Dispatches a control action for triggering a registry dispatch.

return: {Object}  The control descriptor.
param: {string} storeKey    The key for the store the action belongs to
param: {string} actionName  The name of the action to dispatch
param: {Array}  args        Arguments for the dispatch action.

createThunkMiddleware(args) X-Ref

No description

getIsResolving(state, selectorName, args) X-Ref

Returns the raw `isResolving` value for a given selector name,
and arguments set. May be undefined if the selector has never been resolved
or not resolved for the given set of arguments, otherwise true or false for
resolution started and completed respectively.

return: {?boolean} isResolving value.
param: {Object} state Data state.
param: {string} selectorName Selector name.
param: {Array} args Arguments passed to selector.

hasStartedResolution(state, selectorName, args = []) X-Ref

Returns true if resolution has already been triggered for a given
selector name, and arguments set.

return: {boolean} Whether resolution has been triggered.
param: {Object} state Data state.
param: {string} selectorName Selector name.
param: {?Array} args Arguments passed to selector (default `[]`).

hasFinishedResolution(state, selectorName, args = []) X-Ref

Returns true if resolution has completed for a given selector
name, and arguments set.

return: {boolean} Whether resolution has completed.
param: {Object} state Data state.
param: {string} selectorName Selector name.
param: {?Array} args Arguments passed to selector.

isResolving(state, selectorName, args = []) X-Ref

Returns true if resolution has been triggered but has not yet completed for
a given selector name, and arguments set.

return: {boolean} Whether resolution is in progress.
param: {Object} state Data state.
param: {string} selectorName Selector name.
param: {?Array} args Arguments passed to selector.

getCachedResolvers(state) X-Ref

Returns the list of the cached resolvers.

return: {Object} Resolvers mapped by args and selectorName.
param: {Object} state Data state.

startResolution(selectorName, args) X-Ref

Returns an action object used in signalling that selector resolution has
started.

return: {Object} Action object.
param: {string} selectorName Name of selector for which resolver triggered.
param: {...*} args Arguments to associate for uniqueness.

finishResolution(selectorName, args) X-Ref

Returns an action object used in signalling that selector resolution has
completed.

return: {Object} Action object.
param: {string} selectorName Name of selector for which resolver triggered.
param: {...*} args Arguments to associate for uniqueness.

startResolutions(selectorName, args) X-Ref

Returns an action object used in signalling that a batch of selector resolutions has
started.

return: {Object} Action object.
param: {string} selectorName Name of selector for which resolver triggered.
param: {...*} args Array of arguments to associate for uniqueness, each item

finishResolutions(selectorName, args) X-Ref

Returns an action object used in signalling that a batch of selector resolutions has
completed.

return: {Object} Action object.
param: {string} selectorName Name of selector for which resolver triggered.
param: {...*} args Array of arguments to associate for uniqueness, each item

invalidateResolution(selectorName, args) X-Ref

Returns an action object used in signalling that we should invalidate the resolution cache.

return: {Object} Action object.
param: {string} selectorName Name of selector for which resolver should be invalidated.
param: {Array} args Arguments to associate for uniqueness.

invalidateResolutionForStore() X-Ref

Returns an action object used in signalling that the resolution
should be invalidated.

return: {Object} Action object.

invalidateResolutionForStoreSelector(selectorName) X-Ref

Returns an action object used in signalling that the resolution cache for a
given selectorName should be invalidated.

return: {Object} Action object.
param: {string} selectorName Name of selector for which all resolvers should

createResolversCache() X-Ref

Create a cache to track whether resolvers started running or not.

return: {Object} Resolvers Cache.

createReduxStore(key, options) X-Ref

Creates a data store definition for the provided Redux store options containing
properties describing reducer, actions, selectors, controls and resolvers.

return: {WPDataStore} Store Object.
param: {string} key Unique namespace identifier.
param: {WPDataReduxStoreConfig} options Registered store options, with properties

instantiateReduxStore(key, options, registry, thunkArgs) X-Ref

Creates a redux store for a namespace.

return: {Object} Newly created redux store.
param: {string}         key      Unique namespace identifier.
param: {Object}         options  Registered store options, with properties
param: {WPDataRegistry} registry Registry reference.
param: {Object} thunkArgs        Argument object for the thunk middleware.

mapSelectors(selectors, store) X-Ref

Maps selectors to a store.

return: {Object} Selectors mapped to the provided store.
param: {Object} selectors Selectors to register. Keys will be used as the
param: {Object} store The store to which the selectors should be mapped.

mapActions(actions, store) X-Ref

Maps actions to dispatch from a given store.

return: {Object}           Actions mapped to the redux store provided.
param: {Object} actions    Actions to register.
param: {Object} store      The redux store to which the actions should be mapped.

mapResolveSelectors(selectors, store) X-Ref

Maps selectors to functions that return a resolution promise for them

return: {Object} Selectors mapped to their resolution functions.
param: {Object} selectors Selectors to map.
param: {Object} store The redux store the selectors select from.

mapResolvers(resolvers, selectors, store, resolversCache) X-Ref

Returns resolvers with matched selectors for a given namespace.
Resolvers are side effects invoked once per argument set of a given selector call,
used in ensuring that the data needs for the selector are satisfied.

param: {Object} resolvers      Resolvers to register.
param: {Object} selectors      The current selectors to be modified.
param: {Object} store          The redux store to which the resolvers should be mapped.
param: {Object} resolversCache Resolvers Cache.

createCoreDataStore(registry) X-Ref

No description

createRegistry(storeConfigs = {}, parent = null) X-Ref

Creates a new store registry, given an optional object of initial store
configurations.

return: {WPDataRegistry} Data registry.
param: {Object} storeConfigs Initial store configurations.
param: {Object?} parent Parent registry.

globalListener() X-Ref

Global listener called for each store's update.

select(storeNameOrDefinition) X-Ref

Calls a selector given the current state and extra arguments.

return: {*} The selector's returned value.
param: {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store

__experimentalMarkListeningStores(callback, ref) X-Ref

No description

resolveSelect(storeNameOrDefinition) X-Ref

Given the name of a registered store, returns an object containing the store's
selectors pre-bound to state so that you only need to supply additional arguments,
and modified so that they return promises that resolve to their eventual values,
after any resolvers have ran.

return: {Object} Each key of the object matches the name of a selector.
param: {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store

dispatch(storeNameOrDefinition) X-Ref

Returns the available actions for a part of the state.

return: {*} The action's returned value.
param: {string|WPDataStore} storeNameOrDefinition Unique namespace identifier for the store

withPlugins(attributes) X-Ref

No description

registerGenericStore(key, config) X-Ref

Registers a generic store.

param: {string} key Store registry key.
param: {Object} config Configuration (getSelectors, getActions, subscribe).

Registers a new store definition.

param: {WPDataStore} store Store definition.

__experimentalSubscribeStore(storeName, handler) X-Ref

Subscribe handler to a store.

return: {Function} A function to unsubscribe the handler.
param: {string[]} storeName The store name.
param: {Function} handler The function subscribed to the store.

use(plugin, options) X-Ref

No description

createPersistenceInterface(options) X-Ref

Creates a persistence interface, exposing getter and setter methods (`get`
and `set` respectively).

return: {Object} Persistence interface.
param: {WPDataPersistencePluginOptions} options Plugin options.

getData() X-Ref

Returns the persisted data as an object, defaulting to an empty object.

return: {Object} Persisted data.

setData(key, value) X-Ref

Merges an updated reducer state into the persisted data.

param: {string} key Key to update.
param: {*} value Updated value.

persistencePlugin(registry, pluginOptions) X-Ref

Data plugin to persist store state into a single storage key.

return: {WPDataPlugin} Data plugin.
param: {WPDataRegistry} registry Data registry.
param: {?WPDataPersistencePluginOptions} pluginOptions Plugin options.

createPersistOnChange(getState, storeName, keys) X-Ref

Creates an enhanced store dispatch function, triggering the state of the
given store name to be persisted when changed.

return: {Function} Enhanced dispatch function.
param: {Function}       getState  Function which returns current state.
param: {string}         storeName Store name.
param: {?Array<string>} keys      Optional subset of keys to save.

useRegistry() X-Ref

A custom react hook exposing the registry context for use.

This exposes the `registry` value provided via the
<a href="#RegistryProvider">Registry Provider</a> to a component implementing
this hook.

It acts similarly to the `useContext` react hook.

Note: Generally speaking, `useRegistry` is a low level hook that in most cases
won't be needed for implementation. Most interactions with the `@wordpress/data`
API can be performed via the `useSelect` hook, or the `withSelect` and
`withDispatch` higher order components.

return: {Function} A custom react hook exposing the registry context value.

useAsyncMode() X-Ref

Internal dependencies

useSelect(_mapSelect, deps) X-Ref

Custom react hook for retrieving props from registered selectors.

In general, this custom React hook follows the
[rules of hooks](https://reactjs.org/docs/hooks-rules.html).

return: {Function}  A custom react hook.
param: {Function|WPDataStore|string} _mapSelect  Function called on every state change. The
param: {Array}                       deps        If provided, this memoizes the mapSelect so the

_extends() X-Ref

No description

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

PHP Cross Reference of WordPress

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

Defines 87 functions