@ynput/ayon-frontend-shared 0.4.2 → 0.4.4

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

@@ -2,6 +2,9 @@ import { ButtonProps } from '@ynput/ayon-react-components';
 import { FC } from 'react';
 import { SettingHighlightedId } from '../../context/SettingsPanelContext';
 import { SettingConfig } from '../SettingsPanel/SettingsPanel';
+import { MenuItemType } from '../Menu';
+import { ParentColumnDefinition } from '../../containers';
+import { ColumnIdAliases } from '../../containers/ProjectTreeTable/utils/columnIds';
 interface Props extends ButtonProps {
     defaultSelected?: string | null;
 }
@@ -12,6 +15,7 @@ export type ProjectTableSettingsProps = {
     extraColumns?: {
         value: string;
         label: string;
+        icon?: string;
     }[];
     hiddenColumns?: string[];
     hiddenSettings?: ('columns' | 'row-height' | 'group-by' | 'sort-by')[];
@@ -20,6 +24,9 @@ export type ProjectTableSettingsProps = {
     hideSortBy?: boolean;
     order?: string[];
     scope?: string;
+    extraMenuItems?: MenuItemType[];
+    parentColumns?: ParentColumnDefinition[];
+    columnIdAliases?: ColumnIdAliases;
 };
 export declare const ProjectTableSettings: FC<ProjectTableSettingsProps>;
 export {};

package/dist/types/components/ProjectTableSettings/SortableColumnItem.d.ts

@@ -1,4 +1,4 @@
-import { FC } from 'react';
+import { default as React, FC } from 'react';
 import { SettingsPanelItem } from '../SettingsPanel';
 interface SortableColumnItemProps {
     id: string;
@@ -9,6 +9,9 @@ interface SortableColumnItemProps {
     isDisabled?: boolean;
     onTogglePinning: (columnId: string) => void;
     onToggleVisibility: (columnId: string) => void;
+    onPaintStart?: (columnId: string) => void;
+    onPaintEnter?: (columnId: string, pressed: boolean) => void;
+    onDragStart?: (event: React.PointerEvent) => void;
 }
 declare const SortableColumnItem: FC<SortableColumnItemProps>;
 export default SortableColumnItem;

package/dist/types/components/ProjectTableSettings/addColumnsMenu.d.ts

@@ -0,0 +1,32 @@
+import { default as React } from 'react';
+import { MenuItemType } from '../Menu';
+import { SettingsPanelItem } from '../SettingsPanel/SettingsPanelItemTemplate';
+import { EntityType } from '../../containers';
+export declare const DEFAULT_COLUMN_ICON = "text_fields";
+export declare const getDefaultColumnIcon: ({ field, parentScope, }: Pick<AddColumnItem, "field" | "parentScope">) => string;
+export type AddColumnItem = SettingsPanelItem & {
+    attrib?: {
+        builtin?: boolean;
+        scope?: string[];
+    };
+    field?: string;
+    isLink?: boolean;
+    parentScope?: EntityType;
+};
+export type AddColumnSection = {
+    id: string;
+    label: string;
+    icon: string;
+    match: (item: AddColumnItem) => boolean;
+};
+export declare const getAddColumnSection: (item: AddColumnItem, scopes?: string[]) => AddColumnSection | undefined;
+export declare const buildAddColumnsMenu: ({ columns, onToggle, isColumnVisible, onPaintStart, onPaintEnter, onDragStart, scopes, extraItems, }: {
+    columns: AddColumnItem[];
+    onToggle: (columnId: string) => void;
+    isColumnVisible: (columnId: string) => boolean;
+    onPaintStart?: (columnId: string) => void;
+    onPaintEnter?: (columnId: string, pressed: boolean) => void;
+    onDragStart?: (column: AddColumnItem, event: React.PointerEvent) => void;
+    scopes?: string[];
+    extraItems?: MenuItemType[];
+}) => MenuItemType[];

package/dist/types/components/ProjectTableSettings/index.d.ts

@@ -1,4 +1,5 @@
 export * from './ProjectTableSettings';
 export * from './ColumnsSettings';
 export * from './TableSettingsFallback';
+export * from './AddColumnButton';
 export * from '../SizeSlider/SizeSlider';

package/dist/types/components/ProjectTableSettings/useAddColumnDrag.d.ts

@@ -0,0 +1,7 @@
+import { AddColumnItem } from './addColumnsMenu';
+export declare const useAddColumnDrag: () => {
+    armDrag: (column: AddColumnItem, event: React.PointerEvent) => void;
+    cancelDrag: () => void;
+    isDragging: boolean;
+    dragOverlay: import('react').ReactPortal | null;
+};

package/dist/types/components/ProjectTableSettings/useAddColumnsMenu.d.ts

@@ -0,0 +1,15 @@
+import { AddColumnItem } from './addColumnsMenu';
+import { MenuItemType } from '../Menu';
+interface UseAddColumnsMenuProps {
+    columns: AddColumnItem[];
+    scopes?: string[];
+    extraItems?: MenuItemType[];
+}
+export declare const useAddColumnsMenu: ({ columns, scopes, extraItems }: UseAddColumnsMenuProps) => {
+    menuItems: MenuItemType[];
+    hasMenuItems: boolean;
+    dragOverlay: import('react').ReactPortal | null;
+    onColumnDragStart: (column: AddColumnItem, event: React.PointerEvent) => void;
+    isColumnDragging: boolean;
+};
+export {};

package/dist/types/components/ProjectTableSettings/useProjectTableColumnItems.d.ts

@@ -0,0 +1,37 @@
+import { ParentColumnDefinition } from '../../containers';
+interface UseProjectTableColumnItemsProps {
+    extraColumns?: {
+        value: string;
+        label: string;
+        icon?: string;
+    }[];
+    hiddenColumns?: string[];
+    includeLinks?: boolean;
+    parentColumns?: ParentColumnDefinition[];
+}
+export declare const useProjectTableColumnItems: ({ extraColumns, hiddenColumns, includeLinks, parentColumns, }: UseProjectTableColumnItemsProps) => {
+    columns: (import('..').SettingsPanelItem & {
+        attrib?: {
+            builtin?: boolean;
+            scope?: string[];
+        };
+        field?: string;
+        isLink?: boolean;
+        parentScope?: import('../../containers').EntityType;
+    } & {
+        hidden?: boolean;
+    })[];
+    visibleColumns: (import('..').SettingsPanelItem & {
+        attrib?: {
+            builtin?: boolean;
+            scope?: string[];
+        };
+        field?: string;
+        isLink?: boolean;
+        parentScope?: import('../../containers').EntityType;
+    } & {
+        hidden?: boolean;
+    })[];
+    scopes: string[];
+};
+export {};

package/dist/types/components/ProjectTableSettings/useVisibilityPaint.d.ts

@@ -0,0 +1,19 @@
+import { VisibilityState } from '@tanstack/react-table';
+interface UseVisibilityPaintProps {
+    columnVisibility: VisibilityState;
+    defaultColumnVisibility?: VisibilityState;
+    updateColumnVisibility: (visibility: VisibilityState) => void;
+    isLocked?: (columnId: string) => boolean;
+}
+export interface VisibilityPaint {
+    baseVisibility: VisibilityState;
+    displayVisibility: VisibilityState;
+    isVisible: (columnId: string) => boolean;
+    onPaintStart: (columnId: string) => void;
+    onPaintEnter: (columnId: string, pressed: boolean) => void;
+    toggle: (columnId: string) => void;
+    cancelPaint: () => void;
+    isPainting: boolean;
+}
+export declare const useVisibilityPaint: ({ columnVisibility, defaultColumnVisibility, updateColumnVisibility, isLocked, }: UseVisibilityPaintProps) => VisibilityPaint;
+export {};

package/dist/types/components/ReviewablesSelector/Card.d.ts

@@ -14,5 +14,6 @@ export type ReviewableCardProps = ReviewableCard & {
     onMouseOver: (event: MouseEvent<HTMLDivElement>, { label }: {
         label?: string;
     }) => void;
+    shortcut?: string;
 };
-export default function Card({ fileId, label, selected, projectName, onKeyDown, onMouseOver, onChange, tag, contextMenuItems, selectionVariant, }: ReviewableCardProps): import("react/jsx-runtime").JSX.Element;
+export default function Card({ fileId, label, selected, projectName, onKeyDown, onMouseOver, onChange, tag, contextMenuItems, selectionVariant, shortcut, }: ReviewableCardProps): import("react/jsx-runtime").JSX.Element;

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

@@ -11,6 +11,7 @@ export interface SettingConfig {
     component: ReactNode;
     icon?: string;
     preview?: string | number;
+    headerActions?: ReactNode;
 }
 export interface SettingsPanelProps {
     settings: SettingConfig[];

package/dist/types/components/SettingsPanel/SettingsPanelItemTemplate.d.ts

@@ -8,6 +8,7 @@ export type SettingsPanelItem = {
     value: string;
     label: string;
     icon?: string;
+    path?: string;
 };
 export interface SettingsPanelItemTemplateProps extends React.HTMLAttributes<HTMLLIElement> {
     item: SettingsPanelItem;

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

@@ -12,5 +12,6 @@ export interface ShareOptionIconProps {
     icon?: string;
     size?: number;
     withBackground?: boolean;
+    withTooltip?: boolean;
 }
 export declare const ShareOptionIcon: FC<ShareOptionIconProps>;

package/dist/types/components/SimpleForm/FormField.d.ts

@@ -0,0 +1,14 @@
+import { SimpleFormField } from '../../api';
+import { SimpleFormValue } from './types';
+export interface FormFieldProps {
+    field: SimpleFormField;
+    value: SimpleFormValue;
+    onChange: (value: SimpleFormValue) => void;
+}
+/**
+ * Renders the input for a single (non-label) field. `field` is expected to
+ * already be the *effective* field - static definition with any matching
+ * rule's patch (readOnly/disabled/hidden/options/...) merged on top - SimpleForm
+ * does that merging, this component just renders whatever it's handed.
+ */
+export declare const FormField: ({ field, value, onChange }: FormFieldProps) => import("react/jsx-runtime").JSX.Element | undefined;

package/dist/types/components/SimpleForm/FormLabel.d.ts

@@ -0,0 +1,5 @@
+import { SimpleFormField } from '../../api';
+export interface FormLabelProps {
+    field: SimpleFormField;
+}
+export declare const FormLabel: ({ field }: FormLabelProps) => import("react/jsx-runtime").JSX.Element;

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

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { SimpleFormField } from '../../api';
+import { SimpleFormValueDict } from './types';
+export interface SimpleFormProps {
+    fields: SimpleFormField[];
+    /** Initial/seed values - keyed by field name, same shape as onChange emits */
+    values?: SimpleFormValueDict;
+    /** Called with the full value dict whenever anything changes - a direct
+     * edit, a rule forcing a value, or a stale select value getting cleared */
+    onChange?: (values: SimpleFormValueDict) => void;
+    className?: string;
+    style?: React.CSSProperties;
+}
+/**
+ * The embeddable AYON simple form: renders `fields` (as built by
+ * ayon_server.forms.SimpleForm) with live rule evaluation and enum_resolver
+ * fetching. Owns its own field state - drop it in a dialog, a page, a
+ * sidebar, wherever; `onChange` is how a parent reads the current values.
+ *
+ * See useFormState for the rule/resolver "engine"; this component is just
+ * the render loop over its output.
+ */
+export declare const SimpleForm: ({ fields, values, onChange, className, style }: SimpleFormProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/SimpleForm/defaults.d.ts

@@ -0,0 +1,3 @@
+import { SimpleFormField } from '../../api';
+import { SimpleFormValueDict } from './types';
+export declare const getDefaults: (fields: SimpleFormField[], values: SimpleFormValueDict) => SimpleFormValueDict;

package/dist/types/components/SimpleForm/getFieldOptions.d.ts

@@ -0,0 +1,9 @@
+import { FormFieldPatch, FormOptionItem, SimpleFormField } from '../../api';
+import { ResolvedOptionsState } from './useResolvedOptions';
+/**
+ * The options a select/multiselect field should show right now: a rule's
+ * `set.options` wins if present, otherwise a resolver's live results (or `[]`
+ * while those haven't loaded yet), otherwise the field's own static list.
+ * Returns `undefined` for a field that isn't a select/multiselect at all.
+ */
+export declare const getFieldOptions: (field: SimpleFormField, patch: FormFieldPatch | undefined, resolvedOptions: ResolvedOptionsState) => FormOptionItem[] | undefined;

package/dist/types/components/SimpleForm/index.d.ts

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

package/dist/types/components/SimpleForm/ruleEngine.d.ts

@@ -0,0 +1,17 @@
+import { FormFieldPatch, QueryCondition, QueryFilter, SimpleFormField } from '../../api';
+type FormValues = Record<string, unknown>;
+export declare const evaluateCondition: (condition: QueryCondition, values: FormValues) => boolean;
+export declare const evaluateFilter: (filter: QueryFilter, values: FormValues) => boolean;
+export type FieldPatchMap = Record<string, FormFieldPatch>;
+/** Merge every matching rule's `set` for each field, in rule order (later rules win). */
+export declare const computeFieldPatches: (fields: SimpleFormField[], values: FormValues) => FieldPatchMap;
+/** Collect every `{{fieldName}}` reference out of a (possibly nested) value. */
+export declare const extractTemplateVars: (value: unknown) => string[];
+/**
+ * Substitute `{{fieldName}}` references with values from `values`.
+ * A string that is *only* a single template reference resolves to the referenced
+ * value as-is (preserving its type); a template embedded in a larger string is
+ * stringified in place.
+ */
+export declare const resolveTemplates: (value: unknown, values: FormValues) => unknown;
+export {};

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

@@ -0,0 +1,3 @@
+import { FormFileData } from './FormFile';
+export type SimpleFormValue = string | number | boolean | string[] | number[] | FormFileData | null | undefined;
+export type SimpleFormValueDict = Record<string, SimpleFormValue>;

package/dist/types/components/SimpleForm/useFormState.d.ts

@@ -0,0 +1,19 @@
+import { SimpleFormField } from '../../api';
+import { SimpleFormValue, SimpleFormValueDict } from './types';
+import { FieldPatchMap } from './ruleEngine';
+import { ResolvedOptionsState } from './useResolvedOptions';
+export interface FormStateApi {
+    formData: SimpleFormValueDict | null;
+    patches: FieldPatchMap;
+    resolvedOptions: ResolvedOptionsState;
+    setFieldValue: (name: string, value: SimpleFormValue) => void;
+}
+/**
+ * Owns every "moving part" of a SimpleForm: the field values themselves,
+ * which rules currently match (and the FormFieldPatch that follows from
+ * that), live enum_resolver options, and the two derived-state clamps that
+ * keep formData consistent with both of those:
+ *  - a rule forcing a value (e.g. clearing a field while it's read-only)
+ *  - a select/multiselect whose options changed out from under its value
+ */
+export declare const useFormState: (fields: SimpleFormField[], values?: SimpleFormValueDict) => FormStateApi;

package/dist/types/components/SimpleForm/useResolvedOptions.d.ts

@@ -0,0 +1,18 @@
+import { FormOptionItem, SimpleFormField } from '../../api';
+type FormValues = Record<string, unknown>;
+export type ResolvedOptionsState = Record<string, {
+    options: FormOptionItem[];
+    loading: boolean;
+}>;
+/**
+ * Fetches live options through the enum resolver registry for every field that
+ * declares one, re-fetching whenever its (template-resolved) params change.
+ *
+ * A field whose enumResolverParams reference an earlier field that isn't set
+ * yet is left with no options rather than firing a request the resolver
+ * would reject outright (e.g. ayon_server's "attrib" resolver 400s without a
+ * `name` param) - pair this with a `rules` entry that keeps the field
+ * read-only/cleared until its dependency is set.
+ */
+export declare const useResolvedOptions: (fields: SimpleFormField[], values: FormValues) => ResolvedOptionsState;
+export {};

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

@@ -1,7 +1,5 @@
-import { FormFileData } from './FormFile';
+import { SimpleFormValueDict } from '../SimpleForm';
 import { SimpleFormField } from '../../api';
-export type SimpleFormValue = string | number | boolean | string[] | number[] | FormFileData | null | undefined;
-export type SimpleFormValueDict = Record<string, SimpleFormValue>;
 export interface SimpleFormDialogProps {
     title: string;
     fields: SimpleFormField[];
@@ -14,4 +12,10 @@ export interface SimpleFormDialogProps {
     onSubmit: (values: SimpleFormValueDict) => void;
     isOpen: boolean;
 }
+/**
+ * Dialog chrome (header/footer/buttons) around an embedded SimpleForm. All
+ * the actual field rendering and rule/enumResolver logic lives in SimpleForm
+ * (and its helper modules) - this component only tracks the latest values
+ * for the submit button and stays out of the way otherwise.
+ */
 export declare const SimpleFormDialog: ({ fields, values, onClose, onSubmit, isOpen, title, submitLabel, cancelLabel, submitIcon, cancelIcon, }: SimpleFormDialogProps) => import("react/jsx-runtime").JSX.Element | null;

package/dist/types/components/SimpleFormDialog/index.d.ts

@@ -1 +1,2 @@
 export * from './SimpleFormDialog';
+export type { SimpleFormValue, SimpleFormValueDict } from '../SimpleForm';

package/dist/types/components/SubtasksManager/SubtasksManagerWrapper.d.ts

@@ -1,23 +1,41 @@
-import { QueryFilter, SubTaskNode, UserModel, useUpdateSubtasksMutation } from '../../api';
-import { useNavigate } from 'react-router';
+import { ThunkDispatch, UnknownAction } from '@reduxjs/toolkit';
+import { QueryFilter, SubTaskNode, UpdateEntitiesArgs, UpdateEntityOperation, UserModel, useUpdateSubtasksMutation } from '../../api';
+import { ProjectContextValue } from '../../context';
+import { useNavigate } from 'react-router-dom';
 type UpdateSubtasksMutation = ReturnType<typeof useUpdateSubtasksMutation>[0];
+export type EntityLinkChange = {
+    action: 'created' | 'removed';
+    linkId?: string;
+    linkType: string;
+    input: string;
+    output?: string;
+    outputType?: string;
+    inputType?: string;
+    data?: Record<string, unknown>;
+};
 export interface SubtasksManagerProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'title'> {
     subtasks: SubTaskNode[];
     projectName: string;
     taskId: string;
+    taskName: string;
+    folderId?: string;
     selectedSubtaskIds?: string[];
     users: UserModel[];
     title?: string | null;
     filters?: QueryFilter;
     actionsPortalClassName?: string;
+    projectContext: ProjectContextValue;
     onClose?: () => void;
     onSelectSubtasks?: (subtaskIds: string[]) => void;
     updateSubtasks: UpdateSubtasksMutation;
+    updateEntities: (args: UpdateEntitiesArgs) => Promise<UpdateEntityOperation[]>;
     useNavigate: typeof useNavigate;
+    onLink?: (change: EntityLinkChange) => void;
     onNotFound?: () => void;
+    dispatch?: ThunkDispatch<any, any, UnknownAction>;
 }
-export type SubtasksManagerWrapperProps = Omit<SubtasksManagerProps, 'updateSubtasks' | 'users'> & {
+export type SubtasksManagerWrapperProps = Omit<SubtasksManagerProps, 'updateSubtasks' | 'users' | 'projectContext'> & {
     SubtasksManager: React.ComponentType<SubtasksManagerProps>;
 };
-export declare const SubtasksManagerWrapper: ({ SubtasksManager, ...props }: SubtasksManagerWrapperProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SubtasksManagerWrapper: ({ SubtasksManager, dispatch, ...props }: SubtasksManagerWrapperProps) => import("react/jsx-runtime").JSX.Element;
 export {};

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

@@ -0,0 +1,8 @@
+import { FC } from 'react';
+export interface TableSearchProps {
+    value: string;
+    onChange: (value: string) => void;
+    onClose: () => void;
+    className?: string;
+}
+export declare const TableSearch: FC<TableSearchProps>;

package/dist/types/components/TableSearch/index.d.ts

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

package/dist/types/components/VersionUploader/context/VersionUploadContext.d.ts

@@ -36,7 +36,7 @@ export interface VersionUploadContextType {
     form: FormData;
     setForm: React.Dispatch<React.SetStateAction<FormData>>;
     isSubmitting: boolean;
-    error: string;
+    error: unknown;
     createdProductId: string | null;
     createdVersionId: string | null;
     onOpenVersionUpload: (params: {

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

@@ -14,9 +14,11 @@ export * from './DoneCheckbox';
 export * from './EarlyPreview';
 export * from './EmptyPlaceholder';
 export * from './InfoMessage';
+export * from './JsonViewer';
 export * from './EnumEditor';
 export * from './EntityPanelUploader';
 export * from './EntityPath';
+export * from './EntityTooltip';
 export * from './FeaturedVersionOrder';
 export * from './Feedback';
 export * from './FileThumbnail';
@@ -36,12 +38,14 @@ export * from './ReviewablesList';
 export * from './SearchFilter';
 export * from './SettingsPanel';
 export * from './ShareOptionIcon';
+export * from './SimpleForm';
 export * from './SimpleFormDialog';
 export * from './SizeSlider';
 export * from './StyledLink';
 export * from './SubtasksManager';
 export * from './SyncButton';
 export * from './TableGridSwitch';
+export * from './TableSearch';
 export * from './Thumbnail';
 export * from './ThumbnailSimple';
 export * from './UserImage';

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

@@ -16,6 +16,9 @@ interface EntityPickerDialogProps extends Pick<DialogProps, 'onClose'> {
     disabledMessage?: string;
     getDisabledMessage?: (id: string) => string | undefined;
     reviewableRequired?: boolean;
+    showReviewablesSwitch?: boolean;
+    defaultReviewablesOnly?: boolean;
+    showTaskNames?: boolean;
     isLoading?: boolean;
 }
 export declare const EntityPickerDialog: FC<EntityPickerDialogProps>;

package/dist/types/containers/EntityPickerDialog/components/EntityTypeTable.d.ts

@@ -3,6 +3,7 @@ import { PickerEntityType } from '../EntityPickerDialog';
 import { SimpleTableRow } from '../../SimpleTable/SimpleTable.types';
 interface EntityTypeTableProps {
     entityType: PickerEntityType;
+    projectName: string;
     tableData: SimpleTableRow[];
     isLoading?: boolean;
     error?: string;

package/dist/types/containers/EntityPickerDialog/hooks/useDeselectHiddenRows.d.ts

@@ -0,0 +1,11 @@
+import { RowSelectionState } from '@tanstack/react-table';
+import { PickerEntityType, PickerSelection } from '../EntityPickerDialog';
+import { EntityPickerDataReturn } from './useGetEntityPickerData';
+interface UseDeselectHiddenRowsProps {
+    entityHierarchy: PickerEntityType[];
+    entityData: EntityPickerDataReturn;
+    rowSelection: PickerSelection;
+    setEntityRowSelection: (selection: RowSelectionState, entityType: PickerEntityType) => void;
+}
+export declare const useDeselectHiddenRows: ({ entityHierarchy, entityData, rowSelection, setEntityRowSelection, }: UseDeselectHiddenRowsProps) => void;
+export {};

package/dist/types/containers/EntityPickerDialog/hooks/useGetEntityPickerData.d.ts

@@ -23,6 +23,8 @@ interface useGetEntityPickerDataProps {
     entityType: PickerEntityType;
     search: PickerSearch;
     selection: Record<PickerEntityType, string[]>;
+    reviewablesOnly?: boolean;
+    includeTask?: boolean;
 }
-export declare const useGetEntityPickerData: ({ projectName, entityType, search, selection, }: useGetEntityPickerDataProps) => EntityPickerDataReturn;
+export declare const useGetEntityPickerData: ({ projectName, entityType, search, selection, reviewablesOnly, includeTask, }: useGetEntityPickerDataProps) => EntityPickerDataReturn;
 export {};

package/dist/types/containers/EntityPickerDialog/hooks/useRowTooltip.d.ts

@@ -0,0 +1,22 @@
+import { SimpleTableRow } from '../../SimpleTable/SimpleTable.types';
+export type RowTooltipTarget = {
+    entityType: string;
+    entityId: string;
+};
+type HoveredRow = RowTooltipTarget & {
+    rowId: string;
+    pos: {
+        left: number;
+        top: number;
+    };
+};
+export declare const useRowTooltip: (entityType: string, rows?: SimpleTableRow[]) => {
+    hovered: HoveredRow | null;
+    onMouseOver: (event: React.MouseEvent<HTMLTableRowElement>) => void;
+    onMouseLeave: () => void;
+    tooltipProps: {
+        onMouseEnter: () => void;
+        onMouseLeave: () => void;
+    };
+};
+export {};

package/dist/types/containers/EntityPickerDialog/util/buildEntityPickerTableData.d.ts

@@ -5,5 +5,5 @@ export type EntityAnatomy = {
     icon?: string;
     color?: string;
 };
-export declare const buildEntityPickerTableData: (data: SearchEntityLink[], anatomies?: EntityAnatomy[]) => SimpleTableRow[];
-export declare const buildFolderPickerTableData: (data: FolderListItem[], anatomies: EntityAnatomy[]) => SimpleTableRow[];
+export declare const buildEntityPickerTableData: (data: SearchEntityLink[], projectName: string, anatomies?: EntityAnatomy[]) => SimpleTableRow[];
+export declare const buildFolderPickerTableData: (data: FolderListItem[], projectName: string, anatomies: EntityAnatomy[]) => SimpleTableRow[];

package/dist/types/containers/Feed/components/CommentInput/helpers.d.ts

@@ -5,5 +5,5 @@ type UploadedFile = {
     data: any;
 };
 export declare const uploadFile: (file: any, projectName: any, onUploadProgress: any) => Promise<UploadedFile>;
-export declare const handleFileDrop: (e: any, projectName: any, onProgress: any, onSuccess: any) => void;
+export declare const handleFileDrop: (e: any, projectName: any, onProgress: any, onSuccess: any, onError?: any) => void;
 export {};

package/dist/types/containers/Feed/components/CommentInput/hooks/useAnnotationsSync.d.ts

@@ -1,11 +1,14 @@
+type UploadingFile = {
+    name: string;
+};
 type Props = {
     entityId: string;
-    filesUploading: File[];
+    filesUploading: UploadingFile[];
 };
 export type AnnotationPreview = any & {
     unsavedAnnotation: any;
 };
-export declare const filterEntityAnnotations: (annotations: Record<string, any>, entityId: string, filesUploading: File[]) => AnnotationPreview[];
+export declare const filterEntityAnnotations: (annotations: Record<string, any>, entityId: string, filesUploading: UploadingFile[]) => AnnotationPreview[];
 declare const useAnnotationsSync: ({ entityId, filesUploading }: Props) => {
     annotations: any[];
     goToAnnotation: (annotation: AnnotationPreview) => void;

package/dist/types/containers/Feed/components/CommentInput/hooks/useAnnotationsUpload.d.ts

@@ -1,9 +1,12 @@
 import { SavedAnnotationMetadata } from '../../../index';
 type Props = {
     projectName: string;
-    onSuccess: (data: any) => any;
+    onSuccess: (data: any, isAnnotationLayer?: boolean) => any;
+    onProgress?: (e: any, file: any) => void;
+    onStart?: (annotation: any) => void;
+    onError?: (annotation: any) => void;
 };
-declare const useAnnotationsUpload: ({ projectName, onSuccess }: Props) => (annotations: any[]) => Promise<{
+declare const useAnnotationsUpload: ({ projectName, onSuccess, onProgress, onStart, onError }: Props) => (annotations: any[]) => Promise<{
     files: any[];
     metadata: SavedAnnotationMetadata[];
 }>;

package/dist/types/containers/Feed/components/CommentInput/hooks/useMentionLink.d.ts

@@ -1,5 +1,6 @@
 interface MentionLinkOptions {
     projectName: string;
+    editorRef: React.RefObject<any>;
 }
-declare const useMentionLink: ({ projectName }: MentionLinkOptions) => void;
+declare const useMentionLink: ({ projectName, editorRef }: MentionLinkOptions) => void;
 export default useMentionLink;

package/dist/types/containers/Feed/components/FileUploadPreview/FileUploadPreview.styled.d.ts

@@ -5,3 +5,4 @@ export declare const DialogWrapper: import('styled-components/dist/types').IStyl
 }, never>>> & string & Omit<import('react').ForwardRefExoticComponent<import('@ynput/ayon-react-components').DialogProps & import('react').RefAttributes<HTMLDivElement>>, keyof import('react').Component<any, {}, any>>;
 export declare const Image: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').ImgHTMLAttributes<HTMLImageElement>, HTMLImageElement>, never>>> & string;
 export declare const ScrollableContent: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
+export declare const PlayerWrapper: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;

package/dist/types/containers/Feed/components/FileUploadPreview/Mimes/VideoMime.d.ts

@@ -0,0 +1,11 @@
+import { FeedActivityMediaInfo } from '../../../../../api';
+interface VideoMimeProps {
+    file: {
+        id: string;
+        projectName: string;
+        name: string;
+        mediaInfo?: FeedActivityMediaInfo | null;
+    };
+}
+declare const VideoMime: ({ file }: VideoMimeProps) => import("react/jsx-runtime").JSX.Element;
+export default VideoMime;

package/dist/types/containers/Feed/components/FileUploadPreview/Mimes/VideoPlayer.d.ts

@@ -0,0 +1,13 @@
+export interface VideoPlayerProps {
+    id: string;
+    name: string;
+    url: string;
+    projectName: string;
+    duration: number;
+    width: number;
+    height: number;
+    fps?: number;
+    codec?: string;
+}
+declare const VideoPlayer: ({ id, name, url, projectName, duration, width, height, fps, codec, }: VideoPlayerProps) => import("react/jsx-runtime").JSX.Element;
+export default VideoPlayer;

package/dist/types/containers/Feed/components/Tooltips/EntityTooltip/EntityTooltip.d.ts

@@ -5,8 +5,6 @@ interface EntityTooltipProps {
         left?: number;
         top?: number;
     };
-    projectName?: string;
-    projectInfo?: any;
 }
 declare const EntityTooltip: React.FC<EntityTooltipProps>;
 export default EntityTooltip;