@rebasepro/app 0.0.1-canary.4829d6e

package/dist/components/Debug/crm-dashboard/TaskTable.d.ts

@@ -0,0 +1,50 @@
+import React from "react";
+interface TaskEntity {
+    id: string;
+    values: {
+        title: string;
+        status: string;
+        resolution: string | null;
+        dueDate: string | null;
+        stageId: string | null;
+        description: string | null;
+        notes: string | null;
+        clientId: string | null;
+        client?: {
+            name?: string;
+        } | null;
+        priority?: string | null;
+        createdAt: string | null;
+    };
+}
+export interface TaskTableProps {
+    tasks: TaskEntity[];
+    loading: boolean;
+    pendingTasks: TaskEntity[];
+    visiblePendingTasks: TaskEntity[];
+    hasMorePending: boolean;
+    onLoadMorePending: () => void;
+    pendingCount: number;
+    togglingIds: Set<string>;
+    onToggleTask: (taskId: string, currentStatus: string) => void;
+    onOpenTask: (taskId: string) => void;
+    onOpenClient: (clientId: string) => void;
+    clientsMap: Map<string, {
+        name: string;
+        picture?: string;
+    }>;
+    stageLabels: Record<string, string>;
+    recentlyToggledIds: Set<string>;
+    completedTasks: TaskEntity[];
+    completedLoaded: boolean;
+    loadingCompleted: boolean;
+    completedHasMore: boolean;
+    onExpandCompleted: () => void;
+    onLoadMoreCompleted: () => void;
+}
+export declare const resolutionDisplay: Record<string, {
+    label: string;
+    colorScheme: string;
+}>;
+export declare function TaskTable({ tasks, loading, pendingTasks, visiblePendingTasks, hasMorePending, onLoadMorePending, pendingCount, togglingIds, onToggleTask, onOpenTask, onOpenClient, clientsMap, stageLabels, recentlyToggledIds, completedTasks, completedLoaded, loadingCompleted, completedHasMore, onExpandCompleted, onLoadMoreCompleted }: TaskTableProps): React.JSX.Element;
+export {};

package/dist/components/Debug/crm-dashboard/TasksView.d.ts

@@ -0,0 +1,41 @@
+import React from "react";
+interface TaskEntity {
+    id: string;
+    values: {
+        title: string;
+        status: string;
+        resolution: string | null;
+        dueDate: string | null;
+        stageId: string | null;
+        description: string | null;
+        notes: string | null;
+        clientId: string | null;
+        client?: {
+            name?: string;
+        } | null;
+        priority?: string | null;
+        createdAt: string | null;
+    };
+}
+export interface TasksViewProps {
+    loading: boolean;
+    tasks: TaskEntity[];
+    togglingIds: Set<string>;
+    onToggleTask: (taskId: string, currentStatus: string) => void;
+    onOpenTask: (taskId: string) => void;
+    onOpenClient: (clientId: string) => void;
+    clientsMap: Map<string, {
+        name: string;
+        picture?: string;
+    }>;
+    pipelineStages: any[];
+    recentlyToggledIds: Set<string>;
+    completedTasks: TaskEntity[];
+    completedLoaded: boolean;
+    loadingCompleted: boolean;
+    completedHasMore: boolean;
+    onExpandCompleted: () => void;
+    onLoadMoreCompleted: () => void;
+}
+export declare function TasksView({ loading, tasks, togglingIds, onToggleTask, onOpenTask, onOpenClient, clientsMap, pipelineStages, recentlyToggledIds, completedTasks, completedLoaded, loadingCompleted, completedHasMore, onExpandCompleted, onLoadMoreCompleted }: TasksViewProps): React.JSX.Element;
+export {};

package/dist/components/ErrorTooltip.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { TooltipProps } from "@rebasepro/ui";
+export declare function ErrorTooltip(props: TooltipProps): React.JSX.Element;

package/dist/components/ErrorView.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+/**
+ * @group Components
+ */
+export interface ErrorViewProps {
+    title?: string;
+    error: Error | React.ReactElement | string;
+    tooltip?: string;
+    onRetry?: () => void;
+}
+/**
+ * Generic error view. Displayed for example when an unexpected value comes
+ * from the driver in a collection view.
+ * @param title
+ * @param error
+ * @param tooltip
+ * @param onRetry
+
+ * @group Components
+ */
+export declare function ErrorView({ title, error, tooltip, onRetry }: ErrorViewProps): React.ReactElement;

package/dist/components/LanguageToggle.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare function LanguageToggle(): React.JSX.Element;

package/dist/components/LoginView/LoginView.d.ts

@@ -0,0 +1,113 @@
+import React, { ReactNode } from "react";
+/** Google Identity Services SDK — injected by the GIS <script> tag. */
+declare global {
+    interface Window {
+        google?: {
+            accounts: {
+                oauth2: {
+                    initCodeClient(config: {
+                        client_id: string;
+                        scope: string;
+                        ux_mode: "popup" | "redirect";
+                        callback: (response: {
+                            code?: string;
+                            error?: string;
+                        }) => void;
+                    }): {
+                        requestCode(): void;
+                    };
+                };
+            };
+        };
+    }
+}
+import { AuthControllerExtended } from "@rebasepro/types";
+/**
+ * Props for the generic LoginView.
+ * Consumes {@link AuthControllerExtended} — works with any backend
+ * (Rebase custom backend, Firebase, etc.)
+ */
+export interface LoginViewProps {
+    /**
+     * Auth controller — must implement AuthControllerExtended.
+     */
+    authController: AuthControllerExtended;
+    /**
+     * Path to the logo displayed in the login screen
+     */
+    logo?: string;
+    /**
+     * Enable the skip login button
+     */
+    allowSkipLogin?: boolean;
+    /**
+     * Disable the login buttons
+     */
+    disabled?: boolean;
+    /**
+     * Prevent users from creating new accounts.
+     * If not set, checks `authController.capabilities.registration`.
+     */
+    disableSignupScreen?: boolean;
+    /**
+     * Display this component when no user is found
+     */
+    noUserComponent?: ReactNode;
+    /**
+     * Display this component below the sign-in buttons
+     */
+    additionalComponent?: ReactNode;
+    /**
+     * Display this component above the sign-in buttons
+     */
+    topComponent?: ReactNode;
+    /**
+     * Error message when user is not allowed access
+     */
+    notAllowedError?: string | Error;
+    /**
+     * Google client ID for Google OAuth.
+     * Required when Google login is enabled via ID token flow.
+     */
+    googleClientId?: string;
+    /**
+     * GitHub client ID for GitHub OAuth.
+     */
+    githubClientId?: string;
+    /**
+     * LinkedIn client ID for LinkedIn OAuth.
+     */
+    linkedinClientId?: string;
+    /**
+     * Optional custom title shown above options
+     */
+    title?: string;
+    /**
+     * Optional custom subtitle shown above options
+     */
+    subtitle?: string;
+    /**
+     * When true, shows bootstrap/setup UI (first-user creation).
+     * If not set, derived from `authController` if it exposes `needsSetup`.
+     */
+    needsSetup?: boolean;
+    /**
+     * Whether registration is enabled.
+     * If not set, derived from `authController.capabilities.registration`.
+     */
+    registrationEnabled?: boolean;
+    /**
+     * Pre-fill the email field (e.g. for demo or testing environments).
+     */
+    defaultEmail?: string;
+    /**
+     * Pre-fill the password field (e.g. for demo or testing environments).
+     */
+    defaultPassword?: string;
+}
+/**
+ * Generic login view component that works with any AuthControllerExtended.
+ * Feature-detects capabilities to show/hide login methods.
+ * @group Core
+ */
+export declare function LoginView({ logo, authController, noUserComponent, disableSignupScreen, disabled, notAllowedError, googleClientId, githubClientId, linkedinClientId, title, subtitle, needsSetup, registrationEnabled, additionalComponent, topComponent, defaultEmail, defaultPassword }: LoginViewProps): React.JSX.Element;

package/dist/components/LoginView/index.d.ts

@@ -0,0 +1,2 @@
+export { LoginView } from "./LoginView";
+export type { LoginViewProps } from "./LoginView";

package/dist/components/NotFoundPage.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare function NotFoundPage(): React.JSX.Element;

package/dist/components/RebaseAuth.d.ts

@@ -0,0 +1,10 @@
+import type { RebaseAuthConfig } from "@rebasepro/types";
+/**
+ * Declarative component to configure authentication in Rebase.
+ * Renders nothing — purely registers config into the RebaseRegistry.
+ *
+ * This is a framework-level component that lives in core since
+ * authentication is cross-cutting (CMS, Studio, any app area).
+ * @group Core
+ */
+export declare function RebaseAuth({ loginView }: RebaseAuthConfig): null;

package/dist/components/RebaseLogo.d.ts

@@ -0,0 +1,7 @@
+import React from "react";
+export declare function RebaseLogo({ width, height, className, style }: {
+    width?: string;
+    height?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}): React.JSX.Element;

package/dist/components/SchemaDriftBanner.d.ts

@@ -0,0 +1,27 @@
+import React from "react";
+interface SchemaDriftContextValue {
+    /** Report a schema drift error (call from any data-loading hook). */
+    reportSchemaDrift: (message: string) => void;
+    /** The most recent schema drift message, or null. */
+    schemaDriftMessage: string | null;
+    /** Dismiss the banner for this session. */
+    dismiss: () => void;
+}
+export declare function useSchemaDriftContext(): SchemaDriftContextValue;
+/**
+ * Detects schema drift from an error object.
+ * Checks both the error code (from `RebaseApiError`) and the message
+ * for schema drift indicators.
+ */
+export declare function isSchemaDriftError(error: unknown): boolean;
+export declare function SchemaDriftProvider({ children }: {
+    children: React.ReactNode;
+}): React.JSX.Element;
+export interface SchemaDriftBannerProps {
+    className?: string;
+}
+/**
+ * Persistent banner shown when a schema drift error is detected.
+ */
+export declare function SchemaDriftBanner({ className }: SchemaDriftBannerProps): React.JSX.Element | null;
+export {};

package/dist/components/UnsavedChangesDialog.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export interface UnsavedChangesDialogProps {
+    open: boolean;
+    body?: React.ReactNode;
+    title?: string;
+    handleOk: () => void;
+    handleCancel: () => void;
+}
+export declare function UnsavedChangesDialog({ open, handleOk, handleCancel, body, title }: UnsavedChangesDialogProps): React.JSX.Element;

package/dist/components/UserDisplay.d.ts

@@ -0,0 +1,7 @@
+import { User } from "@rebasepro/types";
+/**
+ * Component to render a single user with name and email
+ */
+export declare function UserDisplay({ user }: {
+    user: User | null;
+}): import("react").JSX.Element;

package/dist/components/UserSelectPopover.d.ts

@@ -0,0 +1,63 @@
+import React from "react";
+/**
+ * Represents a selectable user item with optional role information.
+ */
+export interface SelectableUser {
+    uid: string;
+    displayName?: string | null;
+    email?: string | null;
+    photoURL?: string | null;
+    roles?: string[];
+}
+export interface UserSelectPopoverProps {
+    /**
+     * The currently selected user, or `null` for "self"/default.
+     */
+    selectedUser: SelectableUser | null;
+    /**
+     * Called when the user selection changes.
+     * `null` means "reset to self/default".
+     */
+    onUserSelected: (user: SelectableUser | null) => void;
+    /**
+     * Full list of users to display.
+     * The component handles client-side search/filter internally.
+     */
+    users: SelectableUser[];
+    /**
+     * Whether users are currently loading.
+     */
+    loading?: boolean;
+    /**
+     * The current user (displayed as the "self" option at the top).
+     */
+    currentUser?: SelectableUser | null;
+    /**
+     * Label to display when no user is selected.
+     * @default "Current user"
+     */
+    defaultLabel?: string;
+    /**
+     * Maximum number of users to render at a time (for performance).
+     * Users can still be found via search.
+     * @default 100
+     */
+    renderLimit?: number;
+    /**
+     * Additional class name for the trigger button.
+     */
+    className?: string;
+    /**
+     * Size variant.
+     * @default "small"
+     */
+    size?: "small" | "medium";
+}
+/**
+ * A reusable user picker popover with search support.
+ * Designed to handle very large user lists (100k+) by filtering
+ * client-side and limiting the rendered set.
+ *
+ * @group Components
+ */
+export declare function UserSelectPopover({ selectedUser, onUserSelected, users, loading, currentUser, defaultLabel, renderLimit, className, size }: UserSelectPopoverProps): React.JSX.Element;

package/dist/components/UserSettingsView.d.ts

@@ -0,0 +1,2 @@
+import React from "react";
+export declare function UserSettingsView(): React.JSX.Element | null;

package/dist/components/common/index.d.ts

@@ -0,0 +1,6 @@
+export * from "./types";
+export * from "./useDebouncedData";
+export * from "./useColumnsIds";
+export * from "./useDataTableController";
+export * from "./useScrollRestoration";
+export * from "./table_height";

package/dist/components/common/table_height.d.ts

@@ -0,0 +1,5 @@
+/**
+ * @group Components
+ */
+export type TableSize = "xs" | "s" | "m" | "l" | "xl";
+export declare function getRowHeight(size: TableSize): number;

package/dist/components/common/types.d.ts

@@ -0,0 +1,66 @@
+import type { Property, Entity } from "@rebasepro/types";
+import { CollectionSize, SelectedCellProps } from "@rebasepro/types";
+export type DataCollectionTableController<M extends Record<string, unknown>> = {
+    /**
+     * This cell is displayed as selected
+     */
+    selectedCell?: SelectedCellProps;
+    /**
+     * Store used to sync selection state across cells efficiently.
+     */
+    selectionStore?: {
+        getEntity: () => SelectedCellProps | undefined;
+        subscribe: (cb: () => void) => () => void;
+    };
+    /**
+     * Select a table cell
+     * @param cell
+     */
+    select: (cell?: SelectedCellProps<M>) => void;
+    /**
+     * The cell that is displayed as a popup view.
+     * @param cell
+     */
+    setPopupCell?: (cell?: SelectedCellProps<M>) => void;
+    /**
+     * Callback used when the value of a cell has changed.
+     * @param params
+     */
+    onValueChange?: (params: OnCellValueChangeParams<unknown, Entity<M>>) => void;
+    /**
+     * Size of the elements in the collection
+     */
+    size: CollectionSize;
+};
+/**
+ * Props passed in a callback when the content of a cell in a table has been edited
+ * @group Collection components
+ */
+export interface OnCellValueChangeParams<T = unknown, D = unknown> {
+    value: T;
+    propertyKey: string;
+    data?: D;
+    onValueUpdated: () => void;
+    setError: (e: Error | undefined) => void;
+}
+/**
+ * @group Collection components
+ */
+export type UniqueFieldValidator = (props: {
+    name: string;
+    value: unknown;
+    property: Property;
+    entityId?: string | number;
+}) => Promise<boolean>;
+/**
+ * Callback when a cell has changed in a table
+ * @group Collection components
+ */
+export type OnCellValueChange<T, M extends Record<string, unknown>> = (params: OnCellValueChangeParams<T, Entity<M>>) => Promise<void> | void;
+/**
+ * @group Collection components
+ */
+export type OnColumnResizeParams = {
+    width: number;
+    key: string;
+};

package/dist/components/common/useColumnsIds.d.ts

@@ -0,0 +1,9 @@
+import type { CollectionConfig, Property } from "@rebasepro/types";
+export type PropertyColumnConfig = {
+    key: string;
+    disabled: boolean;
+};
+export declare function getSubcollectionColumnId(collection: CollectionConfig<any>): string;
+export declare function useColumnIds<M extends Record<string, any>>(collection: CollectionConfig<M>, includeSubcollections: boolean): PropertyColumnConfig[];
+export declare function getColumnKeysForProperty(property: Property, key: string, disabled?: boolean): PropertyColumnConfig[];
+export declare function getFormFieldKeys(collection: CollectionConfig): string[];

package/dist/components/common/useDataTableController.d.ts

@@ -0,0 +1,45 @@
+import type { CollectionConfig } from "@rebasepro/types";
+import { Entity, EntityTableController, FilterValues, User } from "@rebasepro/types";
+import { ScrollRestorationController } from "./useScrollRestoration";
+export declare const DEFAULT_PAGE_SIZE = 50;
+export type DataTableControllerProps<M extends Record<string, any> = any> = {
+    /**
+     * Full path where the data of this table is located
+     */
+    path: string;
+    /**
+     * The collection that is represented by this config.
+     */
+    collection: CollectionConfig<M>;
+    /**
+     * List of entities that will be displayed on top, no matter the ordering.
+     * This is used for reference fields selection
+     */
+    entitiesDisplayedFirst?: Entity<M>[];
+    lastDeleteTimestamp?: number;
+    /**
+     * Force filter to be applied to the table.
+     */
+    fixedFilter?: FilterValues<string>;
+    scrollRestoration?: ScrollRestorationController;
+    /**
+     * When set to true the filters and sort will be updated in the URL
+     */
+    updateUrl?: boolean;
+};
+/**
+ * Use this hook to build a controller for the {@link DataCollectionTable}.
+ * This controller is bound to data in a path in your specified driver.
+ *
+ * Note that you can build your own hook returning a {@link EntityTableController}
+ * if you would like to display different data.
+ *
+ * @param path
+ * @param collection
+ * @param scrollRestoration
+ * @param entitiesDisplayedFirst
+ * @param lastDeleteTimestamp
+ * @param fixedFilterFromProps
+ * @param updateUrl
+ */
+export declare function useDataTableController<M extends Record<string, any> = any, USER extends User = User>({ path, collection, scrollRestoration, entitiesDisplayedFirst, lastDeleteTimestamp: _lastDeleteTimestamp, fixedFilter: fixedFilterFromProps, updateUrl }: DataTableControllerProps<M>): EntityTableController<M>;

package/dist/components/common/useDebouncedData.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Hack to prevent data updates for incomplete callbacks from Firestore
+ * triggers.
+ * If any deps change, the update is immediate
+ * @param data
+ * @param deps
+ * @param timeoutMs
+ */
+export declare function useDebouncedData<T>(data: T[], deps: unknown, timeoutMs?: number): T[];

package/dist/components/common/useScrollRestoration.d.ts

@@ -0,0 +1,14 @@
+import { Entity, FilterValues } from "@rebasepro/types";
+export type ScrollRestorationController = {
+    getCollectionScroll: (path: string, filters?: FilterValues<any>) => {
+        scrollOffset: number;
+        data: Entity<any>[];
+    } | undefined;
+    updateCollectionScroll: (props: {
+        path: string;
+        scrollOffset: number;
+        filters?: FilterValues<any>;
+        data: Entity<any>[];
+    }) => void;
+};
+export declare function useScrollRestoration(): ScrollRestorationController;

package/dist/components/index.d.ts

@@ -0,0 +1,18 @@
+export type { ErrorViewProps } from "./ErrorView";
+export { ErrorView } from "./ErrorView";
+export * from "./common";
+export * from "./NotFoundPage";
+export * from "./ConfirmationDialog";
+export * from "./ErrorTooltip";
+export * from "./RebaseLogo";
+export * from "./AIIcon";
+export * from "./Debug/UIStyleGuide";
+export * from "./Debug/UIReferenceView";
+export { CrmDashboardDemo } from "./Debug/crm-dashboard/CrmDashboardDemo";
+export * from "./UserSettingsView";
+export * from "./LanguageToggle";
+export * from "./UserSelectPopover";
+export * from "./UserDisplay";
+export * from "./LoginView";
+export * from "./RebaseAuth";
+export * from "./SchemaDriftBanner";

package/dist/contexts/AdminModeController.d.ts

@@ -0,0 +1,4 @@
+import React from "react";
+import { AdminModeController } from "../hooks";
+export declare const AdminModeControllerContext: React.Context<AdminModeController>;
+export declare const AdminModeControllerProvider: React.Provider<AdminModeController>;

package/dist/contexts/AnalyticsContext.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { AnalyticsController } from "@rebasepro/types";
+export declare const AnalyticsContext: React.Context<AnalyticsController>;

package/dist/contexts/AuthControllerContext.d.ts

@@ -0,0 +1,3 @@
+import React from "react";
+import { AuthController } from "@rebasepro/types";
+export declare const AuthControllerContext: React.Context<AuthController<any, any>>;

package/dist/contexts/CollectionScopeContext.d.ts

@@ -0,0 +1,50 @@
+import React from "react";
+import type { CollectionConfig } from "@rebasepro/types";
+/**
+ * Carries the collection a UI subtree is currently bound to.
+ *
+ * Mounted by every collection binding (main collection views, entity
+ * edit/detail views, side panels, reference-selection dialogs, import
+ * previews) via {@link CollectionScopeProvider}. Leaf components read it with
+ * {@link useCollectionScope} to derive collection-dependent behavior — e.g.
+ * filter fields resolve the engine's supported operators from
+ * `collection.engine` — without every intermediate component threading
+ * collection props.
+ *
+ * @internal
+ */
+export declare const CollectionScopeContext: React.Context<CollectionConfig | undefined>;
+/**
+ * Read the collection the current subtree is bound to, or `undefined` when
+ * rendered outside any collection scope (e.g. a fully standalone table).
+ *
+ * @group Hooks
+ */
+export declare function useCollectionScope(): CollectionConfig | undefined;
+/**
+ * Scopes a UI subtree to a collection.
+ *
+ * Provides two things at once:
+ * 1. The collection itself — readable via {@link useCollectionScope} —
+ *    so leaf components (filter fields, previews, …) can derive
+ *    collection-dependent behavior such as engine capabilities.
+ * 2. The collection's component overrides (`collection.components`),
+ *    by mounting {@link CollectionComponentOverrideProvider}.
+ *
+ * Mount this wherever a subtree is bound to a specific collection. If you
+ * build a custom view around `SelectableTable` / `CollectionTableBinding`,
+ * wrap it in this provider to get engine-aware filters and collection-scoped
+ * component overrides for free:
+ *
+ * ```tsx
+ * <CollectionScopeProvider collection={myCollection}>
+ *     <CollectionTableBinding ... />
+ * </CollectionScopeProvider>
+ * ```
+ *
+ * @group Components
+ */
+export declare function CollectionScopeProvider({ collection, children }: {
+    collection: CollectionConfig<any> | undefined;
+    children: React.ReactNode;
+}): React.JSX.Element;