← All changes | build/scripts/data/index.js +155 -46 23.4.0 → trunk View file →

		@@ -1,4 +1,5 @@
	1	+(function() {
1	2	"use strict";
2	3	var wp;
3	4	(wp ||= {}).data = (() => {
4	5	var __create = Object.create;
		@@ -415,9 +416,9 @@
415	416	createReduxStore: () => createReduxStore,
416	417	createRegistry: () => createRegistry,
417	418	createRegistryControl: () => createRegistryControl,
418	419	createRegistrySelector: () => createRegistrySelector,
419		- createSelector: () => rememo_default,
	420	+ createSelector: () => createSelector,
420	421	dispatch: () => dispatch2,
421	422	keyedReducer: () => keyedReducer,
422	423	plugins: () => plugins_exports,
423	424	register: () => register,
		@@ -1089,8 +1090,11 @@
1089	1090	callSelector
1090	1091	);
1091	1092	}
1092	1093
	1094	+ // packages/data/build-module/create-selector.mjs
	1095	+ var createSelector = rememo_default;
	1096	+
1093	1097	// packages/data/build-module/redux-store/metadata/selectors.mjs
1094	1098	function getResolutionState(state, selectorName, args) {
1095	1099	const map = state[selectorName];
1096	1100	if (!map) {
		@@ -1142,9 +1146,9 @@
1142	1146	)
1143	1147	)
1144	1148	);
1145	1149	}
1146		- var countSelectorsByStatus = rememo_default(
	1150	+ var countSelectorsByStatus = createSelector(
1147	1151	(state) => {
1148	1152	const selectorsByStatus = {};
1149	1153	Object.values(state).forEach(
1150	1154	(selectorState) => (
		@@ -1393,9 +1397,9 @@
1393	1397	selector.registry = registry;
1394	1398	}
1395	1399	return selector(state.root, ...args);
1396	1400	};
1397		- boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
	1401	+ boundSelector.normalizeArgs = getNormalizeArgs(selector);
1398	1402	const resolver = resolvers[selectorName];
1399	1403	if (!resolver) {
1400	1404	boundSelector.hasResolver = false;
1401	1405	return boundSelector;
		@@ -1418,8 +1422,15 @@
1418	1422	targetSelector,
1419	1423	selectorArgs
1420	1424	);
1421	1425	}
	1426	+ const resolver = resolvers[selectorName];
	1427	+ if (resolver && selectorArgs) {
	1428	+ selectorArgs = normalizeResolutionArgs(
	1429	+ resolver,
	1430	+ selectorArgs
	1431	+ );
	1432	+ }
1422	1433	}
1423	1434	const state = store.__unstableOriginalGetState();
1424	1435	return metaDataSelector(
1425	1436	state.metadata,
		@@ -1577,13 +1588,20 @@
1577	1588	return async (...args) => selector(...args);
1578	1589	}
1579	1590	return (...args) => new Promise((resolve, reject) => {
1580	1591	const resolver = resolvers[selectorName];
	1592	+ const resolutionArgs = normalizeResolutionArgs(
	1593	+ resolver,
	1594	+ normalize(selector, args)
	1595	+ );
1581	1596	const hasFinished = () => {
1582	1597	return boundMetadataSelectors.hasFinishedResolution(
1583	1598	selectorName,
1584	1599	args
1585		- ) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args);
	1600	+ ) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(
	1601	+ store.getState(),
	1602	+ ...resolutionArgs
	1603	+ );
1586	1604	};
1587	1605	const finalize = (result2) => {
1588	1606	const hasFailed = boundMetadataSelectors.hasResolutionFailed(
1589	1607	selectorName,
		@@ -1660,10 +1678,14 @@
1660	1678	// Add the fulfill method.
1661	1679	};
1662	1680	}
1663	1681	function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
1664		- function fulfillSelector(args) {
1665		- if (resolversCache.isRunning(selectorName, args) || boundMetadataSelectors.hasStartedResolution(selectorName, args) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args)) {
	1682	+ function fulfillSelector(selectorArgs) {
	1683	+ const args = normalizeResolutionArgs(resolver, selectorArgs);
	1684	+ if (resolversCache.isRunning(selectorName, args) || boundMetadataSelectors.hasStartedResolution(
	1685	+ selectorName,
	1686	+ selectorArgs
	1687	+ ) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args)) {
1666	1688	return;
1667	1689	}
1668	1690	resolversCache.markAsRunning(selectorName, args);
1669	1691	setTimeout(async () => {
		@@ -1691,16 +1713,27 @@
1691	1713	fulfillSelector(args);
1692	1714	return selector(...args);
1693	1715	};
1694	1716	selectorResolver.hasResolver = true;
	1717	+ selectorResolver.normalizeArgs = selector.normalizeArgs;
1695	1718	return selectorResolver;
1696	1719	}
	1720	+ function getNormalizeArgs(selector) {
	1721	+ return selector.normalizeArgs ?? selector.__unstableNormalizeArgs;
	1722	+ }
1697	1723	function normalize(selector, args) {
1698		- if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) {
1699		- return selector.__unstableNormalizeArgs(args);
	1724	+ const normalizeArgs = getNormalizeArgs(selector);
	1725	+ if (typeof normalizeArgs === "function" && args?.length) {
	1726	+ return normalizeArgs(args);
1700	1727	}
1701	1728	return args;
1702	1729	}
	1730	+ function normalizeResolutionArgs(resolver, args) {
	1731	+ if (typeof resolver.getResolutionArgs === "function") {
	1732	+ return resolver.getResolutionArgs(...args);
	1733	+ }
	1734	+ return args;
	1735	+ }
1703	1736
1704	1737	// packages/data/build-module/store/index.mjs
1705	1738	var coreDataStore = {
1706	1739	name: "core/data",
		@@ -1753,14 +1786,16 @@
1753	1786	function createEmitter() {
1754	1787	let isPaused = false;
1755	1788	let isPending = false;
1756	1789	const listeners = /* @__PURE__ */ new Set();
1757		- const notifyListeners = () => (
1758		- // We use Array.from to clone the listeners Set
1759		- // This ensures that we don't run a listener
1760		- // that was added as a response to another listener.
1761		- Array.from(listeners).forEach((listener) => listener())
1762		- );
	1790	+ let clonedListeners = null;
	1791	+ const notifyListeners = () => {
	1792	+ clonedListeners ??= Array.from(listeners);
	1793	+ const currentListeners = clonedListeners;
	1794	+ for (let i = 0; i < currentListeners.length; i++) {
	1795	+ currentListeners[i]();
	1796	+ }
	1797	+ };
1763	1798	return {
1764	1799	get isPaused() {
1765	1800	return isPaused;
1766	1801	},
		@@ -1765,9 +1800,13 @@
1765	1800	return isPaused;
1766	1801	},
1767	1802	subscribe(listener) {
1768	1803	listeners.add(listener);
1769		- return () => listeners.delete(listener);
	1804	+ clonedListeners = null;
	1805	+ return () => {
	1806	+ listeners.delete(listener);
	1807	+ clonedListeners = null;
	1808	+ };
1770	1809	},
1771	1810	pause() {
1772	1811	isPaused = true;
1773	1812	},
		@@ -1795,11 +1834,41 @@
1795	1834	function createRegistry(storeConfigs = {}, parent = null) {
1796	1835	const stores = {};
1797	1836	const emitter = createEmitter();
1798	1837	let listeningStores = null;
	1838	+ const pendingListeners = /* @__PURE__ */ new Map();
1799	1839	function globalListener() {
1800	1840	emitter.emit();
1801	1841	}
	1842	+ function subscribePending(storeName, listener) {
	1843	+ const pending = { listener };
	1844	+ let listeners = pendingListeners.get(storeName);
	1845	+ if (!listeners) {
	1846	+ listeners = /* @__PURE__ */ new Set();
	1847	+ pendingListeners.set(storeName, listeners);
	1848	+ }
	1849	+ listeners.add(pending);
	1850	+ return () => {
	1851	+ pending.unsubscribe?.();
	1852	+ const stillPending = pendingListeners.get(storeName);
	1853	+ if (stillPending) {
	1854	+ stillPending.delete(pending);
	1855	+ if (stillPending.size === 0) {
	1856	+ pendingListeners.delete(storeName);
	1857	+ }
	1858	+ }
	1859	+ };
	1860	+ }
	1861	+ function connectPendingListeners(name, store) {
	1862	+ const listeners = pendingListeners.get(name);
	1863	+ if (!listeners) {
	1864	+ return;
	1865	+ }
	1866	+ pendingListeners.delete(name);
	1867	+ for (const pending of listeners) {
	1868	+ pending.unsubscribe = store.subscribe(pending.listener);
	1869	+ }
	1870	+ }
1802	1871	const subscribe2 = (listener, storeNameOrDescriptor) => {
1803	1872	if (!storeNameOrDescriptor) {
1804	1873	return emitter.subscribe(listener);
1805	1874	}
		@@ -1808,9 +1877,9 @@
1808	1877	if (store) {
1809	1878	return store.subscribe(listener);
1810	1879	}
1811	1880	if (!parent) {
1812		- return emitter.subscribe(listener);
	1881	+ return subscribePending(storeName, listener);
1813	1882	}
1814	1883	return parent.subscribe(listener, storeNameOrDescriptor);
1815	1884	};
1816	1885	function select3(storeNameOrDescriptor) {
		@@ -1887,25 +1956,13 @@
1887	1956	if (typeof store.subscribe !== "function") {
1888	1957	throw new TypeError("store.subscribe must be a function");
1889	1958	}
1890	1959	store.emitter = createEmitter();
1891		- const currentSubscribe = store.subscribe;
1892		- store.subscribe = (listener) => {
1893		- const unsubscribeFromEmitter = store.emitter.subscribe(listener);
1894		- const unsubscribeFromStore = currentSubscribe(() => {
1895		- if (store.emitter.isPaused) {
1896		- store.emitter.emit();
1897		- return;
1898		- }
1899		- listener();
1900		- });
1901		- return () => {
1902		- unsubscribeFromStore?.();
1903		- unsubscribeFromEmitter?.();
1904		- };
1905		- };
	1960	+ store.subscribe(() => store.emitter.emit());
	1961	+ store.subscribe = (listener) => store.emitter.subscribe(listener);
1906	1962	stores[name] = store;
1907	1963	store.subscribe(globalListener);
	1964	+ connectPendingListeners(name, store);
1908	1965	if (parent) {
1909	1966	try {
1910	1967	unlock(store.store).registerPrivateActions(
1911	1968	unlock(parent).privateActionsOf(name)
		@@ -2216,10 +2273,9 @@
2216	2273	// packages/data/build-module/components/async-mode-provider/context.mjs
2217	2274	var import_element3 = __toESM(require_element(), 1);
2218	2275	var Context2 = (0, import_element3.createContext)(false);
2219	2276	Context2.displayName = "AsyncModeContext";
2220		- var { Consumer: Consumer2, Provider: Provider2 } = Context2;
2221		- var context_default2 = Provider2;
	2277	+ var context_default2 = Context2.Provider;
2222	2278
2223	2279	// packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2224	2280	function useAsyncMode() {
2225	2281	return (0, import_element4.useContext)(Context2);
		@@ -2236,8 +2292,41 @@
2236	2292	"The `useSelect` hook returns different values when called with the same state and parameters.\nThis can lead to unnecessary re-renders and performance issues if not fixed.\n\nNon-equal value keys: %s\n\n",
2237	2293	keys.join(", ")
2238	2294	);
2239	2295	}
	2296	+ var deferredBuckets = /* @__PURE__ */ new WeakMap();
	2297	+ function subscribeDeferred(registry, storeName, listener) {
	2298	+ let buckets = deferredBuckets.get(registry);
	2299	+ if (!buckets) {
	2300	+ buckets = /* @__PURE__ */ new Map();
	2301	+ deferredBuckets.set(registry, buckets);
	2302	+ }
	2303	+ let addToBucket = buckets.get(storeName);
	2304	+ if (!addToBucket) {
	2305	+ const listeners = /* @__PURE__ */ new Set();
	2306	+ const flush = () => {
	2307	+ for (const { context, callback } of listeners) {
	2308	+ renderQueue.add(context, callback);
	2309	+ }
	2310	+ };
	2311	+ const unsubscribe = registry.subscribe(
	2312	+ () => renderQueue.add(listeners, flush),
	2313	+ storeName
	2314	+ );
	2315	+ addToBucket = (newListener) => {
	2316	+ listeners.add(newListener);
	2317	+ return () => {
	2318	+ if (listeners.delete(newListener) && listeners.size === 0) {
	2319	+ buckets.delete(storeName);
	2320	+ renderQueue.cancel(listeners);
	2321	+ unsubscribe();
	2322	+ }
	2323	+ };
	2324	+ };
	2325	+ buckets.set(storeName, addToBucket);
	2326	+ }
	2327	+ return addToBucket(listener);
	2328	+ }
2240	2329	function Store(registry, suspense) {
2241	2330	const select3 = suspense ? registry.suspendSelect : registry.select;
2242	2331	const queueContext = {};
2243	2332	let lastMapSelect;
		@@ -2265,25 +2354,34 @@
2265	2354	const onStoreChange = () => {
2266	2355	lastMapResultValid = false;
2267	2356	listener();
2268	2357	};
2269		- const onChange = () => {
	2358	+ function listenToStore(storeName) {
2270	2359	if (lastIsAsync) {
2271		- renderQueue.add(queueContext, onStoreChange);
2272		- } else {
2273		- onStoreChange();
	2360	+ return subscribeDeferred(registry, storeName, {
	2361	+ context: queueContext,
	2362	+ callback: onStoreChange
	2363	+ });
2274	2364	}
2275		- };
2276		- const unsubs = [];
	2365	+ return registry.subscribe(onStoreChange, storeName);
	2366	+ }
	2367	+ const unsubs = /* @__PURE__ */ new Map();
2277	2368	function subscribeStore(storeName) {
2278		- unsubs.push(registry.subscribe(onChange, storeName));
	2369	+ unsubs.set(storeName, listenToStore(storeName));
2279	2370	}
	2371	+ function resubscribeStores() {
	2372	+ for (const [storeName, unsub] of unsubs) {
	2373	+ unsub?.();
	2374	+ unsubs.set(storeName, listenToStore(storeName));
	2375	+ }
	2376	+ }
2280	2377	for (const storeName of activeStores) {
2281	2378	subscribeStore(storeName);
2282	2379	}
2283		- activeSubscriptions.add(subscribeStore);
	2380	+ const subscription = { subscribeStore, resubscribeStores };
	2381	+ activeSubscriptions.add(subscription);
2284	2382	return () => {
2285		- activeSubscriptions.delete(subscribeStore);
	2383	+ activeSubscriptions.delete(subscription);
2286	2384	for (const unsub of unsubs.values()) {
2287	2385	unsub?.();
2288	2386	}
2289	2387	renderQueue.cancel(queueContext);
		@@ -2295,13 +2393,18 @@
2295	2393	continue;
2296	2394	}
2297	2395	activeStores.push(newStore);
2298	2396	for (const subscription of activeSubscriptions) {
2299		- subscription(newStore);
	2397	+ subscription.subscribeStore(newStore);
2300	2398	}
2301	2399	}
2302	2400	}
2303		- return { subscribe: subscribe2, updateStores };
	2401	+ function switchMode() {
	2402	+ for (const subscription of activeSubscriptions) {
	2403	+ subscription.resubscribeStores();
	2404	+ }
	2405	+ }
	2406	+ return { subscribe: subscribe2, updateStores, switchMode };
2304	2407	};
2305	2408	return (mapSelect, isAsync) => {
2306	2409	function updateValue() {
2307	2410	if (lastMapResultValid && mapSelect === lastMapSelect) {
		@@ -2338,14 +2441,18 @@
2338	2441	function getValue() {
2339	2442	updateValue();
2340	2443	return lastMapResult;
2341	2444	}
2342		- if (lastIsAsync && !isAsync) {
	2445	+ const wasAsync = lastIsAsync;
	2446	+ lastIsAsync = isAsync;
	2447	+ if (wasAsync && !isAsync) {
2343	2448	lastMapResultValid = false;
2344	2449	renderQueue.cancel(queueContext);
2345	2450	}
2346	2451	updateValue();
2347		- lastIsAsync = isAsync;
	2452	+ if (wasAsync !== isAsync) {
	2453	+ subscriber.switchMode();
	2454	+ }
2348	2455	return { subscribe: subscriber.subscribe, getValue };
2349	2456	};
2350	2457	}
2351	2458	function _useStaticSelect(storeName) {
		@@ -2503,5 +2610,7 @@
2503	2610	* Copyright (c) 2014-2017, Jon Schlinkert.
2504	2611	* Released under the MIT License.
2505	2612	*)
2506	2613	*/
	2614	+(window.wp ||= {}).data = wp.data;
	2615	+})();
2507	2616	//# sourceMappingURL=index.js.map