@ynput/ayon-frontend-shared 0.1.0

package/dist/types/containers/ProjectTreeTable/components/HeaderActionButton.d.ts

@@ -0,0 +1,6 @@
+import { ButtonProps } from '@ynput/ayon-react-components';
+import { FC } from 'react';
+interface HeaderActionButtonProps extends ButtonProps {
+}
+declare const HeaderActionButton: FC<HeaderActionButtonProps>;
+export default HeaderActionButton;

package/dist/types/containers/ProjectTreeTable/components/RowSelectionHeader.d.ts

@@ -0,0 +1,3 @@
+import { default as React } from 'react';
+declare const _default: React.NamedExoticComponent<{}>;
+export default _default;

package/dist/types/containers/ProjectTreeTable/components/SelectionCell.d.ts

@@ -0,0 +1,5 @@
+interface SelectionCellProps extends React.HTMLAttributes<HTMLDivElement> {
+    isSelected?: boolean;
+}
+export declare const SelectionCell: import('react').ForwardRefExoticComponent<SelectionCellProps & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/containers/ProjectTreeTable/context/CellEditingContext.d.ts

@@ -0,0 +1,18 @@
+import { default as React, ReactNode } from 'react';
+import { CellId } from '../utils/cellUtils';
+import { InheritFromParent, UpdateTableEntities } from '../hooks/useUpdateOverview';
+export interface CellEditingContextType {
+    editingCellId: CellId | null;
+    setEditingCellId: (id: CellId | null) => void;
+    isEditing: (id: CellId) => boolean;
+    updateEntities: UpdateTableEntities;
+    inheritFromParent: InheritFromParent;
+    undo: () => Promise<void>;
+    redo: () => Promise<void>;
+    canUndo: boolean;
+    canRedo: boolean;
+}
+export declare const CellEditingProvider: React.FC<{
+    children: ReactNode;
+}>;
+export declare const useCellEditing: () => CellEditingContextType;

package/dist/types/containers/ProjectTreeTable/context/ClipboardContext.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+import { ClipboardContextType, ClipboardProviderProps } from './clipboard/clipboardTypes';
+export declare const ClipboardProvider: React.FC<ClipboardProviderProps>;
+export declare const useClipboard: () => ClipboardContextType;

package/dist/types/containers/ProjectTreeTable/context/ColumnSettingsContext.d.ts

@@ -0,0 +1,30 @@
+import { default as React, ReactNode } from 'react';
+import { ColumnOrderState, ColumnPinningState, OnChangeFn, VisibilityState } from '@tanstack/react-table';
+export interface ColumnSettingsContextType {
+    columnVisibility: VisibilityState;
+    setColumnVisibility: (columnVisibility: VisibilityState) => void;
+    updateColumnVisibility: (columnVisibility: VisibilityState) => void;
+    columnVisibilityUpdater: OnChangeFn<VisibilityState>;
+    columnPinning: ColumnPinningState;
+    setColumnPinning: (columnPinning: ColumnPinningState) => void;
+    updateColumnPinning: (columnPinning: ColumnPinningState) => void;
+    columnPinningUpdater: OnChangeFn<ColumnPinningState>;
+    columnOrder: ColumnOrderState;
+    setColumnOrder: (columnOrder: ColumnOrderState) => void;
+    updateColumnOrder: (columnOrder: ColumnOrderState) => void;
+    columnOrderUpdater: OnChangeFn<ColumnOrderState>;
+    setColumnsConfig: (config: ColumnsConfig) => void;
+}
+export type ColumnsConfig = {
+    columnVisibility: VisibilityState;
+    columnOrder: ColumnOrderState;
+    columnPinning: ColumnPinningState;
+};
+interface ColumnSettingsProviderProps {
+    children: ReactNode;
+    config: Record<string, any>;
+    onChange: (config: ColumnsConfig) => void;
+}
+export declare const ColumnSettingsProvider: React.FC<ColumnSettingsProviderProps>;
+export declare const useColumnSettings: () => ColumnSettingsContextType;
+export {};

package/dist/types/containers/ProjectTreeTable/context/ProjectTableContext.d.ts

@@ -0,0 +1,76 @@
+import { ReactNode } from 'react';
+import { ExpandedState, OnChangeFn, SortingState } from '@tanstack/react-table';
+import { Filter } from '@ynput/ayon-react-components';
+import { EditorTaskNode, FolderNodeMap, MatchingFolder, TableRow, TaskNodeMap, TasksByFolderMap } from '../types/table';
+import { FindInheritedValueFromAncestors, GetAncestorsOf, GetInheritedDependents, FindNonInheritedValues } from '../hooks/useFolderRelationships';
+import { RowId } from '../utils/cellUtils';
+import { ProjectModel } from '../types/project';
+import { AttributeWithPermissions, LoadingTasks } from '../types';
+import { QueryFilter } from '../types/folders';
+type User = {
+    name: string;
+    fullName?: string;
+};
+export interface ProjectTableContextProps {
+    isInitialized: ProjectTableProviderProps['isInitialized'];
+    isLoading: ProjectTableProviderProps['isLoading'];
+    projectInfo: ProjectTableProviderProps['projectInfo'];
+    projectName: ProjectTableProviderProps['projectName'];
+    users: ProjectTableProviderProps['users'];
+    attribFields: ProjectTableProviderProps['attribFields'];
+    tableData: TableRow[];
+    tasksMap: ProjectTableProviderProps['tasksMap'];
+    foldersMap: ProjectTableProviderProps['foldersMap'];
+    fetchNextPage: ProjectTableProviderProps['fetchNextPage'];
+    reloadTableData: ProjectTableProviderProps['reloadTableData'];
+    getEntityById: (id: string) => MatchingFolder | EditorTaskNode | undefined;
+    filters: ProjectTableProviderProps['filters'];
+    setFilters: ProjectTableProviderProps['setFilters'];
+    queryFilters: ProjectTableProviderProps['queryFilters'];
+    showHierarchy: ProjectTableProviderProps['showHierarchy'];
+    updateShowHierarchy: ProjectTableProviderProps['updateShowHierarchy'];
+    expanded: ProjectTableProviderProps['expanded'];
+    toggleExpanded: ProjectTableProviderProps['toggleExpanded'];
+    updateExpanded: ProjectTableProviderProps['updateExpanded'];
+    toggleExpandAll: (rowId: RowId[], expand?: boolean) => void;
+    sorting: ProjectTableProviderProps['sorting'];
+    updateSorting: ProjectTableProviderProps['updateSorting'];
+    getInheritedDependents: GetInheritedDependents;
+    findInheritedValueFromAncestors: FindInheritedValueFromAncestors;
+    findNonInheritedValues: FindNonInheritedValues;
+    getAncestorsOf: GetAncestorsOf;
+}
+export interface ProjectTableProviderProps {
+    children: ReactNode;
+    isInitialized: boolean;
+    isLoading: boolean;
+    isLoadingMore: boolean;
+    loadingTasks: LoadingTasks;
+    projectInfo?: ProjectModel;
+    projectName: string;
+    users: User[];
+    attribFields: AttributeWithPermissions[];
+    tasksMap: TaskNodeMap;
+    foldersMap: FolderNodeMap;
+    tasksByFolderMap: TasksByFolderMap;
+    fetchNextPage: () => void;
+    reloadTableData: () => void;
+    filters: Filter[];
+    setFilters: (filters: Filter[]) => void;
+    queryFilters: {
+        filter: QueryFilter | undefined;
+        filterString?: string;
+        search: string | undefined;
+    };
+    showHierarchy: boolean;
+    updateShowHierarchy: (showHierarchy: boolean) => void;
+    expanded: ExpandedState;
+    toggleExpanded: (id: string) => void;
+    updateExpanded: OnChangeFn<ExpandedState>;
+    setExpanded: (expanded: ExpandedState) => void;
+    sorting: SortingState;
+    updateSorting: OnChangeFn<SortingState>;
+}
+export declare const ProjectTableProvider: ({ children, foldersMap, tasksMap, tasksByFolderMap, expanded, projectInfo, showHierarchy, loadingTasks, isLoadingMore, isLoading, isInitialized, projectName, users, attribFields, filters, setFilters, queryFilters, updateShowHierarchy, toggleExpanded, updateExpanded, sorting, updateSorting, fetchNextPage, reloadTableData, setExpanded, }: ProjectTableProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useProjectTableContext: () => ProjectTableContextProps;
+export {};

package/dist/types/containers/ProjectTreeTable/context/ProjectTableQueriesContext.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+import { OperationModel, OperationsRequestModel } from '../types/operations';
+import { PatchOperation } from '../types';
+export interface ProjectTableQueriesContextProps {
+    updateEntities: ProjectTableQueriesProviderProps['updateEntities'];
+    getFoldersTasks: ProjectTableQueriesProviderProps['getFoldersTasks'];
+}
+export interface ProjectTableQueriesProviderProps {
+    children: ReactNode;
+    updateEntities: ({ operations, }: {
+        operations: OperationModel[];
+        patchOperations?: PatchOperation[];
+    }) => Promise<OperationsRequestModel | undefined>;
+    getFoldersTasks: (args: {
+        parentIds: string[];
+        filter?: string;
+        search?: string;
+    }, force?: boolean) => Promise<any>;
+}
+export declare const ProjectTableQueriesProvider: ({ children, updateEntities, getFoldersTasks, }: ProjectTableQueriesProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useProjectTableQueriesContext: () => ProjectTableQueriesContextProps;

package/dist/types/containers/ProjectTreeTable/context/SelectedRowsContext.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export interface SelectedRowsContextProps {
+    selectedRows: string[];
+    isRowSelected: (rowId: string) => boolean;
+    clearRowsSelection: () => void;
+    selectAllRows: () => void;
+    areAllRowsSelected: () => boolean;
+    areSomeRowsSelected: () => boolean;
+}
+interface SelectedRowsProviderProps {
+    children: ReactNode;
+}
+export declare const SelectedRowsProvider: ({ children }: SelectedRowsProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useSelectedRowsContext: () => SelectedRowsContextProps;
+export {};

package/dist/types/containers/ProjectTreeTable/context/SelectionContext.d.ts

@@ -0,0 +1,35 @@
+import { default as React, ReactNode } from 'react';
+import { CellId, RowId, ColId, CellPosition } from '../utils/cellUtils';
+export declare const ROW_SELECTION_COLUMN_ID = "__row_selection__";
+export interface GridMap {
+    rowIdToIndex: Map<RowId, number>;
+    colIdToIndex: Map<ColId, number>;
+    indexToRowId: Map<number, RowId>;
+    indexToColId: Map<number, ColId>;
+}
+export interface SelectionContextType {
+    selectedCells: Set<CellId>;
+    focusedCellId: CellId | null;
+    selectionInProgress: boolean;
+    anchorCell: CellPosition | null;
+    gridMap: GridMap;
+    selectedRows: string[];
+    setSelectedCells: React.Dispatch<React.SetStateAction<Set<CellId>>>;
+    setFocusedCellId: React.Dispatch<React.SetStateAction<CellId | null>>;
+    setAnchorCell: React.Dispatch<React.SetStateAction<CellPosition | null>>;
+    registerGrid: (rows: RowId[], columns: ColId[]) => void;
+    selectCell: (cellId: CellId, additive: boolean, range: boolean) => void;
+    startSelection: (cellId: CellId, additive: boolean) => void;
+    extendSelection: (cellId: CellId, isRowSelectionColumn?: boolean) => void;
+    endSelection: (cellId: CellId) => void;
+    focusCell: (cellId: CellId | null) => void;
+    clearSelection: () => void;
+    isCellSelected: (cellId: CellId) => boolean;
+    isCellFocused: (cellId: CellId) => boolean;
+    getCellPositionFromId: (cellId: CellId) => CellPosition | null;
+    getCellBorderClasses: (cellId: CellId) => string[];
+}
+export declare const SelectionProvider: React.FC<{
+    children: ReactNode;
+}>;
+export declare const useSelectionContext: () => SelectionContextType;

package/dist/types/containers/ProjectTreeTable/context/clipboard/clipboardTypes.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode } from 'react';
+import { FolderNodeMap, TaskNodeMap } from '../../types/table';
+import { AttributeEnumItem, BuiltInFieldOptions } from '../../types';
+export declare const builtInFieldMappings: {
+    status: string;
+    folderType: string;
+    taskType: string;
+};
+export interface ColumnEnums extends BuiltInFieldOptions {
+    [attrib: string]: AttributeEnumItem[];
+}
+export interface ClipboardContextType {
+    copyToClipboard: (selected?: string[], fullRow?: boolean) => Promise<void>;
+    pasteFromClipboard: (selected?: string[]) => Promise<void>;
+    exportCSV: (selected: string[], projectName: string, fullRow?: boolean) => void;
+}
+export interface ClipboardProviderProps {
+    children: ReactNode;
+    foldersMap: FolderNodeMap;
+    tasksMap: TaskNodeMap;
+    columnEnums: ColumnEnums;
+    columnReadOnly: string[];
+}
+export interface ParsedClipboardData {
+    values: string[];
+    colIds: string[];
+}

package/dist/types/containers/ProjectTreeTable/context/clipboard/clipboardUtils.d.ts

@@ -0,0 +1,6 @@
+import { FolderNodeMap, TaskNodeMap } from '../../types/table';
+import { ParsedClipboardData } from './clipboardTypes';
+export declare const clipboardError: (error: string) => import('react-toastify').Id;
+export declare const parseClipboardText: (clipboardText: string) => ParsedClipboardData[];
+export declare const getEntityPath: (entityId: string, isFolder: boolean, foldersMap: FolderNodeMap, tasksMap: TaskNodeMap) => string;
+export declare const processFieldValue: (value: string, fieldValueType: "string" | "number" | "boolean" | "array") => any;

package/dist/types/containers/ProjectTreeTable/context/clipboard/clipboardValidation.d.ts

@@ -0,0 +1,12 @@
+import { ColumnEnums, ParsedClipboardData } from './clipboardTypes';
+export declare const validateClipboardData: (params: {
+    colId: string;
+    isFolder: boolean;
+    pasteValue: string;
+    parsedData: ParsedClipboardData[];
+    columnEnums: ColumnEnums;
+    columnReadOnly: string[];
+    rowIndex: number;
+    colIndex: number;
+    isSingleCellValue: boolean;
+}) => boolean;

package/dist/types/containers/ProjectTreeTable/context/clipboard/index.d.ts

@@ -0,0 +1,3 @@
+export * from './clipboardTypes';
+export * from './clipboardUtils';
+export * from './clipboardValidation';

package/dist/types/containers/ProjectTreeTable/context/index.d.ts

@@ -0,0 +1,8 @@
+export * from './clipboard';
+export * from './CellEditingContext';
+export * from './ClipboardContext';
+export * from './ColumnSettingsContext';
+export * from './ProjectTableContext';
+export * from './ProjectTableQueriesContext';
+export * from './SelectedRowsContext';
+export * from './SelectionContext';

package/dist/types/containers/ProjectTreeTable/hooks/useCellContextMenu.d.ts

@@ -0,0 +1,10 @@
+import { AttributeWithPermissions } from '../types';
+type ContextEvent = React.MouseEvent<HTMLTableSectionElement, MouseEvent>;
+type CellContextMenuProps = {
+    attribs: AttributeWithPermissions[];
+    onOpenNew?: (type: 'folder' | 'task') => void;
+};
+declare const useCellContextMenu: ({ attribs, onOpenNew }: CellContextMenuProps) => {
+    handleTableBodyContextMenu: (e: ContextEvent) => void;
+};
+export default useCellContextMenu;

package/dist/types/containers/ProjectTreeTable/hooks/useColumnVirtualization.d.ts

@@ -0,0 +1,17 @@
+import { useVirtualizer } from '@tanstack/react-virtual';
+import { Column } from '@tanstack/react-table';
+import { TableRow } from '../types/table';
+interface UseColumnVirtualizationProps {
+    visibleColumns: Column<TableRow, unknown>[];
+    tableContainerRef: React.RefObject<HTMLDivElement>;
+    columnPinning: {
+        left?: string[];
+    };
+}
+interface UseColumnVirtualizationResult {
+    columnVirtualizer: ReturnType<typeof useVirtualizer<HTMLDivElement, HTMLTableCellElement>>;
+    virtualPaddingLeft: number | undefined;
+    virtualPaddingRight: number | undefined;
+}
+declare const useColumnVirtualization: ({ visibleColumns, tableContainerRef, columnPinning, }: UseColumnVirtualizationProps) => UseColumnVirtualizationResult;
+export default useColumnVirtualization;

package/dist/types/containers/ProjectTreeTable/hooks/useCustomColumnWidthVars.d.ts

@@ -0,0 +1,6 @@
+import { ColumnSizingState, Table } from '@tanstack/react-table';
+import { TableRow } from '../types/table';
+declare const useCustomColumnWidthVars: (table: Table<TableRow>, columnSizing: ColumnSizingState) => {
+    [key: string]: number;
+};
+export default useCustomColumnWidthVars;

package/dist/types/containers/ProjectTreeTable/hooks/useDeleteEntities.d.ts

@@ -0,0 +1,5 @@
+type UseDeleteEntitiesProps = {
+    onSuccess?: () => void;
+};
+declare const useDeleteEntities: ({ onSuccess }: UseDeleteEntitiesProps) => (entityIds: string[]) => Promise<void>;
+export default useDeleteEntities;

package/dist/types/containers/ProjectTreeTable/hooks/useFolderRelationships.d.ts

@@ -0,0 +1,29 @@
+import { EditorTaskNode, FolderNodeMap, MatchingFolder, TaskNodeMap } from '../types/table';
+import { ProjectAttribModel2 } from '../types/project';
+import { AttributeWithPermissions } from '../types';
+export interface InheritedDependent {
+    entityId: string;
+    entityType: 'task' | 'folder';
+    attrib: Record<string, any>;
+}
+export type GetInheritedDependents = (entities: InheritedDependent[]) => InheritedDependent[];
+export type FindInheritedValueFromAncestors = (entityId: string, entityType: 'folder' | 'task', attribName: string) => any;
+export type FindNonInheritedValues = (folderId: string, attribNames: string[]) => Record<string, any>;
+export type GetAncestorsOf = (id: string) => string[];
+interface UseFolderRelationshipsProps {
+    foldersMap: FolderNodeMap;
+    tasksMap: TaskNodeMap;
+    tasksByFolderMap: Map<string, string[]>;
+    getEntityById: (id: string) => any;
+    projectAttrib: ProjectAttribModel2 | undefined;
+    attribFields: AttributeWithPermissions[] | undefined;
+}
+export default function useFolderRelationships({ foldersMap, tasksMap, tasksByFolderMap, getEntityById, projectAttrib, attribFields, }: UseFolderRelationshipsProps): {
+    folderChildrenMap: Map<string, string[]>;
+    getChildrenEntities: (id: string) => (MatchingFolder | EditorTaskNode)[];
+    getInheritedDependents: GetInheritedDependents;
+    findInheritedValueFromAncestors: FindInheritedValueFromAncestors;
+    findNonInheritedValues: FindNonInheritedValues;
+    getAncestorsOf: GetAncestorsOf;
+};
+export {};

package/dist/types/containers/ProjectTreeTable/hooks/useHistory.d.ts

@@ -0,0 +1,17 @@
+import { EntityUpdate, InheritFromParentEntity } from './useUpdateOverview';
+export interface HistoryEntityUpdate extends EntityUpdate {
+    ownAttrib: string[];
+    folderId?: string;
+    wasInherited?: boolean;
+}
+type SplitEntitiesByInherited = [EntityUpdate[], InheritFromParentEntity[]];
+export interface UseHistoryReturn {
+    pushHistory: (undo: HistoryEntityUpdate[], redo: HistoryEntityUpdate[]) => void;
+    undo: () => SplitEntitiesByInherited | null;
+    redo: () => SplitEntitiesByInherited | null;
+    canUndo: boolean;
+    canRedo: boolean;
+    clearHistory: () => void;
+}
+declare const useHistory: (maxHistorySize?: number) => UseHistoryReturn;
+export default useHistory;

package/dist/types/containers/ProjectTreeTable/hooks/useKeyboardNavigation.d.ts

@@ -0,0 +1,10 @@
+export default function useKeyboardNavigation(): {
+    handleKeyDown: (e: KeyboardEvent) => void;
+    focusedCellId: string | null;
+    gridMap: import('../context/SelectionContext').GridMap;
+    selectCell: (cellId: import('../utils/cellUtils').CellId, additive: boolean, range: boolean) => void;
+    focusCell: (cellId: import('../utils/cellUtils').CellId | null) => void;
+    clearSelection: () => void;
+    setEditingCellId: (id: import('../utils/cellUtils').CellId | null) => void;
+    editingCellId: string | null;
+};

package/dist/types/containers/ProjectTreeTable/hooks/useOverviewTable.d.ts

@@ -0,0 +1,32 @@
+import { FolderNodeMap, TableRow, TaskNodeMap, TasksByFolderMap } from '../types/table';
+import { ExpandedState } from '@tanstack/react-table';
+import { LoadingTasks } from '../types';
+import { FolderType, TaskType } from '../types/project';
+type Params = {
+    foldersMap: FolderNodeMap;
+    tasksMap: TaskNodeMap;
+    tasksByFolderMap: TasksByFolderMap;
+    expanded: ExpandedState;
+    folderTypes?: FolderType[];
+    taskTypes?: TaskType[];
+    showHierarchy: boolean;
+    loadingTasks: LoadingTasks;
+    isLoadingMore?: boolean;
+};
+/**
+ * React hook that creates a hierarchical tree structure from folders and tasks for use with TanStack Table
+ * Uses memoization to avoid unnecessary recalculations on re-render
+ *
+ * @param foldersMap - Map of folders organized by folder ID
+ * @param tasksMap - Map of tasks organized by task ID
+ * @param tasksByFolderMap - Map of tasks organized by folder ID
+ * @param expanded - Object with folder IDs as keys to indicate expanded folders
+ * @param folderTypes - Array of folder types for to add things like folder icon
+ * @param taskTypes - Array of task types for to add things like task icon
+ * @param showHierarchy - Boolean to indicate if the hierarchy should be shown
+ * @param loadingTasks - Object with folder IDs as keys to indicate loading tasks
+ * @param isLoadingMore - Boolean to indicate if more tasks are being loaded
+ * @returns An array of TableRow objects with nested subRows suitable for TanStack Table
+ */
+export default function useOverviewTable({ foldersMap, tasksMap, tasksByFolderMap, expanded, folderTypes, taskTypes, showHierarchy, loadingTasks, isLoadingMore, }: Params): TableRow[];
+export {};

package/dist/types/containers/ProjectTreeTable/hooks/usePrefetchFolderTasks.d.ts

@@ -0,0 +1,4 @@
+export declare const usePrefetchFolderTasks: () => {
+    handlePreFetchTasks: (e: React.MouseEvent<HTMLTableSectionElement>) => void;
+};
+export default usePrefetchFolderTasks;

package/dist/types/containers/ProjectTreeTable/hooks/useUpdateOverview.d.ts

@@ -0,0 +1,30 @@
+import { CellId } from '../utils/cellUtils';
+import { CellValue } from '../widgets/CellWidget';
+import { UseHistoryReturn } from './useHistory';
+export type EntityUpdate = {
+    id: string;
+    type: string;
+    field: string;
+    value: CellValue | CellValue[] | null;
+    isAttrib?: boolean;
+};
+export type UpdateTableEntities = (entities: EntityUpdate[], pushHistory?: boolean) => Promise<void>;
+export type InheritFromParentEntity = {
+    entityId: string;
+    entityType: string;
+    attribs: string[];
+    ownAttrib: string[];
+    folderId: string;
+};
+export type InheritFromParent = (entities: InheritFromParentEntity[], pushHistory?: boolean) => Promise<void>;
+export type UpdateTableEntity = (cellId: CellId, value: string, { includeSelection }: {
+    includeSelection: boolean;
+}) => Promise<void>;
+interface UseUpdateOverviewProps {
+    pushHistory?: UseHistoryReturn['pushHistory'];
+}
+declare const useUpdateOverview: (props?: UseUpdateOverviewProps) => {
+    updateEntities: UpdateTableEntities;
+    inheritFromParent: InheritFromParent;
+};
+export default useUpdateOverview;

package/dist/types/containers/ProjectTreeTable/hooks/useValidateUpdates.d.ts

@@ -0,0 +1,3 @@
+import { EntityUpdate } from './useUpdateOverview';
+declare const useValidateUpdates: () => (entities?: EntityUpdate[]) => void;
+export default useValidateUpdates;

package/dist/types/containers/ProjectTreeTable/index.d.ts

@@ -0,0 +1,14 @@
+export * from './ProjectTreeTable';
+export { SelectionProvider, useSelectionContext, ROW_SELECTION_COLUMN_ID, } from './context/SelectionContext';
+export type { GridMap, SelectionContextType } from './context/SelectionContext';
+export { ProjectTableProvider, useProjectTableContext } from './context/ProjectTableContext';
+export type { ProjectTableContextProps } from './context/ProjectTableContext';
+export { ProjectTableQueriesProvider, useProjectTableQueriesContext, } from './context/ProjectTableQueriesContext';
+export type { ProjectTableQueriesContextProps } from './context/ProjectTableQueriesContext';
+export { SelectedRowsProvider, useSelectedRowsContext } from './context/SelectedRowsContext';
+export type { SelectedRowsContextProps } from './context/SelectedRowsContext';
+export { ColumnSettingsProvider, useColumnSettings } from './context/ColumnSettingsContext';
+export type { ColumnSettingsContextType } from './context/ColumnSettingsContext';
+export * from './utils';
+export * from './types';
+export * from './context';

package/dist/types/containers/ProjectTreeTable/types/folders.d.ts

@@ -0,0 +1,14 @@
+export type QueryCondition = {
+    /** Path to the key separated by slashes */
+    key: string;
+    /** Value to compare against */
+    value?: string | number | number | string[] | number[] | number[];
+    /** Comparison operator */
+    operator?: 'eq' | 'like' | 'lt' | 'gt' | 'lte' | 'gte' | 'ne' | 'isnull' | 'notnull' | 'in' | 'notin' | 'includes' | 'excludes' | 'includesall' | 'excludesall' | 'includesany' | 'excludesany';
+};
+export type QueryFilter = {
+    /** List of conditions to be evaluated */
+    conditions?: (QueryCondition | QueryFilter)[];
+    /** Operator to use when joining conditions */
+    operator?: 'and' | 'or';
+};

package/dist/types/containers/ProjectTreeTable/types/index.d.ts

@@ -0,0 +1,62 @@
+import { OperationModel } from './operations';
+export * from './table';
+export type AttributeEnumItem = {
+    value: string | number | number | boolean;
+    label: string;
+    icon?: string;
+    color?: string;
+};
+export type AttributeData = {
+    /** Type of attribute value */
+    type: 'string' | 'integer' | 'float' | 'boolean' | 'datetime' | 'list_of_strings' | 'list_of_integers' | 'list_of_any' | 'list_of_submodels' | 'dict';
+    /** Nice, human readable title of the attribute */
+    title?: string;
+    description?: string;
+    /** Example value of the field. */
+    example?: any;
+    /** Default value for the attribute. Do not set for list types. */
+    default?: any;
+    gt?: number | number;
+    ge?: number | number;
+    lt?: number | number;
+    le?: number | number;
+    minLength?: number;
+    maxLength?: number;
+    /** Minimum number of items in list type. */
+    minItems?: number;
+    /** Only for list types. Maximum number of items in the list. */
+    maxItems?: number;
+    /** Only for string types. The value must match this regex. */
+    regex?: string;
+    /** List of enum items used for displaying select/multiselect widgets */
+    enum?: AttributeEnumItem[];
+    /** Inherit the attribute value from the parent entity. */
+    inherit?: boolean;
+};
+export type AttributeModel = {
+    name: string;
+    /** Default order */
+    position: number;
+    /** List of entity types the attribute is available on */
+    scope?: (('folder' | 'product' | 'version' | 'representation' | 'task' | 'workfile') | ('project' | 'user'))[];
+    /** Is attribute builtin. Built-in attributes cannot be removed. */
+    builtin?: boolean;
+    data: AttributeData;
+};
+export interface AttributeWithPermissions extends AttributeModel {
+    readOnly?: boolean;
+}
+export type LoadingTasks = Record<string, number>;
+export type PatchOperation = Pick<OperationModel, 'entityId' | 'entityType' | 'data'> & {
+    type?: OperationModel['type'];
+};
+interface EnumOption extends AttributeEnumItem {
+    scope?: string[];
+}
+export type BuiltInFieldOptions = {
+    folderTypes: EnumOption[];
+    taskTypes: EnumOption[];
+    statuses: EnumOption[];
+    assignees: EnumOption[];
+    tags: EnumOption[];
+};