@rebasepro/core 0.0.1-canary.0

package/dist/hooks/index.d.ts

@@ -0,0 +1,41 @@
+export * from "./data/useDataSource";
+export * from "./data/useCollectionFetch";
+export * from "./data/useEntityFetch";
+export * from "./data/useRelationSelector";
+export * from "./data/save";
+export * from "./data/delete";
+export * from "./navigation/contexts";
+export * from "./navigation/useBuildCollectionRegistryController";
+export * from "./navigation/useBuildCMSUrlController";
+export * from "./navigation/useBuildNavigationStateController";
+export * from "./navigation/useResolvedCollections";
+export * from "./navigation/useResolvedViews";
+export * from "./navigation/useTopLevelNavigation";
+export * from "./useUnsavedChangesDialog";
+export * from "./useResolvedNavigationFrom";
+export * from "./useStorageSource";
+export * from "./useAuthController";
+export * from "./useDialogsController";
+export * from "./useSideDialogsController";
+export * from "./useAdminModeController";
+export * from "./useBuildAdminModeController";
+export * from "./useEffectiveRoleController";
+export * from "./useBuildEffectiveRoleController";
+export * from "./useSideEntityController";
+export * from "./useRebaseContext";
+export * from "./useSnackbarController";
+export * from "./useModeController";
+export * from "./useClipboard";
+export * from "./useLargeLayout";
+export * from "./useCollapsedGroups";
+export * from "./useInternalUserManagementController";
+export * from "./useEntitySelectionDialog";
+export * from "./useBrowserTitleAndIcon";
+export * from "./useCustomizationController";
+export * from "./useBuildNavigationController";
+export * from "./useBuildLocalConfigurationPersistence";
+export * from "./useBuildModeController";
+export * from "./useValidateAuthenticator";
+export * from "./useBackendStorageSource";
+export * from "./usePermissions";
+export * from "./ApiConfigContext";

package/dist/hooks/navigation/contexts/CMSUrlContext.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { CMSUrlController } from "@rebasepro/types";
+export declare const CMSUrlContext: React.Context<CMSUrlController>;
+export declare function useCMSUrlController(): CMSUrlController;

package/dist/hooks/navigation/contexts/CollectionRegistryContext.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { CollectionRegistryController, EntityCollection } from "@rebasepro/types";
+export declare const CollectionRegistryContext: React.Context<CollectionRegistryController>;
+export declare function useCollectionRegistryController<EC extends EntityCollection = EntityCollection<any>>(): CollectionRegistryController<EC>;

package/dist/hooks/navigation/contexts/NavigationStateContext.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { NavigationStateController } from "@rebasepro/types";
+export declare const NavigationStateContext: React.Context<NavigationStateController>;
+export declare function useNavigationStateController(): NavigationStateController;

package/dist/hooks/navigation/contexts/index.d.ts

@@ -0,0 +1,3 @@
+export { CollectionRegistryContext, useCollectionRegistryController } from "./CollectionRegistryContext";
+export { NavigationStateContext, useNavigationStateController } from "./NavigationStateContext";
+export { CMSUrlContext, useCMSUrlController } from "./CMSUrlContext";

package/dist/hooks/navigation/useBuildCMSUrlController.d.ts

@@ -0,0 +1,6 @@
+import { CMSUrlController, CollectionRegistryController } from "@rebasepro/types";
+export declare function useBuildCMSUrlController(props: {
+    basePath: string;
+    baseCollectionPath: string;
+    collectionRegistryController: CollectionRegistryController;
+}): CMSUrlController;

package/dist/hooks/navigation/useBuildCollectionRegistryController.d.ts

@@ -0,0 +1,7 @@
+import { CollectionRegistry } from "@rebasepro/common";
+import { UserConfigurationPersistence, CollectionRegistryController } from "@rebasepro/types";
+export declare function useBuildCollectionRegistryController(props: {
+    userConfigPersistence?: UserConfigurationPersistence;
+}): CollectionRegistryController & {
+    collectionRegistryRef: React.MutableRefObject<CollectionRegistry>;
+};

package/dist/hooks/navigation/useBuildNavigationStateController.d.ts

@@ -0,0 +1,32 @@
+import { CMSView, EntityCollection, RebasePlugin, AuthController, EntityCollectionsBuilder, CMSViewsBuilder, NavigationStateController, DataSource, CollectionRegistryController, CMSUrlController, NavigationGroupMapping, User } from "@rebasepro/types";
+import { CollectionRegistry } from "@rebasepro/common";
+import { EffectiveRoleController, UserManagementDelegate } from "@rebasepro/types";
+export type BuildNavigationStateProps<EC extends EntityCollection, USER extends User> = {
+    authController: AuthController<USER>;
+    collections?: EC[] | EntityCollectionsBuilder<EC>;
+    views?: CMSView[] | CMSViewsBuilder;
+    adminViews?: CMSView[] | CMSViewsBuilder;
+    dataSource: DataSource;
+    plugins?: RebasePlugin[];
+    navigationGroupMappings?: NavigationGroupMapping[];
+    disabled?: boolean;
+    viewsOrder?: string[];
+    collectionRegistryController: CollectionRegistryController<EC> & {
+        collectionRegistryRef: React.MutableRefObject<CollectionRegistry>;
+    };
+    cmsUrlController: CMSUrlController;
+    adminMode?: "content" | "studio" | "settings";
+    effectiveRoleController?: EffectiveRoleController;
+    userManagement?: UserManagementDelegate<USER>;
+};
+/**
+ * Main hook that resolves collections, views, and admin views into a
+ * NavigationStateController. This is a thin composition of three focused hooks:
+ *
+ * - useResolvedCollections: resolves collection props and registers with CollectionRegistry
+ * - useResolvedViews: resolves view/admin view props and injects Users/Roles views
+ * - useTopLevelNavigation: computes the NavigationResult from resolved data
+ *
+ * The NavigationStateController type is preserved as a public API.
+ */
+export declare function useBuildNavigationStateController<EC extends EntityCollection, USER extends User>(props: BuildNavigationStateProps<EC, USER>): NavigationStateController;

package/dist/hooks/navigation/useNavigationRegistry.d.ts

@@ -0,0 +1,10 @@
+import { CollectionRegistry } from "@rebasepro/common";
+import { EntityCollection, EntityReference, UserConfigurationPersistence } from "@rebasepro/types";
+export declare function useNavigationRegistry(userConfigPersistence?: UserConfigurationPersistence): {
+    collectionRegistryRef: import("react").RefObject<CollectionRegistry>;
+    getCollection: (slugOrPath: string, includeUserOverride?: boolean) => EntityCollection | undefined;
+    getRawCollection: (slugOrPath: string) => EntityCollection | undefined;
+    getParentReferencesFromPath: (path: string) => EntityReference[];
+    getParentCollectionIds: (path: string) => string[];
+    convertIdsToPaths: (ids: string[]) => string[];
+};

package/dist/hooks/navigation/useNavigationResolution.d.ts

@@ -0,0 +1,5 @@
+import { AuthController, CMSView, CMSViewsBuilder, DataSource, EntityCollection, EntityCollectionsBuilder, RebasePlugin, User } from "@rebasepro/types";
+export declare function filterOutNotAllowedCollections(resolvedCollections: EntityCollection[], authController: AuthController<User>): EntityCollection[];
+export declare function applyPluginModifyCollection(resolvedCollections: EntityCollection[], modifyCollection: (collection: EntityCollection) => EntityCollection): EntityCollection<any, any>[];
+export declare function resolveCollections(collections: undefined | EntityCollection[] | EntityCollectionsBuilder<any>, authController: AuthController, dataSource: DataSource, plugins: RebasePlugin[] | undefined): Promise<EntityCollection[]>;
+export declare function resolveCMSViews(baseViews: CMSView[] | CMSViewsBuilder | undefined, authController: AuthController, dataSource: DataSource, plugins?: RebasePlugin[]): Promise<CMSView[]>;

package/dist/hooks/navigation/useNavigationURLs.d.ts

@@ -0,0 +1,11 @@
+import { CollectionRegistry } from "@rebasepro/common";
+export declare function encodePath(input: string): string;
+export declare function useNavigationURLs(basePath: string, baseCollectionPath: string, collectionRegistryRef: React.MutableRefObject<CollectionRegistry>): {
+    homeUrl: string;
+    fullCollectionPath: string;
+    buildCMSUrlPath: (path: string) => string;
+    buildUrlCollectionPath: (path: string) => string;
+    isUrlCollectionPath: (path: string) => boolean;
+    urlPathToDataPath: (path: string) => string;
+    resolveDatabasePathsFrom: (path: string) => string;
+};

package/dist/hooks/navigation/useResolvedCollections.d.ts

@@ -0,0 +1,26 @@
+import { AuthController, CollectionRegistryController, DataSource, EntityCollection, EntityCollectionsBuilder, RebasePlugin, User } from "@rebasepro/types";
+import { CollectionRegistry } from "@rebasepro/common";
+export type UseResolvedCollectionsProps<EC extends EntityCollection, USER extends User> = {
+    authController: AuthController<USER>;
+    collections?: EC[] | EntityCollectionsBuilder<EC>;
+    dataSource: DataSource;
+    plugins?: RebasePlugin[];
+    disabled?: boolean;
+    collectionRegistryController: CollectionRegistryController<EC> & {
+        collectionRegistryRef: React.MutableRefObject<CollectionRegistry>;
+    };
+};
+export type UseResolvedCollectionsResult = {
+    collections: EntityCollection[];
+    loading: boolean;
+    error: Error | undefined;
+    refresh: () => void;
+};
+/**
+ * Hook that resolves collection props (which may be async builders or arrays)
+ * into concrete EntityCollection[], and registers them with the CollectionRegistry.
+ *
+ * Uses refs for potentially-unstable dependencies (dataSource, authController,
+ * plugins) to avoid re-triggering effects when their object identity changes.
+ */
+export declare function useResolvedCollections<EC extends EntityCollection, USER extends User>(props: UseResolvedCollectionsProps<EC, USER>): UseResolvedCollectionsResult;

package/dist/hooks/navigation/useResolvedViews.d.ts

@@ -0,0 +1,28 @@
+import { AuthController, CMSView, CMSViewsBuilder, DataSource, EffectiveRoleController, RebasePlugin, User } from "@rebasepro/types";
+import { UserManagementDelegate } from "@rebasepro/types";
+export type UseResolvedViewsProps<USER extends User> = {
+    authController: AuthController<USER>;
+    views?: CMSView[] | CMSViewsBuilder;
+    adminViews?: CMSView[] | CMSViewsBuilder;
+    dataSource: DataSource;
+    plugins?: RebasePlugin[];
+    adminMode?: "content" | "studio" | "settings";
+    effectiveRoleController?: EffectiveRoleController;
+    userManagement?: UserManagementDelegate<USER>;
+};
+export type UseResolvedViewsResult = {
+    views: CMSView[] | undefined;
+    adminViews: CMSView[] | undefined;
+    loading: boolean;
+    error: Error | undefined;
+    refresh: () => void;
+};
+/**
+ * Hook that resolves view and admin view props (which may be async builders or arrays)
+ * into concrete CMSView[]. Also injects Users/Roles admin views when userManagement
+ * is provided.
+ *
+ * Uses refs for potentially-unstable dependencies (dataSource, authController,
+ * plugins) to avoid re-triggering effects when their object identity changes.
+ */
+export declare function useResolvedViews<USER extends User>(props: UseResolvedViewsProps<USER>): UseResolvedViewsResult;

package/dist/hooks/navigation/useTopLevelNavigation.d.ts

@@ -0,0 +1,26 @@
+import { CMSView, CMSUrlController, EntityCollection, RebasePlugin, NavigationGroupMapping, NavigationResult, CollectionRegistryController } from "@rebasepro/types";
+import { CollectionRegistry } from "@rebasepro/common";
+export type UseTopLevelNavigationProps = {
+    collections: EntityCollection[];
+    views: CMSView[] | undefined;
+    adminViews: CMSView[] | undefined;
+    plugins?: RebasePlugin[];
+    navigationGroupMappings?: NavigationGroupMapping[];
+    viewsOrder?: string[];
+    cmsUrlController: CMSUrlController;
+    adminMode?: "content" | "studio" | "settings";
+    collectionRegistryController: CollectionRegistryController<any> & {
+        collectionRegistryRef: React.MutableRefObject<CollectionRegistry>;
+    };
+};
+export type UseTopLevelNavigationResult = {
+    topLevelNavigation: NavigationResult | undefined;
+};
+/**
+ * Hook that computes the top-level NavigationResult from resolved collections,
+ * views, and admin views. Pure computation — no async, no effects.
+ *
+ * The `onNavigationEntriesUpdate` callback is embedded in the result for API
+ * compatibility, but its reference is stable via useCallback.
+ */
+export declare function useTopLevelNavigation(props: UseTopLevelNavigationProps): UseTopLevelNavigationResult;

package/dist/hooks/navigation/utils.d.ts

@@ -0,0 +1,12 @@
+import { CMSView, EntityCollection, RebasePlugin, NavigationGroupMapping } from "@rebasepro/types";
+export declare const NAVIGATION_DEFAULT_GROUP_NAME = "Views";
+export declare const NAVIGATION_ADMIN_GROUP_NAME = "Admin";
+export declare function getGroup(collectionOrView: EntityCollection<any, any> | CMSView): string;
+export declare function computeNavigationGroups({ navigationGroupMappings, collections, views, plugins }: {
+    navigationGroupMappings?: NavigationGroupMapping[];
+    collections?: EntityCollection[];
+    views?: CMSView[];
+    plugins?: RebasePlugin[];
+}): NavigationGroupMapping[];
+export declare function areCollectionListsEqual(a: EntityCollection[], b: EntityCollection[], visitedSlugs?: string[]): boolean;
+export declare function areCollectionsEqual(a: EntityCollection, b: EntityCollection, visitedSlugs?: string[]): boolean;

package/dist/hooks/useAdminModeController.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Use this controller to change the admin mode (developer vs editor)
+ * @group Hooks and utilities
+ */
+export interface AdminModeController {
+    mode: "content" | "studio" | "settings";
+    setMode: (mode: "content" | "studio" | "settings") => void;
+}
+/**
+ * Hook to retrieve the current admin mode ("developer" | "editor"), and `setMode`
+ * to change it.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @see AdminModeController
+ * @group Hooks and utilities
+ */
+export declare const useAdminModeController: () => AdminModeController;

package/dist/hooks/useAnalyticsController.d.ts

@@ -0,0 +1,5 @@
+import { AnalyticsController } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export declare const useAnalyticsController: () => AnalyticsController;

package/dist/hooks/useAuthController.d.ts

@@ -0,0 +1,11 @@
+import { AuthController, User } from "@rebasepro/types";
+/**
+ * Hook to retrieve the AuthContext.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @see AuthController
+ * @group Hooks and utilities
+ */
+export declare const useAuthController: <USER extends User = User, AuthControllerType extends AuthController<USER> = AuthController<USER>>() => AuthControllerType;

package/dist/hooks/useBackendStorageSource.d.ts

@@ -0,0 +1,30 @@
+/**
+ * React hook for using backend storage API as a StorageSource
+ */
+import { StorageSource } from '@rebasepro/types';
+export interface BackendStorageSourceProps {
+    /**
+     * Backend API URL (e.g., 'http://localhost:3001')
+     */
+    apiUrl: string;
+    /**
+     * Function to get the current auth token
+     */
+    getAuthToken: () => Promise<string>;
+}
+/**
+ * Hook to create a StorageSource that uses the backend storage REST API.
+ * Use this for self-hosted Rebase with local or S3 storage.
+ *
+ * @example
+ * ```tsx
+ * const storageSource = useBackendStorageSource({
+ *     apiUrl: 'http://localhost:3001',
+ *     getAuthToken: authController.getAuthToken
+ * });
+ *
+ * // Then pass to Rebase:
+ * <Rebase storageSource={storageSource} ... />
+ * ```
+ */
+export declare function useBackendStorageSource({ apiUrl, getAuthToken }: BackendStorageSourceProps): StorageSource;

package/dist/hooks/useBreadcrumbsController.d.ts

@@ -0,0 +1,42 @@
+/**
+ * @group Hooks and utilities
+ */
+export interface BreadcrumbsController {
+    breadcrumbs: BreadcrumbEntry[];
+    set: (props: {
+        breadcrumbs: BreadcrumbEntry[];
+    }) => void;
+    /**
+     * Update the count for a specific breadcrumb by ID.
+     */
+    updateCount: (id: string, count: number | null | undefined) => void;
+}
+/**
+ * @group Hooks and utilities
+ */
+export interface BreadcrumbEntry {
+    title: string;
+    url: string;
+    /**
+     * Optional entity count for collection breadcrumbs.
+     * - undefined: not applicable (e.g., entity breadcrumb, custom view)
+     * - null: loading
+     * - number: loaded count
+     */
+    count?: number | null;
+    /**
+     * Unique identifier for this breadcrumb (e.g., collection path).
+     * Used to update count without replacing entire breadcrumb array.
+     */
+    id?: string;
+}
+/**
+ * Hook to retrieve the BreadcrumbsController.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @see BreadcrumbsController
+ * @group Hooks and utilities
+ */
+export declare const useBreadcrumbsController: () => BreadcrumbsController;

package/dist/hooks/useBrowserTitleAndIcon.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Internal hook to handle the browser title and icon
+ * @param name
+ * @param logo
+ */
+export declare function useBrowserTitleAndIcon(name: string, logo?: string): void;

package/dist/hooks/useBuildAdminModeController.d.ts

@@ -0,0 +1,6 @@
+import { AdminModeController } from "./index";
+/**
+ * Use this hook to build an admin mode controller that determines
+ * whether the UI shows Developer or Editor tools.
+ */
+export declare function useBuildAdminModeController(): AdminModeController;

package/dist/hooks/useBuildEffectiveRoleController.d.ts

@@ -0,0 +1,8 @@
+import { EffectiveRoleController } from "@rebasepro/types";
+/**
+ * Use this hook to build an effective role controller that determines
+ * what role is simulated in Editor mode when Dev mode is active.
+ *
+ * It uses localStorage to persist the simulated role across reloads.
+ */
+export declare function useBuildEffectiveRoleController(): EffectiveRoleController;

package/dist/hooks/useBuildLocalConfigurationPersistence.d.ts

@@ -0,0 +1,2 @@
+import { UserConfigurationPersistence } from "@rebasepro/types";
+export declare function useBuildLocalConfigurationPersistence(): UserConfigurationPersistence;

package/dist/hooks/useBuildModeController.d.ts

@@ -0,0 +1,6 @@
+import { ModeController } from "./index";
+/**
+ * Use this hook to build a color mode controller that determines
+ * the theme of the CMS
+ */
+export declare function useBuildModeController(): ModeController;

package/dist/hooks/useBuildNavigationController.d.ts

@@ -0,0 +1,16 @@
+import { EntityCollection, CMSView, User, NavigationController, NavigationGroupMapping, RebasePlugin, AuthController, EntityCollectionsBuilder, CMSViewsBuilder, UserConfigurationPersistence, DataSource } from "@rebasepro/types";
+export type BuildNavigationContextProps<EC extends EntityCollection, USER extends User> = {
+    basePath?: string;
+    baseCollectionPath?: string;
+    authController: AuthController<USER>;
+    collections?: EC[] | EntityCollectionsBuilder<EC>;
+    views?: CMSView[] | CMSViewsBuilder;
+    adminViews?: CMSView[] | CMSViewsBuilder;
+    userConfigPersistence?: UserConfigurationPersistence;
+    dataSource: DataSource;
+    plugins?: RebasePlugin[];
+    navigationGroupMappings?: NavigationGroupMapping[];
+    disabled?: boolean;
+    viewsOrder?: string[];
+};
+export declare function useBuildNavigationController<EC extends EntityCollection, USER extends User>(props: BuildNavigationContextProps<EC, USER>): NavigationController;

package/dist/hooks/useClipboard.d.ts

@@ -0,0 +1,57 @@
+import { MutableRefObject } from "react";
+export interface UseClipboardProps {
+    /**
+     * It's callback function that is called after the `copy` command
+     * is executed.
+     *
+     * @param text: The selected clipboard text.
+     */
+    onSuccess?: (text: string) => void;
+    /**
+     * Triggers when the hook encounters an error.
+     * If passed hook won't throw an error.
+     *
+     * @param error: cause of the error
+     */
+    onError?: (error: string) => void;
+    /**
+     * Disables the new clipboard API `navigator.clipboard` even if
+     * it is supported.
+     */
+    disableClipboardAPI?: boolean;
+    /**
+     * revert back the isCopied flag to false again if a value is set.
+     */
+    copiedDuration?: number;
+}
+export interface useClipboardReturnType {
+    /**
+     * Use ref to pull the text content from.
+     */
+    ref: MutableRefObject<any>;
+    /**
+     * Use it to perform the copy operation
+     */
+    copy: (text?: string) => void;
+    /**
+     * Use it to perform the cut operation
+     */
+    cut: () => void;
+    /**
+     * Indicates wheater the content was successfully copied or not.
+     */
+    isCoppied: boolean;
+    /**
+     * Current selected clipboard content.
+     */
+    clipboard: string;
+    /**
+     * Clears the user clipboard.
+     */
+    clearClipboard: () => void;
+    /**
+     * Check to see if the browser supports the new `navigator.clipboard` API.
+     */
+    isSupported: () => boolean;
+}
+export declare const useClipboard: (options?: UseClipboardProps) => useClipboardReturnType;

package/dist/hooks/useCollapsedGroups.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Custom hook for managing collapsed/expanded state of navigation groups
+ * with localStorage persistence. Automatically cleans up stale group entries
+ * when groups are removed from the navigation.
+ *
+ * @param groupNames - Array of group names to track
+ * @param namespace - Namespace for localStorage key (e.g., "home", "drawer") to allow independent state
+ */
+export declare function useCollapsedGroups(groupNames: string[], namespace?: string): {
+    isGroupCollapsed: (name: string) => boolean;
+    toggleGroupCollapsed: (name: string) => void;
+};

package/dist/hooks/useCustomizationController.d.ts

@@ -0,0 +1,11 @@
+import { CustomizationController } from "@rebasepro/types";
+/**
+ * Use this hook to retrieve the customization controller.
+ * This hook includes all the customization options that can be used
+ * to customize the CMS.
+ *
+ * You will likely not need to use this hook directly.
+ *
+ * @group Hooks and utilities
+ */
+export declare const useCustomizationController: () => CustomizationController;

package/dist/hooks/useDialogsController.d.ts

@@ -0,0 +1,11 @@
+import { DialogsController } from "@rebasepro/types";
+/**
+ * Use this hook to open a dialog imperatively.
+ * Alternatively, you can use dialogs declaratively using the `Dialog` component.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @group Hooks and utilities
+ */
+export declare const useDialogsController: () => DialogsController;

package/dist/hooks/useEffectiveRoleController.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Hook to retrieve the {@link EffectiveRoleController}
+ *
+ * @see EffectiveRoleController
+ * @category Hooks and utilities
+ */
+export declare const useEffectiveRoleController: () => import("@rebasepro/types").EffectiveRoleController;

package/dist/hooks/useEntitySelectionDialog.d.ts

@@ -0,0 +1,18 @@
+import { EntitySelectionProps } from "../components";
+/**
+ * This hook is used to open a side dialog that allows the selection
+ * of entities under a given path.
+ * You can use it in custom views for selecting entities.
+ * You need to specify the path of the target collection at least.
+ * If your collection is not defined in your  top collection configuration
+ * (in your `Rebase` component), you need to specify explicitly.
+ * This is the same hook used internally when a reference property is defined.
+ * @group Hooks and utilities
+ */
+export declare function useEntitySelectionDialog<M extends Record<string, any>>(referenceDialogProps: Omit<EntitySelectionProps<M>, "path"> & {
+    path?: string | false;
+    onClose?: () => void;
+}): {
+    open: () => void;
+    close: () => void;
+};

package/dist/hooks/useInternalUserManagementController.d.ts

@@ -0,0 +1,12 @@
+import { User, UserManagementDelegate } from "@rebasepro/types";
+/**
+ * Use this hook to get the internal user management of the app.
+ * Note that this is different from the user management plugin controller.
+ * This controller will be eventually replaced by the one provided
+ * by the user management plugin.
+ *
+ * Use at your own risk!
+ *
+ * @group Hooks and utilities
+ */
+export declare function useInternalUserManagementController<USER extends User>(): UserManagementDelegate<USER> | undefined;

package/dist/hooks/useLargeLayout.d.ts

@@ -0,0 +1 @@
+export declare const useLargeLayout: () => boolean;

package/dist/hooks/useModeController.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Use this controller to change color mode
+ * @group Hooks and utilities
+ */
+export interface ModeController {
+    mode: "light" | "dark";
+    setMode: (mode: "light" | "dark" | "system") => void;
+}
+/**
+ * Hook to retrieve the current mode ("light" | "dark"), and `setMode`
+ * or `toggle` functions to change it.
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @see ModeController
+ * @group Hooks and utilities
+ */
+export declare const useModeController: () => ModeController;

package/dist/hooks/usePermissions.d.ts

@@ -0,0 +1,11 @@
+import { EntityCollection, Entity } from "@rebasepro/types";
+/**
+ * Hook to evaluate roles and permissions for the current user.
+ * It abstracts away the need to pass `authController` to permission evaluation functions.
+ */
+export declare function usePermissions(): {
+    canCreate: (collection: EntityCollection<any>, path: string) => boolean;
+    canEdit: (collection: EntityCollection<any>, path: string, entity: Entity<any> | null) => boolean;
+    canDelete: (collection: EntityCollection<any>, path: string, entity: Entity<any> | null) => boolean;
+    canRead: (collection: EntityCollection<any>) => boolean;
+};

package/dist/hooks/useRebaseContext.d.ts

@@ -0,0 +1,11 @@
+import { AuthController, RebaseContext, User } from "@rebasepro/types";
+/**
+ * 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 declare const useRebaseContext: <USER extends User = User, AuthControllerType extends AuthController<USER> = AuthController<USER>>() => RebaseContext<USER, AuthControllerType>;