cs

2026-02-09 16:30:59 +08:00
commit 52c6322a24
2780 changed files with 166403 additions and 0 deletions
--- a/node_modules/@ant-design/cssinjs/lib/hooks/useGlobalCache.js
+++ b/node_modules/@ant-design/cssinjs/lib/hooks/useGlobalCache.js
@@ -0,0 +1,108 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _typeof = require("@babel/runtime/helpers/typeof");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = useGlobalCache;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+var React = _interopRequireWildcard(require("react"));
+var _Cache = require("../Cache");
+var _StyleContext = _interopRequireDefault(require("../StyleContext"));
+var _useCompatibleInsertionEffect = _interopRequireDefault(require("./useCompatibleInsertionEffect"));
+var _useEffectCleanupRegister = _interopRequireDefault(require("./useEffectCleanupRegister"));
+var _useHMR = _interopRequireDefault(require("./useHMR"));
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function useGlobalCache(prefix, keyPath, cacheFn, onCacheRemove,
+// Add additional effect trigger by `useInsertionEffect`
+onCacheEffect) {
+  var _React$useContext = React.useContext(_StyleContext.default),
+    globalCache = _React$useContext.cache;
+  var fullPath = [prefix].concat((0, _toConsumableArray2.default)(keyPath));
+  var fullPathStr = (0, _Cache.pathKey)(fullPath);
+  var register = (0, _useEffectCleanupRegister.default)([fullPathStr]);
+  var HMRUpdate = (0, _useHMR.default)();
+  var buildCache = function buildCache(updater) {
+    globalCache.opUpdate(fullPathStr, function (prevCache) {
+      var _ref = prevCache || [undefined, undefined],
+        _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+        _ref2$ = _ref2[0],
+        times = _ref2$ === void 0 ? 0 : _ref2$,
+        cache = _ref2[1];
+
+      // HMR should always ignore cache since developer may change it
+      var tmpCache = cache;
+      if (process.env.NODE_ENV !== 'production' && cache && HMRUpdate) {
+        onCacheRemove === null || onCacheRemove === void 0 || onCacheRemove(tmpCache, HMRUpdate);
+        tmpCache = null;
+      }
+      var mergedCache = tmpCache || cacheFn();
+      var data = [times, mergedCache];
+
+      // Call updater if need additional logic
+      return updater ? updater(data) : data;
+    });
+  };
+
+  // Create cache
+  React.useMemo(function () {
+    buildCache();
+  }, /* eslint-disable react-hooks/exhaustive-deps */
+  [fullPathStr]
+  /* eslint-enable */);
+  var cacheEntity = globalCache.opGet(fullPathStr);
+
+  // HMR clean the cache but not trigger `useMemo` again
+  // Let's fallback of this
+  // ref https://github.com/ant-design/cssinjs/issues/127
+  if (process.env.NODE_ENV !== 'production' && !cacheEntity) {
+    buildCache();
+    cacheEntity = globalCache.opGet(fullPathStr);
+  }
+  var cacheContent = cacheEntity[1];
+
+  // Remove if no need anymore
+  (0, _useCompatibleInsertionEffect.default)(function () {
+    onCacheEffect === null || onCacheEffect === void 0 || onCacheEffect(cacheContent);
+  }, function (polyfill) {
+    // It's bad to call build again in effect.
+    // But we have to do this since StrictMode will call effect twice
+    // which will clear cache on the first time.
+    buildCache(function (_ref3) {
+      var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+        times = _ref4[0],
+        cache = _ref4[1];
+      if (polyfill && times === 0) {
+        onCacheEffect === null || onCacheEffect === void 0 || onCacheEffect(cacheContent);
+      }
+      return [times + 1, cache];
+    });
+    return function () {
+      globalCache.opUpdate(fullPathStr, function (prevCache) {
+        var _ref5 = prevCache || [],
+          _ref6 = (0, _slicedToArray2.default)(_ref5, 2),
+          _ref6$ = _ref6[0],
+          times = _ref6$ === void 0 ? 0 : _ref6$,
+          cache = _ref6[1];
+        var nextCount = times - 1;
+        if (nextCount === 0) {
+          // Always remove styles in useEffect callback
+          register(function () {
+            // With polyfill, registered callback will always be called synchronously
+            // But without polyfill, it will be called in effect clean up,
+            // And by that time this cache is cleaned up.
+            if (polyfill || !globalCache.opGet(fullPathStr)) {
+              onCacheRemove === null || onCacheRemove === void 0 || onCacheRemove(cache, false);
+            }
+          });
+          return null;
+        }
+        return [times - 1, cache];
+      });
+    };
+  }, [fullPathStr]);
+  return cacheContent;
+}