@rebasepro/app 0.17.3 → 0.18.0

package/src/hooks/useNavigationBlocker.tsx

@@ -1,108 +0,0 @@
-import React, { createContext, useCallback, useContext, useEffect, useId, useMemo, useRef, useState } from "react";
-import { Blocker, BlockerFunction, useBlocker } from "react-router";
-
-const IDLE_BLOCKER: Blocker = {
-    state: "unblocked",
-    proceed: undefined,
-    reset: undefined,
-    location: undefined
-};
-
-type NavigationBlockerContextValue = {
-    register: (id: string, predicate: BlockerFunction) => void;
-    unregister: (id: string) => void;
-    blocker: Blocker;
-    /** Id of the registration that caused the current block, if any. */
-    blockedBy: string | null;
-};
-
-const NavigationBlockerContext = createContext<NavigationBlockerContextValue | null>(null);
-
-/**
- * Owns the single React Router blocker for the whole app.
- *
- * React Router only honours **one** blocker at a time: `shouldBlockNavigation`
- * picks the last-registered blocker function and silently ignores every other
- * one (it only logs a dev warning). Because blockers register in a `useEffect`,
- * the winner is whichever surface mounted most recently — so an unsaved-changes
- * guard could be disabled by an unrelated component mounting after it.
- *
- * This provider registers the only `useBlocker` in the tree and multiplexes it,
- * so every surface that needs to guard navigation gets a say regardless of
- * mount order. Surfaces register through {@link useNavigationBlocker}.
- */
-export function NavigationBlockerProvider({ children }: { children: React.ReactNode }) {
-
-    const predicates = useRef(new Map<string, BlockerFunction>());
-
-    // State, not a ref: the owning registration only renders its dialog once
-    // this has propagated, so it has to go through React.
-    const [blockedBy, setBlockedBy] = useState<string | null>(null);
-
-    const shouldBlock = useCallback<BlockerFunction>((args) => {
-        for (const [id, predicate] of predicates.current) {
-            if (predicate(args)) {
-                setBlockedBy(id);
-                return true;
-            }
-        }
-        setBlockedBy(null);
-        return false;
-    }, []);
-
-    const blocker = useBlocker(shouldBlock);
-
-    const register = useCallback((id: string, predicate: BlockerFunction) => {
-        predicates.current.set(id, predicate);
-    }, []);
-
-    const unregister = useCallback((id: string) => {
-        predicates.current.delete(id);
-        setBlockedBy((current) => (current === id ? null : current));
-    }, []);
-
-    const value = useMemo<NavigationBlockerContextValue>(() => ({
-        register,
-        unregister,
-        blocker,
-        blockedBy
-    }), [register, unregister, blocker, blockedBy]);
-
-    return (
-        <NavigationBlockerContext.Provider value={value}>
-            {children}
-        </NavigationBlockerContext.Provider>
-    );
-}
-
-/**
- * Guard navigation with `predicate`, sharing the app-wide blocker.
- *
- * Returns a {@link Blocker} that is only ever in the `blocked` state when *this*
- * registration is what blocked the navigation — so several guards can coexist
- * without each of them popping a dialog.
- *
- * Returns an idle blocker when no {@link NavigationBlockerProvider} is mounted
- * above, rather than competing for React Router's single blocker slot.
- */
-export function useNavigationBlocker(predicate: BlockerFunction): Blocker {
-
-    const context = useContext(NavigationBlockerContext);
-    const id = useId();
-
-    // Keep the latest predicate without re-registering on every render.
-    const predicateRef = useRef(predicate);
-    predicateRef.current = predicate;
-
-    const register = context?.register;
-    const unregister = context?.unregister;
-
-    useEffect(() => {
-        if (!register || !unregister) return;
-        register(id, (args) => predicateRef.current(args));
-        return () => unregister(id);
-    }, [register, unregister, id]);
-
-    if (!context) return IDLE_BLOCKER;
-    return context.blockedBy === id ? context.blocker : IDLE_BLOCKER;
-}

package/src/hooks/usePermissions.ts

@@ -1,45 +0,0 @@
-
-import { useAuthController } from "./useAuthController";
-import { Entity } from "@rebasepro/types";
-import { canCreateEntity, canEditEntity, canDeleteEntity, canReadCollection } from "@rebasepro/common";
-import { useCallback, useMemo } from "react";
-import type { AdminCollection } from "@rebasepro/cms-types";
-
-/**
- * Hook to evaluate roles and permissions for the current user.
- * It abstracts away the need to pass `authController` to permission evaluation functions.
- */
-export function usePermissions() {
-    const authController = useAuthController();
-
-    const canCreate = useCallback(
-        (collection: AdminCollection<any>, path: string) =>
-            canCreateEntity(collection, authController, path, null),
-        [authController]
-    );
-
-    const canEdit = useCallback(
-        (collection: AdminCollection<any>, path: string, entity: Entity<any> | null) =>
-            canEditEntity(collection, authController, path, entity),
-        [authController]
-    );
-
-    const canDelete = useCallback(
-        (collection: AdminCollection<any>, path: string, entity: Entity<any> | null) =>
-            canDeleteEntity(collection, authController, path, entity),
-        [authController]
-    );
-
-    const canRead = useCallback(
-        (collection: AdminCollection<any>) =>
-            canReadCollection(collection, authController),
-        [authController]
-    );
-
-    return useMemo(() => ({
-        canCreate,
-        canEdit,
-        canDelete,
-        canRead
-    }), [canCreate, canEdit, canDelete, canRead]);
-}

package/src/hooks/useRebaseClient.tsx

@@ -1,10 +0,0 @@
-import { useContext } from "react";
-import { RebaseClientInstanceContext } from "../contexts/RebaseClientInstanceContext";
-
-/**
- * Hook to retrieve the full RebaseClient instance from context.
- * Returns `undefined` if no client was provided to `<Rebase>`.
- */
-export function useRebaseClient<T = any>(): T | undefined {
-    return useContext(RebaseClientInstanceContext) as T | undefined;
-}

package/src/hooks/useRebaseContext.tsx

@@ -1,84 +0,0 @@
-import { User } from "@rebasepro/types";
-import { AuthController, RebaseContext } from "@rebasepro/cms-types";
-import { wrapAsSdkData } from "@rebasepro/common";
-import { useAuthController } from "./useAuthController";
-import { useRebaseClient } from "./useRebaseClient";
-import { useData } from "./data/useData";
-import { useStorageSource } from "./useStorageSource";
-import { useSnackbarController } from "./useSnackbarController";
-import { useUserConfigurationPersistence } from "./useUserConfigurationPersistence";
-import { useDialogsController } from "./useDialogsController";
-import { useCustomizationController } from "./useCustomizationController";
-import { useAnalyticsController } from "./useAnalyticsController";
-import { useEffectiveRoleController } from "./useEffectiveRoleController";
-import React, { useEffect, useContext } from "react";
-
-
-// DatabaseAdmin is provided by <Rebase> via DatabaseAdminContext.
-import { DatabaseAdminContext } from "../contexts/DatabaseAdminContext";
-
-/**
- * Hook to retrieve the {@link RebaseContext}.
- *
- * Consider that in order to use this hook you need to have a parent
- * `Rebase` component.
- *
- * @see RebaseContext
- * @group Hooks and utilities
- */
-export const useRebaseContext = <USER extends User = User, AuthControllerType extends AuthController<USER> = AuthController<USER>>(): RebaseContext<USER, AuthControllerType> => {
-
-    const client = useRebaseClient<any>();
-
-    const authController = useAuthController<USER, AuthControllerType>();
-    // `context.data` is the flat SDK view — identical in shape to the backend
-    // `context.data` and the frontend SDK client, so callbacks behave the same
-    // everywhere. The admin reads Entities via `useData()` directly.
-    const entityData = useData();
-    const data = React.useMemo(() => wrapAsSdkData(entityData), [entityData]);
-    const storageSource = useStorageSource();
-    const snackbarController = useSnackbarController();
-    const userConfigPersistence = useUserConfigurationPersistence();
-    const dialogsController = useDialogsController();
-    const customizationController = useCustomizationController();
-    const analyticsController = useAnalyticsController();
-    const effectiveRoleController = useEffectiveRoleController();
-
-
-    // Will get `databaseAdmin` from context
-    const databaseAdmin = useContext(DatabaseAdminContext);
-
-    const rebaseContextRef = React.useRef<RebaseContext<USER, AuthControllerType>>({
-        authController,
-        data,
-        storageSource,
-        snackbarController,
-        userConfigPersistence,
-        dialogsController,
-        customizationController,
-        analyticsController,
-        effectiveRoleController,
-        databaseAdmin,
-        client: client! // Client should be provided
-    });
-
-    React.useEffect(() => {
-        rebaseContextRef.current = {
-            authController,
-            data,
-            storageSource,
-            snackbarController,
-            userConfigPersistence,
-            dialogsController,
-            customizationController,
-            analyticsController,
-            effectiveRoleController,
-            databaseAdmin,
-            client: client!
-        };
-    }, [authController, data, storageSource, snackbarController, userConfigPersistence,
-        dialogsController, customizationController, analyticsController,
-        effectiveRoleController, databaseAdmin, client]);
-
-    return rebaseContextRef.current;
-}

package/src/hooks/useRebaseRegistry.tsx

@@ -1,91 +0,0 @@
-import React, { createContext, useContext, useState, useCallback, useMemo, useRef } from "react";
-import type { RebaseRegistryController, RebaseCMSConfig, RebaseStudioConfig, RebaseAuthViewConfig } from "@rebasepro/cms-types";
-
-/**
- * Split into two contexts to prevent infinite re-render loops:
- * - DispatchContext: stable register/unregister functions (never changes identity)
- * - StateContext: the current config values (changes when modules register)
- *
- * Feature components (RebaseAuth, RebaseCMS, RebaseStudio) only consume
- * the dispatch context, so registering does NOT cause them to re-render.
- * RebaseShell consumes state context to read the collected configs.
- */
-
-interface RegistryDispatch {
-    registerAdmin: (config: RebaseCMSConfig) => void;
-    unregisterAdmin: () => void;
-    registerStudio: (config: RebaseStudioConfig) => void;
-    unregisterStudio: () => void;
-    registerAuth: (config: RebaseAuthViewConfig) => void;
-    unregisterAuth: () => void;
-}
-
-interface RegistryState {
-    cmsConfig: RebaseCMSConfig | null;
-    studioConfig: RebaseStudioConfig | null;
-    authConfig: RebaseAuthViewConfig | null;
-}
-
-const RegistryDispatchContext = createContext<RegistryDispatch | undefined>(undefined);
-const RegistryStateContext = createContext<RegistryState>({
-    cmsConfig: null,
-    studioConfig: null,
-    authConfig: null
-});
-
-export function RebaseRegistryProvider({ children }: { children: React.ReactNode }) {
-    const [cmsConfig, setCmsConfig] = useState<RebaseCMSConfig | null>(null);
-    const [studioConfig, setStudioConfig] = useState<RebaseStudioConfig | null>(null);
-    const [authConfig, setAuthConfig] = useState<RebaseAuthViewConfig | null>(null);
-
-    // Dispatch functions are stable — never change identity
-    const dispatch = useMemo<RegistryDispatch>(() => ({
-        registerAdmin: (config: RebaseCMSConfig) => setCmsConfig(config),
-        unregisterAdmin: () => setCmsConfig(null),
-        registerStudio: (config: RebaseStudioConfig) => setStudioConfig(config),
-        unregisterStudio: () => setStudioConfig(null),
-        registerAuth: (config: RebaseAuthViewConfig) => setAuthConfig(config),
-        unregisterAuth: () => setAuthConfig(null)
-    }), []);
-
-    const state = useMemo<RegistryState>(() => ({
-        cmsConfig,
-studioConfig,
-authConfig
-    }), [cmsConfig, studioConfig, authConfig]);
-
-    return (
-        <RegistryDispatchContext.Provider value={dispatch}>
-            <RegistryStateContext.Provider value={state}>
-                {children}
-            </RegistryStateContext.Provider>
-        </RegistryDispatchContext.Provider>
-    );
-}
-
-/**
- * Returns the full registry (state + dispatch).
- * Use this in RebaseShell where you need to read configs.
- */
-export function useRebaseRegistry(): RebaseRegistryController {
-    const dispatch = useContext(RegistryDispatchContext);
-    const state = useContext(RegistryStateContext);
-    if (!dispatch) {
-        throw new Error("useRebaseRegistry must be used within RebaseRegistryProvider");
-    }
-    return useMemo(() => ({ ...state,
-...dispatch }), [state, dispatch]);
-}
-
-/**
- * Returns only the stable dispatch functions.
- * Use this in feature components (RebaseAuth, RebaseCMS, RebaseStudio)
- * to avoid re-render loops.
- */
-export function useRebaseRegistryDispatch(): RegistryDispatch {
-    const dispatch = useContext(RegistryDispatchContext);
-    if (!dispatch) {
-        throw new Error("useRebaseRegistryDispatch must be used within RebaseRegistryProvider");
-    }
-    return dispatch;
-}

package/src/hooks/useResolvedComponent.tsx

@@ -1,195 +0,0 @@
-import React, { useMemo } from "react";
-import { lazyChunk } from "@rebasepro/ui";
-import type { ComponentRef, LazyComponentRef } from "@rebasepro/types";
-import { isLazyComponentRef } from "@rebasepro/types";
-
-/**
- * Internal cache for resolved lazy components.
- *
- * `React.lazy()` must return the SAME wrapper across renders — if we call
- * `lazy(loader)` on every render, React will treat each result as a new
- * component type and unmount/remount on each render cycle.
- *
- * This WeakMap keeps a stable mapping from a `ComponentRef` (object/function)
- * to the `React.lazy()` wrapper it produced. Strings are keyed by a separate
- * plain Map since they can't be WeakMap keys.
- */
-
-const lazyCache = new WeakMap<object | ((...args: any[]) => any), React.ComponentType<any>>();
-
-/**
- * Resolves a `ComponentRef` into a renderable `React.ComponentType`.
- *
- * This hook handles all three forms of `ComponentRef`:
- *
- * 1. **`LazyComponentRef`** (produced by the Vite plugin from string paths):
- *    Wraps the lazy loader with `React.lazy()` for automatic code-splitting.
- *
- * 2. **`() => Promise<{ default: ComponentType }>`** (manual lazy import):
- *    Also wraps with `React.lazy()`. Distinguished from regular components
- *    by checking that the function has no parameters and is not a known
- *    React internal (no `$$typeof`).
- *
- * 3. **Direct `React.ComponentType`**:
- *    Returned as-is.
- *
- * If the ref is `undefined` or a raw string (which should never happen at
- * runtime in the browser since the Vite plugin transforms strings), returns `undefined`.
- *
- * The returned component is stable across re-renders as long as the `ref`
- * is referentially stable.
- *
- * **Usage:** Wrap the rendered component in `<Suspense>` to handle the
- * loading state of lazy components.
- *
- * @example
- * ```tsx
- * const ResolvedField = useResolvedComponent(property.ui?.Field);
- * if (!ResolvedField) return null;
- * return (
- *     <Suspense fallback={<CircularProgress />}>
- *         <ResolvedField {...fieldProps} />
- *     </Suspense>
- * );
- * ```
- * */
-export function useResolvedComponent<P = unknown>(
-    ref: ComponentRef<P> | undefined
-): React.ComponentType<P> | undefined {
-    return useMemo(() => resolveComponentRef(ref), [ref]);
-}
-
-/**
- * Wraps a loader function with `React.lazy()`, caching the result so the
- * same loader always returns the same lazy component identity.
- */
-function getOrCreateLazy<P>(
-    key: object | ((...args: any[]) => any),
-    loader: () => Promise<{ default: React.ComponentType<P> }>
-): React.ComponentType<P> {
-    const cached = lazyCache.get(key);
-    if (cached) return cached as React.ComponentType<P>;
-
-    // SAFETY: React.lazy returns LazyExoticComponent which is structurally compatible with ComponentType<P>
-    // `lazyChunk`, not `lazy`: a custom view is a chunk like any other, and a
-    // tab left open across a deploy cannot fetch it either.
-    const LazyComponent = lazyChunk(loader) as React.ComponentType<P>;
-    lazyCache.set(key, LazyComponent);
-    return LazyComponent;
-}
-
-/**
- * Pure function version of the resolver, for use outside React components.
- * Same resolution logic as `useResolvedComponent`.
- *
- * Results are cached per reference identity — calling this multiple times
- * with the same `ref` object returns the same `React.ComponentType`.
- */
-export function resolveComponentRef<P = unknown>(
-    ref: ComponentRef<P> | undefined
-): React.ComponentType<P> | undefined {
-    if (ref == null) return undefined;
-
-    // 1. String — should not happen at runtime (Vite transforms them).
-    //    Log a warning and bail out.
-    if (typeof ref === "string") {
-        console.warn(
-            `[Rebase] Encountered a raw string ComponentRef ("${ref}") at runtime. ` +
-            "This usually means the Vite transform plugin did not process this file. " +
-            "Ensure the file is inside the configured collectionsDir."
-        );
-        return undefined;
-    }
-
-    // 2. LazyComponentRef — produced by the Vite plugin from string paths.
-    //    The object has { __rebaseLazy: true, load: () => import(...) }.
-    if (isLazyComponentRef(ref)) {
-        return getOrCreateLazy<P>(
-            ref as object,
-            // `load()` resolves to `ComponentLike<P>` — the structural stand-in
-            // that lets `ComponentRef` live in the React-free core. This function
-            // is the one place that boundary is crossed, so it is the one place
-            // the widening is asserted: `ComponentLike` accepts a return type of
-            // `unknown` where React wants `ReactNode`. What actually arrives is
-            // whatever the collection file pointed at, and rendering it is
-            // React's problem either way.
-            () => (ref as LazyComponentRef<P>).load() as Promise<{ default: React.ComponentType<P> }>
-        );
-    }
-
-    // 3. Function — either a React component or a lazy import loader.
-    if (typeof ref === "function") {
-        const fn = ref as (...args: any[]) => any;
-
-        // Class components (React.Component / PureComponent) have this flag
-        if (fn.prototype?.isReactComponent) {
-            return ref as React.ComponentType<P>;
-        }
-
-        // React internals (forwardRef, memo, etc.) carry $$typeof
-        if ("$$typeof" in fn) {
-            return ref as React.ComponentType<P>;
-        }
-
-        // A function with declared parameters (fn.length > 0) is a regular
-        // component that accepts props — return as-is.
-        if (fn.length > 0) {
-            return ref as React.ComponentType<P>;
-        }
-
-        // Zero-parameter function — either a React component that takes no props,
-        // or a lazy loader `() => import(...)`.
-        //
-        // Nothing here can be decided with certainty from the outside, so the
-        // signals are ordered by how much they can be trusted, and the strongest
-        // one is what the function *does*, not what it is called.
-        //
-        // The name alone is not usable evidence, which is what this used to rely on.
-        // `admin: { Preview: () => import("./BodyPartsPreview") }` gives the arrow
-        // the *inferred* name "Preview" — JS names an anonymous function after the
-        // property key it is assigned to — so the "starts with an uppercase letter,
-        // therefore a component" rule matched every lazy loader written in the
-        // documented way. The thunk was then handed to React as a component, React
-        // called it, got a Promise back, and rendered nothing. That is what a blank
-        // custom preview column in the demo was.
-        const source = (() => {
-            try {
-                return Function.prototype.toString.call(fn);
-            } catch {
-                return "";
-            }
-        })();
-
-        // A dynamic module load in the body is the strongest signal, and it outranks
-        // the name: a toolchain cannot rename it away without breaking the fetch,
-        // whereas the name is often not the author's at all.
-        //
-        // Both spellings are checked because the body reaching us depends on the
-        // transform. Vite and any ESM build keep `import(...)`; ts-jest and other
-        // CommonJS transforms rewrite it to `require(...)`. Matching only the first
-        // passes in the browser and fails in the test suite, which is precisely how
-        // this went unnoticed. A zero-argument *component* containing either call is
-        // not a thing — components import at module scope.
-        const loadsAChunk = /\b(?:import|require)\s*\(/.test(source);
-
-        if (!loadsAChunk && fn.name && /^[A-Z]/.test(fn.name)) {
-            // Named like a component and does not load a chunk: a component.
-            return ref as React.ComponentType<P>;
-        }
-
-        // Treat as a lazy loader — wrap with React.lazy, cached by identity.
-        return getOrCreateLazy<P>(
-            fn,
-            ref as () => Promise<{ default: React.ComponentType<P> }>
-        );
-    }
-
-    // 4. React wrapper objects (React.forwardRef, React.memo) —
-    //    These are objects with $$typeof but are not functions.
-    if (typeof ref === "object" && "$$typeof" in (ref as object)) {
-        return ref as unknown as React.ComponentType<P>;
-    }
-
-    // 5. Unknown shape — return undefined to be safe
-    return undefined;
-}

package/src/hooks/useSlot.tsx

@@ -1,64 +0,0 @@
-import type { SlotName, SlotRegistry } from "@rebasepro/cms-types";
-import React, { useMemo } from "react";
-;
-import { useCustomizationController } from "./useCustomizationController";
-import { ErrorBoundary } from "@rebasepro/ui";
-
-/**
- * Hook that retrieves and renders all slot contributions for a given slot name.
- *
- * @param slot - The slot name to render contributions for.
- * @param props - Props passed to each slot component.
- * @returns An array of rendered React nodes, each wrapped in an ErrorBoundary.
- *
- * @example
- * ```tsx
- * const actions = useSlot("home.actions", { context });
- * return <div>{actions}</div>;
- * ```
- *
- * @group Hooks
- */
-export function useSlot<K extends SlotName>(
-    slot: K,
-    props: SlotRegistry[K]
-): React.ReactNode[] {
-    const { resolvedSlots } = useCustomizationController();
-
-    const propsRef = React.useRef(props);
-    const currentProps = props as unknown as Record<string, unknown>;
-    const prevProps = propsRef.current as unknown as Record<string, unknown>;
-
-    let changed = false;
-    if (currentProps !== prevProps) {
-        const keys = Object.keys(currentProps);
-        const prevKeys = Object.keys(prevProps);
-        if (keys.length !== prevKeys.length) {
-            changed = true;
-        } else {
-            for (let i = 0; i < keys.length; i++) {
-                if (currentProps[keys[i]] !== prevProps[keys[i]]) {
-                    changed = true;
-                    break;
-                }
-            }
-        }
-    }
-
-    if (changed) {
-        propsRef.current = props;
-    }
-
-    const stableProps = propsRef.current;
-
-    return useMemo(() => {
-        return resolvedSlots
-            .filter(s => s.slot === slot)
-            .sort((a, b) => (a.order ?? 50) - (b.order ?? 50))
-            .map((s, i) => (
-                <ErrorBoundary key={`${slot}_${i}`}>
-                    <s.Component {...(stableProps as unknown as Record<string, unknown>)} {...(s.props ?? {})}/>
-                </ErrorBoundary>
-            ));
-    }, [resolvedSlots, slot, stableProps]);
-}

package/src/hooks/useSnackbarController.tsx

@@ -1,80 +0,0 @@
-import type { SnackbarAction, SnackbarMessageType } from "@rebasepro/cms-types";
-import React, { useCallback, useMemo } from "react";
-import { useSnackbar } from "notistack";
-import { Button } from "@rebasepro/ui";
-
-/**
- * Hook to retrieve the SnackbarContext.
- *
- * Consider that in order to use this hook you need to have a parent
- * `Rebase`
- *
- * @see SnackbarController
- * @group Hooks and utilities
- */
-export const useSnackbarController = () => {
-
-    const {
-        enqueueSnackbar,
-        closeSnackbar
-    } = useSnackbar();
-
-    const open = useCallback((props: {
-        type: SnackbarMessageType;
-        title?: string;
-        message: React.ReactNode;
-        autoHideDuration?: number;
-        action?: SnackbarAction;
-    }) => {
-        const {
-            type,
-            message,
-            autoHideDuration,
-            action
-        } = props;
-        enqueueSnackbar({
-            message: props.title ? <div className={"flex flex-col"}>
-                <strong>{props.title}</strong>
-                {message}
-            </div> : message,
-            variant: type,
-            autoHideDuration,
-            // The provider sets `preventDuplicate`, which collapses two
-            // snackbars carrying the same message into one. That is right for a
-            // confirmation and wrong for an action: deleting two rows in a row
-            // produces the same "Deleted" text twice, and swallowing the second
-            // would leave the second deletion with no way to undo it. A key
-            // makes each one distinct.
-            ...(action ? { key: nextActionKey() } : {}),
-            action: action
-                ? (key) => (
-                    <Button variant={"text"}
-                            size={"small"}
-                            className={"text-inherit"}
-                            onClick={() => {
-                                action.onClick();
-                                // The offer has been taken; leaving it up
-                                // invites a second click that undoes nothing,
-                                // or worse, undoes something else.
-                                closeSnackbar(key);
-                            }}>
-                        {action.label}
-                    </Button>
-                )
-                : undefined
-        })
-    }, [enqueueSnackbar, closeSnackbar]);
-
-    const close = useCallback(() => {
-        closeSnackbar();
-    }, [closeSnackbar]);
-
-    return useMemo(() => ({
-        open,
-        close
-    }), [open, close]);
-
-};
-
-let actionKeySeq = 0;
-const nextActionKey = () => `rebase-snackbar-action-${actionKeySeq++}`;