@faasjs/react 0.0.2-beta.310 → 0.0.2-beta.320

package/{lib/react/src → dist}/index.d.ts

@@ -1,31 +1,33 @@
-/// <reference types="react" />
-import { Options, Response, ResponseError } from '@faasjs/browser';
-import { FaasAction, FaasData, FaasParams } from '@faasjs/types';
-export type { FaasBrowserClient, Options, Response, ResponseHeaders, ResponseError } from '@faasjs/browser';
-declare type FaasDataInjection<Data = any> = {
-    loading: boolean;
-    data: Data;
-    error: any;
-    promise: Promise<Response<Data>>;
-    reload(params?: Record<string, any>): Promise<Response<Data>>;
-    setData: React.Dispatch<React.SetStateAction<Data>>;
-    setLoading: React.Dispatch<React.SetStateAction<boolean>>;
-    setPromise: React.Dispatch<React.SetStateAction<Promise<Response<Data>>>>;
-    setError: React.Dispatch<React.SetStateAction<any>>;
-};
-declare type FaasDataProps<PathOrData extends FaasAction> = {
-    element(args: FaasDataInjection<FaasData<PathOrData>>): JSX.Element;
-    fallback?: JSX.Element | false;
-    action: string;
-    params?: FaasParams<PathOrData>;
-    onDataChange?(args: FaasDataInjection<FaasData<PathOrData>>): void;
-};
-export declare function FaasReactClient({ domain, options, onError }: {
-    domain: string;
-    options?: Options;
-    onError?: (action: string, params: Record<string, any>) => (res: ResponseError) => Promise<void>;
-}): {
-    faas: <PathOrData extends FaasAction>(action: string | PathOrData, params: FaasParams<PathOrData>) => Promise<Response<FaasData<PathOrData>>>;
-    useFaas: <PathOrData extends FaasAction>(action: string | PathOrData, defaultParams: FaasParams<PathOrData>) => FaasDataInjection<FaasData<PathOrData>>;
-    FaasData<PathOrData extends FaasAction>(props: FaasDataProps<PathOrData>): JSX.Element;
-};
+import { Options, ResponseError, Response } from '@faasjs/browser';
+export { FaasBrowserClient, Options, Response, ResponseError, ResponseHeaders } from '@faasjs/browser';
+import { FaasAction, FaasParams, FaasData } from '@faasjs/types';
+
+declare type FaasDataInjection<Data = any> = {
+    loading: boolean;
+    data: Data;
+    error: any;
+    promise: Promise<Response<Data>>;
+    reload(params?: Record<string, any>): Promise<Response<Data>>;
+    setData: React.Dispatch<React.SetStateAction<Data>>;
+    setLoading: React.Dispatch<React.SetStateAction<boolean>>;
+    setPromise: React.Dispatch<React.SetStateAction<Promise<Response<Data>>>>;
+    setError: React.Dispatch<React.SetStateAction<any>>;
+};
+declare type FaasDataProps<PathOrData extends FaasAction> = {
+    element(args: FaasDataInjection<FaasData<PathOrData>>): JSX.Element;
+    fallback?: JSX.Element | false;
+    action: string;
+    params?: FaasParams<PathOrData>;
+    onDataChange?(args: FaasDataInjection<FaasData<PathOrData>>): void;
+};
+declare function FaasReactClient({ domain, options, onError }: {
+    domain: string;
+    options?: Options;
+    onError?: (action: string, params: Record<string, any>) => (res: ResponseError) => Promise<void>;
+}): {
+    faas: <PathOrData extends FaasAction>(action: string | PathOrData, params: FaasParams<PathOrData>) => Promise<Response<FaasData<PathOrData>>>;
+    useFaas: <PathOrData extends FaasAction>(action: string | PathOrData, defaultParams: FaasParams<PathOrData>) => FaasDataInjection<FaasData<PathOrData>>;
+    FaasData<PathOrData extends FaasAction>(props: FaasDataProps<PathOrData>): JSX.Element;
+};
+
+export { FaasReactClient };

package/dist/index.js

@@ -0,0 +1,125 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __reExport = (target, module2, copyDefault, desc) => {
+  if (module2 && typeof module2 === "object" || typeof module2 === "function") {
+    for (let key of __getOwnPropNames(module2))
+      if (!__hasOwnProp.call(target, key) && (copyDefault || key !== "default"))
+        __defProp(target, key, { get: () => module2[key], enumerable: !(desc = __getOwnPropDesc(module2, key)) || desc.enumerable });
+  }
+  return target;
+};
+var __toCommonJS = /* @__PURE__ */ ((cache) => {
+  return (module2, temp) => {
+    return cache && cache.get(module2) || (temp = __reExport(__markAsModule({}), module2, 1), cache && cache.set(module2, temp), temp);
+  };
+})(typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : 0);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  FaasReactClient: () => FaasReactClient
+});
+var import_browser = require("@faasjs/browser");
+var import_react = require("react");
+function FaasReactClient({
+  domain,
+  options,
+  onError
+}) {
+  const client = new import_browser.FaasBrowserClient(domain, options);
+  async function faas(action, params) {
+    if (onError)
+      return client.action(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] = (0, import_react.useState)(true);
+    const [data, setData] = (0, import_react.useState)();
+    const [error, setError] = (0, import_react.useState)();
+    const [promise, setPromise] = (0, import_react.useState)();
+    const [params, setParams] = (0, import_react.useState)(defaultParams);
+    const [reloadTimes, setReloadTimes] = (0, import_react.useState)(0);
+    (0, import_react.useEffect)(function() {
+      if (JSON.stringify(defaultParams) !== JSON.stringify(params)) {
+        setParams(defaultParams);
+      }
+    }, [JSON.stringify(defaultParams)]);
+    (0, import_react.useEffect)(function() {
+      setLoading(true);
+      const request = client.action(action, params);
+      setPromise(request);
+      request.then((r) => setData(r.data)).catch(async (e) => {
+        if (onError)
+          try {
+            await onError(action, params)(e);
+          } catch (error2) {
+            setError(error2);
+          }
+        else
+          setError(e);
+        return Promise.reject(e);
+      }).finally(() => setLoading(false));
+      return () => setLoading(false);
+    }, [
+      action,
+      JSON.stringify(params),
+      reloadTimes
+    ]);
+    return {
+      loading,
+      data,
+      error,
+      promise,
+      async reload(params2) {
+        if (params2)
+          setParams(params2);
+        setReloadTimes(reloadTimes + 1);
+        return promise;
+      },
+      setData,
+      setLoading,
+      setPromise,
+      setError
+    };
+  }
+  return {
+    faas,
+    useFaas,
+    FaasData({
+      action,
+      params,
+      fallback,
+      element,
+      onDataChange
+    }) {
+      const request = useFaas(action, params);
+      const [loaded, setLoaded] = (0, import_react.useState)(false);
+      (0, import_react.useEffect)(function() {
+        if (!loaded && !request.loading)
+          setLoaded(true);
+      }, [request.loading]);
+      (0, import_react.useEffect)(function() {
+        if (onDataChange)
+          onDataChange(request);
+      }, [JSON.stringify(request.data)]);
+      if (loaded)
+        return element(request);
+      return fallback || null;
+    }
+  };
+}
+module.exports = __toCommonJS(src_exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FaasReactClient
+});

package/dist/index.mjs

@@ -0,0 +1,98 @@
+// src/index.ts
+import {
+  FaasBrowserClient
+} from "@faasjs/browser";
+import { useState, useEffect } from "react";
+function FaasReactClient({
+  domain,
+  options,
+  onError
+}) {
+  const client = new FaasBrowserClient(domain, options);
+  async function faas(action, params) {
+    if (onError)
+      return client.action(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] = useState(true);
+    const [data, setData] = useState();
+    const [error, setError] = useState();
+    const [promise, setPromise] = useState();
+    const [params, setParams] = useState(defaultParams);
+    const [reloadTimes, setReloadTimes] = useState(0);
+    useEffect(function() {
+      if (JSON.stringify(defaultParams) !== JSON.stringify(params)) {
+        setParams(defaultParams);
+      }
+    }, [JSON.stringify(defaultParams)]);
+    useEffect(function() {
+      setLoading(true);
+      const request = client.action(action, params);
+      setPromise(request);
+      request.then((r) => setData(r.data)).catch(async (e) => {
+        if (onError)
+          try {
+            await onError(action, params)(e);
+          } catch (error2) {
+            setError(error2);
+          }
+        else
+          setError(e);
+        return Promise.reject(e);
+      }).finally(() => setLoading(false));
+      return () => setLoading(false);
+    }, [
+      action,
+      JSON.stringify(params),
+      reloadTimes
+    ]);
+    return {
+      loading,
+      data,
+      error,
+      promise,
+      async reload(params2) {
+        if (params2)
+          setParams(params2);
+        setReloadTimes(reloadTimes + 1);
+        return promise;
+      },
+      setData,
+      setLoading,
+      setPromise,
+      setError
+    };
+  }
+  return {
+    faas,
+    useFaas,
+    FaasData({
+      action,
+      params,
+      fallback,
+      element,
+      onDataChange
+    }) {
+      const request = useFaas(action, params);
+      const [loaded, setLoaded] = useState(false);
+      useEffect(function() {
+        if (!loaded && !request.loading)
+          setLoaded(true);
+      }, [request.loading]);
+      useEffect(function() {
+        if (onDataChange)
+          onDataChange(request);
+      }, [JSON.stringify(request.data)]);
+      if (loaded)
+        return element(request);
+      return fallback || null;
+    }
+  };
+}
+export {
+  FaasReactClient
+};

package/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@faasjs/react",
-  "version": "0.0.2-beta.310",
+  "version": "0.0.2-beta.320",
   "license": "MIT",
-  "main": "lib/index.js",
-  "types": "lib/react/src/index.d.ts",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "module": "dist/index.mjs",
   "homepage": "https://faasjs.com/doc/react.html",
   "repository": {
     "type": "git",
@@ -15,24 +16,23 @@
   },
   "funding": "https://github.com/sponsors/faasjs",
   "scripts": {
-    "prepack": "rm -rf ./lib && rollup -c"
+    "build": "rm -rf ./dist && tsup src/index.ts --format esm,cjs --dts"
   },
   "files": [
-    "lib"
+    "dist"
   ],
   "peerDependencies": {
-    "@faasjs/browser": "^0.0.2-beta.280",
+    "@faasjs/browser": "^0.0.2-beta.320",
+    "@faasjs/types": "^0.0.2-beta.320",
     "react": "*"
   },
   "devDependencies": {
     "@types/react": "*",
-    "react": "*",
-    "rollup": "*",
-    "rollup-plugin-typescript2": "*",
+    "tsup": "*",
     "typescript": "*"
   },
   "engines": {
     "npm": ">=8.0.0"
   },
-  "gitHead": "0bfca56ec223e3b4b8fd91e51058263f010d4ea6"
+  "gitHead": "39d192f58071b851ec483dfca81fa4458307e3a2"
 }

package/lib/index.js

@@ -1,97 +0,0 @@
-(function (global, factory) {
-  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 browser.FaasBrowserClient(domain, options);
-      async function faas(action, params) {
-          if (onError)
-              return client.action(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.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.useEffect(function () {
-              setLoading(true);
-              const request = client.action(action, params);
-              setPromise(request);
-              request
-                  .then(r => setData(r.data))
-                  .catch(async (e) => {
-                  if (onError)
-                      try {
-                          await onError(action, params)(e);
-                      }
-                      catch (error) {
-                          setError(error);
-                      }
-                  else
-                      setError(e);
-                  return Promise.reject(e);
-              })
-                  .finally(() => setLoading(false));
-              return () => setLoading(false);
-          }, [
-              action,
-              JSON.stringify(params),
-              reloadTimes
-          ]);
-          return {
-              loading,
-              data,
-              error,
-              promise,
-              async reload(params) {
-                  if (params)
-                      setParams(params);
-                  setReloadTimes(reloadTimes + 1);
-                  return promise;
-              },
-              setData,
-              setLoading,
-              setPromise,
-              setError,
-          };
-      }
-      return {
-          faas,
-          useFaas,
-          FaasData({ action, params, fallback, element, onDataChange }) {
-              const request = useFaas(action, params);
-              const [loaded, setLoaded] = react.useState(false);
-              react.useEffect(function () {
-                  if (!loaded && !request.loading)
-                      setLoaded(true);
-              }, [request.loading]);
-              react.useEffect(function () {
-                  if (onDataChange)
-                      onDataChange(request);
-              }, [JSON.stringify(request.data)]);
-              if (loaded)
-                  return element(request);
-              return fallback || null;
-          }
-      };
-  }
-
-  exports.FaasReactClient = FaasReactClient;
-
-  Object.defineProperty(exports, '__esModule', { value: true });
-
-}));