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