@ynput/ayon-frontend-shared 0.2.3 → 0.2.5

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

@@ -0,0 +1,23 @@
+import { ColumnDef, Row } from '@tanstack/react-table';
+import { TableRow } from './types/table';
+import { ProjectTableAttribute, BuiltInFieldOptions } from './types';
+import { ROW_SELECTION_COLUMN_ID } from './context/SelectionCellsContext';
+export type DefaultColumns = typeof ROW_SELECTION_COLUMN_ID | 'thumbnail' | 'name' | 'status' | 'subType' | 'assignees' | 'tags';
+export type TreeTableExtraColumn = {
+    column: ColumnDef<TableRow>;
+    position?: number;
+};
+export type BuildTreeTableColumnsProps = {
+    attribs: ProjectTableAttribute[];
+    showHierarchy: boolean;
+    options: BuiltInFieldOptions;
+    excluded?: (DefaultColumns | string)[];
+    extraColumns?: TreeTableExtraColumn[];
+};
+declare const buildTreeTableColumns: ({ attribs, showHierarchy, options, excluded, extraColumns, }: BuildTreeTableColumnsProps) => ColumnDef<TableRow>[];
+export default buildTreeTableColumns;
+export declare const getValueIdType: (row: Row<TableRow>, field: string, nestedField?: keyof TableRow) => {
+    value: any;
+    id: string;
+    type: string;
+};

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

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

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

@@ -1,5 +1,5 @@
 import { default as React, ReactNode } from 'react';
-import { ColumnOrderState, ColumnPinningState, OnChangeFn, VisibilityState } from '@tanstack/react-table';
+import { ColumnOrderState, ColumnPinningState, OnChangeFn, VisibilityState, ColumnSizingState } from '@tanstack/react-table';
 export interface ColumnSettingsContextType {
     columnVisibility: VisibilityState;
     setColumnVisibility: (columnVisibility: VisibilityState) => void;
@@ -13,12 +13,16 @@ export interface ColumnSettingsContextType {
     setColumnOrder: (columnOrder: ColumnOrderState) => void;
     updateColumnOrder: (columnOrder: ColumnOrderState) => void;
     columnOrderUpdater: OnChangeFn<ColumnOrderState>;
+    columnSizing: ColumnSizingState;
+    setColumnSizing: (columnSizing: ColumnSizingState) => void;
+    columnSizingUpdater: OnChangeFn<ColumnSizingState>;
     setColumnsConfig: (config: ColumnsConfig) => void;
 }
 export type ColumnsConfig = {
     columnVisibility: VisibilityState;
     columnOrder: ColumnOrderState;
     columnPinning: ColumnPinningState;
+    columnSizing: ColumnSizingState;
 };
 interface ColumnSettingsProviderProps {
     children: ReactNode;
@@ -26,5 +30,5 @@ interface ColumnSettingsProviderProps {
     onChange: (config: ColumnsConfig) => void;
 }
 export declare const ColumnSettingsProvider: React.FC<ColumnSettingsProviderProps>;
-export declare const useColumnSettings: () => ColumnSettingsContextType;
+export declare const useColumnSettingsContext: () => ColumnSettingsContextType;
 export {};

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

@@ -1,58 +1,33 @@
 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 { EntitiesMap, EntityMap, FolderNodeMap, 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 { ProjectTableAttribute, LoadingTasks } from '../types';
 import { QueryFilter } from '../types/folders';
+import { ContextMenuItemConstructors } from '../hooks/useCellContextMenu';
 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 type ToggleExpandAll = (rowIds: RowId[], expand?: boolean) => void;
 export interface ProjectTableProviderProps {
     children: ReactNode;
     isInitialized: boolean;
     isLoading: boolean;
     isLoadingMore: boolean;
-    loadingTasks: LoadingTasks;
+    loadingTasks?: LoadingTasks;
     projectInfo?: ProjectModel;
     projectName: string;
     users: User[];
-    attribFields: AttributeWithPermissions[];
+    attribFields: ProjectTableAttribute[];
     tasksMap: TaskNodeMap;
     foldersMap: FolderNodeMap;
+    entitiesMap: EntitiesMap;
     tasksByFolderMap: TasksByFolderMap;
+    tableRows?: TableRow[];
     fetchNextPage: () => void;
     reloadTableData: () => void;
     filters: Filter[];
@@ -70,7 +45,39 @@ export interface ProjectTableProviderProps {
     setExpanded: (expanded: ExpandedState) => void;
     sorting: SortingState;
     updateSorting: OnChangeFn<SortingState>;
+    contextMenuItems: ContextMenuItemConstructors;
+}
+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'];
+    entitiesMap: ProjectTableProviderProps['entitiesMap'];
+    fetchNextPage: ProjectTableProviderProps['fetchNextPage'];
+    reloadTableData: ProjectTableProviderProps['reloadTableData'];
+    getEntityById: (id: string) => EntityMap | 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: ToggleExpandAll;
+    sorting: ProjectTableProviderProps['sorting'];
+    updateSorting: ProjectTableProviderProps['updateSorting'];
+    getInheritedDependents: GetInheritedDependents;
+    findInheritedValueFromAncestors: FindInheritedValueFromAncestors;
+    findNonInheritedValues: FindNonInheritedValues;
+    getAncestorsOf: GetAncestorsOf;
+    contextMenuItems: ProjectTableProviderProps['contextMenuItems'];
 }
-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 ProjectTableProvider: ({ children, foldersMap, tableRows, tasksMap, entitiesMap, tasksByFolderMap, expanded, projectInfo, showHierarchy, loadingTasks, isLoadingMore, isLoading, isInitialized, projectName, users, attribFields, filters, setFilters, queryFilters, updateShowHierarchy, toggleExpanded, updateExpanded, sorting, updateSorting, fetchNextPage, reloadTableData, setExpanded, contextMenuItems, }: ProjectTableProviderProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useProjectTableContext: () => ProjectTableContextProps;
 export {};

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

@@ -1,6 +1,7 @@
 import { ReactNode } from 'react';
-import { OperationModel, OperationsRequestModel } from '../types/operations';
+import { OperationsRequestModel } from '../types/operations';
 import { PatchOperation } from '../types';
+import { OperationWithRowId } from '../hooks/useUpdateTableData';
 export interface ProjectTableQueriesContextProps {
     updateEntities: ProjectTableQueriesProviderProps['updateEntities'];
     getFoldersTasks: ProjectTableQueriesProviderProps['getFoldersTasks'];
@@ -8,7 +9,7 @@ export interface ProjectTableQueriesContextProps {
 export interface ProjectTableQueriesProviderProps {
     children: ReactNode;
     updateEntities: ({ operations, }: {
-        operations: OperationModel[];
+        operations: OperationWithRowId[];
         patchOperations?: PatchOperation[];
     }) => Promise<OperationsRequestModel | undefined>;
     getFoldersTasks: (args: {

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

@@ -1,4 +1,5 @@
 import { ReactNode } from 'react';
+import { EntitiesMap } from '../../types/table';
 import { AttributeEnumItem, BuiltInFieldOptions } from '../../types';
 export declare const builtInFieldMappings: {
     status: string;
@@ -15,7 +16,9 @@ export interface ClipboardContextType {
 }
 export interface ClipboardProviderProps {
     children: ReactNode;
-    options: BuiltInFieldOptions;
+    entitiesMap: EntitiesMap;
+    columnEnums: ColumnEnums;
+    columnReadOnly: string[];
 }
 export interface ParsedClipboardData {
     values: string[];

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

@@ -1,6 +1,6 @@
-import { FolderNodeMap, TaskNodeMap } from '../../types/table';
+import { EntitiesMap } 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 getEntityPath: (entityId: string, entitiesMap: EntitiesMap) => string;
 export declare const processFieldValue: (value: string, fieldValueType: "string" | "number" | "boolean" | "array") => any;

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

@@ -1,7 +1,26 @@
-import { AttributeWithPermissions } from '../types';
+import { ContextMenuItemType } from '../../ContextMenu/useCreateContextMenu';
+import { ProjectTableAttribute } from '../types';
+import { UseHistoryReturn } from './useHistory';
 type ContextEvent = React.MouseEvent<HTMLTableSectionElement, MouseEvent>;
+export type TableCellContextData = {
+    entityId: string;
+    cellId: string;
+    columnId: string;
+    entityType: 'folder' | 'task' | 'product' | 'version' | undefined;
+    attribField: ProjectTableAttribute | undefined;
+};
+type DefaultMenuItem = 'copy-paste' | 'show-details' | 'expand-collapse' | 'inherit' | 'delete' | 'export' | 'create-folder' | 'create-task';
+export type ContextMenuItemConstructor = (e: ContextEvent, cell: TableCellContextData, selectedCells: TableCellContextData[], meta: {
+    selectedCells: string[];
+    selectedRows: string[];
+    selectedColumns: string[];
+    selectedFullRows: string[];
+}, context: {
+    history: UseHistoryReturn;
+}) => ContextMenuItemType | ContextMenuItemType[] | undefined;
+export type ContextMenuItemConstructors = (DefaultMenuItem | ContextMenuItemConstructor)[];
 type CellContextMenuProps = {
-    attribs: AttributeWithPermissions[];
+    attribs: ProjectTableAttribute[];
     onOpenNew?: (type: 'folder' | 'task') => void;
 };
 declare const useCellContextMenu: ({ attribs, onOpenNew }: CellContextMenuProps) => {

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

@@ -1,6 +1,6 @@
-import { EditorTaskNode, FolderNodeMap, MatchingFolder, TaskNodeMap } from '../types/table';
+import { EditorTaskNode, EntitiesMap, MatchingFolder, TaskNodeMap } from '../types/table';
 import { ProjectAttribModel2 } from '../types/project';
-import { AttributeWithPermissions } from '../types';
+import { ProjectTableAttribute } from '../types';
 export interface InheritedDependent {
     entityId: string;
     entityType: 'task' | 'folder';
@@ -11,14 +11,14 @@ export type FindInheritedValueFromAncestors = (entityId: string, entityType: 'fo
 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[]>;
+    tasksMap?: TaskNodeMap;
+    entitiesMap?: EntitiesMap;
+    tasksByFolderMap?: Map<string, string[]>;
     getEntityById: (id: string) => any;
     projectAttrib: ProjectAttribModel2 | undefined;
-    attribFields: AttributeWithPermissions[] | undefined;
+    attribFields: ProjectTableAttribute[] | undefined;
 }
-export default function useFolderRelationships({ foldersMap, tasksMap, tasksByFolderMap, getEntityById, projectAttrib, attribFields, }: UseFolderRelationshipsProps): {
+export default function useFolderRelationships({ tasksMap, entitiesMap, tasksByFolderMap, getEntityById, projectAttrib, attribFields, }: UseFolderRelationshipsProps): {
     folderChildrenMap: Map<string, string[]>;
     getChildrenEntities: (id: string) => (MatchingFolder | EditorTaskNode)[];
     getInheritedDependents: GetInheritedDependents;

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

@@ -0,0 +1,6 @@
+import { ProjectModel } from '../types/project';
+type Props = {
+    projectInfo?: ProjectModel;
+};
+declare const useGetEntityTypeData: ({ projectInfo }: Props) => (type: "folder" | "task" | "product" | string | undefined, subType?: string) => any;
+export default useGetEntityTypeData;

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

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

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

@@ -1,32 +1,17 @@
 import { FolderNodeMap, TableRow, TaskNodeMap, TasksByFolderMap } from '../types/table';
 import { ExpandedState } from '@tanstack/react-table';
 import { LoadingTasks } from '../types';
-import { FolderType, TaskType } from '../types/project';
+import { ProjectModel } from '../types/project';
 type Params = {
     foldersMap: FolderNodeMap;
     tasksMap: TaskNodeMap;
     tasksByFolderMap: TasksByFolderMap;
+    rows?: TableRow[];
     expanded: ExpandedState;
-    folderTypes?: FolderType[];
-    taskTypes?: TaskType[];
+    projectInfo?: ProjectModel;
     showHierarchy: boolean;
-    loadingTasks: LoadingTasks;
+    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 default function useOverviewTable({ foldersMap, tasksMap, rows, tasksByFolderMap, expanded, projectInfo, showHierarchy, loadingTasks, isLoadingMore, }: Params): TableRow[];
 export {};

package/dist/types/containers/ProjectTreeTable/hooks/{useUpdateOverview.d.ts → useUpdateTableData.d.ts}

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

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

@@ -1,3 +1,4 @@
+import { default as useGetEntityTypeData } from './hooks/useGetEntityTypeData';
 export * from './ProjectTreeTable';
 export { SelectionCellsProvider, useSelectionCellsContext, ROW_SELECTION_COLUMN_ID, } from './context/SelectionCellsContext';
 export type { GridMap, SelectionCellsContextType } from './context/SelectionCellsContext';
@@ -7,8 +8,11 @@ export { ProjectTableQueriesProvider, useProjectTableQueriesContext, } from './c
 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 { ColumnSettingsProvider, useColumnSettingsContext } from './context/ColumnSettingsContext';
 export type { ColumnSettingsContextType } from './context/ColumnSettingsContext';
 export * from './utils';
 export * from './types';
 export * from './context';
+export * from './buildTreeTableColumns';
+export * from './hooks/useUpdateTableData';
+export { useGetEntityTypeData };

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

@@ -43,7 +43,7 @@ export type AttributeModel = {
     builtin?: boolean;
     data: AttributeData;
 };
-export interface AttributeWithPermissions extends AttributeModel {
+export interface ProjectTableAttribute extends Omit<AttributeModel, 'position'> {
     readOnly?: boolean;
 }
 export type LoadingTasks = Record<string, number>;
@@ -53,10 +53,8 @@ export type PatchOperation = Pick<OperationModel, 'entityId' | 'entityType' | 'd
 interface EnumOption extends AttributeEnumItem {
     scope?: string[];
 }
+export type TreeTableSubType = 'folderType' | 'taskType' | 'productType';
+type BuiltInFieldOptionKey = TreeTableSubType | 'status' | 'assignee' | 'tag';
 export type BuiltInFieldOptions = {
-    folderTypes: EnumOption[];
-    taskTypes: EnumOption[];
-    statuses: EnumOption[];
-    assignees: EnumOption[];
-    tags: EnumOption[];
+    [key in BuiltInFieldOptionKey]: EnumOption[];
 };

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

@@ -49,35 +49,74 @@ export type GetTasksByParentQuery = {
 };
 export type TableRow = {
     id: string;
-    parentId?: string;
+    entityId?: string;
+    entityType: string;
     name: string;
     label: string;
-    icon: string | null;
-    color: string | null;
-    img: string | null;
-    startContent?: JSX.Element;
+    path: string | null | undefined;
+    ownAttrib: string[];
+    tags: string[];
+    status: string;
+    updatedAt?: string;
+    parentId?: string;
     subRows: TableRow[];
-    status?: string;
+    icon?: string | null;
+    color?: string | null;
+    img?: string | null;
+    startContent?: JSX.Element;
     assignees?: string[];
-    tags: string[];
     attrib?: Record<string, any>;
     childOnlyMatch?: boolean;
     subType?: string | null;
-    entityType: string;
-    ownAttrib: string[];
-    path: string | null | undefined;
     isLoading?: boolean;
 };
 export type MatchingFolder = FolderListItem & {
     childOnlyMatch?: boolean;
-    entityType?: 'folder';
+    entityId: string;
+    entityType: 'folder';
 };
 export type FolderNodeMap = Map<string, MatchingFolder>;
 type TaskNode = GetTasksByParentQuery['project']['tasks']['edges'][0]['node'];
 export type EditorTaskNode = TaskNode & {
     attrib: Record<string, any>;
-    entityType?: 'task';
+    entityId: string;
+    entityType: 'task';
+};
+type EditorVersionNode = {
+    id: string;
+    entityId: string;
+    entityType: 'version';
+    folderId: string;
+    label?: string | null;
+    name: string;
+    ownAttrib: Array<string>;
+    status: string;
+    tags: Array<string>;
+    taskType: string;
+    updatedAt: any;
+    active: boolean;
+    assignees: Array<string>;
+    allAttrib: string;
+};
+type EditorProductNode = {
+    id: string;
+    entityId: string;
+    entityType: 'product';
+    folderId: string;
+    label?: string | null;
+    name: string;
+    ownAttrib: Array<string>;
+    status: string;
+    tags: Array<string>;
+    taskType: string;
+    updatedAt: any;
+    active: boolean;
+    assignees: Array<string>;
+    allAttrib: string;
 };
 export type TaskNodeMap = Map<string, EditorTaskNode>;
+export type EntityMap = EditorTaskNode | MatchingFolder | EditorVersionNode | EditorProductNode;
+export type EntitiesMap = Map<string, EntityMap>;
+export type EMapResult<T extends 'folder' | 'task' | 'product' | 'version'> = T extends 'folder' ? MatchingFolder : T extends 'task' ? EditorTaskNode : T extends 'product' ? EditorProductNode : EditorVersionNode;
 export type TasksByFolderMap = Map<string, string[]>;
 export {};

package/dist/types/containers/ProjectTreeTable/utils/cellUtils.d.ts

@@ -1,6 +1,4 @@
-/**
- * Shared cell utilities for table operations
- */
+import { EMapResult, EntitiesMap } from '../types';
 export type CellId = string;
 export type RowId = string;
 export type ColId = string;
@@ -40,3 +38,4 @@ export declare const getCellBorders: (rowIndex: number, colIndex: number, select
  * Converts border position flags to CSS classes for shadow styling
  */
 export declare const getBorderClasses: (borders: BorderPosition) => string[];
+export declare const getEntityDataById: <T extends "folder" | "task" | "product" | "version">(id: string, entitiesMap: EntitiesMap) => EMapResult<T> | undefined;

package/dist/types/containers/ProjectTreeTable/utils/clientFilterToQueryFilter.d.ts

@@ -1,4 +1,16 @@
-import { Filter } from '@ynput/ayon-react-components';
 import { QueryFilter } from '../types/operations';
-export declare const clientFilterToQueryFilter: (filters: Filter[]) => QueryFilter;
+export type FilterForQuery = {
+    id: string;
+    values?: {
+        id: string;
+        values?: {
+            id: string;
+        }[];
+    }[];
+    type?: string;
+    singleSelect?: boolean;
+    inverted?: boolean;
+    operator?: string;
+};
+export declare const clientFilterToQueryFilter: (filters: FilterForQuery[]) => QueryFilter;
 export default clientFilterToQueryFilter;

package/dist/types/containers/ProjectTreeTable/utils/getReadOnlyLists.d.ts

@@ -0,0 +1,5 @@
+import { ProjectTableAttribute } from '../types';
+export declare const getReadOnlyLists: (attribFields: ProjectTableAttribute[], extra?: string[]) => {
+    readOnlyColumns: string[];
+    readOnlyAttribs: string[];
+};

package/dist/types/containers/ProjectTreeTable/utils/getTableFieldOptions.d.ts

@@ -0,0 +1,14 @@
+import { BuiltInFieldOptions } from '../types';
+import { FolderType, Status, Tag, TaskType } from '../types/project';
+type Params = {
+    users: {
+        name: string;
+        fullName?: string;
+    }[];
+    statuses: Status[];
+    folderTypes: FolderType[];
+    taskTypes: TaskType[];
+    tags: Tag[];
+};
+export declare const getTableFieldOptions: ({ users, statuses, folderTypes, taskTypes, tags, }: Params) => BuiltInFieldOptions;
+export {};

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

@@ -1,4 +1,6 @@
 export * from '../types/table';
 export * from './clientFilterToQueryFilter';
 export * from './loadingUtils';
+export * from './getTableFieldOptions';
+export * from './getReadOnlyLists';
 export * from './cellUtils';

package/dist/types/containers/ProjectTreeTable/utils/validateUpdateEntities.d.ts

@@ -0,0 +1,4 @@
+import { ProjectTableAttribute } from '../types';
+import { EntityUpdate } from '../hooks/useUpdateTableData';
+declare const validateUpdateEntities: (entities: EntityUpdate[] | undefined, attribFields: ProjectTableAttribute[]) => void;
+export default validateUpdateEntities;

package/dist/types/containers/ProjectTreeTable/widgets/EntityNameWidget.d.ts

@@ -4,7 +4,7 @@ type EntityNameWidgetProps = {
     name: string;
     path?: string | null;
     showHierarchy?: boolean;
-    icon: string | null;
+    icon?: string | null;
     type: string;
     isExpanded: boolean;
     toggleExpandAll: (id: string) => void;

package/dist/types/containers/ProjectTreeTable/widgets/EnumWidget.d.ts

@@ -19,7 +19,7 @@ interface EnumTemplateProps extends React.HTMLAttributes<HTMLSpanElement> {
     selectedOptions: AttributeEnumItem[];
     placeholder?: string;
     hasMultipleValues: boolean;
-    isMultiSelect?: boolean;
+    isMultiSelect: boolean;
     isOpen?: boolean;
     isItem?: boolean;
     isSelected?: boolean;

package/dist/types/containers/ProjectTreeTable/widgets/TextWidget.d.ts

@@ -1,9 +1,11 @@
 import { WidgetBaseProps } from './CellWidget';
 import { AttributeData } from '../types';
+import { AttributeEnumItem } from '../../../api';
 type AttributeType = AttributeData['type'];
 export type TextWidgetType = Extract<AttributeType, 'string' | 'integer' | 'float'>;
 export interface TextWidgetProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'onChange'>, WidgetBaseProps {
     value: string;
+    option?: AttributeEnumItem;
     isInherited?: boolean;
 }
 export declare const TextWidget: import('react').ForwardRefExoticComponent<TextWidgetProps & import('react').RefAttributes<HTMLSpanElement>>;