@ynput/ayon-frontend-shared 0.1.0

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

@@ -0,0 +1,99 @@
+export type EventOperationsApiResponse = any;
+export type EventOperationsApiArg = {
+    eventOperationModel: EventOperationModel;
+};
+export type ActivitiesOperationsApiResponse = 
+/** status 200 Successful Response */ ActivityOperationsResponseModel;
+export type ActivitiesOperationsApiArg = {
+    projectName: string;
+    'x-sender'?: string;
+    'x-sender-type'?: string;
+    activityOperationsRequestModel: ActivityOperationsRequestModel;
+};
+export type OperationsApiResponse = OperationsResponseModel;
+export type OperationsApiArg = {
+    projectName: string;
+    'x-sender'?: string;
+    'x-sender-type'?: string;
+    operationsRequestModel: OperationsRequestModel;
+};
+export type ValidationError = {
+    loc: (string | number)[];
+    msg: string;
+    type: string;
+};
+export type HttpValidationError = {
+    detail?: ValidationError[];
+};
+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';
+};
+export type EventOperationModel = {
+    type: 'delete' | 'restart' | 'abort';
+    /** Filter source events */
+    filter: QueryFilter;
+};
+export type ActivityOperationResponseModel = {
+    id: string;
+    type: 'create' | 'update' | 'delete';
+    success: boolean;
+    status?: number;
+    detail?: string;
+    /** `None` if type is `create` and the operation fails. */
+    activityId?: string;
+};
+export type ActivityOperationsResponseModel = {
+    operations?: ActivityOperationResponseModel[];
+    success: boolean;
+};
+export type ActivityOperationModel = {
+    /** identifier manually or automatically assigned to each operation */
+    id?: string;
+    type: 'create' | 'update' | 'delete';
+    /** ID of the activity. None for create */
+    activityId?: string;
+    /** Data to be used for create or update. Ignored for delete.See create/patch activity endpoint for details */
+    data?: object;
+};
+export type ActivityOperationsRequestModel = {
+    operations?: ActivityOperationModel[];
+    canFail?: boolean;
+};
+export type OperationResponseModel = {
+    id: string;
+    type: 'create' | 'update' | 'delete';
+    entityType: 'folder' | 'product' | 'version' | 'representation' | 'task' | 'workfile';
+    entityId?: string;
+    success: boolean;
+    status: number;
+    errorCode?: string;
+    detail?: string;
+};
+export type OperationsResponseModel = {
+    operations?: OperationResponseModel[];
+    success: boolean;
+};
+export type OperationModel = {
+    id?: string;
+    type: 'create' | 'update' | 'delete';
+    entityType: 'folder' | 'product' | 'version' | 'representation' | 'task' | 'workfile';
+    entityId?: string;
+    data?: object;
+    force?: boolean;
+    asUser?: string;
+};
+export type OperationsRequestModel = {
+    operations?: OperationModel[];
+    canFail?: boolean;
+};

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

@@ -0,0 +1,223 @@
+export type ActivityResponseModel = {
+    /** Activity per day normalized to 0-100 */
+    activity: number[];
+};
+export type ProjectTeamsResponseModel = {
+    /** Number of active team members */
+    teamSizeActive?: number;
+    /** Total number of team members */
+    teamSizeTotal?: number;
+    /** Number of active users */
+    usersWithAccessActive?: number;
+    /** Total number of users */
+    usersWithAccessTotal?: number;
+    /** Number of users per role */
+    roles: {
+        [key: string]: number;
+    };
+};
+export type Root = {
+    name: string;
+    windows?: string;
+    linux?: string;
+    darwin?: string;
+};
+export type WorkTemplate = {
+    name: string;
+    directory: string;
+    file: string;
+};
+export type PublishTemplate = {
+    name: string;
+    directory: string;
+    file: string;
+};
+export type HeroTemplate = {
+    name: string;
+    directory: string;
+    file: string;
+};
+export type DeliveryTemplate = {
+    name: string;
+    directory: string;
+    file: string;
+};
+export type StagingDirectory = {
+    name: string;
+    directory?: string;
+};
+export type CustomTemplate = {
+    name: string;
+    value?: string;
+};
+export type Templates = {
+    version_padding?: number;
+    version?: string;
+    frame_padding?: number;
+    frame?: string;
+    work?: WorkTemplate[];
+    publish?: PublishTemplate[];
+    hero?: HeroTemplate[];
+    delivery?: DeliveryTemplate[];
+    staging?: StagingDirectory[];
+    others?: CustomTemplate[];
+};
+export type ProjectAttribModel = {
+    priority?: 'urgent' | 'high' | 'normal' | 'low';
+    /** Frame rate */
+    fps?: number;
+    /** Horizontal resolution */
+    resolutionWidth?: number;
+    /** Vertical resolution */
+    resolutionHeight?: number;
+    pixelAspect?: number;
+    clipIn?: number;
+    clipOut?: number;
+    frameStart?: number;
+    frameEnd?: number;
+    handleStart?: number;
+    handleEnd?: number;
+    /** Date and time when the project or task or asset was started */
+    startDate?: string;
+    /** Deadline date and time */
+    endDate?: string;
+    /** Textual description of the entity */
+    description?: string;
+    applications?: string[];
+    tools?: string[];
+};
+export type FolderType = {
+    name: string;
+    original_name?: string;
+    shortName?: string;
+    icon?: string;
+};
+export type TaskType = {
+    name: string;
+    original_name?: string;
+    shortName?: string;
+    color?: string;
+    icon?: string;
+};
+export type LinkType = {
+    link_type: string;
+    input_type: 'folder' | 'product' | 'version' | 'representation' | 'task' | 'workfile';
+    output_type: 'folder' | 'product' | 'version' | 'representation' | 'task' | 'workfile';
+    color?: string;
+    style?: 'solid' | 'dashed';
+};
+export type Status = {
+    name: string;
+    original_name?: string;
+    shortName?: string;
+    state?: 'not_started' | 'in_progress' | 'done' | 'blocked';
+    icon?: string;
+    color?: string;
+    /** Limit the status to specific entity types. */
+    scope?: string[];
+};
+export type Tag = {
+    name: string;
+    original_name?: string;
+    color?: string;
+};
+export type Anatomy = {
+    /** Setup root paths for the project */
+    roots?: Root[];
+    /** Path templates configuration */
+    templates?: Templates;
+    /** Attributes configuration */
+    attributes?: ProjectAttribModel;
+    /** Folder types configuration */
+    folder_types?: FolderType[];
+    /** Task types configuration */
+    task_types?: TaskType[];
+    /** Link types configuration */
+    link_types?: LinkType[];
+    /** Statuses configuration */
+    statuses?: Status[];
+    /** Tags configuration */
+    tags?: Tag[];
+};
+export type ListProjectsItemModel = {
+    name: string;
+    code: string;
+    active: boolean;
+    createdAt: string;
+    updatedAt: string;
+};
+export type ListProjectsResponseModel = {
+    detail?: string;
+    /** Total count of projects (regardless the pagination) */
+    count?: number;
+    /** List of projects */
+    projects?: ListProjectsItemModel[];
+};
+export type LinkTypeModel = {
+    /** Name of the link type */
+    name: string;
+    /** Type of the link */
+    linkType: string;
+    /** Input entity type */
+    inputType: string;
+    /** Output entity type */
+    outputType: string;
+    /** Additional link type data */
+    data?: object;
+};
+export type ProjectAttribModel2 = {
+    priority?: 'urgent' | 'high' | 'normal' | 'low';
+    /** Frame rate */
+    fps?: number;
+    /** Horizontal resolution */
+    resolutionWidth?: number;
+    /** Vertical resolution */
+    resolutionHeight?: number;
+    pixelAspect?: number;
+    clipIn?: number;
+    clipOut?: number;
+    frameStart?: number;
+    frameEnd?: number;
+    handleStart?: number;
+    handleEnd?: number;
+    /** Date and time when the project or task or asset was started */
+    startDate?: string;
+    /** Deadline date and time */
+    endDate?: string;
+    /** Textual description of the entity */
+    description?: string;
+    applications?: string[];
+    tools?: string[];
+};
+export type ProjectModel = {
+    /** Name is an unique id of the {entity_name} */
+    name: string;
+    code: string;
+    library?: boolean;
+    folderTypes?: FolderType[];
+    taskTypes?: TaskType[];
+    linkTypes?: LinkTypeModel[];
+    statuses?: Status[];
+    tags?: Tag[];
+    config?: object;
+    attrib?: ProjectAttribModel2;
+    data?: object;
+    /** Whether the project is active */
+    active?: boolean;
+    ownAttrib?: string[];
+    /** Time of creation */
+    createdAt?: string;
+    /** Time of last update */
+    updatedAt?: string;
+};
+export type UriResponseItem = {
+    id: string;
+    uri: string;
+};
+export type GetUrisResponse = {
+    uris?: UriResponseItem[];
+};
+export type GetUrisRequest = {
+    entityType: 'folder' | 'product' | 'version' | 'representation' | 'task' | 'workfile';
+    ids?: string[];
+};

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

@@ -0,0 +1,83 @@
+export type FolderListItem = {
+    id: string;
+    path: string;
+    parentId?: string;
+    parents: string[];
+    name: string;
+    label?: string;
+    folderType: string;
+    hasTasks?: boolean;
+    hasChildren?: boolean;
+    taskNames?: string[];
+    tags?: string[];
+    status: string;
+    attrib?: object;
+    ownAttrib?: string[];
+    updatedAt: string;
+};
+export type GetTasksByParentQuery = {
+    __typename?: 'Query';
+    project: {
+        __typename?: 'ProjectNode';
+        name: string;
+        tasks: {
+            __typename?: 'TasksConnection';
+            edges: Array<{
+                __typename?: 'TaskEdge';
+                node: {
+                    __typename?: 'TaskNode';
+                    id: string;
+                    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;
+                    folder: {
+                        __typename?: 'FolderNode';
+                        path?: string | null;
+                    };
+                };
+            }>;
+        };
+    };
+};
+export type TableRow = {
+    id: string;
+    parentId?: string;
+    name: string;
+    label: string;
+    icon: string | null;
+    color: string | null;
+    img: string | null;
+    startContent?: JSX.Element;
+    subRows: TableRow[];
+    status?: string;
+    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';
+};
+export type FolderNodeMap = Map<string, MatchingFolder>;
+type TaskNode = GetTasksByParentQuery['project']['tasks']['edges'][0]['node'];
+export type EditorTaskNode = TaskNode & {
+    attrib: Record<string, any>;
+    entityType?: 'task';
+};
+export type TaskNodeMap = Map<string, EditorTaskNode>;
+export type TasksByFolderMap = Map<string, string[]>;
+export {};

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

@@ -0,0 +1,42 @@
+/**
+ * Shared cell utilities for table operations
+ */
+export type CellId = string;
+export type RowId = string;
+export type ColId = string;
+export interface CellPosition {
+    rowId: RowId;
+    colId: ColId;
+}
+export declare enum BorderPosition {
+    None = 0,
+    Top = 1,
+    Right = 2,
+    Bottom = 4,
+    Left = 8,
+    All = 15
+}
+/**
+ * Create a standardized cell ID from row and column IDs
+ */
+export declare const getCellId: (rowId: RowId, colId: ColId) => CellId;
+/**
+ * Parse a cell ID to extract row and column IDs
+ * @returns CellPosition or null if invalid format
+ */
+export declare const parseCellId: (cellId: CellId) => CellPosition | null;
+export declare const getCellValue: (obj: any, path: string) => any;
+/**
+ * Determines which borders to display for a selected cell
+ * based on its position within the selection grid
+ *
+ * @param rowIndex Current cell's row index
+ * @param colIndex Current cell's column index
+ * @param selectedCells 2D array representing selection state (true = selected)
+ * @returns BorderPosition flags indicating which borders to display
+ */
+export declare const getCellBorders: (rowIndex: number, colIndex: number, selectedCells: boolean[][]) => BorderPosition;
+/**
+ * Converts border position flags to CSS classes for shadow styling
+ */
+export declare const getBorderClasses: (borders: BorderPosition) => string[];

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

@@ -0,0 +1,4 @@
+import { Filter } from '@ynput/ayon-react-components';
+import { QueryFilter } from '../types/operations';
+export declare const clientFilterToQueryFilter: (filters: Filter[]) => QueryFilter;
+export default clientFilterToQueryFilter;

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

@@ -0,0 +1,3 @@
+export * from '../types/table';
+export * from './clientFilterToQueryFilter';
+export * from './loadingUtils';

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

@@ -0,0 +1,36 @@
+import { TableRow, FolderNodeMap } from '../types/table';
+import { AttributeModel, LoadingTasks } from '../types';
+/**
+ * Generates an array of placeholder rows for loading state
+ * @param attribs - Attribute models used to populate empty attribute fields
+ * @param count - Number of loading rows to generate (default: 50)
+ * @returns Array of TableRow objects with loading state
+ */
+export declare const generateLoadingRows: (attribs: {
+    name: string;
+}[], count?: number, { type, parentId }?: {
+    type?: string;
+    parentId?: string;
+}) => TableRow[];
+/**
+ * Generates an array of dummy attribute models for loading states
+ * @param count - Number of dummy attributes to generate (default: 10)
+ * @returns Array of AttributeModel objects
+ */
+export declare const generateDummyAttributes: (count?: number) => AttributeModel[];
+/**
+ * Parameters for determineLoadingTaskFolders function
+ */
+export type DetermineLoadingTaskFoldersParams = {
+    expandedFoldersTasks: {
+        folderId: string | null;
+    }[];
+    expandedParentIds: string[];
+    foldersMap: FolderNodeMap;
+};
+/**
+ * Determines which folders are currently loading tasks
+ * @param params - Object containing parameters for determining loading folders
+ * @returns Array of folder IDs that are in loading state
+ */
+export declare const determineLoadingTaskFolders: ({ expandedFoldersTasks, expandedParentIds, foldersMap, }: DetermineLoadingTaskFoldersParams) => LoadingTasks;

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

@@ -0,0 +1,7 @@
+import { WidgetBaseProps } from './CellWidget';
+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/ProjectTreeTable/widgets/CellWidget.d.ts

@@ -0,0 +1,24 @@
+import { AttributeData, AttributeEnumItem } from '../types';
+type WidgetAttributeData = Pick<AttributeData, 'type'>;
+export type CellValue = string | number | boolean;
+interface EditorCellProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
+    rowId: string;
+    columnId: string;
+    value: CellValue | CellValue[];
+    attributeData?: WidgetAttributeData;
+    options?: AttributeEnumItem[];
+    isCollapsed?: boolean;
+    isInherited?: boolean;
+    isPlaceholder?: boolean;
+    isFocused?: boolean;
+    isReadOnly?: boolean;
+    enableCustomValues?: boolean;
+    onChange?: (value: CellValue | CellValue[], key?: 'Enter' | 'Click' | 'Escape') => void;
+}
+export interface WidgetBaseProps {
+    isEditing?: boolean;
+    onChange: Required<EditorCellProps>['onChange'];
+    onCancelEdit?: () => void;
+}
+export declare const CellWidget: import('react').NamedExoticComponent<EditorCellProps>;
+export {};

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

@@ -0,0 +1,5 @@
+interface CollapsedWidgetProps extends React.HTMLAttributes<HTMLDivElement> {
+    color?: string;
+}
+export declare const CollapsedWidget: import('react').ForwardRefExoticComponent<CollapsedWidgetProps & import('react').RefAttributes<HTMLDivElement>>;
+export {};

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

@@ -0,0 +1,8 @@
+import { WidgetBaseProps } from './CellWidget';
+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/ProjectTreeTable/widgets/DateWidgetInput.d.ts

@@ -0,0 +1,8 @@
+import { WidgetBaseProps } from './CellWidget';
+interface DateWidgetInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange'>, WidgetBaseProps {
+    value: string;
+    onCancel?: () => void;
+    autoFocus?: boolean;
+}
+export declare const DateWidgetInput: import('react').ForwardRefExoticComponent<DateWidgetInputProps & import('react').RefAttributes<HTMLInputElement>>;
+export {};

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

@@ -0,0 +1,14 @@
+type EntityNameWidgetProps = {
+    id: string;
+    label: string;
+    name: string;
+    path?: string | null;
+    showHierarchy?: boolean;
+    icon: string | null;
+    type: string;
+    isExpanded: boolean;
+    toggleExpandAll: (id: string) => void;
+    toggleExpanded: () => void;
+};
+export declare const EntityNameWidget: ({ id, label, name, path, showHierarchy, icon, type, isExpanded, toggleExpandAll, toggleExpanded, }: EntityNameWidgetProps) => import("react/jsx-runtime").JSX.Element;
+export {};

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

@@ -0,0 +1,28 @@
+import { DropdownProps } from '@ynput/ayon-react-components';
+import { WidgetBaseProps } from './CellWidget';
+import { AttributeData, AttributeEnumItem } from '../types';
+interface EnumWidgetProps extends Omit<DropdownProps, 'onChange' | 'value'>, WidgetBaseProps {
+    value: (string | number | boolean)[];
+    options: AttributeEnumItem[];
+    type?: AttributeData['type'];
+    autoOpen?: boolean;
+    isReadOnly?: boolean;
+    enableCustomValues?: boolean;
+    pt?: {
+        template?: Partial<EnumTemplateProps>;
+    };
+    onOpen?: () => void;
+    onNext?: () => void;
+}
+export declare const EnumWidget: import('react').ForwardRefExoticComponent<EnumWidgetProps & import('react').RefAttributes<HTMLDivElement>>;
+interface EnumTemplateProps extends React.HTMLAttributes<HTMLSpanElement> {
+    selectedOptions: AttributeEnumItem[];
+    placeholder?: string;
+    hasMultipleValues: boolean;
+    isMultiSelect?: boolean;
+    isOpen?: boolean;
+    isItem?: boolean;
+    isSelected?: boolean;
+    isReadOnly?: boolean;
+}
+export {};

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

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

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

@@ -0,0 +1,9 @@
+import { WidgetBaseProps } from './CellWidget';
+interface TextWidgetInputProps extends Omit<React.InputHTMLAttributes<HTMLInputElement>, 'onChange'> {
+    value: string;
+    onCancel?: () => void;
+    onChange: WidgetBaseProps['onChange'];
+    autoFocus?: boolean;
+}
+export declare const TextWidgetInput: import('react').ForwardRefExoticComponent<TextWidgetInputProps & import('react').RefAttributes<HTMLInputElement>>;
+export {};

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

@@ -0,0 +1,7 @@
+export { CollapsedWidget } from './CollapsedWidget';
+export { DateWidget } from './DateWidget';
+export { EnumWidget } from './EnumWidget';
+export { TextWidget } from './TextWidget';
+export { BooleanWidget } from './BooleanWidget';
+export { CellWidget } from './CellWidget';
+export { EntityNameWidget } from './EntityNameWidget';

package/dist/types/containers/Slicer/createFilterFromSlicer.d.ts

@@ -0,0 +1,6 @@
+import { SelectionData, SliceFilter, SliceType } from './types';
+export type CreateFilterFromSlicer = ({ selection, type, }: {
+    selection: SelectionData;
+    type: SliceType;
+}) => SliceFilter | null;
+export declare const createFilterFromSlicer: CreateFilterFromSlicer;

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

@@ -0,0 +1,2 @@
+export * from './types';
+export * from './createFilterFromSlicer';

package/dist/types/containers/Slicer/types.d.ts

@@ -0,0 +1,18 @@
+import { FilterValue } from '@ynput/ayon-react-components';
+export type SliceType = 'hierarchy' | 'assignees' | 'status' | 'type' | 'taskType';
+export type SliceDataItem = {
+    id: string;
+    name?: string | null;
+    label?: string | null;
+    subType?: string | null;
+};
+export type SelectionData = Record<string, SliceDataItem>;
+export interface SliceFilter extends FilterValue {
+    values: {
+        id: string;
+        label: string;
+    }[];
+}
+export type FilterBySliceData = {
+    filter: SliceFilter | null;
+};

package/dist/types/hooks/index.d.ts

@@ -0,0 +1 @@
+export * from './useLocalStorage';

package/dist/types/hooks/useLocalStorage.d.ts

@@ -0,0 +1 @@
+export declare function useLocalStorage<T>(key: string, defaultValue: T): [T, (value: T) => void];

package/dist/types/hooks.d.ts

@@ -0,0 +1 @@
+export {}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+import { EmptyPlaceholder, ThumbnailSimple, UserImage } from './components';
+export { EmptyPlaceholder, ThumbnailSimple, UserImage };