@next-core/brick-kit 2.107.4 → 2.110.0

package/CHANGELOG.md

@@ -3,6 +3,39 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# [2.110.0](https://github.com/easyops-cn/next-core/compare/@next-core/brick-kit@2.109.0...@next-core/brick-kit@2.110.0) (2022-03-23)
+
+
+### Features
+
+* support console in storyboard functions ([db24b0b](https://github.com/easyops-cn/next-core/commit/db24b0b1e6545a64974ab2ec1ffb1d8a2220d726))
+
+
+
+
+
+# [2.109.0](https://github.com/easyops-cn/next-core/compare/@next-core/brick-kit@2.108.0...@next-core/brick-kit@2.109.0) (2022-03-22)
+
+
+### Features
+
+* React组件支持调用skd生成的provider ([aced8ff](https://github.com/easyops-cn/next-core/commit/aced8ffc0d05f5f700169ee06525c5a56e309fe3))
+
+
+
+
+
+# [2.108.0](https://github.com/easyops-cn/next-core/compare/@next-core/brick-kit@2.107.4...@next-core/brick-kit@2.108.0) (2022-03-18)
+
+
+### Features
+
+* React组件支持调用provider ([1fe6096](https://github.com/easyops-cn/next-core/commit/1fe60963f96b4cddd889837da3ae5dd19f472d46))
+
+
+
+
+
 ## [2.107.4](https://github.com/easyops-cn/next-core/compare/@next-core/brick-kit@2.107.3...@next-core/brick-kit@2.107.4) (2022-03-15)
 
 **Note:** Version bump only for package @next-core/brick-kit

package/dist/index.bundle.js

@@ -1510,6 +1510,39 @@
     permissionMap.clear();
   }
 
+  var THROW = () => {
+    throw new Error("Can't modify read-only proxy object");
+  };
+
+  var readOnlyHandler = {
+    set: THROW,
+    defineProperty: THROW,
+    deleteProperty: THROW,
+    setPrototypeOf: THROW
+  };
+  function getReadOnlyProxy(object) {
+    return new Proxy(object, readOnlyHandler);
+  } // First, we want to make accessing property of globals lazy,
+  // So we use *Proxy* to make a dynamic accessor for each of these globals.
+  // But we also want to keep them working in devtools.
+
+  function getDynamicReadOnlyProxy(_ref) {
+    var {
+      get,
+      ownKeys
+    } = _ref;
+
+    if (getDevHook()) {
+      // In devtools, we extract them at beginning.
+      var target = Object.fromEntries(ownKeys(null).map(key => [key, get(null, key, null)]));
+      return getReadOnlyProxy(target);
+    }
+
+    return new Proxy(Object.freeze({}), {
+      get
+    });
+  }
+
   // `GeneralGlobals` are globals which are page-state-agnostic,
   // thus they can be used both in storyboard expressions and functions.
   function getGeneralGlobals(attemptToVisitGlobals, options) {
@@ -1531,7 +1564,8 @@
       collectCoverage,
       widgetId,
       app,
-      storyboardFunctions
+      storyboardFunctions,
+      isStoryboardFunction
     } = _ref;
 
     switch (variableName) {
@@ -1559,6 +1593,9 @@
         return {
           getTheme: collectCoverage ? () => "light" : getTheme
         };
+
+      case "console":
+        return isStoryboardFunction ? getReadOnlyProxy(console) : undefined;
     }
   }
 
@@ -1645,7 +1682,8 @@
           collectCoverage,
           widgetId,
           app: currentApp,
-          storyboardFunctions
+          storyboardFunctions,
+          isStoryboardFunction: true
         })),
         hooks: collector && {
           beforeEvaluate: collector.beforeEvaluate,
@@ -1699,39 +1737,6 @@
     registerStoryboardFunctions(functions);
   }
 
-  var THROW = () => {
-    throw new Error("Can't modify read-only proxy object");
-  };
-
-  var readOnlyHandler = {
-    set: THROW,
-    defineProperty: THROW,
-    deleteProperty: THROW,
-    setPrototypeOf: THROW
-  };
-  function getReadOnlyProxy(object) {
-    return new Proxy(object, readOnlyHandler);
-  } // First, we want to make accessing property of globals lazy,
-  // So we use *Proxy* to make a dynamic accessor for each of these globals.
-  // But we also want to keep them working in devtools.
-
-  function getDynamicReadOnlyProxy(_ref) {
-    var {
-      get,
-      ownKeys
-    } = _ref;
-
-    if (getDevHook()) {
-      // In devtools, we extract them at beginning.
-      var target = Object.fromEntries(ownKeys(null).map(key => [key, get(null, key, null)]));
-      return getReadOnlyProxy(target);
-    }
-
-    return new Proxy(Object.freeze({}), {
-      get
-    });
-  }
-
   /*! (c) Andrea Giammarchi - ISC */
   var self = {};
 
@@ -2647,7 +2652,7 @@
     }) : internalOptions;
   }
 
-  var _excluded$4 = ["children"],
+  var _excluded$6 = ["children"],
       _excluded2$1 = ["items", "app"];
   var symbolAppId = Symbol("appId");
   // Caching menu requests to avoid flicker.
@@ -2859,7 +2864,7 @@
         var {
           children
         } = _ref,
-            rest = _objectWithoutProperties__default["default"](_ref, _excluded$4);
+            rest = _objectWithoutProperties__default["default"](_ref, _excluded$6);
 
         return _objectSpread__default["default"](_objectSpread__default["default"]({}, yield computeRealValueWithOverrideApp(rest, rest[symbolAppId], context, kernel)), {}, {
           children: children && (yield computeMenuItemsWithOverrideApp(children, context, kernel))
@@ -3420,7 +3425,7 @@
     return kernel.loadDynamicBricksInBrickConf(brickConf);
   }
 
-  var _excluded$3 = ["extraQuery", "clear", "keepHash"];
+  var _excluded$5 = ["extraQuery", "clear", "keepHash"];
   function historyExtended(browserHistory) {
     var {
       push: originalPush,
@@ -3436,7 +3441,7 @@
           clear,
           keepHash
         } = options,
-            state = _objectWithoutProperties__default["default"](options, _excluded$3);
+            state = _objectWithoutProperties__default["default"](options, _excluded$5);
 
         var urlSearchParams = new URLSearchParams(clear ? "" : browserHistory.location.search);
         var params = {};
@@ -6606,7 +6611,7 @@
     }
   }
 
-  var _excluded$2 = ["feature_flags"];
+  var _excluded$4 = ["feature_flags"];
   function standaloneBootstrap() {
     return _standaloneBootstrap.apply(this, arguments);
   }
@@ -6642,7 +6647,7 @@
           var {
             feature_flags: featureFlags
           } = sys_settings,
-              rest = _objectWithoutProperties__default["default"](sys_settings, _excluded$2);
+              rest = _objectWithoutProperties__default["default"](sys_settings, _excluded$4);
 
           settings = _objectSpread__default["default"]({
             featureFlags
@@ -10334,7 +10339,7 @@
     }
   }
 
-  var _excluded$1 = ["properties", "slots"],
+  var _excluded$3 = ["properties", "slots"],
       _excluded2 = ["ref", "slots"];
   function expandCustomTemplate(brickConf, proxyBrick, context) {
     var tplContext = new CustomTemplateContext(proxyBrick);
@@ -10375,7 +10380,7 @@
       properties: templateProperties,
       slots: externalSlots
     } = brickConf,
-        restBrickConf = _objectWithoutProperties__default["default"](brickConf, _excluded$1);
+        restBrickConf = _objectWithoutProperties__default["default"](brickConf, _excluded$3);
 
     var newBrickConf = restBrickConf; // Get a copy of proxy for each instance of custom template.
 
@@ -12811,7 +12816,7 @@
     checkoutTplContext: lodash.noop
   };
 
-  var _excluded = ["type"];
+  var _excluded$2 = ["type"];
   // Inspired by [LitElement](https://github.com/Polymer/lit-element)
 
   /**
@@ -13081,7 +13086,7 @@
       var {
         type
       } = options,
-          eventInit = _objectWithoutProperties__default["default"](options, _excluded);
+          eventInit = _objectWithoutProperties__default["default"](options, _excluded$2);
 
       this.__dev_only_definedEvents.add(type); // Make event emitter readonly.
 
@@ -13173,6 +13178,290 @@
     };
   }, UpdatingElement);
 
+  var useProviderArgsDefaults = {
+    provider: "",
+    customOptions: {
+      onError: () => {
+        /* Do nothing.. */
+      },
+      transform: (oldData, newData) => newData,
+      data: undefined,
+      loading: false,
+      suspense: false
+    },
+    dependencies: undefined
+  };
+  var defaults = Object.entries(useProviderArgsDefaults).reduce((acc, _ref) => {
+    var [key, value] = _ref;
+    if (Object.prototype.toString.call(value) === "[object Object]") return _objectSpread__default["default"](_objectSpread__default["default"]({}, acc), value);
+    return _objectSpread__default["default"](_objectSpread__default["default"]({}, acc), {}, {
+      [key]: value
+    });
+  }, {});
+
+  var _excluded$1 = ["args"];
+  function useProviderArgs(providerOrParamsOrGlobalOptions, gloabalOptionsOrDeps, deps) {
+    var provider = React.useMemo(() => {
+      if (typeof providerOrParamsOrGlobalOptions === "string") {
+        return providerOrParamsOrGlobalOptions;
+      }
+
+      return useProviderArgsDefaults.provider;
+    }, [providerOrParamsOrGlobalOptions, gloabalOptionsOrDeps]);
+    var options = React.useMemo(() => {
+      var localOptions = {};
+
+      if (lodash.isObject(providerOrParamsOrGlobalOptions)) {
+        localOptions = providerOrParamsOrGlobalOptions;
+      } else if (lodash.isObject(gloabalOptionsOrDeps)) {
+        localOptions = gloabalOptionsOrDeps;
+      }
+
+      return _objectSpread__default["default"](_objectSpread__default["default"]({}, defaults), localOptions);
+    }, [providerOrParamsOrGlobalOptions, gloabalOptionsOrDeps]);
+    var requestInit = React.useMemo(() => {
+      var customOptionKeys = [...Object.keys(useProviderArgsDefaults), ...Object.keys(useProviderArgsDefaults.customOptions)];
+
+      var _reduce = Object.keys(options).reduce((acc, key) => {
+        if (!customOptionKeys.includes(key)) acc[key] = options[key];
+        return acc;
+      }, {}),
+          {
+        args = null
+      } = _reduce,
+          restOptions = _objectWithoutProperties__default["default"](_reduce, _excluded$1);
+
+      return {
+        options: _objectSpread__default["default"]({}, restOptions),
+        args
+      };
+    }, [options]);
+    var dependencies = React.useMemo(() => {
+      if (Array.isArray(gloabalOptionsOrDeps)) return gloabalOptionsOrDeps;
+      if (Array.isArray(deps)) return deps;
+      return defaults.dependencies;
+    }, [gloabalOptionsOrDeps, deps]);
+    var loading = options.loading || Array.isArray(dependencies);
+    var customOptions = React.useMemo(() => {
+      var customOptionKeys = Object.keys(useProviderArgsDefaults.customOptions);
+      var customOptions = customOptionKeys.reduce((opts, key) => {
+        opts[key] = options[key];
+        return opts;
+      }, {});
+      return _objectSpread__default["default"](_objectSpread__default["default"]({}, customOptions), {}, {
+        loading
+      });
+    }, [options]);
+    return {
+      provider,
+      customOptions,
+      requestInit,
+      dependencies
+    };
+  }
+
+  var cache$1 = new Map();
+  function fetchProviderArgs(_x, _x2) {
+    return _fetchProviderArgs.apply(this, arguments);
+  }
+
+  function _fetchProviderArgs() {
+    _fetchProviderArgs = _asyncToGenerator__default["default"](function* (provider, args) {
+      for (var _len = arguments.length, originalArgs = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+        originalArgs[_key - 2] = arguments[_key];
+      }
+
+      var cacheKey = JSON.stringify({
+        provider,
+        args,
+        originalArgs
+      });
+      if (cache$1.has(cacheKey)) return cache$1.get(cacheKey);
+      var actualArgs = yield getArgsOfCustomApi(provider, [...args, ...originalArgs]);
+      cache$1.set(cacheKey, actualArgs);
+      return actualArgs;
+    });
+    return _fetchProviderArgs.apply(this, arguments);
+  }
+
+  var cache = new Map();
+  function fetch(_x) {
+    return _fetch.apply(this, arguments);
+  }
+
+  function _fetch() {
+    _fetch = _asyncToGenerator__default["default"](function* (provider) {
+      for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        args[_key - 1] = arguments[_key];
+      }
+
+      var cacheKey = JSON.stringify({
+        provider,
+        args
+      });
+      var promise;
+
+      if (cache.has(cacheKey)) {
+        promise = cache.get(cacheKey);
+      } else {
+        promise = _asyncToGenerator__default["default"](function* () {
+          if (!isCustomApiProvider(provider)) {
+            var providerBrick = yield _internalApiGetProviderBrick(provider);
+            var providerTagName = providerBrick.tagName.toLowerCase();
+
+            if (!customElements.get(providerTagName)) {
+              throw new Error("Provider not defined: \"".concat(providerTagName, "\", please make sure the related package is installed."));
+            }
+
+            return providerBrick["resolve"](...args);
+          }
+
+          return CustomApi(...args);
+        })();
+        cache.set(cacheKey, promise);
+      }
+
+      return promise;
+    });
+    return _fetch.apply(this, arguments);
+  }
+
+  var _excluded = ["onError", "transform", "suspense"];
+  function useProvider() {
+    var {
+      provider,
+      customOptions,
+      dependencies,
+      requestInit
+    } = useProviderArgs(...arguments);
+
+    var {
+      onError,
+      transform,
+      suspense
+    } = customOptions,
+        defaults = _objectWithoutProperties__default["default"](customOptions, _excluded);
+
+    var [loading, setLoading] = React.useState(defaults.loading);
+    var suspenseStatus = React.useRef("pending");
+    var suspender = React.useRef();
+    var mounted = React.useRef(false);
+    var error = React.useRef();
+    var response = React.useRef();
+    var data = React.useRef(defaults.data);
+    var forceUpdate = React.useReducer(() => ({}), [])[1];
+    var doFetch = React.useCallback( /*#__PURE__*/_asyncToGenerator__default["default"](function* () {
+      try {
+        error.current = undefined;
+        if (!suspense) setLoading(true);
+
+        for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+          args[_key] = arguments[_key];
+        }
+
+        var newRes = yield fetch(provider, ...args);
+        response.current = newRes;
+        data.current = transform(data.current, newRes);
+      } catch (e) {
+        error.current = e;
+      }
+
+      if (!suspense) setLoading(false);
+      if (error.current) onError(error.current);
+      return data.current;
+    }), [provider, customOptions, dependencies, requestInit, suspense, transform, defaults.data, onError]);
+    var makeFetch = React.useCallback( /*#__PURE__*/function () {
+      var _ref2 = _asyncToGenerator__default["default"](function* (providerOrBody, args) {
+        var providerStr = provider;
+        var providerArgs = [];
+
+        if (lodash.isString(providerOrBody)) {
+          providerStr = providerOrBody;
+        }
+
+        if (lodash.isObject(providerOrBody)) {
+          providerArgs = providerOrBody;
+        } else if (lodash.isObject(args)) {
+          providerArgs = args;
+        }
+
+        var actualArgs = yield fetchProviderArgs(providerStr, providerArgs, requestInit.options);
+
+        if (suspense) {
+          return _asyncToGenerator__default["default"](function* () {
+            suspender.current = doFetch(...actualArgs).then(newData => {
+              suspenseStatus.current = "success";
+              return newData;
+            }, error => {
+              suspenseStatus.current = "error";
+              error.current = error;
+              return error;
+            });
+            forceUpdate();
+            return yield suspender.current;
+          })();
+        }
+
+        return doFetch(...actualArgs);
+      });
+
+      return function (_x, _x2) {
+        return _ref2.apply(this, arguments);
+      };
+    }(), [doFetch]);
+    var request = React.useMemo(() => Object.defineProperties({
+      query: makeFetch
+    }, {
+      loading: {
+        get() {
+          return loading;
+        }
+
+      },
+      data: {
+        get() {
+          return data.current;
+        }
+
+      },
+      error: {
+        get() {
+          return error.current;
+        }
+
+      }
+    }), [makeFetch]); // onMount/onUpdate
+
+    React.useEffect(() => {
+      mounted.current = true;
+
+      if (Array.isArray(dependencies) && provider) {
+        request.query(provider, requestInit.args);
+      }
+
+      return () => mounted.current = false;
+    }, dependencies);
+
+    if (suspense && suspender.current) {
+      switch (suspenseStatus.current) {
+        case "pending":
+          throw suspender.current;
+
+        case "error":
+          throw error.current;
+      }
+    }
+
+    return Object.assign([request, response.current, loading, error.current], _objectSpread__default["default"](_objectSpread__default["default"]({
+      request
+    }, request), {}, {
+      response: response.current,
+      data: data.current,
+      loading,
+      error: error.current
+    }));
+  }
+
   exports.BrickAsComponent = BrickAsComponent;
   exports.BrickWrapper = BrickWrapper;
   exports.DisplayByFeatureFlags = DisplayByFeatureFlags;
@@ -13222,6 +13511,7 @@
   exports.useCurrentTheme = useCurrentTheme;
   exports.useFeatureFlags = useFeatureFlags;
   exports.useLocation = useLocation;
+  exports.useProvider = useProvider;
   exports.useRecentApps = useRecentApps;
 
   Object.defineProperty(exports, '__esModule', { value: true });