← All changes | build/scripts/data/index.js +150 -44 23.6.2 → 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;
		@@ -1396,9 +1397,9 @@
1396	1397	selector.registry = registry;
1397	1398	}
1398	1399	return selector(state.root, ...args);
1399	1400	};
1400		- boundSelector.__unstableNormalizeArgs = selector.__unstableNormalizeArgs;
	1401	+ boundSelector.normalizeArgs = getNormalizeArgs(selector);
1401	1402	const resolver = resolvers[selectorName];
1402	1403	if (!resolver) {
1403	1404	boundSelector.hasResolver = false;
1404	1405	return boundSelector;
		@@ -1421,8 +1422,15 @@
1421	1422	targetSelector,
1422	1423	selectorArgs
1423	1424	);
1424	1425	}
	1426	+ const resolver = resolvers[selectorName];
	1427	+ if (resolver && selectorArgs) {
	1428	+ selectorArgs = normalizeResolutionArgs(
	1429	+ resolver,
	1430	+ selectorArgs
	1431	+ );
	1432	+ }
1425	1433	}
1426	1434	const state = store.__unstableOriginalGetState();
1427	1435	return metaDataSelector(
1428	1436	state.metadata,
		@@ -1580,13 +1588,20 @@
1580	1588	return async (...args) => selector(...args);
1581	1589	}
1582	1590	return (...args) => new Promise((resolve, reject) => {
1583	1591	const resolver = resolvers[selectorName];
	1592	+ const resolutionArgs = normalizeResolutionArgs(
	1593	+ resolver,
	1594	+ normalize(selector, args)
	1595	+ );
1584	1596	const hasFinished = () => {
1585	1597	return boundMetadataSelectors.hasFinishedResolution(
1586	1598	selectorName,
1587	1599	args
1588		- ) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(store.getState(), ...args);
	1600	+ ) || typeof resolver.isFulfilled === "function" && resolver.isFulfilled(
	1601	+ store.getState(),
	1602	+ ...resolutionArgs
	1603	+ );
1589	1604	};
1590	1605	const finalize = (result2) => {
1591	1606	const hasFailed = boundMetadataSelectors.hasResolutionFailed(
1592	1607	selectorName,
		@@ -1663,10 +1678,14 @@
1663	1678	// Add the fulfill method.
1664	1679	};
1665	1680	}
1666	1681	function mapSelectorWithResolver(selector, selectorName, resolver, store, resolversCache, boundMetadataSelectors) {
1667		- function fulfillSelector(args) {
1668		- 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)) {
1669	1688	return;
1670	1689	}
1671	1690	resolversCache.markAsRunning(selectorName, args);
1672	1691	setTimeout(async () => {
		@@ -1694,16 +1713,27 @@
1694	1713	fulfillSelector(args);
1695	1714	return selector(...args);
1696	1715	};
1697	1716	selectorResolver.hasResolver = true;
	1717	+ selectorResolver.normalizeArgs = selector.normalizeArgs;
1698	1718	return selectorResolver;
1699	1719	}
	1720	+ function getNormalizeArgs(selector) {
	1721	+ return selector.normalizeArgs ?? selector.__unstableNormalizeArgs;
	1722	+ }
1700	1723	function normalize(selector, args) {
1701		- if (selector.__unstableNormalizeArgs && typeof selector.__unstableNormalizeArgs === "function" && args?.length) {
1702		- return selector.__unstableNormalizeArgs(args);
	1724	+ const normalizeArgs = getNormalizeArgs(selector);
	1725	+ if (typeof normalizeArgs === "function" && args?.length) {
	1726	+ return normalizeArgs(args);
1703	1727	}
1704	1728	return args;
1705	1729	}
	1730	+ function normalizeResolutionArgs(resolver, args) {
	1731	+ if (typeof resolver.getResolutionArgs === "function") {
	1732	+ return resolver.getResolutionArgs(...args);
	1733	+ }
	1734	+ return args;
	1735	+ }
1706	1736
1707	1737	// packages/data/build-module/store/index.mjs
1708	1738	var coreDataStore = {
1709	1739	name: "core/data",
		@@ -1756,14 +1786,16 @@
1756	1786	function createEmitter() {
1757	1787	let isPaused = false;
1758	1788	let isPending = false;
1759	1789	const listeners = /* @__PURE__ */ new Set();
1760		- const notifyListeners = () => (
1761		- // We use Array.from to clone the listeners Set
1762		- // This ensures that we don't run a listener
1763		- // that was added as a response to another listener.
1764		- Array.from(listeners).forEach((listener) => listener())
1765		- );
	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	+ };
1766	1798	return {
1767	1799	get isPaused() {
1768	1800	return isPaused;
1769	1801	},
		@@ -1768,9 +1800,13 @@
1768	1800	return isPaused;
1769	1801	},
1770	1802	subscribe(listener) {
1771	1803	listeners.add(listener);
1772		- return () => listeners.delete(listener);
	1804	+ clonedListeners = null;
	1805	+ return () => {
	1806	+ listeners.delete(listener);
	1807	+ clonedListeners = null;
	1808	+ };
1773	1809	},
1774	1810	pause() {
1775	1811	isPaused = true;
1776	1812	},
		@@ -1798,11 +1834,41 @@
1798	1834	function createRegistry(storeConfigs = {}, parent = null) {
1799	1835	const stores = {};
1800	1836	const emitter = createEmitter();
1801	1837	let listeningStores = null;
	1838	+ const pendingListeners = /* @__PURE__ */ new Map();
1802	1839	function globalListener() {
1803	1840	emitter.emit();
1804	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	+ }
1805	1871	const subscribe2 = (listener, storeNameOrDescriptor) => {
1806	1872	if (!storeNameOrDescriptor) {
1807	1873	return emitter.subscribe(listener);
1808	1874	}
		@@ -1811,9 +1877,9 @@
1811	1877	if (store) {
1812	1878	return store.subscribe(listener);
1813	1879	}
1814	1880	if (!parent) {
1815		- return emitter.subscribe(listener);
	1881	+ return subscribePending(storeName, listener);
1816	1882	}
1817	1883	return parent.subscribe(listener, storeNameOrDescriptor);
1818	1884	};
1819	1885	function select3(storeNameOrDescriptor) {
		@@ -1890,25 +1956,13 @@
1890	1956	if (typeof store.subscribe !== "function") {
1891	1957	throw new TypeError("store.subscribe must be a function");
1892	1958	}
1893	1959	store.emitter = createEmitter();
1894		- const currentSubscribe = store.subscribe;
1895		- store.subscribe = (listener) => {
1896		- const unsubscribeFromEmitter = store.emitter.subscribe(listener);
1897		- const unsubscribeFromStore = currentSubscribe(() => {
1898		- if (store.emitter.isPaused) {
1899		- store.emitter.emit();
1900		- return;
1901		- }
1902		- listener();
1903		- });
1904		- return () => {
1905		- unsubscribeFromStore?.();
1906		- unsubscribeFromEmitter?.();
1907		- };
1908		- };
	1960	+ store.subscribe(() => store.emitter.emit());
	1961	+ store.subscribe = (listener) => store.emitter.subscribe(listener);
1909	1962	stores[name] = store;
1910	1963	store.subscribe(globalListener);
	1964	+ connectPendingListeners(name, store);
1911	1965	if (parent) {
1912	1966	try {
1913	1967	unlock(store.store).registerPrivateActions(
1914	1968	unlock(parent).privateActionsOf(name)
		@@ -2219,10 +2273,9 @@
2219	2273	// packages/data/build-module/components/async-mode-provider/context.mjs
2220	2274	var import_element3 = __toESM(require_element(), 1);
2221	2275	var Context2 = (0, import_element3.createContext)(false);
2222	2276	Context2.displayName = "AsyncModeContext";
2223		- var { Consumer: Consumer2, Provider: Provider2 } = Context2;
2224		- var context_default2 = Provider2;
	2277	+ var context_default2 = Context2.Provider;
2225	2278
2226	2279	// packages/data/build-module/components/async-mode-provider/use-async-mode.mjs
2227	2280	function useAsyncMode() {
2228	2281	return (0, import_element4.useContext)(Context2);
		@@ -2239,8 +2292,41 @@
2239	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",
2240	2293	keys.join(", ")
2241	2294	);
2242	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	+ }
2243	2329	function Store(registry, suspense) {
2244	2330	const select3 = suspense ? registry.suspendSelect : registry.select;
2245	2331	const queueContext = {};
2246	2332	let lastMapSelect;
		@@ -2268,25 +2354,34 @@
2268	2354	const onStoreChange = () => {
2269	2355	lastMapResultValid = false;
2270	2356	listener();
2271	2357	};
2272		- const onChange = () => {
	2358	+ function listenToStore(storeName) {
2273	2359	if (lastIsAsync) {
2274		- renderQueue.add(queueContext, onStoreChange);
2275		- } else {
2276		- onStoreChange();
	2360	+ return subscribeDeferred(registry, storeName, {
	2361	+ context: queueContext,
	2362	+ callback: onStoreChange
	2363	+ });
2277	2364	}
2278		- };
2279		- const unsubs = [];
	2365	+ return registry.subscribe(onStoreChange, storeName);
	2366	+ }
	2367	+ const unsubs = /* @__PURE__ */ new Map();
2280	2368	function subscribeStore(storeName) {
2281		- unsubs.push(registry.subscribe(onChange, storeName));
	2369	+ unsubs.set(storeName, listenToStore(storeName));
2282	2370	}
	2371	+ function resubscribeStores() {
	2372	+ for (const [storeName, unsub] of unsubs) {
	2373	+ unsub?.();
	2374	+ unsubs.set(storeName, listenToStore(storeName));
	2375	+ }
	2376	+ }
2283	2377	for (const storeName of activeStores) {
2284	2378	subscribeStore(storeName);
2285	2379	}
2286		- activeSubscriptions.add(subscribeStore);
	2380	+ const subscription = { subscribeStore, resubscribeStores };
	2381	+ activeSubscriptions.add(subscription);
2287	2382	return () => {
2288		- activeSubscriptions.delete(subscribeStore);
	2383	+ activeSubscriptions.delete(subscription);
2289	2384	for (const unsub of unsubs.values()) {
2290	2385	unsub?.();
2291	2386	}
2292	2387	renderQueue.cancel(queueContext);
		@@ -2298,13 +2393,18 @@
2298	2393	continue;
2299	2394	}
2300	2395	activeStores.push(newStore);
2301	2396	for (const subscription of activeSubscriptions) {
2302		- subscription(newStore);
	2397	+ subscription.subscribeStore(newStore);
2303	2398	}
2304	2399	}
2305	2400	}
2306		- return { subscribe: subscribe2, updateStores };
	2401	+ function switchMode() {
	2402	+ for (const subscription of activeSubscriptions) {
	2403	+ subscription.resubscribeStores();
	2404	+ }
	2405	+ }
	2406	+ return { subscribe: subscribe2, updateStores, switchMode };
2307	2407	};
2308	2408	return (mapSelect, isAsync) => {
2309	2409	function updateValue() {
2310	2410	if (lastMapResultValid && mapSelect === lastMapSelect) {
		@@ -2341,14 +2441,18 @@
2341	2441	function getValue() {
2342	2442	updateValue();
2343	2443	return lastMapResult;
2344	2444	}
2345		- if (lastIsAsync && !isAsync) {
	2445	+ const wasAsync = lastIsAsync;
	2446	+ lastIsAsync = isAsync;
	2447	+ if (wasAsync && !isAsync) {
2346	2448	lastMapResultValid = false;
2347	2449	renderQueue.cancel(queueContext);
2348	2450	}
2349	2451	updateValue();
2350		- lastIsAsync = isAsync;
	2452	+ if (wasAsync !== isAsync) {
	2453	+ subscriber.switchMode();
	2454	+ }
2351	2455	return { subscribe: subscriber.subscribe, getValue };
2352	2456	};
2353	2457	}
2354	2458	function _useStaticSelect(storeName) {
		@@ -2506,5 +2610,7 @@
2506	2610	* Copyright (c) 2014-2017, Jon Schlinkert.
2507	2611	* Released under the MIT License.
2508	2612	*)
2509	2613	*/
	2614	+(window.wp ||= {}).data = wp.data;
	2615	+})();
2510	2616	//# sourceMappingURL=index.js.map