@rebasepro/app 0.0.1-canary.4829d6e

package/dist/hooks/data/useCollection.d.ts

@@ -0,0 +1,62 @@
+import type { CollectionConfig } from "@rebasepro/types";
+import { Entity, FilterValues, User } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export interface CollectionProps<M extends Record<string, any>> {
+    /**
+     * Absolute collection path
+     */
+    path: string;
+    /**
+     * collection of the entity displayed by this collection
+     */
+    collection: CollectionConfig<M>;
+    /**
+     * Number of entities to fetch
+     */
+    itemCount?: number;
+    /**
+     * Number of items to skip
+     */
+    offset?: number;
+    /**
+     * Page number (1-indexed), alternative to offset
+     */
+    page?: number;
+    /**
+     * Filter the fetched data by the property
+     */
+    filterValues?: FilterValues<Extract<keyof M, string>>;
+    /**
+     * Sort the results by
+     */
+    sortBy?: [Extract<keyof M, string>, "asc" | "desc"];
+    /**
+     * Search string
+     */
+    searchString?: string;
+}
+/**
+ * @group Hooks and utilities
+ */
+export interface CollectionResult<M extends Record<string, any>> {
+    data: Entity<M>[];
+    dataLoading: boolean;
+    noMoreToLoad: boolean;
+    dataLoadingError?: Error;
+    totalCount?: number;
+}
+/**
+ * This hook is used to fetch collections using a given collection
+ * @param path
+ * @param collection
+ * @param filterValues
+ * @param sortBy
+ * @param itemCount
+ * @param offset
+ * @param page
+ * @param searchString
+ * @group Hooks and utilities
+ */
+export declare function useCollection<M extends Record<string, any>, USER extends User>({ path, collection, filterValues, sortBy, itemCount, offset, page, searchString }: CollectionProps<M>): CollectionResult<M>;

package/dist/hooks/data/useData.d.ts

@@ -0,0 +1,13 @@
+import { RebaseData } from "@rebasepro/types";
+/**
+ * Use this hook to access the unified data API.
+ *
+ * ```ts
+ * const data = useData();
+ * const { data: products } = await data.products.find({ where: { status: ["==", "published"] } });
+ * await data.products.create({ name: "Camera", price: 299 });
+ * ```
+ *
+ * @group Hooks and utilities
+ */
+export declare const useData: () => RebaseData;

package/dist/hooks/data/useDataOrder.d.ts

@@ -0,0 +1,12 @@
+import { Entity } from "@rebasepro/types";
+export interface DataOrderProps<M extends Record<string, any>> {
+    data: Entity<M>[];
+    entitiesDisplayedFirst?: Entity<M>[];
+}
+/**
+ * This hook is used to have some entities at the beginning of data.
+ * @param path
+ * @param entitiesDisplayedFirst
+ * @group Hooks and utilities
+ */
+export declare function useDataOrder<M extends Record<string, any>>({ data, entitiesDisplayedFirst }: DataOrderProps<M>): Entity<M>[];

package/dist/hooks/data/useFetch.d.ts

@@ -0,0 +1,43 @@
+import type { CollectionConfig } from "@rebasepro/types";
+import { Entity, User } from "@rebasepro/types";
+/**
+ * @group Hooks and utilities
+ */
+export interface FetchProps<M extends Record<string, any>, USER extends User = User> {
+    path: string;
+    entityId?: string | number;
+    databaseId?: string;
+    collection: CollectionConfig<M, USER>;
+    useCache?: boolean;
+}
+/**
+ * @group Hooks and utilities
+ */
+export interface FetchResult<M extends Record<string, any>> {
+    entity?: Entity<M>;
+    dataLoading: boolean;
+    dataLoadingError?: Error;
+}
+/**
+ * Pre-populate the entity fetch cache with entities loaded from a collection.
+ * This allows entity detail views to render instantly using cached data,
+ * while the background fetch/listener brings in fresh data.
+ * @param path - The collection path (e.g. "products")
+ * @param entities - Array of entities to cache
+ */
+export declare function populateFetchCache<M extends Record<string, any>>(path: string, entities: Entity<M>[]): void;
+/**
+ * Clear the entity fetch cache. Call this on auth state changes (e.g. logout)
+ * to prevent stale data from a previous session leaking into the next.
+ */
+export declare function clearFetchCache(): void;
+/**
+ * This hook is used to fetch a entity.
+ * It gives real time updates if the driver supports it.
+ * @param path
+ * @param collection
+ * @param entityId
+ * @param useCache
+ * @group Hooks and utilities
+ */
+export declare function useFetch<M extends Record<string, any>, USER extends User = User>({ path, entityId, collection, databaseId, useCache }: FetchProps<M, USER>): FetchResult<M>;

package/dist/hooks/data/useRelationSelector.d.ts

@@ -0,0 +1,52 @@
+import type { CollectionConfig } from "@rebasepro/types";
+import { Entity, EntityRelation, FilterValues } from "@rebasepro/types";
+export interface RelationItem {
+    id: string | number;
+    label: string;
+    description?: string;
+    data: Entity<any>;
+    relation: EntityRelation;
+}
+export interface UseRelationSelectorProps<M extends Record<string, any> = any> {
+    /**
+     * Full path where the relation data is located
+     */
+    path: string;
+    /**
+     * The collection that represents the relation entities
+     */
+    collection: CollectionConfig<M>;
+    /**
+     * Force filter to be applied to the relation search
+     */
+    fixedFilter?: FilterValues<string>;
+    /**
+     * Page size for pagination
+     */
+    pageSize?: number;
+    /**
+     * Function to extract the label from a entity
+     */
+    getLabelFromEntity?: (entity: Entity<M>) => string;
+    /**
+     * Function to extract the description from a entity
+     */
+    getDescriptionFromEntity?: (entity: Entity<M>) => string | undefined;
+    /**
+     * Property name to use as the secondary display field
+     */
+    descriptionProperty?: keyof M;
+}
+export interface RelationSelectorController {
+    items: RelationItem[];
+    isLoading: boolean;
+    error: Error | undefined;
+    search: (searchString: string) => void;
+    loadMore: () => void;
+    hasMore: boolean;
+    entityToRelationItem: (entity: Entity<any>, relation: EntityRelation) => RelationItem;
+}
+/**
+ * Hook to manage relation selection with data fetching from Rebase data source
+ */
+export declare function useRelationSelector<M extends Record<string, any> = any>({ path, collection, fixedFilter, pageSize, getLabelFromEntity, getDescriptionFromEntity, descriptionProperty }: UseRelationSelectorProps<M>): RelationSelectorController;

package/dist/hooks/index.d.ts

@@ -0,0 +1,36 @@
+export * from "./data/useData";
+export * from "./data/useCollection";
+export * from "./data/useFetch";
+export * from "./data/useRelationSelector";
+export * from "./data/save";
+export * from "./data/delete";
+export * from "./useUnsavedChangesDialog";
+export * from "./useStorageSource";
+export * from "./useAuthController";
+export * from "./useAuthSubscription";
+export * from "./useDialogsController";
+export * from "./useAdminModeController";
+export * from "./useBuildAdminModeController";
+export * from "./useEffectiveRoleController";
+export * from "./useBuildEffectiveRoleController";
+export * from "./useRebaseContext";
+export * from "./useSnackbarController";
+export * from "./useModeController";
+export * from "./useClipboard";
+export * from "./useLargeLayout";
+export * from "./useCollapsedGroups";
+export * from "./useBrowserTitleAndIcon";
+export * from "./useSlot";
+export * from "./useCustomizationController";
+export * from "./useBuildLocalConfigurationPersistence";
+export * from "./useBuildModeController";
+export * from "./useRebaseRegistry";
+export * from "./useBackendStorageSource";
+export * from "./usePermissions";
+export * from "./ApiConfigContext";
+export * from "./useTranslation";
+export * from "./useRebaseClient";
+export * from "./useAnalyticsController";
+export * from "./useUserConfigurationPersistence";
+export * from "./useResolvedComponent";
+export * from "./useComponentOverride";

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/useAuthSubscription.d.ts

@@ -0,0 +1,2 @@
+import { AuthClient, AuthController } from "@rebasepro/types";
+export declare function useAuthSubscription(authClient?: AuthClient): AuthController;

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/useBridgeRegistration.d.ts

@@ -0,0 +1,18 @@
+import type { StudioBridge } from "./useStudioBridge";
+/**
+ * Registers a value into the self-assembling Studio bridge.
+ *
+ * Each controller (collectionRegistry, sidePanel, url, navigation, breadcrumbs)
+ * calls this hook on mount to inject its real implementation into the bridge.
+ * On unmount the slice is automatically removed, reverting to the noop default.
+ *
+ * Usage:
+ * ```tsx
+ * function SomeProvider({ children }) {
+ *     const controller = useBuildSomeController();
+ *     useBridgeRegistration("sidePanelController", controller);
+ *     return <SomeContext.Provider value={controller}>{children}</SomeContext.Provider>;
+ * }
+ * ```
+ */
+export declare function useBridgeRegistration<K extends keyof StudioBridge>(key: K, value: StudioBridge[K]): void;

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 type { 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/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,27 @@
+/**
+ * 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.
+ *
+ * Groups that have never been toggled by the user fall back to
+ * `defaults[groupName]` (driven by `collapsedByDefault` in config).
+ *
+ * @param groupNames - Array of group names to track
+ * @param namespace - Namespace for localStorage key (e.g., "home", "drawer") to allow independent state
+ * @param defaults - Optional map of group name → collapsed boolean from config
+ */
+export declare function useCollapsedGroups(groupNames: string[], namespace?: string, defaults?: Record<string, boolean>): {
+    isGroupCollapsed: (name: string) => boolean;
+    toggleGroupCollapsed: (name: string) => void;
+};
+/**
+ * Build a defaults map from navigationGroupMappings for a given namespace.
+ * Returns a Record<groupName, collapsed> that can be passed to useCollapsedGroups.
+ */
+export declare function buildCollapsedDefaults(mappings: Array<{
+    name: string;
+    collapsedByDefault?: boolean | {
+        drawer?: boolean;
+        home?: boolean;
+    };
+}> | undefined, namespace: "drawer" | "home"): Record<string, boolean>;

package/dist/hooks/useComponentOverride.d.ts

@@ -0,0 +1,32 @@
+import React from "react";
+import type { OverridableComponentName } from "@rebasepro/types";
+/**
+ * Resolves a potentially overridden component.
+ *
+ * Resolution order:
+ * 1. Collection-scoped override (highest priority)
+ * 2. Global override
+ * 3. Default component (fallback)
+ *
+ * Supports two override modes:
+ * - **Eject** (default): The override component fully replaces the default.
+ * - **Wrap** (`wrap: true`): The override component wraps the default.
+ *   The default is passed as `OriginalComponent` in props.
+ *
+ * @param name - The overridable component name (e.g. `"Entity.Form"`)
+ * @param DefaultComponent - The built-in default component
+ * @returns The resolved component — either the default, a full replacement, or a wrapper
+ *
+ * @example
+ * ```tsx
+ * import { useComponentOverride } from "@rebasepro/app";
+ *
+ * function EntityFormWrapper(props: EntityFormProps) {
+ *     const ResolvedForm = useComponentOverride("Entity.Form", DefaultEntityForm);
+ *     return <ResolvedForm {...props} />;
+ * }
+ * ```
+ *
+ * @group Hooks
+ */
+export declare function useComponentOverride<P>(name: OverridableComponentName, DefaultComponent: React.ComponentType<P>): React.ComponentType<P>;

package/dist/hooks/useCustomizationController.d.ts

@@ -0,0 +1,11 @@
+import type { 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 type { 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/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,12 @@
+import type { CollectionConfig } from "@rebasepro/types";
+import { 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: CollectionConfig<any>, path: string) => boolean;
+    canEdit: (collection: CollectionConfig<any>, path: string, entity: Entity<any> | null) => boolean;
+    canDelete: (collection: CollectionConfig<any>, path: string, entity: Entity<any> | null) => boolean;
+    canRead: (collection: CollectionConfig<any>) => boolean;
+};

package/dist/hooks/useRebaseClient.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Hook to retrieve the full RebaseClient instance from context.
+ * Returns `undefined` if no client was provided to `<Rebase>`.
+ */
+export declare function useRebaseClient<T = any>(): T | undefined;

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>;

package/dist/hooks/useRebaseRegistry.d.ts

@@ -0,0 +1,34 @@
+import React from "react";
+import type { RebaseRegistryController, RebaseAdminConfig, RebaseStudioConfig, RebaseAuthConfig } from "@rebasepro/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, RebaseAdmin, 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 {
+    registerCMS: (config: RebaseAdminConfig) => void;
+    unregisterCMS: () => void;
+    registerStudio: (config: RebaseStudioConfig) => void;
+    unregisterStudio: () => void;
+    registerAuth: (config: RebaseAuthConfig) => void;
+    unregisterAuth: () => void;
+}
+export declare function RebaseRegistryProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+/**
+ * Returns the full registry (state + dispatch).
+ * Use this in RebaseShell where you need to read configs.
+ */
+export declare function useRebaseRegistry(): RebaseRegistryController;
+/**
+ * Returns only the stable dispatch functions.
+ * Use this in feature components (RebaseAuth, RebaseAdmin, RebaseStudio)
+ * to avoid re-render loops.
+ */
+export declare function useRebaseRegistryDispatch(): RegistryDispatch;
+export {};

package/dist/hooks/useResolvedComponent.d.ts

@@ -0,0 +1,47 @@
+import React from "react";
+import type { ComponentRef } from "@rebasepro/types";
+/**
+ * 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 declare function useResolvedComponent<P = unknown>(ref: ComponentRef<P> | undefined): React.ComponentType<P> | undefined;
+/**
+ * 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 declare function resolveComponentRef<P = unknown>(ref: ComponentRef<P> | undefined): React.ComponentType<P> | undefined;