PHPXRef 0.7.1 : WordPress : Detail view of data.js

Given a props object, returns the next merge props by mapSelectToProps.

return: {Object} Props to merge into rendered wrapped element.
param: {Object} props Props to pass as argument to mapSelectToProps.

_class(props) X-Ref

No description

isActionLike(action) X-Ref

Returns true if the given argument appears to be a dispatchable action.

return: {boolean} Whether object is action-like.
param: {*} action Object to test.

isAsyncIterable(object) X-Ref

Returns true if the given object is an async iterable, or false otherwise.

return: {boolean} Whether object is an async iterable.
param: {*} object Object to test.

isIterable(object) X-Ref

Returns true if the given object is iterable, or false otherwise.

return: {boolean} Whether object is iterable.
param: {*} object Object to test.

toAsyncIterable(object) X-Ref

Normalizes the given object argument to an async iterable, asynchronously
yielding on a singular or array of generator yields or promise resolution.

return: {AsyncGenerator} Async iterable actions.
param: {*} object Object to normalize.

withInitialState(reducer, initialState) 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.

get() X-Ref

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

return: {Object} Persisted data.

set(key, value) X-Ref

Merges an updated reducer state into the persisted data.

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

createPersistOnChange(getState, reducerKey, keys) X-Ref

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

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

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

globalListener() X-Ref

Global listener called for each store's update.

registerReducer(reducerKey, reducer) X-Ref

Registers a new sub-reducer to the global state and returns a Redux-like
store object.

return: {Object} Store Object.
param: {string} reducerKey Reducer key.
param: {Object} reducer Reducer function.

registerSelectors(reducerKey, newSelectors) X-Ref

Registers selectors for external usage.

param: {string} reducerKey Part of the state shape to register the
param: {Object} newSelectors Selectors to register. Keys will be used as the

registerResolvers(reducerKey, newResolvers) X-Ref

Registers resolvers for a given reducer key. 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: {string} reducerKey Part of the state shape to register the
param: {Object} newResolvers Resolvers to register.

fulfillSelector() X-Ref

No description

_fulfillSelector() X-Ref

No description

registerActions(reducerKey, newActions) X-Ref

Registers actions for external usage.

param: {string} reducerKey Part of the state shape to register the
param: {Object} newActions Actions to register.

registerStore(reducerKey, options) X-Ref

Convenience for registering reducer with actions and selectors.

return: {Object} Registered store object.
param: {string} reducerKey Reducer key.
param: {Object} options Store description (reducer, actions, selectors, resolvers).

select(reducerKey) X-Ref

Calls a selector given the current state and extra arguments.

return: {*} The selector's returned value.
param: {string} reducerKey Part of the state shape to register the

fulfill(_x, _x2) X-Ref

Calls a resolver given  arguments

param: {string} reducerKey   Part of the state shape to register the
param: {string} selectorName Selector name to fulfill.
param: {Array} args          Selector Arguments.

_fulfill() X-Ref

Returns the available actions for a part of the state.

return: {*} The action's returned value.
param: {string} reducerKey Part of the state shape to dispatch the

dispatch(reducerKey) X-Ref

No description

withPlugins(attributes) X-Ref

Maps an object of function values to proxy invocation through to the
current internal representation of the registry, which may be enhanced
by plugins.

return: {Object<string,Function>} Object enhanced with plugin proxying.
param: {Object<string,Function>} attributes Object of function values.

use(plugin, options) X-Ref

Enhances the registry with the prescribed set of overrides. Returns the
enhanced registry to enable plugin chaining.

return: {WPDataRegistry} Enhanced registry.
param: {WPDataPlugin} plugin Plugin by which to enhance.
param: {?Object} options Optional options to pass to plugin.

startResolution(reducerKey, selectorName, args) X-Ref

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

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

finishResolution(reducerKey, selectorName, args) X-Ref

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

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

getIsResolving(state, reducerKey, selectorName, args) X-Ref

Returns the raw `isResolving` value for a given reducer key, 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} reducerKey   Registered store reducer key.
param: {string} selectorName Selector name.
param: {Array}  args         Arguments passed to selector.

hasStartedResolution(state, reducerKey, selectorName) X-Ref

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

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

hasFinishedResolution(state, reducerKey, selectorName) X-Ref

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

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

isResolving(state, reducerKey, selectorName) X-Ref

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

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

_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

getValuePair(instance, key) X-Ref

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

isPlainObject(obj) X-Ref

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

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

returns: {Store} A Redux store that lets you read the state, dispatch actions
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

ensureCanMutateNextListeners() X-Ref

No description

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.

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

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.

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

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.

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

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.

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

getUndefinedStateErrorMessage(key, action) X-Ref

No description

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.

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

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 a single function as the first argument,
and get a function in return.

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

_defineProperty(obj, key, value) X-Ref

No description

_objectSpread(target) X-Ref

No description

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.

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

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.

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

isCrushed() X-Ref

No description

symbolObservablePonyfill(root) X-Ref

No description

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

PHP Cross Reference of WordPress

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

Defines 94 functions