@firecms/core 3.0.0-alpha.7 → 3.0.0-alpha.70

package/README.md

@@ -83,7 +83,7 @@ data.
 
 ### ✨ Robust Forms
 
-![fields](https://firecms.co/img/post_editing.png)
+![fields](https://firecms.co/img/post_editing.webp)
 
 When editing an entity, FireCMS offers a nested system of side dialogs for
 navigating through **subcollections** and accessing custom views (such as custom

package/dist/components/ArrayContainer.d.ts

@@ -0,0 +1,42 @@
+import React from "react";
+import { DraggableProvided } from "@hello-pangea/dnd";
+interface ArrayContainerProps<T> {
+    droppableId: string;
+    value: T[];
+    addLabel: string;
+    buildEntry: (index: number, internalId: number) => React.ReactNode;
+    disabled?: boolean;
+    size?: "small" | "medium";
+    onInternalIdAdded?: (id: number) => void;
+    includeAddButton?: boolean;
+    newDefaultEntry: T;
+    onValueChange: (value: T[]) => void;
+}
+/**
+ * @group Form custom fields
+ */
+export declare function ArrayContainer<T>({ droppableId, addLabel, value, disabled, buildEntry, size, onInternalIdAdded, includeAddButton, newDefaultEntry, onValueChange }: ArrayContainerProps<T>): import("react/jsx-runtime").JSX.Element;
+type ArrayContainerItemProps = {
+    provided: DraggableProvided;
+    index: number;
+    internalId: number;
+    size?: "small" | "medium";
+    disabled: boolean;
+    buildEntry: (index: number, internalId: number) => React.ReactNode;
+    remove: (index: number) => void;
+    copy: (index: number) => void;
+    isDragging: boolean;
+};
+export declare function ArrayContainerItem({ provided, index, internalId, size, disabled, buildEntry, remove, copy, isDragging }: ArrayContainerItemProps): import("react/jsx-runtime").JSX.Element;
+export declare function ArrayItemOptions({ direction, disabled, remove, index, provided, copy, contentOverflow, measuring }: {
+    direction?: "row" | "column";
+    contentOverflow: boolean;
+    measuring: boolean;
+    disabled: boolean;
+    remove: (index: number) => void;
+    index: number;
+    provided: any;
+    copy: (index: number) => void;
+}): 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 "@firecms/ui";
+/**
+ *
+ * @param text
+ * @param props
+ * @constructor
+ * @ignore
+ */
+export declare function CircularProgressCenter({ text, ...props }: CircularProgressProps & {
+    text?: string;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/DeleteConfirmationDialog.d.ts

@@ -0,0 +1,9 @@
+import React from "react";
+export declare function DeleteConfirmationDialog({ 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/EntityCollectionTable/EntityCollectionTable.d.ts

@@ -0,0 +1,30 @@
+import React from "react";
+import { EntityCollectionTableController } from "./types";
+import { EntityCollectionTableProps } from "./EntityCollectionTableProps";
+export declare const EntityCollectionTableContext: React.Context<EntityCollectionTableController<any>>;
+export declare const useEntityCollectionTableController: () => EntityCollectionTableController<any>;
+/**
+ * This component is in charge of rendering a collection table with a high
+ * degree of customization. It is in charge of fetching data from
+ * the {@link DataSource} and holding the state of filtering and sorting.
+ *
+ * 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}
+ *
+ * If you need a table that is not bound to the datasource or entities and
+ * properties at all, you can check {@link VirtualTable}
+ *
+ * @see EntityCollectionTableProps
+ * @see EntityCollectionView
+ * @see VirtualTable
+ * @group Components
+ */
+export declare const EntityCollectionTable: React.NamedExoticComponent<EntityCollectionTableProps<any>>;

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

@@ -0,0 +1,106 @@
+import React from "react";
+import { AdditionalFieldDelegate, CollectionSize, Entity, FilterValues, ResolvedProperties, ResolvedProperty, SelectionController, TableController, User } from "../../types";
+import { OnCellValueChange, UniqueFieldValidator } from "./types";
+/**
+ * @group Collection components
+ */
+export type OnColumnResizeParams = {
+    width: number;
+    key: string;
+};
+/**
+ * @group Collection components
+ */
+export type EntityCollectionTableProps<M extends Record<string, any>, UserType extends User = User> = {
+    /**
+     * 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;
+    /**
+     * 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;
+    /**
+     * Controller holding the logic for the table
+     * {@link useEntityCollectionTableController}
+     * {@link TableController}
+     */
+    tableController: TableController<M>;
+    displayedColumnIds: PropertyColumnConfig[];
+    forceFilter?: FilterValues<Extract<keyof M, string>>;
+    textSearchEnabled?: boolean;
+    inlineEditing?: boolean | ((entity: Entity<M>) => boolean);
+    additionalFields?: AdditionalFieldDelegate<M, UserType>[];
+    defaultSize?: CollectionSize;
+    properties: ResolvedProperties<M>;
+    getPropertyFor?: (props: GetPropertyForProps<M>) => ResolvedProperties<M>[string];
+    filterable?: boolean;
+    sortable?: boolean;
+    endAdornment?: React.ReactNode;
+    AdditionalHeaderWidget?: (props: {
+        property: ResolvedProperty;
+        propertyKey: string;
+        onHover: boolean;
+    }) => React.ReactNode;
+    AddColumnComponent?: React.ComponentType;
+    additionalIDHeaderWidget?: React.ReactNode;
+    emptyComponent?: React.ReactNode;
+    getIdColumnWidth?: () => number;
+    onTextSearchClick?: () => void;
+    textSearchLoading?: boolean;
+};
+export type GetPropertyForProps<M extends Record<string, any>> = {
+    propertyKey: string;
+    propertyValue: any;
+    entity: Entity<M>;
+};
+export type PropertyColumnConfig = {
+    key: string;
+    disabled: boolean;
+};

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

@@ -0,0 +1,15 @@
+import { CollectionSize, EntityReference, FilterValues } from "../../../types";
+type TableReferenceFieldProps = {
+    name: string;
+    disabled: boolean;
+    internalValue: EntityReference | EntityReference[] | undefined | null;
+    updateValue: (newValue: (EntityReference | EntityReference[] | null)) => void;
+    size: CollectionSize;
+    multiselect: boolean;
+    previewProperties?: string[];
+    title?: string;
+    path: string;
+    forceFilter?: FilterValues<string>;
+};
+export declare function TableReferenceField(props: TableReferenceFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,33 @@
+import * as React from "react";
+import { Entity, ResolvedArrayProperty, ResolvedStringProperty } from "../../../types";
+import { PreviewSize } from "../../../preview";
+/**
+ * Field that allows to upload files to Google Cloud Storage.
+ *
+ * This is one of the internal components that get mapped natively inside forms
+ * and tables to the specified properties.
+ * @group Form fields
+ */
+export declare function TableStorageUpload(props: {
+    propertyKey: string;
+    error: Error | undefined;
+    disabled: boolean;
+    value: string | string[] | null;
+    updateValue: (newValue: (string | string[] | null)) => void;
+    selected: boolean;
+    focused: boolean;
+    property: ResolvedStringProperty | ResolvedArrayProperty<string[]>;
+    entity: Entity<any>;
+    path: string;
+    previewSize: PreviewSize;
+    openPopup?: (cellRect?: DOMRect) => void;
+    onBlur?: React.FocusEventHandler<HTMLInputElement | HTMLTextAreaElement>;
+}): import("react/jsx-runtime").JSX.Element;
+interface TableStorageItemPreviewProps {
+    property: ResolvedStringProperty;
+    value: string;
+    size: PreviewSize;
+    entity: Entity<any>;
+}
+export declare function TableStorageItemPreview({ property, value, size, entity }: TableStorageItemPreviewProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,9 @@
+import { VirtualTableWhereFilterOp } from "../../VirtualTable";
+interface BooleanFieldProps {
+    name: string;
+    value?: [op: VirtualTableWhereFilterOp, fieldValue: any];
+    setValue: (value?: [op: VirtualTableWhereFilterOp, newValue: any]) => void;
+    title?: string;
+}
+export declare function BooleanFilterField({ name, title, value, setValue }: BooleanFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,11 @@
+import { VirtualTableWhereFilterOp } from "../../VirtualTable";
+interface DateTimeFilterFieldProps {
+    name: string;
+    mode?: "date" | "date_time";
+    value?: [op: VirtualTableWhereFilterOp, fieldValue: any];
+    setValue: (value?: [op: VirtualTableWhereFilterOp, newValue: any]) => void;
+    isArray?: boolean;
+    title?: string;
+}
+export declare function DateTimeFilterField({ name, isArray, mode, value, setValue, title }: DateTimeFilterFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,14 @@
+import { VirtualTableWhereFilterOp } from "../../VirtualTable";
+interface ReferenceFilterFieldProps {
+    name: string;
+    value?: [op: VirtualTableWhereFilterOp, fieldValue: any];
+    setValue: (filterValue?: [VirtualTableWhereFilterOp, any]) => void;
+    isArray?: boolean;
+    path?: string;
+    title?: string;
+    previewProperties?: string[];
+    hidden: boolean;
+    setHidden: (hidden: boolean) => void;
+}
+export declare function ReferenceFilterField({ name, value, setValue, isArray, path, title, previewProperties, setHidden }: ReferenceFilterFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,13 @@
+import { VirtualTableWhereFilterOp } from "../../VirtualTable";
+import { EnumValueConfig } from "../../../types";
+interface StringNumberFilterFieldProps {
+    name: string;
+    dataType: "string" | "number";
+    value?: [op: VirtualTableWhereFilterOp, fieldValue: any];
+    setValue: (value?: [op: VirtualTableWhereFilterOp, newValue: any]) => void;
+    isArray?: boolean;
+    enumValues?: EnumValueConfig[];
+    title?: string;
+}
+export declare function StringNumberFilterField({ name, value, setValue, dataType, isArray, enumValues, title }: StringNumberFilterFieldProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,4 @@
+export { EntityCollectionTable } from "./EntityCollectionTable";
+export type { EntityCollectionTableProps, OnColumnResizeParams } from "./EntityCollectionTableProps";
+export type { UniqueFieldValidator, OnCellValueChange, OnCellValueChangeParams } from "./types";
+export * from "./useEntityCollectionTableController";

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

@@ -0,0 +1,18 @@
+import React from "react";
+import { CollectionSize } from "../../../types";
+interface CollectionTableToolbarProps {
+    size: CollectionSize;
+    filterIsSet: boolean;
+    loading: boolean;
+    forceFilter: boolean;
+    actionsStart?: React.ReactNode;
+    actions?: React.ReactNode;
+    title?: React.ReactNode;
+    onTextSearchClick?: () => void;
+    onTextSearch?: (searchString?: string) => void;
+    onSizeChanged: (size: CollectionSize) => void;
+    clearFilter?: () => void;
+    textSearchLoading?: boolean;
+}
+export declare function CollectionTableToolbar(props: CollectionTableToolbarProps): import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,12 @@
+import { Entity, EntityCallbacks, EntityCollection } from "../../../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/internal/EntityCollectionRowActions.d.ts

@@ -0,0 +1,35 @@
+import React from "react";
+import { CollectionSize, Entity, EntityAction, EntityCollection, SelectionController } from "../../../types";
+/**
+ *
+ * @param entity
+ * @param width
+ * @param frozen
+ * @param isSelected
+ * @param selectionEnabled
+ * @param size
+ * @param toggleEntitySelection
+ * @param onCopyClicked
+ * @param onEditClicked
+ * @param onDeleteClicked
+ * @param hideId
+ * @constructor
+ *
+ * @group Collection components
+ */
+export declare const EntityCollectionRowActions: React.NamedExoticComponent<{
+    entity: Entity<any>;
+    collection?: EntityCollection<any, import("../../../types").User> | undefined;
+    fullPath?: string | undefined;
+    width: number;
+    frozen?: boolean | undefined;
+    size: CollectionSize;
+    isSelected: boolean;
+    selectionEnabled?: boolean | undefined;
+    actions?: EntityAction[] | undefined;
+    hideId?: boolean | undefined;
+    onCollectionChange?: (() => void) | undefined;
+    selectionController?: SelectionController | undefined;
+    highlightEntity?: ((entity: Entity<any>) => void) | undefined;
+    unhighlightEntity?: ((entity: Entity<any>) => void) | undefined;
+}>;

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

@@ -0,0 +1,26 @@
+import React from "react";
+import { VirtualTableSize } from "../../VirtualTable";
+interface EntityTableCellProps {
+    children: React.ReactNode;
+    actions?: React.ReactNode;
+    /**
+     * The value is used only to check changes and force re-renders
+     */
+    value?: any;
+    disabled: boolean;
+    saved?: boolean;
+    error?: Error;
+    allowScroll?: boolean;
+    align: "right" | "left" | "center";
+    size: VirtualTableSize;
+    disabledTooltip?: string;
+    width: number;
+    showExpandIcon?: boolean;
+    removePadding?: boolean;
+    fullHeight?: boolean;
+    selected?: boolean;
+    hideOverflow?: boolean;
+    onSelect?: (cellRect: DOMRect | undefined) => void;
+}
+export declare const EntityTableCell: React.FunctionComponent<EntityTableCellProps>;
+export {};

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

@@ -0,0 +1,9 @@
+export interface EntityTableCellActionsProps {
+    showError: false | Error | undefined;
+    disabled: boolean;
+    showExpandIcon: boolean | undefined;
+    selected: boolean | undefined;
+    openPopup?: (cellRect: DOMRect | undefined) => void;
+    children?: React.ReactNode;
+}
+export declare function EntityTableCellActions({ showError, disabled, showExpandIcon, selected, openPopup, children }: EntityTableCellActionsProps): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,18 @@
+import React from "react";
+import { CMSType, Entity, ResolvedProperty } from "../../../types";
+import { CustomFieldValidator } from "../../../form/validation";
+export interface PropertyTableCellProps<T extends CMSType, M extends Record<string, any>> {
+    propertyKey: string;
+    columnIndex: number;
+    align: "right" | "left" | "center";
+    customFieldValidator?: CustomFieldValidator;
+    value: T;
+    readonly: boolean;
+    property: ResolvedProperty<T>;
+    height: number;
+    width: number;
+    entity: Entity<any>;
+    path: string;
+    disabled: boolean;
+}
+export declare const PropertyTableCell: React.FunctionComponent<PropertyTableCellProps<any, any>>;

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

@@ -0,0 +1,4 @@
+import { EntityCollection, Property, ResolvedProperty } from "../../../types";
+export declare function getTableCellAlignment(property: Property | ResolvedProperty): "right" | "left" | "center";
+export declare function getTablePropertyColumnWidth(property: ResolvedProperty): number;
+export declare function getSubcollectionColumnId(collection: EntityCollection): string;

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

@@ -0,0 +1,6 @@
+import { EntityAction } from "../../../types";
+export declare const editEntityAction: EntityAction;
+export declare const copyEntityAction: EntityAction;
+export declare const archiveEntityAction: EntityAction;
+export declare const openWebsiteAction: EntityAction;
+export declare const deleteEntityAction: EntityAction;

package/dist/components/EntityCollectionTable/internal/popup_field/ElementResizeListener.d.ts

@@ -0,0 +1,5 @@
+interface Props {
+    onResize: (event: Event) => void;
+}
+export declare const ElementResizeListener: React.FC<Props>;
+export {};

package/dist/components/EntityCollectionTable/internal/popup_field/PopupFormField.d.ts

@@ -0,0 +1,23 @@
+import { Entity, EntityCollection } from "../../../../types";
+import { CustomFieldValidator } from "../../../../form/validation";
+import { OnCellValueChangeParams } from "../../../../components";
+interface PopupFormFieldProps<M extends Record<string, any>> {
+    entity?: Entity<M>;
+    customFieldValidator?: CustomFieldValidator;
+    path: string;
+    tableKey: string;
+    propertyKey?: Extract<keyof M, string>;
+    collection?: EntityCollection<M>;
+    cellRect?: DOMRect;
+    open: boolean;
+    onClose: () => void;
+    container: HTMLElement | null;
+    /**
+     * Callback when the value of a cell has been edited
+     * @param params
+     */
+    onCellValueChange?: (params: OnCellValueChangeParams<any, M>) => Promise<void>;
+}
+export declare function PopupFormField<M extends Record<string, any>>(props: PopupFormFieldProps<M>): import("react/jsx-runtime").JSX.Element | null;
+export declare function PopupFormFieldInternal<M extends Record<string, any>>({ tableKey, entity: entityProp, customFieldValidator, propertyKey, collection: inputCollection, path, cellRect, open, onClose, onCellValueChange, container }: PopupFormFieldProps<M>): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/EntityCollectionTable/internal/popup_field/useDraggable.d.ts

@@ -0,0 +1,13 @@
+import React from "react";
+interface DraggableProps {
+    containerRef: React.RefObject<HTMLDivElement>;
+    innerRef: React.RefObject<HTMLDivElement>;
+    x?: number;
+    y?: number;
+    onMove: (params: {
+        x: number;
+        y: number;
+    }) => void;
+}
+export declare function useDraggable({ containerRef, innerRef, x, y, onMove }: DraggableProps): void;
+export {};

package/dist/components/EntityCollectionTable/internal/popup_field/useWindowSize.d.ts

@@ -0,0 +1,6 @@
+interface WindowSize {
+    width: number;
+    height: number;
+}
+export declare function useWindowSize(): WindowSize;
+export {};

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

@@ -0,0 +1,39 @@
+import { CollectionSize, Entity, FireCMSContext, ResolvedProperty, SelectedCellProps } from "../../types";
+export type EntityCollectionTableController<M extends Record<string, any>> = {
+    selectedCell?: SelectedCellProps<any>;
+    select: (cell?: SelectedCellProps<M>) => void;
+    setPopupCell?: (cell?: SelectedCellProps<M>) => void;
+    onValueChange?: (params: OnCellValueChangeParams<any, M>) => void;
+    selectedEntityIds?: string[];
+    /**
+     * 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, M extends Record<string, any>> {
+    value: T;
+    propertyKey: string;
+    entity: Entity<M>;
+    onValueUpdated: () => void;
+    setError: (e: Error) => void;
+    fullPath: string;
+    context: FireCMSContext;
+}
+/**
+ * @group Collection components
+ */
+export type UniqueFieldValidator = (props: {
+    name: string;
+    value: any;
+    property: ResolvedProperty;
+    entityId?: string;
+}) => Promise<boolean>;
+/**
+ * Callback when a cell has changed in a table
+ * @group Collection components
+ */
+export type OnCellValueChange<T, M extends Record<string, any>> = (params: OnCellValueChangeParams<T, M>) => Promise<void>;

package/dist/components/EntityCollectionTable/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: any, timeoutMs?: number): T[];

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

@@ -0,0 +1,21 @@
+import { Entity, EntityCollection, FilterValues, TableController, User } from "../../types";
+export type EntityCollectionTableControllerProps<M extends Record<string, any> = any> = {
+    fullPath: string;
+    collection: EntityCollection<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;
+    forceFilter?: FilterValues<string>;
+};
+/**
+ * Use this hook to build a controller for the {@link EntityCollectionTable}
+ * @param fullPath
+ * @param collection
+ * @param entitiesDisplayedFirst
+ * @param lastDeleteTimestamp
+ * @param forceFilterFromProps
+ */
+export declare function useEntityCollectionTableController<M extends Record<string, any> = any, UserType extends User = User>({ fullPath, collection, entitiesDisplayedFirst, lastDeleteTimestamp, forceFilter: forceFilterFromProps, }: EntityCollectionTableControllerProps<M>): TableController<M>;

package/dist/components/EntityCollectionView/EntityCollectionView.d.ts

@@ -0,0 +1,37 @@
+import React from "react";
+import { EntityCollection, SelectionController } from "../../types";
+/**
+ * @group Components
+ */
+export type EntityCollectionViewProps<M extends Record<string, any>> = {
+    fullPath: string;
+    parentCollectionIds?: string[];
+    isSubCollection?: boolean;
+    className?: string;
+} & EntityCollection<M>;
+/**
+ * This component is in charge of binding a datasource path with an {@link EntityCollection}
+ * where it's configuration is defined. It includes an infinite scrolling table
+ * and a 'Add' new entities button,
+ *
+ * This component is the default one used for displaying entity collections
+ * and is in charge of generating all the specific actions and customization
+ * of the lower level {@link EntityCollectionTable}
+ *
+ * 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 need a lower level implementation with more granular options, you
+ * can use {@link EntityCollectionTable}.
+ *
+ * If you need a generic table that is not bound to the datasource or entities and
+ * properties at all, you can check {@link VirtualTable}
+ *
+ * @param fullPath
+ * @param collection
+ * @constructor
+ * @group Components
+ */
+export declare const EntityCollectionView: React.FunctionComponent<EntityCollectionViewProps<any>>;
+export declare function useSelectionController<M extends Record<string, any>>(): SelectionController<M>;

package/dist/components/EntityCollectionView/EntityCollectionViewActions.d.ts

@@ -0,0 +1,14 @@
+import { EntityCollection, SelectionController, TableController } from "../../types";
+export type EntityCollectionViewActionsProps<M extends Record<string, any>> = {
+    collection: EntityCollection<M>;
+    path: string;
+    relativePath: string;
+    parentCollectionIds: string[];
+    selectionEnabled: boolean;
+    onNewClick: () => void;
+    onMultipleDeleteClick: () => void;
+    selectionController: SelectionController<M>;
+    tableController: TableController<M>;
+    collectionEntitiesCount: number;
+};
+export declare function EntityCollectionViewActions<M extends Record<string, any>>({ collection, relativePath, parentCollectionIds, onNewClick, onMultipleDeleteClick, selectionEnabled, path, selectionController, tableController, collectionEntitiesCount }: EntityCollectionViewActionsProps<M>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,4 @@
+import { ResolvedEntityCollection, ResolvedProperty } from "../../types";
+import { PropertyColumnConfig } from "../EntityCollectionTable/EntityCollectionTableProps";
+export declare function useColumnIds<M extends Record<string, any>>(collection: ResolvedEntityCollection<M>, includeSubcollections: boolean): PropertyColumnConfig[];
+export declare function getColumnKeysForProperty(property: ResolvedProperty, key: string, disabled?: boolean): PropertyColumnConfig[];