@rebasepro/admin 0.0.1-canary.4f204c2

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

@@ -0,0 +1,28 @@
+import type { EntityCollection, RebasePlugin } from "@rebasepro/types";
+import { AuthController, CollectionRegistryController, RebaseData, User } from "@rebasepro/types";
+import type { EntityCollectionsBuilder } from "@rebasepro/types";
+import { CollectionRegistry } from "@rebasepro/common";
+export type UseResolvedCollectionsProps<EC extends EntityCollection, USER extends User> = {
+    authController: AuthController<USER>;
+    collections?: EC[] | EntityCollectionsBuilder<EC>;
+    data: RebaseData;
+    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 (driver, 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,29 @@
+import type { AppView, AppViewsBuilder, EffectiveRoleController, RebasePlugin } from "@rebasepro/types";
+import { AuthController, RebaseData, User } from "@rebasepro/types";
+import { UserManagementDelegate } from "@rebasepro/types";
+export type UseResolvedViewsProps<USER extends User> = {
+    authController: AuthController<USER>;
+    views?: AppView[] | AppViewsBuilder;
+    adminViews?: AppView[] | AppViewsBuilder;
+    data: RebaseData;
+    plugins?: RebasePlugin[];
+    adminMode?: "content" | "studio" | "settings";
+    effectiveRoleController?: EffectiveRoleController;
+    userManagement?: UserManagementDelegate<USER>;
+};
+export type UseResolvedViewsResult = {
+    views: AppView[] | undefined;
+    adminViews: AppView[] | 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 AppView[]. Also injects Users/Roles admin views when userManagement
+ * is provided.
+ *
+ * Uses refs for potentially-unstable dependencies (driver, 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,27 @@
+import type { AppView, UrlController, EntityCollection, RebasePlugin, NavigationGroupMapping, NavigationResult } from "@rebasepro/types";
+import { CollectionRegistryController } from "@rebasepro/types";
+import { CollectionRegistry } from "@rebasepro/common";
+export type UseTopLevelNavigationProps = {
+    collections: EntityCollection[];
+    views: AppView[] | undefined;
+    adminViews: AppView[] | undefined;
+    plugins?: RebasePlugin[];
+    navigationGroupMappings?: NavigationGroupMapping[];
+    viewsOrder?: string[];
+    urlController: UrlController;
+    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 type { AppView, 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> | AppView): string;
+export declare function computeNavigationGroups({ navigationGroupMappings, collections, views, plugins }: {
+    navigationGroupMappings?: NavigationGroupMapping[];
+    collections?: EntityCollection[];
+    views?: AppView[];
+    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/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/useBuildSideDialogsController.d.ts

@@ -0,0 +1,2 @@
+import type { SideDialogsController } from "../hooks/useSideDialogsController";
+export declare function useBuildSideDialogsController(): SideDialogsController;

package/dist/hooks/useBuildSideEntityController.d.ts

@@ -0,0 +1,6 @@
+import type { EntityCollection } from "@rebasepro/types";
+import type { CustomizationController, EntitySidePanelProps, SideDialogsController, SideEntityController, UrlController, NavigationStateController } from "@rebasepro/types";
+import { AuthController, CollectionRegistryController } from "@rebasepro/types";
+export declare function getEntityViewWidth(props: EntitySidePanelProps<any>, small: boolean, customizationController: CustomizationController): string;
+export declare const useBuildSideEntityController: (collectionRegistryController: CollectionRegistryController, urlController: UrlController, navigationStateController: NavigationStateController, sideDialogsController: SideDialogsController, authController: AuthController) => SideEntityController;
+export declare function buildSidePanelsFromUrl(path: string, collections: EntityCollection[], newFlag: boolean): EntitySidePanelProps<any>[];

package/dist/hooks/useCMSContext.d.ts

@@ -0,0 +1,27 @@
+import type { AuthController, RebaseContext, SideDialogsController, SideEntityController, User } from "@rebasepro/types";
+import type { CollectionRegistryController, NavigationStateController, UrlController } from "@rebasepro/types";
+/**
+ * The CMS context extends the core RebaseContext with CMS-specific
+ * controllers that are only available inside the CMS routing tree.
+ *
+ * Use {@link useCMSContext} to obtain an instance.
+ * @group Hooks and utilities
+ */
+export type CMSContext<DB = Record<string, unknown>, USER extends User = User, AuthControllerType extends AuthController<USER> = AuthController<USER>> = RebaseContext<USER, AuthControllerType> & {
+    sideEntityController: SideEntityController;
+    sideDialogsController: SideDialogsController;
+    urlController: UrlController;
+    navigationStateController: NavigationStateController;
+    collectionRegistryController: CollectionRegistryController<DB>;
+};
+/**
+ * Hook that builds a fully-populated CMS context by combining the
+ * core {@link RebaseContext} with CMS-specific controllers.
+ *
+ * Use this instead of `useRebaseContext()` in CMS components that
+ * need to pass context to entity action callbacks, plugin slots,
+ * or any consumer that expects CMS controllers on the context object.
+ *
+ * @group Hooks and utilities
+ */
+export declare function useCMSContext<DB = Record<string, unknown>, USER extends User = User, AuthControllerType extends AuthController<USER> = AuthController<USER>>(): CMSContext<DB, USER, AuthControllerType>;

package/dist/hooks/useEntityHistory.d.ts

@@ -0,0 +1,30 @@
+export interface HistoryEntryData {
+    id: string;
+    table_name: string;
+    entity_id: string;
+    action: "create" | "update" | "delete";
+    changed_fields: string[] | null;
+    values: Record<string, unknown> | null;
+    previous_values: Record<string, unknown> | null;
+    updated_by: string | null;
+    updated_at: string;
+}
+export interface UseEntityHistoryResult {
+    entries: HistoryEntryData[];
+    total: number;
+    isLoading: boolean;
+    hasMore: boolean;
+    error?: Error;
+    loadMore: () => void;
+    revert: (historyId: string) => Promise<void>;
+}
+/**
+ * Hook to fetch entity history from the backend REST API.
+ * Replaces the old subcollection-based approach with a proper API call.
+ */
+export declare function useEntityHistory(params: {
+    slug: string;
+    entityId: string | number | undefined;
+    enabled?: boolean;
+    pageSize?: number;
+}): UseEntityHistoryResult;

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, unknown>>(referenceDialogProps: Omit<EntitySelectionProps<M>, "path"> & {
+    path?: string | false;
+    onClose?: () => void;
+}): {
+    open: () => void;
+    close: () => void;
+};

package/dist/hooks/useResolvedNavigationFrom.d.ts

@@ -0,0 +1,73 @@
+import type { EntityCollection, EntityCustomView } from "@rebasepro/types";
+import { Entity, RebaseContext, User } from "@rebasepro/types";
+/**
+ * @see resolveNavigationFrom
+ * @group Hooks and utilities
+ */
+export type ResolvedNavigationEntry<M extends Record<string, unknown>> = ResolvedNavigationEntity<M> | ResolvedNavigationCollection<M> | ResolvedNavigationEntityCustom<M>;
+/**
+ * @see resolveNavigationFrom
+ * @group Hooks and utilities
+ */
+export interface ResolvedNavigationEntity<M extends Record<string, unknown>> {
+    type: "entity";
+    entity: Entity<M>;
+    entityId: string | number;
+    path: string;
+    parentCollection: EntityCollection<M>;
+}
+/**
+ * @see resolveNavigationFrom
+ * @group Hooks and utilities
+ */
+export interface ResolvedNavigationCollection<M extends Record<string, unknown>> {
+    type: "collection";
+    path: string;
+    collection: EntityCollection<M>;
+}
+/**
+ * @see resolveNavigationFrom
+ * @group Hooks and utilities
+ */
+interface ResolvedNavigationEntityCustom<M extends Record<string, unknown>> {
+    type: "custom_view";
+    path: string;
+    view: EntityCustomView<M>;
+}
+/**
+ * Use this function to retrieve an array of navigation entries (resolved
+ * collection, entity or entity custom_view) for the given path. You need to pass the app context
+ * that you receive in different callbacks, such as the save hooks.
+ *
+ * It will take into account the `navigation` provided at the `Rebase` level.
+ *
+ * @param path
+ * @param context
+ * @group Hooks and utilities
+ */
+export declare function resolveNavigationFrom<M extends Record<string, unknown>, USER extends User>({ path, context }: {
+    path: string;
+    context: RebaseContext<USER>;
+}): Promise<ResolvedNavigationEntry<M>[]>;
+/**
+ * @group Hooks and utilities
+ */
+export interface NavigationFromProps {
+    path: string;
+}
+/**
+ * @group Hooks and utilities
+ */
+export interface NavigationFrom<M extends Record<string, unknown>> {
+    data?: ResolvedNavigationEntry<M>[];
+    dataLoading: boolean;
+    dataLoadingError?: Error;
+}
+/**
+ * Use this hook to retrieve an array of navigation entries (resolved
+ * collection or entity) for the given path. You can use this hook
+ * in any React component that lives under `Rebase`
+ * @group Hooks and utilities
+ */
+export declare function useResolvedNavigationFrom<M extends Record<string, unknown>>({ path }: NavigationFromProps): NavigationFrom<M>;
+export {};

package/dist/hooks/useSideDialogsController.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Hook to retrieve the side dialogs' controller.
+ *
+ * This hook allows you to open and close side dialogs. This is the mechanism
+ * used when open a side entity dialog, or when selecting a reference.
+ *
+ * If you want to open a side entity dialog, you can use the {@link useSideEntityController}
+ * hook.
+ *
+ * If you want to select a reference, you can use the {@link useReferenceDialog}
+ *
+ * Consider that in order to use this hook you need to have a parent
+ * `Rebase`
+ *
+ * @group Hooks and utilities
+ */
+import { SideDialogPanelProps, SideDialogsController } from "@rebasepro/types";
+export type { SideDialogPanelProps, SideDialogsController };
+export declare const useSideDialogsController: () => SideDialogsController;

package/dist/hooks/useSideEntityController.d.ts

@@ -0,0 +1,11 @@
+import type { SideEntityController } from "@rebasepro/types";
+import React from "react";
+export declare const SideEntityControllerContext: React.Context<SideEntityController>;
+/**
+ * Use this hook to retrieve an entity controller that allows you to open
+ * a side dialog to edit an entity.
+ *
+ * @see SideEntityController
+ * @group Hooks and utilities
+ */
+export declare const useSideEntityController: () => SideEntityController;

package/dist/index-CBhrgpR7.js

@@ -0,0 +1,12 @@
+import { E as ExportCollectionAction } from "./ExportCollectionAction-Dc0VOWMN.js";
+import { B, d, a, b, g, c } from "./ExportCollectionAction-Dc0VOWMN.js";
+export {
+  B as BasicExportAction,
+  ExportCollectionAction,
+  d as downloadBlob,
+  a as downloadDataAsCsv,
+  b as downloadEntitiesExport,
+  g as getEntityCSVExportableData,
+  c as getEntityJsonExportableData
+};
+//# sourceMappingURL=index-CBhrgpR7.js.map

package/dist/index-CBhrgpR7.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index-CBhrgpR7.js","sources":[],"sourcesContent":[],"names":[],"mappings":";;"}