muffin-admin 1.36.4 → 1.36.6

package/dist/esm/admin.js

@@ -0,0 +1,71 @@
+import _extends from "@babel/runtime/helpers/extends";
+import React from "react";
+import { Admin, AppBar, Layout, Login, ToggleThemeButton, defaultTheme } from "react-admin";
+import { IconButton, SvgIcon, Tooltip, Typography, createTheme } from "@mui/material";
+import * as icons from "@mui/icons-material";
+import authProvider from "./authprovider";
+import dataProvider from "./dataprovider";
+import { processAdmin, setupAdmin } from "./utils";
+import "./dashboard";
+import "./resources";
+var darkTheme = createTheme({
+  palette: {
+    mode: "dark"
+  }
+});
+
+// Initialize the admin
+setupAdmin("admin", function (props) {
+  var apiUrl = props.apiUrl,
+    auth = props.auth,
+    adminProps = props.adminProps,
+    appBarLinks = props.appBarLinks,
+    dashboard = props.dashboard,
+    resources = props.resources;
+  var appBar = function appBar(props) {
+    return /*#__PURE__*/React.createElement(AppBar, props, /*#__PURE__*/React.createElement(Typography, {
+      variant: "h6",
+      color: "inherit",
+      id: "react-admin-title",
+      style: {
+        flex: 1,
+        textOverflow: "ellipsis",
+        whiteSpace: "nowrap",
+        overflow: "hidden"
+      }
+    }), /*#__PURE__*/React.createElement(ToggleThemeButton, {
+      lightTheme: defaultTheme,
+      darkTheme: darkTheme
+    }), appBarLinks.map(function (info) {
+      return /*#__PURE__*/React.createElement(Tooltip, {
+        key: info.url,
+        title: info.title
+      }, /*#__PURE__*/React.createElement(IconButton, {
+        color: "inherit",
+        href: info.url
+      }, /*#__PURE__*/React.createElement(SvgIcon, {
+        component: icons[info.icon]
+      })));
+    }));
+  };
+  return /*#__PURE__*/React.createElement(Admin, _extends({
+    authProvider: processAdmin("auth", auth),
+    dataProvider: processAdmin("data", apiUrl),
+    dashboard: processAdmin("dashboard", dashboard),
+    loginPage: processAdmin("login", auth),
+    layout: function layout(props) {
+      return /*#__PURE__*/React.createElement(Layout, _extends({
+        appBar: appBar
+      }, props));
+    }
+  }, adminProps), processAdmin("resources", resources));
+});
+
+// Initialize authentication and data providers
+setupAdmin("auth", authProvider);
+setupAdmin("data", dataProvider);
+
+// Initialize login page
+setupAdmin("login", function () {
+  return Login;
+});

package/dist/esm/authprovider.js

@@ -0,0 +1,191 @@
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import Cookies from "js-cookie";
+import { makeRequest, processAdmin, requestHeaders, setupAdmin } from "./utils";
+setupAdmin("auth-get", function (_ref) {
+  var storage = _ref.storage;
+  return function (name) {
+    return storage == "localstorage" ? localStorage.getItem(name) : Cookies.get(name);
+  };
+});
+setupAdmin("auth-set", function (_ref2) {
+  var storage = _ref2.storage;
+  return function (name, value) {
+    if (storage == "localstorage") {
+      localStorage.setItem(name, value);
+      requestHeaders["Authorization"] = value;
+    } else Cookies.set(name, value);
+  };
+});
+export default (function (props) {
+  var identityURL = props.identityURL,
+    authorizeURL = props.authorizeURL,
+    logoutURL = props.logoutURL,
+    required = props.required,
+    storage_name = props.storage_name;
+  var authGet = processAdmin("auth-get", props);
+  var authSet = processAdmin("auth-set", props);
+
+  // Initialize request headers
+  authSet(storage_name, authGet(storage_name));
+  var getIdentity = /*#__PURE__*/function () {
+    var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee() {
+      var _yield$makeRequest, json;
+      return _regeneratorRuntime.wrap(function _callee$(_context) {
+        while (1) switch (_context.prev = _context.next) {
+          case 0:
+            if (!identityURL) {
+              _context.next = 6;
+              break;
+            }
+            _context.next = 3;
+            return makeRequest(identityURL);
+          case 3:
+            _yield$makeRequest = _context.sent;
+            json = _yield$makeRequest.json;
+            return _context.abrupt("return", json);
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }, _callee);
+    }));
+    return function getIdentity() {
+      return _ref3.apply(this, arguments);
+    };
+  }();
+  if (required) return {
+    login: function () {
+      var _login = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(data) {
+        var _yield$makeRequest2, json;
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (authorizeURL) {
+                _context2.next = 2;
+                break;
+              }
+              throw {
+                message: "Authorization is not supported"
+              };
+            case 2:
+              _context2.next = 4;
+              return makeRequest(authorizeURL, {
+                data: data,
+                method: "POST"
+              });
+            case 4:
+              _yield$makeRequest2 = _context2.sent;
+              json = _yield$makeRequest2.json;
+              authSet(storage_name, json);
+            case 7:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2);
+      }));
+      function login(_x) {
+        return _login.apply(this, arguments);
+      }
+      return login;
+    }(),
+    checkError: function () {
+      var _checkError = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(error) {
+        var status;
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              status = error.status;
+              if (!(status == 401 || status == 403)) {
+                _context3.next = 4;
+                break;
+              }
+              // Clean storage
+              authSet(storage_name, "");
+              throw {
+                message: "Invalid authorization",
+                redirectTo: logoutURL,
+                logoutUser: !logoutURL
+              };
+            case 4:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3);
+      }));
+      function checkError(_x2) {
+        return _checkError.apply(this, arguments);
+      }
+      return checkError;
+    }(),
+    checkAuth: function () {
+      var _checkAuth = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee4() {
+        var auth, user;
+        return _regeneratorRuntime.wrap(function _callee4$(_context4) {
+          while (1) switch (_context4.prev = _context4.next) {
+            case 0:
+              auth = authGet(storage_name);
+              if (auth) {
+                _context4.next = 3;
+                break;
+              }
+              throw {
+                message: "Authorization required"
+              };
+            case 3:
+              if (identityURL) {
+                _context4.next = 5;
+                break;
+              }
+              return _context4.abrupt("return", auth);
+            case 5:
+              _context4.next = 7;
+              return getIdentity();
+            case 7:
+              user = _context4.sent;
+              if (user) {
+                _context4.next = 10;
+                break;
+              }
+              throw {
+                message: "Authorization required"
+              };
+            case 10:
+              return _context4.abrupt("return", user);
+            case 11:
+            case "end":
+              return _context4.stop();
+          }
+        }, _callee4);
+      }));
+      function checkAuth() {
+        return _checkAuth.apply(this, arguments);
+      }
+      return checkAuth;
+    }(),
+    logout: function () {
+      var _logout = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee5() {
+        return _regeneratorRuntime.wrap(function _callee5$(_context5) {
+          while (1) switch (_context5.prev = _context5.next) {
+            case 0:
+              // Clean storage
+              authSet(storage_name, "");
+              if (logoutURL) window.location = logoutURL;
+            case 2:
+            case "end":
+              return _context5.stop();
+          }
+        }, _callee5);
+      }));
+      function logout() {
+        return _logout.apply(this, arguments);
+      }
+      return logout;
+    }(),
+    getIdentity: getIdentity,
+    getPermissions: function getPermissions() {
+      var role = authGet(storage_name + "_role");
+      return role ? Promise.resolve(role) : Promise.reject();
+    }
+  };
+});

package/dist/esm/buttons/ActionButton.js

@@ -0,0 +1,81 @@
+import React from "react";
+import { Button, useRefresh, useUnselectAll, useNotify, useRecordContext } from "react-admin";
+import * as icons from "@mui/icons-material";
+import useAction from "../hooks/useAction";
+export var BulkActionButton = function BulkActionButton(_ref) {
+  var label = _ref.label,
+    icon = _ref.icon,
+    title = _ref.title,
+    action = _ref.action,
+    resource = _ref.resource,
+    selectedIds = _ref.selectedIds;
+  var refresh = useRefresh(),
+    unselectAll = useUnselectAll(resource),
+    notify = useNotify(),
+    Icon = icons[icon];
+  var mutation = useAction(resource, action);
+  var onClick = function onClick() {
+    mutation.mutate({
+      action: action,
+      ids: selectedIds
+    }, {
+      onSuccess: function onSuccess(_ref2) {
+        var data = _ref2.data;
+        if (data && data.message) notify(data.message, {
+          type: "success"
+        });
+        refresh();
+        unselectAll();
+      },
+      onError: function onError(err) {
+        notify(typeof err === "string" ? err : err.message, {
+          type: "error"
+        });
+      }
+    });
+  };
+  return /*#__PURE__*/React.createElement(Button, {
+    label: label,
+    title: title,
+    onClick: onClick,
+    disabled: mutation.isLoading
+  }, Icon && /*#__PURE__*/React.createElement(Icon, null));
+};
+export var ActionButton = function ActionButton(props) {
+  var icon = props.icon,
+    label = props.label,
+    title = props.title,
+    resource = props.resource,
+    action = props.action;
+  var record = useRecordContext();
+  var mutation = useAction(resource, action);
+  var refresh = useRefresh(),
+    notify = useNotify(),
+    Icon = icons[icon];
+  var onClick = function onClick() {
+    mutation.mutate({
+      record: record
+    }, {
+      onSuccess: function onSuccess(_ref3) {
+        var data = _ref3.data;
+        refresh();
+        if (data && data.redirectTo) window.location = data.redirectTo;
+        if (data && data.message) notify(data.message, {
+          type: "success"
+        });
+      },
+      onError: function onError(error) {
+        notify(typeof error === "string" ? error : error.message, {
+          type: "error"
+        });
+      }
+    });
+  };
+  return /*#__PURE__*/React.createElement(Button, {
+    label: label,
+    title: title,
+    onClick: onClick,
+    disabled: mutation.isLoading
+  }, Icon && /*#__PURE__*/React.createElement(Icon, null));
+};
+export default ActionButton;

package/dist/esm/buttons/LinkButton.js

@@ -0,0 +1,23 @@
+import React from "react";
+import { Button } from "react-admin";
+import { Link } from "react-router-dom";
+import * as icons from "@mui/icons-material";
+var LinkButton = function LinkButton(_ref) {
+  var label = _ref.label,
+    icon = _ref.icon,
+    title = _ref.title,
+    resource = _ref.resource,
+    filters = _ref.filters;
+  var Icon = icons[icon] || icon;
+  var linkParams = {
+    pathname: "/".concat(resource),
+    search: filters ? "filter=".concat(JSON.stringify(filters)) : undefined
+  };
+  return /*#__PURE__*/React.createElement(Button, {
+    label: label,
+    title: title,
+    component: Link,
+    to: linkParams
+  }, Icon && /*#__PURE__*/React.createElement(Icon, null));
+};
+export default LinkButton;

package/dist/esm/dashboard.js

@@ -0,0 +1,60 @@
+import React from "react";
+import { Grid, Card, CardContent, Typography, Table, TableBody, TableRow, TableCell } from "@mui/material";
+import { setupAdmin } from "./utils";
+var AdminTableView = function AdminTableView(_ref) {
+  var src = _ref.src;
+  return /*#__PURE__*/React.createElement(Table, null, /*#__PURE__*/React.createElement(TableBody, null, src.map(function (row, idx) {
+    return /*#__PURE__*/React.createElement(TableRow, {
+      key: idx,
+      hover: true
+    }, row.map(function (cell, idx) {
+      return /*#__PURE__*/React.createElement(TableCell, {
+        key: idx
+      }, cell);
+    }));
+  })));
+};
+var AdminCard = function AdminCard(_ref2) {
+  var src = _ref2.src;
+  if (Array.isArray(src)) {
+    return /*#__PURE__*/React.createElement(Grid, {
+      container: true,
+      item: true,
+      spacing: 2
+    }, src.map(function (card, idx) {
+      return /*#__PURE__*/React.createElement(AdminCard, {
+        key: idx,
+        src: card
+      });
+    }));
+  }
+  var title = src.title,
+    value = src.value;
+  return /*#__PURE__*/React.createElement(Grid, {
+    item: true,
+    xs: true
+  }, /*#__PURE__*/React.createElement(Card, null, /*#__PURE__*/React.createElement(CardContent, null, /*#__PURE__*/React.createElement(Typography, {
+    variant: "h5",
+    component: "h2",
+    m: 2,
+    style: {
+      textAlign: "center"
+    }
+  }, title), Array.isArray(value) && /*#__PURE__*/React.createElement(AdminTableView, {
+    src: value
+  }) || /*#__PURE__*/React.createElement("pre", null, JSON.stringify(value, null, 2)))));
+};
+
+// Process dashboard
+setupAdmin("dashboard", function (props) {
+  if (!props) return;
+  var Dashboard = function Dashboard() {
+    return /*#__PURE__*/React.createElement(Grid, {
+      container: true,
+      spacing: 1
+    }, /*#__PURE__*/React.createElement(AdminCard, {
+      src: props
+    }));
+  };
+  return Dashboard;
+});