@firecms/core 3.0.0-alpha.8 → 3.0.0-alpha.80

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

@@ -0,0 +1,53 @@
+import { CollectionSize, Entity, FireCMSContext, ResolvedProperty, SelectedCellProps } from "../../types";
+export type EntityCollectionTableController<M extends Record<string, any>> = {
+    /**
+     * This cell is displayed as selected
+     */
+    selectedCell?: SelectedCellProps<any>;
+    /**
+     * 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<any, 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 = any, M extends Record<string, any> = 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> | void;

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

@@ -0,0 +1,32 @@
+import { Entity, EntityCollection, FilterValues, EntityTableController, User } from "../../types";
+export type DataSourceEntityCollectionTableControllerProps<M extends Record<string, any> = any> = {
+    /**
+     * Full path where the data of this table is located
+     */
+    fullPath: string;
+    /**
+     * The collection that is represented by this config.
+     */
+    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}.
+ * This controller is bound to data in a path in your specified datasource.
+ *
+ * Note that you can build your own hook returning a {@link EntityTableController}
+ * if you would like to display different data.
+ *
+ * @param fullPath
+ * @param collection
+ * @param entitiesDisplayedFirst
+ * @param lastDeleteTimestamp
+ * @param forceFilterFromProps
+ */
+export declare function useDataSourceEntityCollectionTableController<M extends Record<string, any> = any, UserType extends User = User>({ fullPath, collection, entitiesDisplayedFirst, lastDeleteTimestamp, forceFilter: forceFilterFromProps, }: DataSourceEntityCollectionTableControllerProps<M>): EntityTableController<M>;

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/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, EntityTableController } 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: EntityTableController<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[];

package/dist/components/EntityPreview.d.ts

@@ -0,0 +1,11 @@
+import { Entity, EntityCollection } from "../types";
+/**
+ * @group Components
+ */
+export interface EntityPreviewProps<M extends Record<string, any>> {
+    entity: Entity<M>;
+    collection: EntityCollection<M>;
+    path: string;
+    className?: string;
+}
+export declare function EntityPreview<M extends Record<string, any>>({ entity, collection, path, className }: EntityPreviewProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/components/ErrorBoundary.d.ts

@@ -0,0 +1,11 @@
+import React, { ErrorInfo, PropsWithChildren } from "react";
+export declare class ErrorBoundary extends React.Component<PropsWithChildren<Record<string, unknown>>, {
+    error: Error | null;
+}> {
+    constructor(props: any);
+    static getDerivedStateFromError(error: Error): {
+        error: Error;
+    };
+    componentDidCatch(error: Error, errorInfo: ErrorInfo): void;
+    render(): string | number | boolean | Iterable<React.ReactNode> | import("react/jsx-runtime").JSX.Element | null | undefined;
+}

package/dist/components/ErrorTooltip.d.ts

@@ -0,0 +1,2 @@
+import { TooltipProps } from "@firecms/ui";
+export declare function ErrorTooltip(props: TooltipProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/ErrorView.d.ts

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

package/dist/components/FieldConfigBadge.d.ts

@@ -0,0 +1,4 @@
+import { PropertyConfig } from "../types";
+export declare function FieldConfigBadge({ propertyConfig }: {
+    propertyConfig: PropertyConfig | undefined;
+}): React.ReactNode;

package/dist/components/FireCMSAppBar.d.ts

@@ -0,0 +1,26 @@
+import React from "react";
+import { User } from "../types";
+export type FireCMSAppBarProps<ADDITIONAL_PROPS = object> = {
+    title: string;
+    /**
+     * A component that gets rendered on the upper side of the main toolbar
+     */
+    endAdornment?: React.ReactNode;
+    startAdornment?: React.ReactNode;
+    dropDownActions?: React.ReactNode;
+    includeDrawer?: boolean;
+    drawerOpen: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    user?: User;
+} & ADDITIONAL_PROPS;
+/**
+ * This component renders the main app bar of FireCMS.
+ * You will likely not need to use this component directly.
+ *
+ * @param title
+ * @param toolbarExtraWidget
+ * @param drawerOpen
+ * @constructor
+ */
+export declare const FireCMSAppBar: ({ title, endAdornment, startAdornment, drawerOpen, dropDownActions, includeDrawer, className, style, user: userProp }: FireCMSAppBarProps) => import("react/jsx-runtime").JSX.Element;

package/dist/components/FireCMSLogo.d.ts

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

package/dist/components/HomePage/DefaultHomePage.d.ts

@@ -0,0 +1,21 @@
+import React from "react";
+/**
+ * Default entry view for the CMS. This component renders navigation cards
+ * for each collection defined in the navigation.
+ * @constructor
+ * @group Components
+ */
+export declare function DefaultHomePage({ additionalActions, additionalChildrenStart, additionalChildrenEnd }: {
+    /**
+     * Additional actions to be rendered in the home page, close to the search bar.
+     */
+    additionalActions?: React.ReactNode;
+    /**
+     * Additional children to be rendered in the beginning of the home page.
+     */
+    additionalChildrenStart?: React.ReactNode;
+    /**
+     * Additional children to be rendered at the end of the home page.
+     */
+    additionalChildrenEnd?: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/HomePage/FavouritesView.d.ts

@@ -0,0 +1,3 @@
+export declare function FavouritesView({ hidden }: {
+    hidden: boolean;
+}): import("react/jsx-runtime").JSX.Element | null;

package/dist/components/HomePage/NavigationCollectionCard.d.ts

@@ -0,0 +1,17 @@
+import { TopNavigationEntry } from "../../types";
+/**
+ * This is the component used in the home page to render a card for each
+ * collection.
+ * @group Components
+ * @param view
+ * @param path
+ * @param collection
+ * @param url
+ * @param name
+ * @param description
+ * @param onClick
+ * @constructor
+ */
+export declare function NavigationCollectionCard({ view, path, collection, url, name, description, onClick }: TopNavigationEntry & {
+    onClick?: () => void;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/components/HomePage/NavigationGroup.d.ts

@@ -0,0 +1,4 @@
+import { PropsWithChildren } from "react";
+export declare function NavigationGroup({ children, group }: PropsWithChildren<{
+    group: string | undefined;
+}>): import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,3 @@
+export * from "./DefaultHomePage";
+export * from "./NavigationCollectionCard";
+export * from "./NavigationGroup";

package/dist/components/LabelWithIcon.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+interface LabelWithIconProps {
+    icon: React.ReactNode;
+    title?: string;
+    small?: boolean;
+    className?: string;
+    required?: boolean;
+}
+/**
+ * Render the label of with an icon and the title of a property
+ * @group Form custom fields
+ */
+export declare function LabelWithIcon({ icon, title, small, className, required }: LabelWithIconProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/NotFoundPage.d.ts

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

package/dist/components/ReferenceSelectionInner.d.ts

@@ -0,0 +1,58 @@
+import React from "react";
+import { Entity, EntityCollection, FilterValues } from "../types";
+/**
+ * @group Components
+ */
+export interface ReferenceSelectionInnerProps<M extends Record<string, any>> {
+    /**
+     * Allow multiple selection of values
+     */
+    multiselect?: boolean;
+    /**
+     * Entity collection config
+     */
+    collection?: EntityCollection<M>;
+    /**
+     * Absolute path of the collection.
+     * May be not set if this hook is being used in a component and the path is
+     * dynamic. If not set, the dialog won't open.
+     */
+    path: string;
+    /**
+     * If you are opening the dialog for the first time, you can select some
+     * entity ids to be displayed first.
+     */
+    selectedEntityIds?: string[];
+    /**
+     * If `multiselect` is set to `false`, you will get the selected entity
+     * in this callback.
+     * @param entity
+     * @callback
+     */
+    onSingleEntitySelected?(entity: Entity<any> | null): void;
+    /**
+     * If `multiselect` is set to `true`, you will get the selected entities
+     * in this callback.
+     * @param entities
+     * @callback
+     */
+    onMultipleEntitiesSelected?(entities: Entity<any>[]): void;
+    /**
+     * Allow selection of entities that pass the given filter only.
+     */
+    forceFilter?: FilterValues<string>;
+    /**
+     * Use this description to indicate the user what to do in this dialog.
+     */
+    description?: React.ReactNode;
+    /**
+     * Maximum number of entities that can be selected.
+     */
+    maxSelection?: number;
+}
+/**
+ * This component allows to select entities from a given collection.
+ * You probably want to open this dialog as a side view using {@link useReferenceDialog}
+ * @group Components
+ */
+export declare function ReferenceSelectionInner<M extends Record<string, any>>({ onSingleEntitySelected, onMultipleEntitiesSelected, multiselect, collection, path: pathInput, selectedEntityIds: selectedEntityIdsProp, description, forceFilter, maxSelection }: ReferenceSelectionInnerProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/components/ReferenceWidget.d.ts

@@ -0,0 +1,28 @@
+import { Entity, EntityReference, FilterValues } from "../types";
+import { PreviewSize } from "../preview";
+export type ReferenceWidgetProps<M extends Record<string, any>> = {
+    name?: string;
+    multiselect?: boolean;
+    value: EntityReference<M> | EntityReference<M>[] | null;
+    onReferenceSelected?: (params: {
+        reference: EntityReference<M> | null;
+        entity: Entity<M> | null;
+    }) => void;
+    onMultipleReferenceSelected?: (params: {
+        references: EntityReference<M>[] | null;
+        entities: Entity<M>[] | null;
+    }) => void;
+    path: string;
+    disabled?: boolean;
+    previewProperties?: string[];
+    /**
+     * Allow selection of entities that pass the given filter only.
+     */
+    forceFilter?: FilterValues<string>;
+    size: PreviewSize;
+    className?: string;
+};
+/**
+ * This field allows selecting reference/s.
+ */
+export declare function ReferenceWidget<M extends Record<string, any>>({ name, multiselect, path, disabled, value, onReferenceSelected, onMultipleReferenceSelected, previewProperties, forceFilter, size, className }: ReferenceWidgetProps<M>): import("react/jsx-runtime").JSX.Element;

package/dist/components/SearchIconsView.d.ts

@@ -0,0 +1,5 @@
+export interface SearchIconsProps {
+    selectedIcon?: string;
+    onIconSelected?: (icon: string) => void;
+}
+export declare function SearchIconsView({ selectedIcon, onIconSelected }: SearchIconsProps): import("react/jsx-runtime").JSX.Element;

package/dist/components/VirtualTable/VirtualTable.d.ts

@@ -0,0 +1,11 @@
+import React from "react";
+import { VirtualTableProps } from "./VirtualTableProps";
+/**
+ * This is a Table component that allows displaying arbitrary data, not
+ * necessarily related to entities or properties. It is the component
+ * that powers the entity collections but has a generic API, so it
+ * can be reused.
+ *
+ * @group Components
+ */
+export declare const VirtualTable: React.NamedExoticComponent<VirtualTableProps<any>>;

package/dist/components/VirtualTable/VirtualTableCell.d.ts

@@ -0,0 +1,14 @@
+import React from "react";
+import { CellRendererParams, VirtualTableColumn } from "./VirtualTableProps";
+type VirtualTableCellProps<T extends any> = {
+    dataKey: string;
+    column: VirtualTableColumn;
+    columns: VirtualTableColumn[];
+    rowData: any;
+    cellData: any;
+    rowIndex: any;
+    columnIndex: number;
+    cellRenderer: React.ComponentType<CellRendererParams<T>>;
+};
+export declare const VirtualTableCell: React.NamedExoticComponent<VirtualTableCellProps<any>>;
+export {};

package/dist/components/VirtualTable/VirtualTableHeader.d.ts

@@ -0,0 +1,27 @@
+import React, { RefObject } from "react";
+import { VirtualTableColumn, VirtualTableSort, VirtualTableWhereFilterOp } from "./VirtualTableProps";
+export type FilterFormFieldProps<CustomProps> = {
+    id: React.Key;
+    filterValue: [VirtualTableWhereFilterOp, any] | undefined;
+    setFilterValue: (filterValue?: [VirtualTableWhereFilterOp, any]) => void;
+    column: VirtualTableColumn<CustomProps>;
+    hidden: boolean;
+    setHidden: (hidden: boolean) => void;
+};
+type VirtualTableHeaderProps<M extends Record<string, any>> = {
+    resizeHandleRef: RefObject<HTMLDivElement>;
+    columnIndex: number;
+    isResizingIndex: number;
+    column: VirtualTableColumn<any>;
+    onColumnSort: (key: Extract<keyof M, string>) => void;
+    filter?: [VirtualTableWhereFilterOp, any];
+    sort: VirtualTableSort;
+    onFilterUpdate: (column: VirtualTableColumn, filterForProperty?: [VirtualTableWhereFilterOp, any]) => void;
+    onClickResizeColumn?: (columnIndex: number, column: VirtualTableColumn) => void;
+    createFilterField?: (props: FilterFormFieldProps<any>) => React.ReactNode;
+    AdditionalHeaderWidget?: (props: {
+        onHover: boolean;
+    }) => React.ReactNode;
+};
+export declare const VirtualTableHeader: React.FunctionComponent<VirtualTableHeaderProps<any>>;
+export {};

package/dist/components/VirtualTable/VirtualTableHeaderRow.d.ts

@@ -0,0 +1,2 @@
+import { VirtualTableContextProps } from "./types";
+export declare const VirtualTableHeaderRow: ({ columns, currentSort, onColumnSort, onFilterUpdate, sortByProperty, filter, onColumnResize, onColumnResizeEnd, createFilterField, AddColumnComponent }: VirtualTableContextProps<any>) => import("react/jsx-runtime").JSX.Element;