@faasjs/react 0.0.2-beta.294 → 0.0.2-beta.299

package/lib/index.js

@@ -1,120 +1,53 @@
 (function (global, factory) {
-  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('react')) :
-  typeof define === 'function' && define.amd ? define(['exports', 'react'], factory) :
-  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FaasReactClient = {}, global.React));
-})(this, (function (exports, React) { 'use strict';
-
-  function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
-
-  var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
-
-  class Response {
-      constructor({ status, headers, data }) {
-          this.status = status;
-          this.headers = headers;
-          this.data = data;
-      }
-  }
-  class ResponseError extends Error {
-      constructor({ message, status, headers, body }) {
-          super(message);
-          this.status = status;
-          this.headers = headers;
-          this.body = body;
-      }
-  }
-  class FaasBrowserClient {
-      /**
-       * 创建 FaasJS 浏览器客户端
-       * @param baseUrl {string} 网关地址
-       * @param options {object} 默认配置项
-       */
-      constructor(baseUrl, options) {
-          this.host = baseUrl[baseUrl.length - 1] === '/' ? baseUrl : baseUrl + '/';
-          this.defaultOptions = options || Object.create(null);
-          console.debug('[Faas] baseUrl: ' + this.host);
-      }
-      /**
-       * 发起请求
-       * @param action {string} 动作名称
-       * @param params {any} 动作参数
-       * @param options {object} 默认配置项
-       */
-      async action(action, params = {}, options = {}) {
-          const url = this.host + action.toLowerCase() + '?_=' + new Date().getTime().toString();
-          options = Object.assign(Object.assign({ method: 'POST', headers: { 'Content-Type': 'application/json; charset=UTF-8' }, mode: 'cors', body: JSON.stringify(params) }, this.defaultOptions), options);
-          if (options.beforeRequest)
-              await options.beforeRequest({
-                  action,
-                  params,
-                  options
-              });
-          return fetch(url, options)
-              .then(async (response) => {
-              const headers = {};
-              response.headers.forEach((value, key) => headers[key] = value);
-              return response.json().then(res => {
-                  if (res.error && res.error.message)
-                      return Promise.reject(new ResponseError({
-                          message: res.error.message,
-                          status: response.status,
-                          headers,
-                          body: response
-                      }));
-                  else
-                      return new Response({
-                          status: response.status,
-                          headers,
-                          data: res.data
-                      });
-              });
-          });
-      }
-  }
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('@faasjs/browser'), require('react')) :
+  typeof define === 'function' && define.amd ? define(['exports', '@faasjs/browser', 'react'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.FaasReactClient = {}, global.browser, global.React));
+})(this, (function (exports, browser, react) { 'use strict';
 
   function FaasReactClient({ domain, options, onError }) {
-      const client = new FaasBrowserClient(domain, options);
+      const client = new browser.FaasBrowserClient(domain, options);
       // async function faas<Path extends keyof FaasActions> (action: Path, params: FaasActions[Path]['request']): Promise<Response<FaasActions[Path]['response']>>
       async function faas(action, params) {
           if (onError)
               return client.action(action, params)
-                  .catch(onError(action, params));
+                  .catch(async (res) => {
+                  await onError(action, params)(res);
+                  return Promise.reject(res);
+              });
           return client.action(action, params);
       }
       function useFaas(action, defaultParams) {
-          const [loading, setLoading] = React__default["default"].useState(true);
-          const [data, setData] = React__default["default"].useState();
-          const [error, setError] = React__default["default"].useState();
-          const [promise, setPromise] = React__default["default"].useState();
-          const [params, setParams] = React__default["default"].useState(defaultParams);
-          const [reloadTimes, setReloadTimes] = React__default["default"].useState(0);
-          React__default["default"].useEffect(function () {
+          const [loading, setLoading] = react.useState(true);
+          const [data, setData] = react.useState();
+          const [error, setError] = react.useState();
+          const [promise, setPromise] = react.useState();
+          const [params, setParams] = react.useState(defaultParams);
+          const [reloadTimes, setReloadTimes] = react.useState(0);
+          react.useEffect(function () {
               if (JSON.stringify(defaultParams) !== JSON.stringify(params)) {
                   setParams(defaultParams);
               }
           }, [JSON.stringify(defaultParams)]);
-          React__default["default"].useEffect(function () {
+          react.useEffect(function () {
               setLoading(true);
               const request = client.action(action, params);
               setPromise(request);
               request
-                  .then(r => {
-                  setData(r === null || r === void 0 ? void 0 : r.data);
-              })
+                  .then(r => setData(r.data))
                   .catch(async (e) => {
                   if (onError)
                       try {
-                          setData(await onError(action, params)(e));
+                          await onError(action, params)(e);
                       }
                       catch (error) {
                           setError(error);
                       }
-                  setError(e);
+                  else
+                      setError(e);
+                  return Promise.reject(e);
               })
                   .finally(() => setLoading(false));
-              return () => {
-                  setLoading(false);
-              };
+              return () => setLoading(false);
           }, [
               action,
               JSON.stringify(params),
@@ -142,12 +75,12 @@
           useFaas,
           FaasData({ action, params, fallback, element, onDataChange }) {
               const request = useFaas(action, params);
-              const [loaded, setLoaded] = React__default["default"].useState(false);
-              React.useEffect(function () {
+              const [loaded, setLoaded] = react.useState(false);
+              react.useEffect(function () {
                   if (!loaded && !request.loading)
                       setLoaded(true);
               }, [request.loading]);
-              React.useEffect(() => {
+              react.useEffect(() => {
                   if (onDataChange)
                       onDataChange(request);
               }, [JSON.stringify(request.data)]);

package/lib/react/src/index.d.ts

@@ -1,16 +1,16 @@
 /// <reference types="react" />
-import { Options, Params, Response, ResponseError } from '../../browser/src';
-export type { FaasBrowserClient, Options, Params, Response, ResponseHeaders, ResponseError } from '../../browser/src';
+import { Options, Params, Response, ResponseError } from '@faasjs/browser';
+export type { FaasBrowserClient, Options, Params, Response, ResponseHeaders, ResponseError } from '@faasjs/browser';
 declare type FaasDataInjection<T = any> = {
     loading: boolean;
     data: T;
     error: any;
     promise: Promise<Response<T>>;
     reload(params?: Params): Promise<Response<T>>;
-    setData(data: T): void;
-    setLoading(loading: boolean): void;
-    setPromise(promise: Promise<Response<T>>): void;
-    setError(error: any): void;
+    setData: React.Dispatch<React.SetStateAction<T>>;
+    setLoading: React.Dispatch<React.SetStateAction<boolean>>;
+    setPromise: React.Dispatch<React.SetStateAction<Promise<Response<T>>>>;
+    setError: React.Dispatch<React.SetStateAction<any>>;
 };
 declare type FaasDataProps<T = any> = {
     element(args: FaasDataInjection<T>): JSX.Element;
@@ -19,16 +19,10 @@ declare type FaasDataProps<T = any> = {
     params?: Params;
     onDataChange?(args: FaasDataInjection<T>): void;
 };
-export interface FaasActions {
-    [path: string]: {
-        request: any;
-        response: any;
-    };
-}
 export declare function FaasReactClient({ domain, options, onError }: {
     domain: string;
     options?: Options;
-    onError?: (action: string, params: Params) => (res: ResponseError) => Promise<any>;
+    onError?: (action: string, params: Params) => (res: ResponseError) => Promise<void>;
 }): {
     faas: <T = any>(action: string, params: Params) => Promise<Response<T>>;
     useFaas: <T_1 = any>(action: string, defaultParams: Params) => FaasDataInjection<T_1>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@faasjs/react",
-  "version": "0.0.2-beta.294",
+  "version": "0.0.2-beta.299",
   "license": "MIT",
   "main": "lib/index.js",
   "types": "lib/react/src/index.d.ts",
@@ -27,5 +27,5 @@
     "rollup-plugin-typescript2": "*",
     "typescript": "*"
   },
-  "gitHead": "da80db41bf31736e49762c06c7c2ffe0f1496c72"
+  "gitHead": "e59f67b45534eb87764e6419fbfbbb0d24e3271d"
 }

package/lib/browser/src/index.d.ts

@@ -1,55 +0,0 @@
-export declare type Params = {
-    [key: string]: any;
-};
-export declare type Options = RequestInit & {
-    headers?: {
-        [key: string]: string;
-    };
-    beforeRequest?: ({ action, params, options }: {
-        action: string;
-        params: Params;
-        options: Options;
-    }) => Promise<void> | void;
-};
-export declare type ResponseHeaders = {
-    [key: string]: string;
-};
-export declare class Response<T = any> {
-    readonly status: number;
-    readonly headers: ResponseHeaders;
-    readonly data: T;
-    constructor({ status, headers, data }: {
-        status: number;
-        headers: ResponseHeaders;
-        data: T;
-    });
-}
-export declare class ResponseError extends Error {
-    readonly status: number;
-    readonly headers: ResponseHeaders;
-    readonly body: any;
-    constructor({ message, status, headers, body }: {
-        message: string;
-        status: number;
-        headers: ResponseHeaders;
-        body: any;
-    });
-}
-export declare class FaasBrowserClient {
-    host: string;
-    defaultOptions: Options;
-    /**
-     * 创建 FaasJS 浏览器客户端
-     * @param baseUrl {string} 网关地址
-     * @param options {object} 默认配置项
-     */
-    constructor(baseUrl: string, options?: Options);
-    /**
-     * 发起请求
-     * @param action {string} 动作名称
-     * @param params {any} 动作参数
-     * @param options {object} 默认配置项
-     */
-    action<T = any>(action: string, params?: Params, options?: Options): Promise<Response<T>>;
-}
-export default FaasBrowserClient;