@rebasepro/core 0.0.1-canary.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Rebase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,174 @@
+<p align="center">
+    <img src="https://rebase.pro/img/dark_mode.webp" alt="Intro video" style="max-width: 100%;"/>
+</p>
+
+<p align="center">
+  <a href="https://rebase.pro">
+    <img src="https://rebase.pro/img/logo_small.png" width="240px" alt="Rebase logo" />
+  </a>
+</p>
+
+<h1 align="center">Rebase</h1>
+<h3 align="center">Awesome Firebase/MongoDB-based headless CMS</h3>
+<p align="center"><a href="https://demo.rebase.pro">Live demo</a></p>
+
+<br />
+
+
+[![NPM](https://img.shields.io/npm/v/rebase.svg)](https://www.npmjs.com/package/rebase) [![JavaScript Style Guide](https://img.shields.io/badge/code_style-standard-brightgreen.svg)](https://standardjs.com)
+
+Designed by developers for developers, Rebase is a headless CMS and admin panel
+that seamlessly integrates with **Firebase and Firestore** by default, but is
+also
+compatible with any backend.
+
+Effortlessly generate **CRUD views** based on your configuration. Rebase is
+simple
+to set up for standard cases and easy to extend and customize for more specific
+needs.
+
+Built to produce collection and form views that naturally align with the
+collection/document model, Rebase covers a wide range of basic and advanced use
+cases. With extensibility in mind, it's easy to create your own views or modify
+existing ones.
+
+Rebase does **not impose any data structure** restrictions, ensuring a smooth,
+out-of-the-box experience for any project.
+
+### Core technologies
+
+Rebase is based on this great technologies:
+
+- Typescript
+- Tailwind CSS
+- Firebase SDK 10
+- React + React Router 6
+
+### Quickstart
+
+The easiest way to get going is to check our quickstart guide! You will just
+need to follow some quick steps:
+
+https://rebase.pro/docs
+
+### Demo
+
+Check the demo with all the core functionalities.
+
+https://demo.rebase.pro
+
+> You can modify the data, but it gets periodically restored.
+
+### Changelog
+
+https://rebase.pro/docs/changelog
+
+## Features
+
+Rebase has been meticulously crafted to make it incredibly easy for developers
+to build a CMS/admin tool while offering an excellent data editing experience
+and a user-friendly interface for marketers and content managers.
+
+### 🏓 Exceptional Spreadsheet View
+
+We've developed a highly efficient windowed **spreadsheet view** for
+collections, allowing inline editing for most common fields, as well as popup
+views for other cases and your custom field implementations.
+
+Featuring **real-time** support, Rebase is perfect for apps that require
+constant updates. It also supports **text search** (through an external provider
+like Algolia, if using Firestore), **filtering and sorting**, and **exporting**
+data.
+
+### ✨ Robust Forms
+
+![fields](https://rebase.pro/img/form_editing.webp)
+
+When editing an entity, Rebase offers a nested system of side dialogs for
+navigating through **subcollections** and accessing custom views (such as custom
+forms or blog previews). This functionality can also be accessed
+programmatically using the `useSideEntityController` hook.
+
+Rebase includes **over 20 built-in fields** with numerous customization and
+validation options. The components have been carefully designed for an
+outstanding user experience, including advanced features like **references** to
+other collections, **markdown**, and **array reordering**.
+
+For unsupported use cases, create your own **custom field** as a React
+component.
+
+Rebase also supports **conditional fields** in forms, allowing you to define
+rules for active fields based on your logic.
+
+### 👮 Authentication, Permissions, and Role System
+
+Define which navigation views users can see and the operations (create, edit,
+delete) they can perform based on your role system. You can even configure this
+on a per-entity or collection level.
+
+By default, Rebase supports all Firebase authorization mechanisms, but you can
+implement your own.
+
+### 🏹 Relational Support
+
+Define references to entities in other collections and benefit from the
+integrated reference fields and shortcuts.
+
+You can also define subcollections at the entity level for nesting data in a
+collection/document/collection model.
+
+### 🆒 Real-Time Data
+
+Every view in the CMS supports real-time data, making it suitable for displaying
+constantly updated information.
+
+Forms also support this feature, with any modified value in the database being
+updated in any open form view as long as it hasn't been touched by the user.
+This enables advanced cases where a Cloud Function is triggered after saving an
+entity, modifying some values, and requiring real-time updates.
+
+### 🗂️ File Storage
+
+Rebase supports uploading files to Firebase Storage out of the box and provides
+specific fields for handling single and multiple file uploads, as well as
+reordering.
+
+You can replace the Firebase Storage implementation with your own.
+
+## Included example
+
+You can access the code for the demo project under
+[`example`](https://github.com/Rebaseco/rebase/tree/master/example). It includes
+every feature provided by this CMS.
+
+Keep in mind you need to update the dependencies in that project if you want to
+use it as it is, without linking it to the library source code. More details in
+its README
+
+## Contact and support
+
+If you need general support, you can open a GitHub issue.
+
+Do you need consulting setting up your Firestore-based CMS in no time? We are
+happy to help!
+`hello@rebase.pro`
+
+## Development
+
+If you would like to make changes to the source, feel free to submit a PR!
+
+When developing, the core library can be found under `lib`.
+There is an example project in the folder `example`.
+
+In order to run the project, you need to create a file
+called `firebase_config.ts`
+in `example/src`.
+
+That file needs to export a valid Firebase config, that you can get
+from your Firebase console when creating a webapp for your project.
+
+Then simply run `npm install` and `npm run dev` (or `yarn` and `yarn dev`)
+
+## License
+
+MIT © [Rebase](https://github.com/Rebaseco)

package/dist/app/AppBar.d.ts

@@ -0,0 +1,12 @@
+import { DefaultAppBarProps } from "../core/DefaultAppBar";
+/**
+ * This component renders the main app bar of Rebase.
+ */
+export declare function AppBar({ children, ...props }: {
+    children?: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+} & DefaultAppBarProps): import("react/jsx-runtime").JSX.Element;
+export declare namespace AppBar {
+    var componentType: string;
+}

package/dist/app/Drawer.d.ts

@@ -0,0 +1,19 @@
+/**
+ * This component is in charge of rendering the drawer.
+ * If you add this component under your {@link Scaffold}, it will be rendered
+ * as a drawer, and the open and close functionality will be handled automatically.
+ * If you want to customise the drawer, you can create your own component and pass it as a child.
+ * For custom drawers, you can use the {@link useApp} to open and close the drawer.
+ *
+ */
+export declare function Drawer({ children, title, logo, logoDestination, className, style }: {
+    children?: React.ReactNode;
+    title?: React.ReactNode;
+    logo?: string;
+    logoDestination?: string;
+    className?: string;
+    style?: React.CSSProperties;
+}): import("react/jsx-runtime").JSX.Element;
+export declare namespace Drawer {
+    var componentType: string;
+}

package/dist/app/Scaffold.d.ts

@@ -0,0 +1,34 @@
+import React from "react";
+export declare const DRAWER_WIDTH = 280;
+/**
+ * @group Core
+ */
+export interface ScaffoldProps {
+    /**
+     * Open the drawer on hover
+     */
+    autoOpenDrawer?: boolean;
+    /**
+     * Logo to be displayed in the top bar and drawer.
+     * Note that this has no effect if you are using a custom AppBar or Drawer.
+     */
+    logo?: string;
+    /**
+     * If true, the main content will be padded in large layouts. Defaults to true.
+     */
+    padding?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * This view acts as a scaffold for Rebase.
+ *
+ * It is in charge of displaying the navigation drawer, top bar and main
+ * collection views.
+ * This component needs a parent {@link Rebase}
+ *
+ * @param props
+
+ * @group Core
+ */
+export declare const Scaffold: React.NamedExoticComponent<React.PropsWithChildren<ScaffoldProps>>;

package/dist/app/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./Drawer";
+export * from "./AppBar";
+export * from "./Scaffold";
+export * from "./useApp";

package/dist/app/useApp.d.ts

@@ -0,0 +1,17 @@
+import React from "react";
+/**
+ * This context represents the state of the app in terms of layout.
+ * @group Core
+ */
+export type AppState = {
+    hasDrawer: boolean;
+    drawerHovered: boolean;
+    drawerOpen: boolean;
+    openDrawer: () => void;
+    closeDrawer: () => void;
+    closeHover: () => void;
+    autoOpenDrawer?: boolean;
+    logo?: string;
+};
+export declare const AppContext: React.Context<AppState>;
+export declare function useApp(): AppState;

package/dist/components/AIIcon.d.ts

@@ -0,0 +1,16 @@
+export interface AIIconProps {
+    size?: "smallest" | "small" | "medium" | "large";
+    className?: string;
+}
+/**
+ * AI-styled AutoAwesome icon with gradient coloring.
+ * Used consistently across AI features for visual identification.
+ */
+export declare function AIIcon({ size, className }: AIIconProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Small animated dot indicator for AI-modified elements.
+ * Shows a pulsing gradient dot.
+ */
+export declare function AIModifiedIndicator({ className }: {
+    className?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/AdminModeSyncer.d.ts

@@ -0,0 +1,17 @@
+import { CMSView } from "@rebasepro/types";
+export interface AdminModeSyncerProps {
+    /**
+     * Map of views designated as 'Studio' views.
+     * Navigating to any of these views will automatically flag the admin mode as "studio".
+     */
+    devViews?: CMSView[];
+}
+/**
+ * A highly customizable utility component that observes react-router routes and
+ * actively shifts the internal Rebase `adminModeController` context to match
+ * the user's active window segment (e.g., Content vs Studio mode).
+ *
+ * Placing this anywhere safely inside the Rebase layout automatically triggers
+ * UI mode synchronization.
+ */
+export declare function AdminModeSyncer({ devViews }: AdminModeSyncerProps): null;

package/dist/components/ArrayContainer.d.ts

@@ -0,0 +1,59 @@
+import React from "react";
+export type ArrayEntryParams = {
+    index: number;
+    internalId: number;
+    isDragging: boolean;
+    storedProps?: object;
+    storeProps: (props: object) => void;
+};
+export type ArrayEntryBuilder = (params: ArrayEntryParams) => React.ReactNode;
+export interface ArrayContainerProps<T> {
+    droppableId: string;
+    value: T[];
+    addLabel: string;
+    buildEntry: ArrayEntryBuilder;
+    disabled?: boolean;
+    size?: "small" | "medium";
+    onInternalIdAdded?: (id: number) => void;
+    includeAddButton?: boolean;
+    canAddElements?: boolean;
+    sortable?: boolean;
+    newDefaultEntry: T;
+    onValueChange: (value: T[]) => void;
+    className?: string;
+    min?: number;
+    max?: number;
+}
+type ArrayContainerItemProps = {
+    nodeRef: (node: HTMLElement | null) => void;
+    style: React.CSSProperties;
+    dragHandleProps: any;
+    index: number;
+    internalId: number;
+    size?: "small" | "medium";
+    disabled: boolean;
+    buildEntry: ArrayEntryBuilder;
+    remove: (index: number) => void;
+    copy: (index: number) => void;
+    addInIndex?: (index: number) => void;
+    canAddElements?: boolean;
+    sortable: boolean;
+    isDragging: boolean;
+    storedProps?: object;
+    updateItemCustomProps: (internalId: number, props: object) => void;
+};
+export declare function ArrayContainerItem({ nodeRef, style, dragHandleProps, index, internalId, size, disabled, buildEntry, remove, copy, addInIndex, canAddElements, sortable, isDragging, storedProps, updateItemCustomProps }: ArrayContainerItemProps): import("react/jsx-runtime").JSX.Element;
+export declare function ArrayItemOptions({ dragHandleProps, direction, disabled, remove, index, copy, canAddElements, sortable, addInIndex, }: {
+    dragHandleProps: any;
+    direction?: "row" | "column";
+    disabled: boolean;
+    remove: (index: number) => void;
+    index: number;
+    copy: (index: number) => void;
+    sortable: boolean;
+    canAddElements?: boolean;
+    addInIndex?: (index: number) => void;
+}): import("react/jsx-runtime").JSX.Element;
+export declare function ArrayContainer<T>({ droppableId, addLabel, value, disabled, buildEntry, size, onInternalIdAdded, includeAddButton: deprecatedIncludeAddButton, canAddElements: canAddElementsProp, sortable, newDefaultEntry, onValueChange, className, min, max }: ArrayContainerProps<T>): import("react/jsx-runtime").JSX.Element;
+export declare function getRandomId(): number;
+export {};

package/dist/components/CircularProgressCenter.d.ts

@@ -0,0 +1,11 @@
+import { CircularProgressProps } from "@rebasepro/ui";
+/**
+ *
+ * @param text
+ * @param props
+
+ * @ignore
+ */
+export declare function CircularProgressCenter({ text, ...props }: CircularProgressProps & {
+    text?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/ClearFilterSortButton.d.ts

@@ -0,0 +1,5 @@
+import { EntityTableController } from "@rebasepro/types";
+export declare function ClearFilterSortButton({ tableController, enabled }: {
+    enabled: boolean;
+    tableController: EntityTableController;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/ConfirmationDialog.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export declare function ConfirmationDialog({ open, onAccept, onCancel, title, loading, body }: {
+    open: boolean;
+    onAccept: () => void;
+    onCancel: () => void;
+    loading?: boolean;
+    title: React.ReactNode;
+    body?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/Debug/UIReferenceView.d.ts

@@ -0,0 +1 @@
+export declare function UIReferenceView(): import("react/jsx-runtime").JSX.Element;

package/dist/components/Debug/UIStyleGuide.d.ts

@@ -0,0 +1 @@
+export declare const UIStyleGuide: () => import("react/jsx-runtime").JSX.Element;

package/dist/components/DeleteEntityDialog.d.ts

@@ -0,0 +1,12 @@
+import { Entity, EntityCallbacks, EntityCollection } from "@rebasepro/types";
+export interface DeleteEntityDialogProps<M extends Record<string, any>> {
+    entityOrEntitiesToDelete?: Entity<M> | Entity<M>[];
+    path: string;
+    collection: EntityCollection<M>;
+    open: boolean;
+    onClose: () => void;
+    callbacks?: EntityCallbacks<M>;
+    onEntityDelete?(path: string, entity: Entity<M>): void;
+    onMultipleEntitiesDelete?(path: string, entities: Entity<M>[]): void;
+}
+export declare function DeleteEntityDialog<M extends Record<string, any>>({ entityOrEntitiesToDelete, collection, onClose, open, callbacks, onEntityDelete, onMultipleEntitiesDelete, path }: DeleteEntityDialogProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/components/EntityCollectionTable/EntityCollectionRowActions.d.ts

@@ -0,0 +1,37 @@
+import React from "react";
+import { CollectionSize, Entity, EntityAction, EntityCollection, SelectionController } from "@rebasepro/types";
+/**
+ *
+ * @param entity
+ * @param width
+ * @param frozen
+ * @param isSelected
+ * @param selectionEnabled
+ * @param size
+ * @param toggleEntitySelection
+ * @param hideId
+ *
+ * @group Collection components
+ */
+export declare const EntityCollectionRowActions: ({ entity, collection, path, width, frozen, isSelected, selectionEnabled, size, highlightEntity, onCollectionChange, unhighlightEntity, actions, hideId, selectionController, openEntityMode, sortableNodeRef, sortableStyle, sortableAttributes, isDragging, isDraggable }: {
+    entity: Entity<any>;
+    collection?: EntityCollection<any>;
+    path?: string;
+    width: number;
+    frozen?: boolean;
+    size: CollectionSize;
+    isSelected?: boolean;
+    selectionEnabled?: boolean;
+    actions?: EntityAction[];
+    hideId?: boolean;
+    onCollectionChange?: () => void;
+    selectionController?: SelectionController;
+    highlightEntity?: (entity: Entity<any>) => void;
+    unhighlightEntity?: (entity: Entity<any>) => void;
+    openEntityMode: "side_panel" | "full_screen";
+    sortableNodeRef?: (node: HTMLElement | null) => void;
+    sortableStyle?: React.CSSProperties;
+    sortableAttributes?: Record<string, any>;
+    isDragging?: boolean;
+    isDraggable?: boolean;
+}) => import("react/jsx-runtime").JSX.Element;

package/dist/components/EntityCollectionTable/EntityCollectionTable.d.ts

@@ -0,0 +1,27 @@
+import { User } from "@rebasepro/types";
+import { EntityCollectionTableProps } from "./EntityCollectionTableProps";
+/**
+ * This component is in charge of rendering a collection table with a high
+ * degree of customization.
+ *
+ * This component is used internally by {@link EntityCollectionView} and
+ * {@link useReferenceDialog}
+ *
+ * Please note that you only need to use this component if you are building
+ * a custom view. If you just need to create a default view you can do it
+ * exclusively with config options.
+ *
+ * If you want to bind a {@link EntityCollection} to a table with the default
+ * options you see in collections in the top level navigation, you can
+ * check {@link EntityCollectionView}.
+ *
+ * The data displayed in the table is managed by a {@link EntityTableController}.
+ * You can build the default, bound to a path in the datasource, by using the hook
+ * {@link useDataSourceTableController}
+ *
+ * @see EntityCollectionTableProps
+ * @see EntityCollectionView
+ * @see VirtualTable
+ * @group Components
+ */
+export declare const EntityCollectionTable: <M extends Record<string, any> = any, USER extends User = any>({ className, style, forceFilter, actionsStart, actions, viewModeToggle, title, tableRowActionsBuilder, uniqueFieldValidator, getPropertyFor, onValueChange, selectionController, highlightedEntities, onEntityClick, onColumnResize, initialScroll, onScroll, onSizeChanged, hoverRow, inlineEditing, additionalFields, displayedColumnIds, defaultSize, properties, tableController, filterable, sortable, endAdornment, AddColumnComponent, AdditionalHeaderWidget, additionalIDHeaderWidget, emptyComponent, getIdColumnWidth, onTextSearchClick, textSearchLoading, enablePopupIcon, openEntityMode, onColumnsOrderChange, hideToolbar }: EntityCollectionTableProps<M>) => import("react/jsx-runtime").JSX.Element;

package/dist/components/EntityCollectionTable/EntityCollectionTableProps.d.ts

@@ -0,0 +1,128 @@
+import React from "react";
+import { AdditionalFieldDelegate, CollectionSize, Entity, EntityTableController, FilterValues, Properties, Property, SelectionController, User } from "@rebasepro/types";
+import { OnCellValueChange, OnColumnResizeParams, UniqueFieldValidator } from "../common/types";
+import { VirtualTableColumn } from "../VirtualTable";
+/**
+ * @group Collection components
+ */
+export type EntityCollectionTableProps<M extends Record<string, any>, USER extends User = User> = {
+    className?: string;
+    style?: React.CSSProperties;
+    /**
+     * Display these entities as selected
+     */
+    selectionController: SelectionController<M>;
+    /**
+     * List of entities that will be displayed as selected;
+     */
+    highlightedEntities?: Entity<M>[];
+    /**
+     * Override the title in the toolbar
+     */
+    title?: React.ReactNode;
+    /**
+     * Additional component that renders actions such as buttons in the
+     * collection toolbar, displayed on the left side
+     */
+    actionsStart?: React.ReactNode;
+    /**
+     * Callback when a cell value changes.
+     */
+    onValueChange?: OnCellValueChange<any, M>;
+    uniqueFieldValidator?: UniqueFieldValidator;
+    /**
+     * Builder for creating the buttons in each row
+     * @param entity
+     * @param size
+     */
+    tableRowActionsBuilder?: (params: {
+        entity: Entity<M>;
+        size: CollectionSize;
+        width: number;
+        frozen?: boolean;
+    }) => React.ReactNode;
+    /**
+     * Callback when anywhere on the table is clicked
+     */
+    onEntityClick?(entity: Entity<M>): void;
+    /**
+     * Callback when a column is resized
+     */
+    onColumnResize?(params: OnColumnResizeParams): void;
+    /**
+     * Initial scroll position
+     */
+    initialScroll?: number;
+    /**
+     * Callback when the table is scrolled
+     * @param props
+     */
+    onScroll?: (props: {
+        scrollDirection: "forward" | "backward";
+        scrollOffset: number;
+        scrollUpdateWasRequested: boolean;
+    }) => void;
+    /**
+     * Callback when the selected size of the table is changed
+     */
+    onSizeChanged?(size: CollectionSize): void;
+    /**
+     * Should apply a different style to a row when hovering
+     */
+    hoverRow?: boolean;
+    /**
+     * Additional component that renders actions such as buttons in the
+     * collection toolbar, displayed on the right side
+     */
+    actions?: React.ReactNode;
+    /**
+     * View mode toggle button, positioned left of the search bar.
+     */
+    viewModeToggle?: React.ReactNode;
+    /**
+     * Controller holding the logic for the table
+     * {@link useDataSourceTableController}
+     * {@link EntityTableController}
+     */
+    tableController: EntityTableController<M>;
+    displayedColumnIds?: PropertyColumnConfig[];
+    forceFilter?: FilterValues<Extract<keyof M, string>>;
+    inlineEditing?: boolean;
+    additionalFields?: AdditionalFieldDelegate<M, USER>[];
+    defaultSize?: CollectionSize;
+    properties: Properties;
+    getPropertyFor?: (props: GetPropertyForProps<M>) => Property | null;
+    filterable?: boolean;
+    sortable?: boolean;
+    endAdornment?: React.ReactNode;
+    AdditionalHeaderWidget?: React.ComponentType<{
+        property: Property;
+        propertyKey: string;
+        onHover: boolean;
+    }>;
+    AddColumnComponent?: React.ComponentType;
+    additionalIDHeaderWidget?: React.ReactNode;
+    emptyComponent?: React.ReactNode;
+    getIdColumnWidth?: () => number;
+    onTextSearchClick?: () => void;
+    textSearchLoading?: boolean;
+    enablePopupIcon: boolean;
+    openEntityMode?: "side_panel" | "full_screen";
+    /**
+     * Callback when columns are reordered via drag-and-drop
+     */
+    onColumnsOrderChange?: (columns: VirtualTableColumn[]) => void;
+    /**
+     * If true, the internal toolbar will not be rendered.
+     * Used when the parent component renders its own toolbar.
+     */
+    hideToolbar?: boolean;
+};
+export type GetPropertyForProps<M extends Record<string, any>> = {
+    propertyKey: string;
+    entity: Entity<M>;
+};
+export type PropertyColumnConfig = {
+    key: string;
+    disabled?: boolean;
+};

package/dist/components/EntityCollectionTable/PropertyTableCell.d.ts

@@ -0,0 +1,25 @@
+import React from "react";
+import { Entity, Property } from "@rebasepro/types";
+import { CustomFieldValidator } from "../../form/validation";
+export interface PropertyTableCellProps<T> {
+    propertyKey: string;
+    columnIndex: number;
+    align: "right" | "left" | "center";
+    customFieldValidator?: CustomFieldValidator;
+    value: T;
+    readonly: boolean;
+    property: Property;
+    height: number;
+    width: number;
+    entity: Entity<any>;
+    path: string;
+    disabled: boolean;
+    enablePopupIcon?: boolean;
+    sortableNodeRef?: (node: HTMLElement | null) => void;
+    sortableStyle?: React.CSSProperties;
+    sortableAttributes?: Record<string, any>;
+    isDragging?: boolean;
+    isDraggable?: boolean;
+    frozen?: boolean;
+}
+export declare const PropertyTableCell: React.FunctionComponent<PropertyTableCellProps<any>>;

package/dist/components/EntityCollectionTable/column_utils.d.ts

@@ -0,0 +1,15 @@
+import React from "react";
+import { FilterValues, Properties, Property } from "@rebasepro/types";
+import { VirtualTableColumn } from "../VirtualTable";
+export declare function buildIdColumn(largeLayout?: boolean): VirtualTableColumn;
+export interface PropertiesToColumnsParams<M extends Record<string, any>> {
+    properties: Properties;
+    sortable?: boolean;
+    forceFilter?: FilterValues<keyof M extends string ? keyof M : never>;
+    AdditionalHeaderWidget?: React.ComponentType<{
+        property: Property;
+        propertyKey: string;
+        onHover: boolean;
+    }>;
+}
+export declare function propertiesToColumns<M extends Record<string, any>>({ properties, sortable, forceFilter, AdditionalHeaderWidget }: PropertiesToColumnsParams<M>): VirtualTableColumn[];