@rebasepro/cms 0.17.3 → 0.18.1

package/src/hooks/useResolvedNavigationFrom.tsx

@@ -1,167 +0,0 @@
-
-import type { EntityCustomView, AdminCollection } from "@rebasepro/cms-types";
-import { Entity, User } from "@rebasepro/types";
-import { RebaseContext } from "@rebasepro/cms-types";
-import { useEffect, useState, useMemo } from "react";
-import { getNavigationEntriesFromPath } from "@rebasepro/app";
-import { useAdminContext } from "./useAdminContext";
-
-/**
- * @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: AdminCollection<M>;
-}
-
-/**
- * @see resolveNavigationFrom
- * @group Hooks and utilities
- */
-export interface ResolvedNavigationCollection<M extends Record<string, unknown>> {
-    type: "collection";
-    path: string;
-    collection: AdminCollection<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 function resolveNavigationFrom<M extends Record<string, unknown>, USER extends User>({
-    path,
-    context
-}: {
-    path: string,
-    context: RebaseContext<USER>
-}): Promise<ResolvedNavigationEntry<M>[]> {
-
-    const data = context.data;
-    const { navigationStateController, collectionRegistryController } = context;
-
-    if (!navigationStateController || !collectionRegistryController) {
-        throw Error("Calling resolveNavigationFrom, but main navigation has not yet been initialised");
-    }
-
-    const navigationEntries = getNavigationEntriesFromPath({
-        path,
-        collections: collectionRegistryController.collections ?? []
-    });
-
-    const resultPromises: Promise<ResolvedNavigationEntry<any>>[] = navigationEntries
-        .map((entry) => {
-            if (entry.type === "collection") {
-                return Promise.resolve(entry);
-            } else if (entry.type === "entity") {
-                const collection = collectionRegistryController.getCollection(entry.slug);
-                if (!collection) {
-                    throw Error(`No collection defined in the navigation for the entity with path ${entry.slug}`);
-                }
-                // `context.data` is the flat SDK layer; re-wrap the row into the
-                // Entity view-model the navigation entry expects. The address is
-                // the one we just fetched by — reading it back off the row would
-                // find nothing, since a row is only its columns.
-                return data.collection(entry.slug).findById(entry.entityId)
-                    .then((row) => {
-                        if (!row) return undefined;
-                        const entity = { id: entry.entityId, path: entry.slug, values: row };
-                        return { ...entry,
-entity };
-                    });
-            } else if (entry.type === "custom_view") {
-                return Promise.resolve(entry);
-            } else {
-                throw Error("Unmapped element in useEntitiesFromPath");
-            }
-        })
-        .filter(v => Boolean(v)) as Promise<ResolvedNavigationEntry<any>>[];
-
-    return Promise.all(resultPromises);
-}
-
-/**
- * @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 function useResolvedNavigationFrom<M extends Record<string, unknown>>(
-    {
-        path
-    }: NavigationFromProps): NavigationFrom<M> {
-
-    const context = useAdminContext();
-    const { navigationStateController, collectionRegistryController } = context;
-
-    const [data, setData] = useState<ResolvedNavigationEntry<M>[] | undefined>();
-    const [dataLoading, setDataLoading] = useState<boolean>(false);
-    const [dataLoadingError, setDataLoadingError] = useState<Error | undefined>();
-
-    useEffect(() => {
-        if (navigationStateController && collectionRegistryController) {
-            setDataLoading(true);
-            setDataLoadingError(undefined);
-            resolveNavigationFrom<M, User>({ path,
-context })
-                .then(setData)
-                .catch((e) => setDataLoadingError(e))
-                .finally(() => setDataLoading(false));
-        }
-
-    }, [path, context]);
-
-    return useMemo(() => {
-        if (!navigationStateController) {
-            return { dataLoading: true };
-        }
-        return { data,
-dataLoading,
-dataLoadingError };
-    }, [navigationStateController, data, dataLoading, dataLoadingError]);
-}

package/src/hooks/useResolvedUsers.ts

@@ -1,148 +0,0 @@
-import { useEffect, useState } from "react";
-import type { User } from "@rebasepro/types";
-import { apiBaseOf, useAuthController, useRebaseClient } from "@rebasepro/app";
-
-/**
- * Resolves the auth users behind `userSelect` values.
- *
- * A collection view can ask for dozens of ids at once — one per row — so
- * lookups are coalesced into a single `GET /api/users?ids=…` per tick and
- * cached per base URL. Ids that resolve to nothing are remembered too, so a
- * dangling reference is not retried on every render.
- */
-
-interface UserCache {
-    users: Map<string, User | null>;
-    pending: Map<string, Promise<void>>;
-    queue: Set<string>;
-    flush?: ReturnType<typeof setTimeout>;
-}
-
-const caches = new Map<string, UserCache>();
-
-function getCache(baseUrl: string): UserCache {
-    let cache = caches.get(baseUrl);
-    if (!cache) {
-        cache = { users: new Map(),
-pending: new Map(),
-queue: new Set() };
-        caches.set(baseUrl, cache);
-    }
-    return cache;
-}
-
-async function fetchUsers(apiBase: string, ids: string[], token: string | undefined): Promise<Map<string, User | null>> {
-    const resolved = new Map<string, User | null>();
-    for (const id of ids) resolved.set(id, null);
-
-    const params = new URLSearchParams({ ids: ids.join(",") });
-    // Same route as the selector — see the note there; `/api/users` is a 404,
-    // so every `userSelect` value rendered as a bare id.
-    const response = await fetch(`${apiBase}/admin/users?${params}`, {
-        headers: token ? { Authorization: `Bearer ${token}` } : {}
-    });
-    if (!response.ok) {
-        // A non-admin viewer gets a 403 here. Treat it as "unresolvable" rather
-        // than an error: callers fall back to showing the raw value.
-        return resolved;
-    }
-    const data = await response.json();
-    const rows: Record<string, unknown>[] = data.users ?? data.data ?? [];
-    for (const row of rows) {
-        const uid = (row.uid as string) ?? (row.id as string);
-        if (!uid) continue;
-        resolved.set(uid, {
-            uid,
-            email: (row.email as string) ?? "",
-            displayName: (row.displayName as string) ?? (row.display_name as string) ?? null,
-            photoURL: (row.photoURL as string) ?? (row.photo_url as string) ?? null,
-            providerId: "custom",
-            isAnonymous: false,
-            roles: (row.roles as string[]) ?? []
-        });
-    }
-    return resolved;
-}
-
-function requestUser(
-    baseUrl: string,
-    uid: string,
-    getAuthToken: (() => Promise<string | undefined>) | undefined
-): Promise<void> {
-    const cache = getCache(baseUrl);
-    const existing = cache.pending.get(uid);
-    if (existing) return existing;
-
-    cache.queue.add(uid);
-
-    const promise = new Promise<void>((resolve, reject) => {
-        if (cache.flush) clearTimeout(cache.flush);
-        cache.flush = setTimeout(async () => {
-            const ids = [...cache.queue];
-            cache.queue.clear();
-            cache.flush = undefined;
-            try {
-                const token = await getAuthToken?.();
-                const resolved = await fetchUsers(baseUrl, ids, token);
-                for (const id of ids) {
-                    cache.users.set(id, resolved.get(id) ?? null);
-                    cache.pending.delete(id);
-                }
-                resolve();
-            } catch (error) {
-                for (const id of ids) cache.pending.delete(id);
-                reject(error);
-            }
-        }, 0);
-    });
-
-    cache.pending.set(uid, promise);
-    return promise;
-}
-
-/**
- * The auth user behind a `userSelect` value, or `null` while it is loading or
- * when it cannot be resolved.
- */
-export function useResolvedUser(uid: string | undefined): User | null {
-    const client = useRebaseClient<{ baseUrl?: string, apiPath?: string }>();
-    const { getAuthToken } = useAuthController();
-    /* The API prefix, not the bare origin: it keys the cache and is what a
-       request is built from, and a backend with a non-default `basePath`
-       serves neither at `/api`. */
-    const baseUrl = apiBaseOf(client);
-
-    const [user, setUser] = useState<User | null>(() =>
-        (baseUrl && uid) ? getCache(baseUrl).users.get(uid) ?? null : null);
-
-    useEffect(() => {
-        if (!baseUrl || !uid) {
-            setUser(null);
-            return;
-        }
-        const cache = getCache(baseUrl);
-        if (cache.users.has(uid)) {
-            setUser(cache.users.get(uid) ?? null);
-            return;
-        }
-
-        let active = true;
-        requestUser(baseUrl, uid, getAuthToken)
-            .then(() => {
-                if (active) setUser(getCache(baseUrl).users.get(uid) ?? null);
-            })
-            .catch(() => {
-                if (active) setUser(null);
-            });
-        return () => {
-            active = false;
-        };
-    }, [baseUrl, uid, getAuthToken]);
-
-    return user;
-}
-
-/** Human-readable label for a resolved user. */
-export function getUserLabel(user: User): string {
-    return user.displayName || user.email || user.uid;
-}

package/src/hooks/useSelectionDialog.tsx

@@ -1,58 +0,0 @@
-import { SelectionProps, SelectionTableBinding } from "../components/ReferenceTable/SelectionTableBinding";
-
-import { useCallback, useMemo } from "react";
-import { useSideDialogsController } from "./useSideDialogsController";
-import { useCollectionRegistryController } from "./navigation/contexts/CollectionRegistryContext";
-import type { AdminCollection } from "@rebasepro/cms-types";
-
-/**
- * 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 function useSelectionDialog<M extends Record<string, unknown>>(referenceDialogProps: Omit<SelectionProps<M>, "path"> & {
-    path?: string | false;
-    onClose?: () => void;
-}): { open: () => void; close: () => void } {
-
-    const navigation = useCollectionRegistryController();
-    const sideDialogsController = useSideDialogsController();
-
-    const open = useCallback(() => {
-        if (referenceDialogProps.path) {
-            let usedCollection = referenceDialogProps.collection;
-            if (!usedCollection)
-                usedCollection = navigation.getCollection(referenceDialogProps.path) as AdminCollection<M> | undefined;
-            if (!usedCollection)
-                throw Error("Not able to resolve the collection in useSelectionDialog. Make sure a collection is registered in path " + referenceDialogProps.path);
-            sideDialogsController.open({
-                key: `reference_${referenceDialogProps.path}`,
-                component:
-                    <SelectionTableBinding
-                        collection={usedCollection}
-                        {...referenceDialogProps as SelectionProps<M>}/>,
-                width: "90vw",
-                onClose: () => {
-                    referenceDialogProps.onClose?.();
-                }
-            });
-        } else {
-            throw Error("useReferenceDialog: You are trying to open a reference dialog, but have not declared the `path`")
-        }
-    }, [navigation, referenceDialogProps, sideDialogsController]);
-
-    const close = useCallback(() => {
-        sideDialogsController.close();
-    }, [sideDialogsController]);
-
-    return useMemo(() => ({
-        open,
-        close
-    }), [open, close]);
-
-}

package/src/hooks/useSideDialogsController.tsx

@@ -1,25 +0,0 @@
-import React from "react";
-import { SideDialogsControllerContext } from "../contexts/SideDialogsControllerContext";
-import { useContext } from "react";
-
-/**
- * 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 useSidePanel}
- * 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/cms-types";
-
-export type { SideDialogPanelProps, SideDialogsController };
-
-export const useSideDialogsController = (): SideDialogsController => useContext(SideDialogsControllerContext);

package/src/hooks/useSidePanel.tsx

@@ -1,13 +0,0 @@
-import type { SidePanelController } from "@rebasepro/cms-types";
-import React, { useContext } from "react";
-
-export const SidePanelControllerContext = React.createContext<SidePanelController>({} as SidePanelController);
-
-/**
- * Use this hook to retrieve a entity controller that allows you to open
- * a side dialog to edit a entity.
- *
- * @see SidePanelController
- * @group Hooks and utilities
- */
-export const useSidePanel = (): SidePanelController => useContext(SidePanelControllerContext);

package/src/index.ts

@@ -1,124 +0,0 @@
-// admin-specific types take priority over base types when names conflict
-export * from "./types";
-// Editor types only — the full ProseMirror editor (RichTextEditor) is a heavy import (~300 KB)
-// and is available as a separate entry point: @rebasepro/cms/editor
-export type { RichTextEditorProps, RichTextEditorTextSize, JSONContent, EditorAIController } from "./editor";
-export * from "./form";
-export * from "./preview";
-export * from "./routes";
-
-// Components — explicitly listed to avoid conflicts with ./types re-exports
-export {
-    EntityViewBinding,
-    SelectionTableBinding,
-    SelectableTable,
-    SelectableTableContext,
-    CollectionViewBinding,
-    CollectionViewActions,
-    CollectionCardViewBinding,
-    EntityCardBinding,
-    useSelectionController,
-    PropertyConfigBadge,
-    PropertyIdCopyTooltip,
-    CollectionTableBinding,
-    CollectionRowActions,
-    VirtualTableInput,
-    ArrayContainer,
-    type ArrayEntryParams,
-    ReferenceWidget,
-    SearchIconsView,
-    FieldCaption,
-    EntityPreviewBinding,
-    getFieldConfig,
-    getFieldId,
-    getDefaultFieldConfig,
-    getDefaultFieldId,
-    DEFAULT_FIELD_CONFIGS,
-    editEntityAction,
-    copyEntityAction,
-    deleteEntityAction,
-    resetPasswordAction,
-    SidePanelProvider,
-    Scaffold,
-    AppBar,
-    Drawer,
-    DefaultDrawer,
-    DrawerFooterActions,
-    // The two rows the `Shell.DrawerNavigation*` overrides replace. Public so an
-    // app can wrap the stock ones — pass different props, add a context — instead of
-    // reimplementing a nav row and drifting from the framework's hover, active and
-    // tooltip behaviour on the next release.
-    DrawerNavigationItem,
-    DrawerNavigationGroup,
-    AdminModeSyncer,
-    // ContentHomePage is lazy-loaded — not re-exported here
-    RebaseCMS,
-    RebaseShell,
-    RebaseAuthGate,
-    RebaseNavigation,
-    RebaseLayout,
-    RebaseRouteDefs,
-    SideDialogs,
-    useApp,
-    CollectionPanel
-} from "./components";
-export type {
-    EntityViewBindingProps,
-    SelectionProps,
-    SelectableTableProps,
-    CollectionPanelProps,
-    DrawerNavigationGroupProps,
-    DrawerNavigationItemProps
-} from "./components";
-
-export * from "./hooks";
-// Util
-export {
-    addInitialSlash,
-    removeInitialSlash,
-    removeTrailingSlash,
-    removeInitialAndTrailingSlashes,
-    getLastSegment,
-    getCollectionBySlugWithin,
-    getCollectionPathsCombinations,
-    resolveCollectionPathIds,
-    mergeEntityActions,
-    resolveEntityAction,
-    resolveEntityView,
-    // Property utilities (moved from @rebasepro/app — property-aware logic belongs in admin)
-    isReferenceProperty,
-    isRelationProperty,
-    getIconForWidget,
-    getIconForProperty,
-    getPropertyInPath,
-    getResolvedPropertyInPath,
-    getBracketNotation,
-    getPropertiesWithPropertiesOrder,
-    getDefaultPropertiesOrder,
-    // Preview utilities (moved from @rebasepro/app — property-aware logic belongs in admin)
-    getEntityPreviewKeys,
-    getEntityTitlePropertyKey,
-    getEntityTitlePropertyKeyForEntity
-} from "./util";
-
-// Headless collection view adapters
-// Map entity types to the data-agnostic CollectionView from @rebasepro/ui
-export { mapPropertyToConfig, mapPropertiesToConfigs } from "./util/propertyConfigMapper";
-export { useCollectionDataController, createStaticDataController } from "./util/dataControllerAdapter";
-
-// Data import/export — merged from former standalone packages
-export * from "./data_import";
-export * from "./data_export";
-
-// Collection editor — moved from @rebasepro/studio (admin-dependent visual schema editor)
-export * from "./collection_editor";
-export * from "./collection_editor/liveSchemaClient";
-export * from "./collection_editor/useLiveSchemaEditing";
-// `SchemaChangeDialog` is deliberately absent, like `CollectionEditorDialog`
-// and `PropertyFormDialog` beside it: re-exporting it from the barrel puts it
-// back in the eager bundle and undoes the `lazyChunk` in `useLiveSchemaEditing`.
-// Import it by path if you need the component itself.
-
-
-export { CreationResultDialog } from "./components/admin/CreationResultDialog";
-