@wordpress/data
Version:
Data module for WordPress.
493 lines (491 loc) • 15.8 kB
JavaScript
;
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name in all)
__defProp(target, name, { get: all[name], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// packages/data/src/redux-store/index.js
var redux_store_exports = {};
__export(redux_store_exports, {
combineReducers: () => import_combine_reducers.combineReducers,
default: () => createReduxStore
});
module.exports = __toCommonJS(redux_store_exports);
var import_redux = require("redux");
var import_equivalent_key_map = __toESM(require("equivalent-key-map"));
var import_redux_routine = __toESM(require("@wordpress/redux-routine"));
var import_compose = require("@wordpress/compose");
var import_combine_reducers = require("./combine-reducers");
var import_controls = require("../controls");
var import_lock_unlock = require("../lock-unlock");
var import_promise_middleware = __toESM(require("../promise-middleware"));
var import_resolvers_cache_middleware = __toESM(require("../resolvers-cache-middleware"));
var import_thunk_middleware = __toESM(require("./thunk-middleware"));
var import_reducer = __toESM(require("./metadata/reducer"));
var metadataSelectors = __toESM(require("./metadata/selectors"));
var metadataActions = __toESM(require("./metadata/actions"));
var trimUndefinedValues = (array) => {
const result = [...array];
for (let i = result.length - 1; i >= 0; i--) {
if (result[i] === void 0) {
result.splice(i, 1);
}
}
return result;
};
var mapValues = (obj, callback) => Object.fromEntries(
Object.entries(obj ?? {}).map(([key, value]) => [
key,
callback(value, key)
])
);
var devToolsReplacer = (key, state) => {
if (state instanceof Map) {
return Object.fromEntries(state);
}
if (state instanceof window.HTMLElement) {
return null;
}
return state;
};
function createResolversCache() {
const cache = {};
return {
isRunning(selectorName, args) {
return cache[selectorName] && cache[selectorName].get(trimUndefinedValues(args));
},
clear(selectorName, args) {
if (cache[selectorName]) {
cache[selectorName].delete(trimUndefinedValues(args));
}
},
markAsRunning(selectorName, args) {
if (!cache[selectorName]) {
cache[selectorName] = new import_equivalent_key_map.default();
}
cache[selectorName].set(trimUndefinedValues(args), true);
}
};
}
function createBindingCache(getItem, bindItem) {
const cache = /* @__PURE__ */ new WeakMap();
return {
get(itemName) {
const item = getItem(itemName);
if (!item) {
return null;
}
let boundItem = cache.get(item);
if (!boundItem) {
boundItem = bindItem(item, itemName);
cache.set(item, boundItem);
}
return boundItem;
}
};
}
function createPrivateProxy(publicItems, privateItems) {
return new Proxy(publicItems, {
get: (target, itemName) => privateItems.get(itemName) || Reflect.get(target, itemName)
});
}
function createReduxStore(key, options) {
const privateActions = {};
const privateSelectors = {};
const privateRegistrationFunctions = {
privateActions,
registerPrivateActions: (actions) => {
Object.assign(privateActions, actions);
},
privateSelectors,
registerPrivateSelectors: (selectors) => {
Object.assign(privateSelectors, selectors);
}
};
const storeDescriptor = {
name: key,
instantiate: (registry) => {
const listeners = /* @__PURE__ */ new Set();
const reducer = options.reducer;
const thunkArgs = {
registry,
get dispatch() {
return thunkDispatch;
},
get select() {
return thunkSelect;
},
get resolveSelect() {
return resolveSelectors;
}
};
const store = instantiateReduxStore(
key,
options,
registry,
thunkArgs
);
(0, import_lock_unlock.lock)(store, privateRegistrationFunctions);
const resolversCache = createResolversCache();
function bindAction(action) {
return (...args) => Promise.resolve(store.dispatch(action(...args)));
}
const actions = {
...mapValues(metadataActions, bindAction),
...mapValues(options.actions, bindAction)
};
const allActions = createPrivateProxy(
actions,
createBindingCache(
(name) => privateActions[name],
bindAction
)
);
const thunkDispatch = new Proxy(
(action) => store.dispatch(action),
{ get: (target, name) => allActions[name] }
);
(0, import_lock_unlock.lock)(actions, allActions);
const resolvers = options.resolvers ? mapValues(options.resolvers, mapResolver) : {};
function bindSelector(selector, selectorName) {
if (selector.isRegistrySelector) {
selector.registry = registry;
}
const boundSelector = (...args) => {
args = normalize(selector, args);
const state = store.__unstableOriginalGetState();
if (selector.isRegistrySelector) {
selector.registry = registry;
}
return selector(state.root, ...args);
};
boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
const resolver = resolvers[selectorName];
if (!resolver) {
boundSelector.hasResolver = false;
return boundSelector;
}
return mapSelectorWithResolver(
boundSelector,
selectorName,
resolver,
store,
resolversCache,
boundMetadataSelectors
);
}
function bindMetadataSelector(metaDataSelector) {
const boundSelector = (selectorName, selectorArgs, ...args) => {
if (selectorName) {
const targetSelector = options.selectors?.[selectorName];
if (targetSelector) {
selectorArgs = normalize(
targetSelector,
selectorArgs
);
}
}
const state = store.__unstableOriginalGetState();
return metaDataSelector(
state.metadata,
selectorName,
selectorArgs,
...args
);
};
boundSelector.hasResolver = false;
return boundSelector;
}
const boundMetadataSelectors = mapValues(
metadataSelectors,
bindMetadataSelector
);
const boundSelectors = mapValues(options.selectors, bindSelector);
const selectors = {
...boundMetadataSelectors,
...boundSelectors
};
const boundPrivateSelectors = createBindingCache(
(name) => privateSelectors[name],
bindSelector
);
const allSelectors = createPrivateProxy(
selectors,
boundPrivateSelectors
);
for (const selectorName of Object.keys(privateSelectors)) {
boundPrivateSelectors.get(selectorName);
}
const thunkSelect = new Proxy(
(selector) => selector(store.__unstableOriginalGetState()),
{ get: (target, name) => allSelectors[name] }
);
(0, import_lock_unlock.lock)(selectors, allSelectors);
const bindResolveSelector = mapResolveSelector(
store,
boundMetadataSelectors
);
const resolveSelectors = mapValues(
boundSelectors,
bindResolveSelector
);
const allResolveSelectors = createPrivateProxy(
resolveSelectors,
createBindingCache(
(name) => boundPrivateSelectors.get(name),
bindResolveSelector
)
);
(0, import_lock_unlock.lock)(resolveSelectors, allResolveSelectors);
const bindSuspendSelector = mapSuspendSelector(
store,
boundMetadataSelectors
);
const suspendSelectors = {
...boundMetadataSelectors,
// no special suspense behavior
...mapValues(boundSelectors, bindSuspendSelector)
};
const allSuspendSelectors = createPrivateProxy(
suspendSelectors,
createBindingCache(
(name) => boundPrivateSelectors.get(name),
bindSuspendSelector
)
);
(0, import_lock_unlock.lock)(suspendSelectors, allSuspendSelectors);
const getSelectors = () => selectors;
const getActions = () => actions;
const getResolveSelectors = () => resolveSelectors;
const getSuspendSelectors = () => suspendSelectors;
store.__unstableOriginalGetState = store.getState;
store.getState = () => store.__unstableOriginalGetState().root;
const subscribe = store && ((listener) => {
listeners.add(listener);
return () => listeners.delete(listener);
});
let lastState = store.__unstableOriginalGetState();
store.subscribe(() => {
const state = store.__unstableOriginalGetState();
const hasChanged = state !== lastState;
lastState = state;
if (hasChanged) {
for (const listener of listeners) {
listener();
}
}
});
return {
reducer,
store,
actions,
selectors,
resolvers,
getSelectors,
getResolveSelectors,
getSuspendSelectors,
getActions,
subscribe
};
}
};
(0, import_lock_unlock.lock)(storeDescriptor, privateRegistrationFunctions);
return storeDescriptor;
}
function instantiateReduxStore(key, options, registry, thunkArgs) {
const controls = {
...options.controls,
...import_controls.builtinControls
};
const normalizedControls = mapValues(
controls,
(control) => control.isRegistryControl ? control(registry) : control
);
const middlewares = [
(0, import_resolvers_cache_middleware.default)(registry, key),
import_promise_middleware.default,
(0, import_redux_routine.default)(normalizedControls),
(0, import_thunk_middleware.default)(thunkArgs)
];
const enhancers = [(0, import_redux.applyMiddleware)(...middlewares)];
if (typeof window !== "undefined" && window.__REDUX_DEVTOOLS_EXTENSION__) {
enhancers.push(
window.__REDUX_DEVTOOLS_EXTENSION__({
name: key,
instanceId: key,
serialize: {
replacer: devToolsReplacer
}
})
);
}
const { reducer, initialState } = options;
const enhancedReducer = (0, import_combine_reducers.combineReducers)({
metadata: import_reducer.default,
root: reducer
});
return (0, import_redux.createStore)(
enhancedReducer,
{ root: initialState },
(0, import_compose.compose)(enhancers)
);
}
function mapResolveSelector(store, boundMetadataSelectors) {
return (selector, selectorName) => {
if (!selector.hasResolver) {
return async (...args) => selector.apply(null, args);
}
return (...args) => new Promise((resolve, reject) => {
const hasFinished = () => {
return boundMetadataSelectors.hasFinishedResolution(
selectorName,
args
);
};
const finalize = (result2) => {
const hasFailed = boundMetadataSelectors.hasResolutionFailed(
selectorName,
args
);
if (hasFailed) {
const error = boundMetadataSelectors.getResolutionError(
selectorName,
args
);
reject(error);
} else {
resolve(result2);
}
};
const getResult = () => selector.apply(null, args);
const result = getResult();
if (hasFinished()) {
return finalize(result);
}
const unsubscribe = store.subscribe(() => {
if (hasFinished()) {
unsubscribe();
finalize(getResult());
}
});
});
};
}
function mapSuspendSelector(store, boundMetadataSelectors) {
return (selector, selectorName) => {
if (!selector.hasResolver) {
return selector;
}
return (...args) => {
const result = selector.apply(null, args);
if (boundMetadataSelectors.hasFinishedResolution(
selectorName,
args
)) {
if (boundMetadataSelectors.hasResolutionFailed(
selectorName,
args
)) {
throw boundMetadataSelectors.getResolutionError(
selectorName,
args
);
}
return result;
}
throw new Promise((resolve) => {
const unsubscribe = store.subscribe(() => {
if (boundMetadataSelectors.hasFinishedResolution(
selectorName,
args
)) {
resolve();
unsubscribe();
}
});
});
};
};
}
function mapResolver(resolver) {
if (resolver.fulfill) {
return resolver;
}
return {
...resolver,
// Copy the enumerable properties of the resolver function.
fulfill: resolver
// Add the fulfill method.
};
}
function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
function fulfillSelector(args) {
const state = store.getState();
if (resolversCache.isRunning(selectorName, args) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(state, ...args)) {
return;
}
if (boundMetadataSelectors.hasStartedResolution(selectorName, args)) {
return;
}
resolversCache.markAsRunning(selectorName, args);
setTimeout(async () => {
resolversCache.clear(selectorName, args);
store.dispatch(
metadataActions.startResolution(selectorName, args)
);
try {
const action = resolver.fulfill(...args);
if (action) {
await store.dispatch(action);
}
store.dispatch(
metadataActions.finishResolution(selectorName, args)
);
} catch (error) {
store.dispatch(
metadataActions.failResolution(selectorName, args, error)
);
}
}, 0);
}
const selectorResolver = (...args) => {
args = normalize(selector, args);
fulfillSelector(args);
return selector(...args);
};
selectorResolver.hasResolver = true;
return selectorResolver;
}
function normalize(selector, args) {
if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) {
return selector.__unstableNormalizeArgs(args);
}
return args;
}
// Annotate the CommonJS export names for ESM import in node:
0 && (module.exports = {
combineReducers
});
//# sourceMappingURL=index.js.map