@ynput/ayon-frontend-shared 0.2.2 → 0.2.4

package/dist/types/{containers → shared/src/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 → shared/src/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 → shared/src/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 → shared/src/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/shared/src/containers/ProjectTreeTable/hooks/useCellContextMenu.d.ts

@@ -0,0 +1,29 @@
+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: ProjectTableAttribute[];
+    onOpenNew?: (type: 'folder' | 'task') => void;
+};
+declare const useCellContextMenu: ({ attribs, onOpenNew }: CellContextMenuProps) => {
+    handleTableBodyContextMenu: (e: ContextEvent) => void;
+};
+export default useCellContextMenu;

package/dist/types/{containers → shared/src/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/shared/src/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 → shared/src/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/shared/src/containers/ProjectTreeTable/hooks/useOverviewTable.d.ts

@@ -0,0 +1,17 @@
+import { FolderNodeMap, TableRow, TaskNodeMap, TasksByFolderMap } from '../types/table';
+import { ExpandedState } from '@tanstack/react-table';
+import { LoadingTasks } from '../types';
+import { ProjectModel } from '../types/project';
+type Params = {
+    foldersMap: FolderNodeMap;
+    tasksMap: TaskNodeMap;
+    tasksByFolderMap: TasksByFolderMap;
+    rows?: TableRow[];
+    expanded: ExpandedState;
+    projectInfo?: ProjectModel;
+    showHierarchy: boolean;
+    loadingTasks?: LoadingTasks;
+    isLoadingMore?: boolean;
+};
+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 → shared/src/containers/ProjectTreeTable/hooks/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 → shared/src/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 → shared/src/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 → shared/src/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 → shared/src/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/shared/src/containers/ProjectTreeTable/utils/clientFilterToQueryFilter.d.ts

@@ -0,0 +1,16 @@
+import { QueryFilter } from '../types/operations';
+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/shared/src/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/shared/src/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 → shared/src/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/shared/src/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 → shared/src/containers}/ProjectTreeTable/widgets/BooleanWidget.d.ts

@@ -1,7 +1,6 @@
 import { WidgetBaseProps } from './CellWidget';
-interface BooleanWidgetProps extends Omit<React.HTMLAttributes<HTMLInputElement>, 'onChange'>, WidgetBaseProps {
+export interface BooleanWidgetProps extends Omit<React.HTMLAttributes<HTMLInputElement>, 'onChange'>, WidgetBaseProps {
     value: boolean;
     isReadOnly?: boolean;
 }
 export declare const BooleanWidget: import('react').ForwardRefExoticComponent<BooleanWidgetProps & import('react').RefAttributes<HTMLInputElement>>;
-export {};

package/dist/types/{containers → shared/src/containers}/ProjectTreeTable/widgets/CellWidget.d.ts

@@ -1,3 +1,7 @@
+import { BooleanWidgetProps } from './BooleanWidget';
+import { DateWidgetProps } from './DateWidget';
+import { EnumWidgetProps } from './EnumWidget';
+import { TextWidgetProps } from './TextWidget';
 import { AttributeData, AttributeEnumItem } from '../types';
 type WidgetAttributeData = Pick<AttributeData, 'type'>;
 export type CellValue = string | number | boolean;
@@ -14,6 +18,12 @@ interface EditorCellProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'on
     isReadOnly?: boolean;
     enableCustomValues?: boolean;
     onChange?: (value: CellValue | CellValue[], key?: 'Enter' | 'Click' | 'Escape') => void;
+    pt?: {
+        enum?: Partial<EnumWidgetProps>;
+        text?: Partial<TextWidgetProps>;
+        date?: Partial<DateWidgetProps>;
+        boolean?: Partial<BooleanWidgetProps>;
+    };
 }
 export interface WidgetBaseProps {
     isEditing?: boolean;

package/dist/types/{containers → shared/src/containers}/ProjectTreeTable/widgets/DateWidget.d.ts

@@ -1,8 +1,7 @@
 import { WidgetBaseProps } from './CellWidget';
-interface DateWidgetProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'onChange'>, WidgetBaseProps {
-    value: string;
+export interface DateWidgetProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'onChange'>, WidgetBaseProps {
+    value?: string;
     isReadOnly?: boolean;
     isInherited?: boolean;
 }
 export declare const DateWidget: import('react').ForwardRefExoticComponent<DateWidgetProps & import('react').RefAttributes<HTMLSpanElement>>;
-export {};

package/dist/types/{containers → shared/src/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 → shared/src/containers}/ProjectTreeTable/widgets/EnumWidget.d.ts

@@ -1,7 +1,7 @@
 import { DropdownProps } from '@ynput/ayon-react-components';
 import { WidgetBaseProps } from './CellWidget';
 import { AttributeData, AttributeEnumItem } from '../types';
-interface EnumWidgetProps extends Omit<DropdownProps, 'onChange' | 'value'>, WidgetBaseProps {
+export interface EnumWidgetProps extends Omit<DropdownProps, 'onChange' | 'value'>, WidgetBaseProps {
     value: (string | number | boolean)[];
     options: AttributeEnumItem[];
     type?: AttributeData['type'];
@@ -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 → shared/src/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'>;
-interface TextWidgetProps extends Omit<React.HTMLAttributes<HTMLSpanElement>, 'onChange'>, WidgetBaseProps {
+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>>;

package/dist/types/shared/src/containers/ProjectTreeTable/widgets/ThumbnailWidget.d.ts

@@ -0,0 +1,9 @@
+interface ThumbnailWidgetProps {
+    projectName: string;
+    entityType: string;
+    entityId: string;
+    updatedAt?: string;
+    icon?: string | null;
+}
+export declare const ThumbnailWidget: import('react').NamedExoticComponent<ThumbnailWidgetProps>;
+export {};

package/dist/types/{containers → shared/src/containers}/ProjectTreeTable/widgets/index.d.ts

@@ -5,3 +5,4 @@ export { TextWidget } from './TextWidget';
 export { BooleanWidget } from './BooleanWidget';
 export { CellWidget } from './CellWidget';
 export { EntityNameWidget } from './EntityNameWidget';
+export { ThumbnailWidget } from './ThumbnailWidget';

package/dist/types/shared/src/context/SettingsPanelContext.d.ts

@@ -0,0 +1,20 @@
+import { FC, ReactNode, Dispatch } from 'react';
+export type SettingField = 'columns' | string;
+export type SettingHighlightedId = string | null;
+interface SettingsPanelContextType {
+    isPanelOpen: boolean;
+    selectedSetting: SettingField | null;
+    highlightedSetting: SettingHighlightedId;
+    setHighlightedSetting: Dispatch<React.SetStateAction<SettingHighlightedId>>;
+    openPanel: () => void;
+    closePanel: () => void;
+    togglePanel: (setting?: SettingField | null, highlighted?: SettingHighlightedId) => void;
+    selectSetting: (setting: SettingField | null, highlighted?: SettingHighlightedId) => void;
+    backToMainMenu: () => void;
+}
+interface SettingsPanelProviderProps {
+    children: ReactNode;
+}
+export declare const SettingsPanelProvider: FC<SettingsPanelProviderProps>;
+export declare const useSettingsPanel: () => SettingsPanelContextType;
+export {};

package/dist/types/{context → shared/src/context}/index.d.ts

@@ -1,4 +1,5 @@
 export * from './RemoteModulesContext';
 export * from './DetailsPanelContext';
 export * from './ThumbnailUploaderContext';
+export * from './SettingsPanelContext';
 export * from './pip';