muffin-admin 1.44.4 → 1.45.1

package/dist/MuffinAdmin.d.ts

@@ -0,0 +1,2 @@
+import { AdminOpts } from "./types";
+export declare function MuffinAdmin(props: AdminOpts): import("react/jsx-runtime").JSX.Element;

package/dist/MuffinAdmin.js

@@ -0,0 +1,25 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import IconButton from "@mui/material/IconButton";
+import SvgIcon from "@mui/material/SvgIcon";
+import Tooltip from "@mui/material/Tooltip";
+import Typography from "@mui/material/Typography";
+import createTheme from "@mui/material/styles/createTheme";
+import { Admin, AppBar, Layout, Login, ToggleThemeButton, defaultTheme, } from "react-admin";
+import { AdminPropsContext, buildAdmin, findBuilder, findIcon, setupAdmin } from "./utils";
+const darkTheme = createTheme({
+    palette: { mode: "dark" },
+});
+export function MuffinAdmin(props) {
+    const { resources, auth } = props;
+    const children = resources.map((resource) => buildAdmin(["resource", resource.name], Object.assign(Object.assign({}, resource), { key: resource.name })));
+    const appBar = (props) => (_jsxs(AppBar, Object.assign({}, props, { children: [_jsx(Typography, { variant: "h6", color: "inherit", id: "react-admin-title", style: {
+                    flex: 1,
+                    textOverflow: "ellipsis",
+                    whiteSpace: "nowrap",
+                    overflow: "hidden",
+                } }), _jsx(ToggleThemeButton, { lightTheme: defaultTheme, darkTheme: darkTheme }), props.appBarLinks.map((info) => (_jsx(Tooltip, { title: info.title, children: _jsx(IconButton, { color: "inherit", href: info.url, children: _jsx(SvgIcon, { component: findIcon(info.icon) }) }) }, info.url)))] })));
+    return (_jsx(AdminPropsContext.Provider, { value: props, children: _jsx(Admin, { requireAuth: auth.required, dashboard: buildAdmin(["dashboard"]), loginPage: findBuilder(["loginpage"]), authProvider: buildAdmin(["authprovider"], auth), layout: (props) => _jsx(Layout, Object.assign({}, props, { appBar: appBar })), dataProvider: buildAdmin(["dataprovider"], props), children: children }) }));
+}
+setupAdmin(["admin"], MuffinAdmin);
+// Initialize login page
+setupAdmin(["loginpage"], Login);

package/dist/MuffinDashboard.d.ts

@@ -0,0 +1,2 @@
+import { AdminOpts } from "./types";
+export declare function MuffinDashboard(props: AdminOpts["dashboard"]): import("react/jsx-runtime").JSX.Element;

package/dist/MuffinDashboard.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import Card from "@mui/material/Card";
+import CardContent from "@mui/material/CardContent";
+import Grid from "@mui/material/Grid";
+import Table from "@mui/material/Table";
+import TableBody from "@mui/material/TableBody";
+import TableCell from "@mui/material/TableCell";
+import TableRow from "@mui/material/TableRow";
+import Typography from "@mui/material/Typography";
+export function MuffinDashboard(props) {
+    return (_jsx(Grid, { container: true, spacing: 1, children: Array.isArray(props) ? (props.map((card, idx) => _jsx(DashboardCard, Object.assign({}, card), idx))) : (_jsx(DashboardCard, Object.assign({}, props))) }));
+}
+function DashboardCard(title, value) {
+    return (_jsx(Grid, { item: true, xs: true, children: _jsx(Card, { children: _jsxs(CardContent, { children: [_jsx(Typography, { variant: "h5", component: "h2", m: 2, style: { textAlign: "center" }, children: title }), (Array.isArray(value) && _jsx(AdminTableView, { src: value })) || (_jsx("pre", { children: JSON.stringify(value, null, 2) }))] }) }) }));
+}
+const AdminTableView = ({ src }) => (_jsx(Table, { children: _jsx(TableBody, { children: src.map((row, idx) => (_jsx(TableRow, { hover: true, children: row.map((cell, idx) => (_jsx(TableCell, { children: cell }, idx))) }, idx))) }) }));

package/dist/MuffinResource.d.ts

@@ -0,0 +1,2 @@
+import { AdminResourceProps } from "./types";
+export declare function MuffinResource({ name, create: createProps, edit: editProps, list: listProps, show: showProps, icon, ...props }: AdminResourceProps): import("react/jsx-runtime").JSX.Element;

package/dist/MuffinResource.js

@@ -0,0 +1,19 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Resource } from "react-admin";
+import { buildAdmin, findIcon, setupAdmin } from "./utils";
+export function MuffinResource(_a) {
+    var { name, create: createProps, edit: editProps, list: listProps, show: showProps, icon } = _a, props = __rest(_a, ["name", "create", "edit", "list", "show", "icon"]);
+    return (_jsx(Resource, Object.assign({ name: name, icon: findIcon(icon), create: buildAdmin(["create", name], createProps), edit: buildAdmin(["edit", name], editProps), list: buildAdmin(["list", name], listProps), show: buildAdmin(["show", name], showProps) }, props)));
+}
+setupAdmin(["resource"], MuffinResource);

package/dist/MuffinResourceCreate.d.ts

@@ -0,0 +1,4 @@
+import { AdminResourceProps } from "./types";
+export declare function MuffinResourceCreate({ inputs }: {
+    inputs: AdminResourceProps["create"];
+}): import("react/jsx-runtime").JSX.Element;

package/dist/MuffinResourceCreate.js

@@ -0,0 +1,11 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Create, ListButton, SimpleForm, TopToolbar, useResourceContext } from "react-admin";
+import { buildRA } from "./buildRA";
+import { buildAdmin, setupAdmin } from "./utils";
+export function MuffinResourceCreate({ inputs }) {
+    const resourceName = useResourceContext();
+    return (_jsx(Create, { actions: buildAdmin(["create-actions", resourceName]), children: _jsx(SimpleForm, { children: buildAdmin(["create-inputs", resourceName], inputs) }) }));
+}
+setupAdmin(["create"], (inputs) => _jsx(MuffinResourceCreate, { inputs: inputs }));
+setupAdmin(["create-actions"], () => (_jsx(TopToolbar, { children: _jsx(ListButton, {}) })));
+setupAdmin(["create-inputs"], buildRA);

package/dist/MuffinResourceEdit.d.ts

@@ -0,0 +1,2 @@
+import { AdminResourceProps } from "./types";
+export declare function MuffinResourceEdit({ actions, inputs, ...props }: AdminResourceProps["edit"]): import("react/jsx-runtime").JSX.Element;

package/dist/MuffinResourceEdit.js

@@ -0,0 +1,26 @@
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useContext } from "react";
+import { Edit, ListButton, ShowButton, SimpleForm, TopToolbar, useResourceContext, } from "react-admin";
+import { buildRA } from "./buildRA";
+import { ActionButton } from "./buttons";
+import { AdminPropsContext, buildAdmin, setupAdmin } from "./utils";
+export function MuffinResourceEdit(_a) {
+    var { actions, inputs } = _a, props = __rest(_a, ["actions", "inputs"]);
+    const resourceName = useResourceContext();
+    const { adminProps: { mutationMode }, } = useContext(AdminPropsContext);
+    return (_jsx(Edit, Object.assign({ actions: buildAdmin(["edit-actions", resourceName], actions), mutationMode: mutationMode || "optimistic" }, props, { children: _jsx(SimpleForm, { children: buildAdmin(["edit-inputs", resourceName], inputs) }) })));
+}
+setupAdmin(["edit"], (props) => _jsx(MuffinResourceEdit, Object.assign({}, props)));
+setupAdmin(["edit-actions"], (actions) => (_jsxs(TopToolbar, { children: [actions.map((props, idx) => (_jsx(ActionButton, Object.assign({}, props), idx))), _jsx(ListButton, {}), _jsx(ShowButton, {})] })));
+setupAdmin(["edit-inputs"], buildRA);

package/dist/MuffinResourceList.d.ts

@@ -0,0 +1,2 @@
+import { AdminResourceProps } from "./types";
+export declare function MuffinResourceList(props: AdminResourceProps["list"]): import("react/jsx-runtime").JSX.Element;

package/dist/MuffinResourceList.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import sortBy from "lodash/sortBy";
+import uniq from "lodash/uniq";
+import { BulkDeleteButton, Datagrid, EditButton, List, Pagination, useResourceContext, } from "react-admin";
+import { buildRA } from "./buildRA";
+import { BulkActionButton } from "./buttons";
+import { buildAdmin, setupAdmin } from "./utils";
+export function MuffinResourceList(props) {
+    const resourceName = useResourceContext();
+    const { fields, edit, show, limit, limitMax, filters, actions } = props;
+    return (_jsx(List, { bulkActionButtons: buildAdmin(["list-actions", resourceName], actions), filters: buildAdmin(["list-filters", resourceName], filters) || undefined, perPage: limit, pagination: _jsx(Pagination, { rowsPerPageOptions: sortBy(uniq([10, 25, 50, 100, limit, limitMax])) }), children: _jsxs(Datagrid, { rowClick: show ? "show" : edit ? "edit" : false, children: [buildAdmin(["list-fields", resourceName], fields), edit && _jsx(EditButton, {})] }) }));
+}
+setupAdmin(["list"], (props) => _jsx(MuffinResourceList, Object.assign({}, props)));
+setupAdmin(["list-fields"], buildRA);
+setupAdmin(["list-filters"], buildRA);
+setupAdmin(["list-actions"], (actions) => (_jsxs(_Fragment, { children: [actions.map((props, idx) => (_jsx(BulkActionButton, Object.assign({}, props), idx))), _jsx(BulkDeleteButton, {})] })));

package/dist/MuffinResourceShow.d.ts

@@ -0,0 +1,2 @@
+import { AdminShowProps } from "./types";
+export declare function MuffinResourceShow(props: AdminShowProps): import("react/jsx-runtime").JSX.Element;

package/dist/MuffinResourceShow.js

@@ -0,0 +1,13 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { EditButton, ListButton, Show, SimpleShowLayout, TopToolbar, useResourceContext, } from "react-admin";
+import { LinkAction } from "./actions";
+import { buildRA } from "./buildRA";
+import { ActionButton } from "./buttons";
+import { buildAdmin, setupAdmin } from "./utils";
+export function MuffinResourceShow(props) {
+    const resourceName = useResourceContext();
+    return (_jsx(Show, { actions: buildAdmin(["show-actions", resourceName], props), children: _jsx(SimpleShowLayout, { children: buildAdmin(["show-fields", resourceName], props) }) }));
+}
+setupAdmin(["show"], (props) => _jsx(MuffinResourceShow, Object.assign({}, props)));
+setupAdmin(["show-fields"], ({ fields }) => buildRA(fields));
+setupAdmin(["show-actions"], ({ actions, links }) => (_jsxs(TopToolbar, { children: [_jsx("div", { style: { marginRight: "auto" }, children: Object.keys(links).map((key) => (_jsx(LinkAction, Object.assign({ resource: key }, links[key]), key))) }), actions.map((props, idx) => (_jsx(ActionButton, Object.assign({}, props), idx))), _jsx(ListButton, {}), _jsx(EditButton, {})] })));

package/dist/actions/LinkAction.d.ts

@@ -0,0 +1,4 @@
+import { AdminShowLink } from "../types";
+export declare function LinkAction(props: AdminShowLink & {
+    resource: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/actions/LinkAction.js

@@ -0,0 +1,10 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRecordContext, useResourceContext } from "react-admin";
+import LinkButton from "../buttons/LinkButton";
+export function LinkAction(props) {
+    const record = useRecordContext();
+    const currentResource = useResourceContext();
+    if (!record)
+        return null;
+    return _jsx(LinkButton, Object.assign({}, props, { filters: { [currentResource]: record.id } }));
+}

package/dist/actions/index.d.ts

@@ -0,0 +1 @@
+export * from "./LinkAction";

package/dist/actions/index.js

@@ -0,0 +1 @@
+export * from "./LinkAction";

package/dist/authprovider.d.ts

@@ -0,0 +1,9 @@
+import { AdminOpts } from "./types";
+export declare function MuffinAuthProvider(props: AdminOpts["auth"]): {
+    login: (data: any) => Promise<void>;
+    checkError: (error: any) => Promise<void>;
+    checkAuth: () => Promise<any>;
+    logout: () => Promise<void>;
+    getIdentity: () => Promise<any>;
+    getPermissions: () => Promise<any>;
+};

package/dist/authprovider.js

@@ -0,0 +1,80 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import Cookies from "js-cookie";
+import { buildAdmin, makeRequest, requestHeaders, setupAdmin } from ".";
+setupAdmin(["auth-storage-get"], ({ storage, storageName }) => () => storage == "localstorage" ? localStorage.getItem(storageName) : Cookies.get(storageName));
+setupAdmin(["auth-storage-set"], ({ storage }) => (name, value) => {
+    if (storage == "localstorage") {
+        localStorage.setItem(name, value);
+        requestHeaders["Authorization"] = value;
+    }
+    else
+        Cookies.set(name, value);
+});
+export function MuffinAuthProvider(props) {
+    const { identityURL, authorizeURL, logoutURL, required, storageName } = props;
+    const authGet = buildAdmin(["auth-storage-get"], props);
+    const authSet = buildAdmin(["auth-storage-set"], props);
+    // Initialize request headers
+    authSet(storageName, authGet(storageName));
+    const getIdentity = () => __awaiter(this, void 0, void 0, function* () {
+        if (identityURL) {
+            const { json } = yield makeRequest(identityURL);
+            return json;
+        }
+    });
+    if (required)
+        return {
+            login: (data) => __awaiter(this, void 0, void 0, function* () {
+                if (!authorizeURL)
+                    throw { message: "Authorization is not supported" };
+                const { json } = yield makeRequest(authorizeURL, {
+                    data,
+                    method: "POST",
+                });
+                authSet(storageName, json);
+            }),
+            checkError: (error) => __awaiter(this, void 0, void 0, function* () {
+                const { status } = error || {};
+                if (status == 401 || status == 403) {
+                    // Clean storage
+                    authSet(storageName, "");
+                    throw {
+                        message: "Invalid authorization",
+                        redirectTo: logoutURL,
+                        logoutUser: !logoutURL,
+                    };
+                }
+            }),
+            checkAuth: () => __awaiter(this, void 0, void 0, function* () {
+                const auth = authGet(storageName);
+                if (!auth)
+                    throw { message: "Authorization required" };
+                if (!identityURL)
+                    return auth;
+                const user = yield getIdentity();
+                if (!user)
+                    throw { message: "Authorization required" };
+                return user;
+            }),
+            logout: () => __awaiter(this, void 0, void 0, function* () {
+                // Clean storage
+                authSet(storageName, "");
+                if (logoutURL)
+                    window.location.href = logoutURL;
+            }),
+            getIdentity,
+            getPermissions: () => __awaiter(this, void 0, void 0, function* () {
+                const role = authGet(storageName + "_role");
+                return role || "";
+            }),
+        };
+}
+setupAdmin(["authprovider"], MuffinAuthProvider);

package/dist/buildRA.d.ts

@@ -0,0 +1,2 @@
+export declare function buildRAComponent(name: any, props: any): import("react/jsx-runtime").JSX.Element;
+export declare function buildRA(items: any): any;

package/dist/buildRA.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { ArrayField, ArrayInput, AutocompleteArrayInput, AutocompleteInput, BooleanField, BooleanInput, CheckboxGroupInput, ChipField, DateField, DateInput, DateTimeInput, EmailField, FileField, FileInput, ImageField, ImageInput, NullableBooleanInput, NumberField, NumberInput, PasswordInput, RadioButtonGroupInput, ReferenceArrayField, ReferenceArrayInput, ReferenceField, ReferenceInput, ReferenceManyField, RichTextField, SelectField, SelectInput, TextField, TextInput, UrlField, required, } from "react-admin";
+import { AvatarField, EditableBooleanField, FKField, JsonField } from "./fields";
+import { FKInput, JsonInput } from "./inputs";
+const UI = {
+    // Fields
+    BooleanField,
+    ChipField,
+    DateField,
+    EmailField,
+    ImageField,
+    FileField,
+    NumberField,
+    RichTextField,
+    TextField,
+    UrlField,
+    SelectField,
+    ArrayField,
+    ReferenceField,
+    ReferenceManyField,
+    ReferenceArrayField,
+    AvatarField,
+    EditableBooleanField,
+    FKField,
+    JsonField,
+    // Inputs
+    BooleanInput,
+    NullableBooleanInput,
+    DateInput,
+    DateTimeInput,
+    ImageInput,
+    FileInput,
+    NumberInput,
+    PasswordInput,
+    TextInput,
+    AutocompleteInput,
+    RadioButtonGroupInput,
+    SelectInput,
+    ArrayInput,
+    AutocompleteArrayInput,
+    CheckboxGroupInput,
+    ReferenceArrayInput,
+    ReferenceInput,
+    JsonInput,
+    FKInput,
+};
+export function buildRAComponent(name, props) {
+    var _a;
+    const Item = UI[name];
+    if (!Item)
+        return null;
+    if (props.required) {
+        props.validate = required();
+        delete props.required;
+    }
+    props.fullWidth = (_a = props.fullWidth) !== null && _a !== void 0 ? _a : true;
+    if (props.children)
+        props.children = buildRA(props.children)[0];
+    return _jsx(Item, Object.assign({}, props), props.source);
+}
+export function buildRA(items) {
+    return items.map((item) => buildRAComponent(item[0], item[1]));
+}

package/dist/buttons/ActionButton.d.ts

@@ -0,0 +1,7 @@
+export declare function BulkActionButton({ label, icon, title, action }: {
+    label: any;
+    icon: any;
+    title: any;
+    action: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ActionButton(props: any): import("react/jsx-runtime").JSX.Element;

package/dist/buttons/ActionButton.js

@@ -0,0 +1,51 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import * as icons from "@mui/icons-material";
+import { Button, useListContext, useNotify, useRecordContext, useRefresh, useResourceContext, useUnselectAll, } from "react-admin";
+import { useAction } from "../hooks/useAction";
+import { buildIcon } from "../utils";
+export function BulkActionButton({ label, icon, title, action }) {
+    const resource = useResourceContext();
+    const { selectedIds } = useListContext();
+    const refresh = useRefresh(), unselectAll = useUnselectAll(resource), notify = useNotify();
+    const mutation = useAction(resource, action);
+    const onClick = () => {
+        mutation.mutate({
+            action,
+            ids: selectedIds,
+        }, {
+            onSuccess: ({ data }) => {
+                if (data && data.message)
+                    notify(data.message, { type: "success" });
+                refresh();
+                unselectAll();
+            },
+            onError: (err) => {
+                notify(typeof err === "string" ? err : err.message, { type: "error" });
+            },
+        });
+    };
+    return (_jsx(Button, { label: label, title: title, onClick: onClick, disabled: mutation.isLoading, children: buildIcon(icon) }));
+}
+export function ActionButton(props) {
+    const { icon, label, title, resource, action } = props;
+    const record = useRecordContext();
+    const { mutate, isLoading } = useAction(resource, action);
+    const refresh = useRefresh(), notify = useNotify(), Icon = icons[icon];
+    const onClick = () => {
+        mutate({ record }, {
+            onSuccess: ({ data }) => {
+                refresh();
+                if (data && data.redirectTo)
+                    window.location = data.redirectTo;
+                if (data && data.message)
+                    notify(data.message, { type: "success" });
+            },
+            onError: (err) => {
+                notify(typeof err === "string" ? err : err.message, {
+                    type: "error",
+                });
+            },
+        });
+    };
+    return (_jsx(Button, { label: label, title: title, onClick: onClick, disabled: isLoading, children: Icon && _jsx(Icon, {}) }));
+}

package/dist/buttons/LinkButton.d.ts

@@ -0,0 +1,6 @@
+import { AdminShowLink } from "../types";
+declare const LinkButton: ({ filters, icon, label, resource, title, }: AdminShowLink & {
+    resource: string;
+    filters: any;
+}) => import("react/jsx-runtime").JSX.Element;
+export default LinkButton;

package/dist/buttons/LinkButton.js

@@ -0,0 +1,12 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { Button } from "react-admin";
+import { Link } from "react-router-dom";
+import { buildIcon } from "../utils";
+const LinkButton = ({ filters, icon, label, resource, title, }) => {
+    const linkParams = {
+        pathname: `/${resource}`,
+        search: filters ? `filter=${JSON.stringify(filters)}` : undefined,
+    };
+    return (_jsx(Button, { label: label, title: title, component: Link, to: linkParams, children: buildIcon(icon) }));
+};
+export default LinkButton;

package/dist/buttons/index.d.ts

@@ -0,0 +1,2 @@
+export * from "./ActionButton";
+export * from "./LinkButton";

package/dist/buttons/index.js

@@ -0,0 +1,2 @@
+export * from "./ActionButton";
+export * from "./LinkButton";

package/dist/dataprovider.d.ts

@@ -0,0 +1,59 @@
+import { AdminOpts } from "./types";
+export declare function MuffinDataprovider({ apiUrl }: AdminOpts): {
+    getList: (resource: string, params: any) => Promise<{
+        data: any;
+        total: number;
+    }>;
+    getOne: (resource: any, { id }: {
+        id: any;
+    }) => Promise<{
+        data: any;
+    }>;
+    create: (resource: any, { data }: {
+        data: any;
+    }) => Promise<{
+        data: any;
+    }>;
+    update: (resource: any, { id, data }: {
+        id: any;
+        data: any;
+    }) => Promise<{
+        data: any;
+    }>;
+    updateMany: (resource: any, { ids, data }: {
+        ids: any;
+        data: any;
+    }) => Promise<{
+        data: any;
+    }>;
+    delete: (resource: any, { id }: {
+        id: any;
+    }) => Promise<{
+        data: {
+            id: any;
+        };
+    }>;
+    deleteMany: (resource: any, { ids }: {
+        ids: any;
+    }) => Promise<{
+        data: any;
+    }>;
+    getMany: (resource: any, { ids }: {
+        ids: any;
+    }) => Promise<{
+        data: any;
+        total: number;
+    }>;
+    getManyReference: (resource: any, { target, id, filter, ...opts }: {
+        [x: string]: any;
+        target: any;
+        id: any;
+        filter: any;
+    }) => Promise<{
+        data: any;
+        total: number;
+    }>;
+    runAction: (resource: any, action: any, props: any) => Promise<{
+        data: any;
+    }>;
+};

package/dist/dataprovider.js

@@ -0,0 +1,106 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+import { makeRequest, setupAdmin } from "./utils";
+export function MuffinDataprovider({ apiUrl }) {
+    const methods = {
+        getList: (resource, params) => __awaiter(this, void 0, void 0, function* () {
+            const { filter, pagination, sort } = params;
+            const query = {};
+            if (filter)
+                query.where = JSON.stringify(filter);
+            if (pagination) {
+                const { page, perPage: limit } = pagination;
+                query.limit = limit;
+                query.offset = limit * (page - 1);
+            }
+            if (sort) {
+                const { field, order } = sort;
+                query.sort = order == "ASC" ? field : `-${field}`;
+            }
+            const { headers, json } = yield makeRequest(`${apiUrl}/${resource}`, {
+                query,
+            });
+            return {
+                data: json,
+                total: parseInt(headers.get("x-total"), 10),
+            };
+        }),
+        getOne: (resource, { id }) => __awaiter(this, void 0, void 0, function* () {
+            const { json } = yield makeRequest(`${apiUrl}/${resource}/${id}`);
+            return { data: json };
+        }),
+        create: (resource, { data }) => __awaiter(this, void 0, void 0, function* () {
+            const { json } = yield makeRequest(`${apiUrl}/${resource}`, {
+                data,
+                method: "POST",
+            });
+            return { data: json };
+        }),
+        update: (resource, { id, data }) => __awaiter(this, void 0, void 0, function* () {
+            const { json } = yield makeRequest(`${apiUrl}/${resource}/${id}`, {
+                data,
+                method: "PUT",
+            });
+            return { data: json };
+        }),
+        updateMany: (resource, { ids, data }) => __awaiter(this, void 0, void 0, function* () {
+            yield Promise.all(ids.map((id) => methods.update(resource, { id, data })));
+            return { data: ids };
+        }),
+        delete: (resource, { id }) => __awaiter(this, void 0, void 0, function* () {
+            yield makeRequest(`${apiUrl}/${resource}/${id}`, {
+                method: "DELETE",
+            });
+            return { data: { id } };
+        }),
+        deleteMany: (resource, { ids }) => __awaiter(this, void 0, void 0, function* () {
+            yield makeRequest(`${apiUrl}/${resource}`, {
+                data: ids,
+                method: "DELETE",
+            });
+            return { data: ids };
+        }),
+        getMany: (resource, { ids }) => {
+            return methods.getList(resource, { filter: { id: { $in: ids } } });
+        },
+        getManyReference: (resource, _a) => __awaiter(this, void 0, void 0, function* () {
+            var { target, id, filter } = _a, opts = __rest(_a, ["target", "id", "filter"]);
+            filter = filter || {};
+            filter[target] = id;
+            return yield methods.getList(resource, Object.assign({ filter }, opts));
+        }),
+        runAction: (resource, action, props) => __awaiter(this, void 0, void 0, function* () {
+            const { payload, ids, record } = props;
+            action = action.replace(/^\/+/, "");
+            if (record) {
+                action = action.replace(/\{([^}]+)\}/, (_, field) => record[field]);
+            }
+            const { json } = yield makeRequest(`${apiUrl}/${action}`, {
+                query: { ids },
+                method: "POST",
+                data: payload,
+            });
+            return { data: json };
+        }),
+    };
+    return methods;
+}
+setupAdmin(["dataprovider"], MuffinDataprovider);

package/dist/fields/AvatarField.d.ts

@@ -0,0 +1,13 @@
+export declare function AvatarField({ source, alt, style, nameProp, ...props }: {
+    [x: string]: any;
+    source: any;
+    alt: any;
+    style: any;
+    nameProp: any;
+}): import("react/jsx-runtime").JSX.Element;
+export declare namespace AvatarField {
+    var displayName: string;
+    var defaultProps: {
+        addLabel: boolean;
+    };
+}