@ynput/ayon-frontend-shared 0.3.50 → 0.3.52

package/dist/shared/src/hooks/useUserProjectConfig.es.js.map

@@ -1 +1 @@
-{"version":3,"file":"useUserProjectConfig.es.js","sources":["../../../../src/hooks/useUserProjectConfig.ts"],"sourcesContent":["import { useSetFrontendPreferencesMutation } from '@shared/api'\nimport { useGlobalContext } from '@shared/context'\nimport { toast } from 'react-toastify'\n\ntype Props = {\n  selectors?: (string | undefined | null)[]\n  init?: any\n}\n\ntype Result = [\n  Record<string, any>,\n  (config: Record<string, any>) => Promise<void>,\n  { isSuccess: boolean },\n]\n\nexport const useUserProjectConfig = ({ selectors = [], init }: Props): Result => {\n  // GET CURRENT USER\n  const { user } = useGlobalContext()\n  // extract out columns config for project\n  const { data: { frontendPreferences: preferences = {} } = {} } = user || {}\n\n  const configPath = selectors\n    .filter((selector) => selector !== undefined && selector !== null)\n    .map((selector) => selector.replace(/\\s/g, ''))\n  // Start with the root preferences\n  let userConfig = preferences\n  for (const selector of configPath) {\n    userConfig = userConfig?.[selector]\n  }\n\n  userConfig = userConfig || init || {}\n\n  const [updateUserPreferences] = useSetFrontendPreferencesMutation()\n\n  // update the user preferences when the columns config changes\n  const updateProjectConfig = async (config: Record<string, any>) => {\n    try {\n      if (!user?.name) throw { data: { detail: 'User not found' } }\n\n      // Set the updated config at the correct nested path using only selectors\n      let updatedPreferences = { ...preferences }\n\n      // Helper function to set nested value\n      const setNestedValue = (obj: any, path: string[], value: any): any => {\n        if (path.length === 0) return { ...obj, ...value }\n\n        const [first, ...rest] = path\n        const nestedObj = obj?.[first] || {}\n\n        return {\n          ...obj,\n          [first]: setNestedValue(nestedObj, rest, value),\n        }\n      }\n\n      // Use the helper to set the value at the correct path\n      updatedPreferences = setNestedValue(updatedPreferences, configPath, config)\n\n      await updateUserPreferences({\n        userName: user.name,\n        patchData: updatedPreferences,\n        // @ts-expect-error - disableInvalidations is not in the api\n        disableInvalidations: true,\n      }).unwrap()\n    } catch (error: any) {\n      console.error(error)\n      toast.error(error.data?.detail)\n    }\n  }\n\n  return [userConfig, updateProjectConfig, { isSuccess: true }]\n}\n"],"names":["useUserProjectConfig","selectors","init","user","useGlobalContext","preferences","configPath","selector","userConfig","updateUserPreferences","useSetFrontendPreferencesMutation","config","updatedPreferences","setNestedValue","obj","path","value","first","rest","nestedObj","error","toast"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeO,MAAMA,KAAuB,CAAC,EAAE,WAAAC,IAAY,CAAA,GAAI,MAAAC,QAA0B;AAE/E,QAAM,EAAE,MAAAC,EAAA,IAASC,EAAA,GAEX,EAAE,MAAM,EAAE,qBAAqBC,IAAc,CAAA,MAAO,CAAA,MAAOF,KAAQ,CAAA,GAEnEG,IAAaL,EAChB,OAAO,CAACM,MAAuCA,KAAa,IAAI,EAChE,IAAI,CAACA,MAAaA,EAAS,QAAQ,OAAO,EAAE,CAAC;AAEhD,MAAIC,IAAaH;AACjB,aAAWE,KAAYD;AACrB,IAAAE,IAAaA,IAAaD,CAAQ;AAGpC,EAAAC,IAAaA,KAAcN,KAAQ,CAAA;AAEnC,QAAM,CAACO,CAAqB,IAAIC,EAAA;AAsChC,SAAO,CAACF,GAnCoB,OAAOG,MAAgC;AACjE,QAAI;AACF,UAAI,CAACR,GAAM,KAAM,OAAM,EAAE,MAAM,EAAE,QAAQ,mBAAiB;AAG1D,UAAIS,IAAqB,EAAE,GAAGP,EAAA;AAG9B,YAAMQ,IAAiB,CAACC,GAAUC,GAAgBC,MAAoB;AACpE,YAAID,EAAK,WAAW,EAAG,QAAO,EAAE,GAAGD,GAAK,GAAGE,EAAA;AAE3C,cAAM,CAACC,GAAO,GAAGC,CAAI,IAAIH,GACnBI,IAAYL,IAAMG,CAAK,KAAK,CAAA;AAElC,eAAO;AAAA,UACL,GAAGH;AAAA,UACH,CAACG,CAAK,GAAGJ,EAAeM,GAAWD,GAAMF,CAAK;AAAA,QAAA;AAAA,MAElD;AAGA,MAAAJ,IAAqBC,EAAeD,GAAoBN,GAAYK,CAAM,GAE1E,MAAMF,EAAsB;AAAA,QAC1B,UAAUN,EAAK;AAAA,QACf,WAAWS;AAAA;AAAA,QAEX,sBAAsB;AAAA,MAAA,CACvB,EAAE,OAAA;AAAA,IACL,SAASQ,GAAY;AACnB,cAAQ,MAAMA,CAAK,GACnBC,EAAM,MAAMD,EAAM,MAAM,MAAM;AAAA,IAChC;AAAA,EACF,GAEyC,EAAE,WAAW,IAAM;AAC9D;"}
+{"version":3,"file":"useUserProjectConfig.es.js","sources":["../../../../src/hooks/useUserProjectConfig.ts"],"sourcesContent":["import { useSetFrontendPreferencesMutation } from '@shared/api'\nimport { useGlobalContext } from '@shared/context'\nimport { toast } from 'react-toastify'\n\ntype Props = {\n  selectors?: (string | undefined | null)[]\n  init?: any\n}\n\ntype Result = [\n  Record<string, any>,\n  (config: Record<string, any>) => Promise<void>,\n  { isSuccess: boolean },\n]\n\nexport const useUserProjectConfig = ({ selectors = [], init }: Props): Result => {\n  // GET CURRENT USER\n  const { user } = useGlobalContext()\n  // extract out columns config for project\n  const { data: { frontendPreferences: preferences = {} } = {} } = user || {}\n\n  const configPath = selectors\n    .filter((selector) => selector !== undefined && selector !== null)\n    .map((selector) => selector.replace(/\\s/g, ''))\n  // Start with the root preferences\n  let userConfig = preferences\n  for (const selector of configPath) {\n    userConfig = userConfig?.[selector]\n  }\n\n  userConfig = userConfig || init || {}\n\n  const [updateUserPreferences] = useSetFrontendPreferencesMutation()\n\n  // update the user preferences when the columns config changes\n  const updateProjectConfig = async (config: Record<string, any>) => {\n    try {\n      if (!user?.name) throw { data: { detail: 'User not found' } }\n\n      // Set the updated config at the correct nested path using only selectors\n      let updatedPreferences = { ...preferences }\n\n      // Helper function to set nested value\n      const setNestedValue = (obj: any, path: string[], value: any): any => {\n        if (path.length === 0) return { ...obj, ...value }\n\n        const [first, ...rest] = path\n        const nestedObj = obj?.[first] || {}\n\n        return {\n          ...obj,\n          [first]: setNestedValue(nestedObj, rest, value),\n        }\n      }\n\n      // Use the helper to set the value at the correct path\n      updatedPreferences = setNestedValue(updatedPreferences, configPath, config)\n\n      await updateUserPreferences({\n        userName: user.name,\n        patchData: updatedPreferences,\n        // @ts-expect-error - disableInvalidations is not in the api\n        disableInvalidations: true,\n      }).unwrap()\n    } catch (error: any) {\n      console.error(error)\n      toast.error(error.data?.detail)\n    }\n  }\n\n  return [userConfig, updateProjectConfig, { isSuccess: true }]\n}\n"],"names":["useUserProjectConfig","selectors","init","user","useGlobalContext","preferences","configPath","selector","userConfig","updateUserPreferences","useSetFrontendPreferencesMutation","config","updatedPreferences","setNestedValue","obj","path","value","first","rest","nestedObj","error","toast"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAeO,MAAMA,KAAuB,CAAC,EAAE,WAAAC,IAAY,CAAA,GAAI,MAAAC,QAA0B;AAE/E,QAAM,EAAE,MAAAC,EAAA,IAASC,EAAA,GAEX,EAAE,MAAM,EAAE,qBAAqBC,IAAc,CAAA,MAAO,CAAA,MAAOF,KAAQ,CAAA,GAEnEG,IAAaL,EAChB,OAAO,CAACM,MAAuCA,KAAa,IAAI,EAChE,IAAI,CAACA,MAAaA,EAAS,QAAQ,OAAO,EAAE,CAAC;AAEhD,MAAIC,IAAaH;AACjB,aAAWE,KAAYD;AACrB,IAAAE,IAAaA,IAAaD,CAAQ;AAGpC,EAAAC,IAAaA,KAAcN,KAAQ,CAAA;AAEnC,QAAM,CAACO,CAAqB,IAAIC,EAAA;AAsChC,SAAO,CAACF,GAnCoB,OAAOG,MAAgC;AACjE,QAAI;AACF,UAAI,CAACR,GAAM,KAAM,OAAM,EAAE,MAAM,EAAE,QAAQ,mBAAiB;AAG1D,UAAIS,IAAqB,EAAE,GAAGP,EAAA;AAG9B,YAAMQ,IAAiB,CAACC,GAAUC,GAAgBC,MAAoB;AACpE,YAAID,EAAK,WAAW,EAAG,QAAO,EAAE,GAAGD,GAAK,GAAGE,EAAA;AAE3C,cAAM,CAACC,GAAO,GAAGC,CAAI,IAAIH,GACnBI,IAAYL,IAAMG,CAAK,KAAK,CAAA;AAElC,eAAO;AAAA,UACL,GAAGH;AAAA,UACH,CAACG,CAAK,GAAGJ,EAAeM,GAAWD,GAAMF,CAAK;AAAA,QAAA;AAAA,MAElD;AAGA,MAAAJ,IAAqBC,EAAeD,GAAoBN,GAAYK,CAAM,GAE1E,MAAMF,EAAsB;AAAA,QAC1B,UAAUN,EAAK;AAAA,QACf,WAAWS;AAAA;AAAA,QAEX,sBAAsB;AAAA,MAAA,CACvB,EAAE,OAAA;AAAA,IACL,SAASQ,GAAY;AACnB,cAAQ,MAAMA,CAAK,GACnBC,EAAM,MAAMD,EAAM,MAAM,MAAM;AAAA,IAChC;AAAA,EACF,GAEyC,EAAE,WAAW,IAAM;AAC9D;"}

package/dist/types/NewEntity.d.ts

@@ -0,0 +1,2 @@
+export * from './containers/NewEntity/index'
+export {}

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

@@ -50,3 +50,4 @@ export * from './Menu';
 export * from './EntityIcon';
 export * from './ReviewablesSelector';
 export * from './ColumnHeaderMenuUI';
+export * from 'primereact/confirmdialog';

package/dist/types/containers/Feed/components/ActivityFieldChange/ActivityFieldChange.d.ts

@@ -0,0 +1,36 @@
+import { default as React } from 'react';
+type FieldDisplayValue = {
+    name: string;
+    icon?: string;
+    color?: string;
+    items?: {
+        label: string;
+        color?: string;
+    }[];
+};
+interface ActivityFieldChangeProps {
+    entityType?: string;
+    projectInfo?: {
+        tags?: {
+            name: string;
+            color?: string;
+        }[];
+        [key: string]: any;
+    };
+    activity: {
+        activityType?: string;
+        authorName?: string;
+        authorFullName?: string;
+        createdAt?: string;
+        oldStatus?: FieldDisplayValue;
+        newStatus?: FieldDisplayValue;
+        activityData?: {
+            key?: string;
+            oldValue?: unknown;
+            newValue?: unknown;
+        };
+        [key: string]: any;
+    };
+}
+declare const ActivityFieldChange: React.FC<ActivityFieldChangeProps>;
+export default ActivityFieldChange;

package/dist/types/containers/Feed/components/{ActivityStatusChange/ActivityStatusChange.styled.d.ts → ActivityFieldChange/ActivityFieldChange.styled.d.ts}

@@ -1,3 +1,3 @@
-export declare const StatusChange: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, never>>> & string;
+export declare const FieldChange: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, never>>> & string;
 export declare const Body: 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 Text: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>> & string;

package/dist/types/containers/Feed/components/ActivityFieldChange/FieldValue.d.ts

@@ -0,0 +1,11 @@
+interface FieldValueProps extends React.HTMLAttributes<HTMLDivElement> {
+    icon?: string;
+    color?: string;
+    name: string;
+    items?: {
+        label: string;
+        color?: string;
+    }[];
+}
+export declare const FieldValue: import('react').ForwardRefExoticComponent<FieldValueProps & import('react').RefAttributes<HTMLDivElement>>;
+export {};

package/dist/types/containers/Feed/components/ActivityGroup/ActivityGroup.d.ts

@@ -4,6 +4,7 @@ interface ActivityGroupProps {
         disabled?: boolean;
         isLoading?: boolean;
     };
+    projectInfo?: Record<string, any>;
 }
 declare const ActivityGroup: ({ activities, editProps, ...props }: ActivityGroupProps) => import("react/jsx-runtime").JSX.Element;
 export default ActivityGroup;

package/dist/types/containers/Feed/components/ActivityVersionReview/ActivityVersionReview.d.ts

@@ -16,6 +16,6 @@ interface ActivityVersionReviewProps {
 }
 export declare const getVerbForFeedback: (feedback: VersionReviewFeedback) => "requested changes" | "approved this";
 export declare const getVerbForFeedbackBody: (feedback: VersionReviewFeedback, entityType: string) => string;
-export declare const getIconForFeedback: (feedback: VersionReviewFeedback) => "refresh" | "task_alt";
+export declare const getIconForFeedback: (feedback: VersionReviewFeedback) => "task_alt" | "refresh";
 declare const ActivityVersionReview: React.FC<ActivityVersionReviewProps>;
 export default ActivityVersionReview;

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

@@ -0,0 +1,10 @@
+import { FC } from 'react';
+import { MultiEntityMoveData, OnMoveComplete } from './types';
+interface MoveEntityDialogProps {
+    projectName: string;
+    movingEntities: MultiEntityMoveData | null;
+    onClose: () => void;
+    onMoveComplete?: OnMoveComplete;
+}
+export declare const MoveEntityDialog: FC<MoveEntityDialogProps>;
+export {};

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

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

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

@@ -0,0 +1,12 @@
+export type EntityMoveType = 'folder' | 'task';
+export interface EntityMoveData {
+    entityId: string;
+    entityType: EntityMoveType;
+    name?: string;
+    currentParentId?: string;
+}
+export interface MultiEntityMoveData {
+    entities: EntityMoveData[];
+}
+export type OnMoveComplete = (targetFolderId: string) => void;
+export type OpenMoveDialog = (data: EntityMoveData | MultiEntityMoveData) => void;

package/dist/types/containers/NewEntity/components/FolderSequence.d.ts

@@ -0,0 +1,36 @@
+import { default as React, ReactNode } from 'react';
+interface SequenceTypeOption {
+    name: string;
+    shortName?: string;
+    [key: string]: unknown;
+}
+type SequenceEntityType = 'folder' | 'task';
+interface SequenceValues {
+    id?: string;
+    entityType?: SequenceEntityType;
+    base?: string;
+    increment?: string;
+    length?: number;
+    type?: string;
+    prefix?: boolean;
+    prefixDepth?: number;
+    parentBases?: string[];
+    [key: string]: unknown;
+}
+interface FolderSequenceProps extends SequenceValues {
+    onChange: (value: SequenceValues, id?: string | null, entityType?: SequenceEntityType) => void;
+    parentId?: string | null;
+    children?: ReactNode;
+    depth?: number;
+    onNew?: (parentId: string | null, entityType?: SequenceEntityType) => void;
+    index?: number;
+    nesting?: boolean;
+    isRoot?: boolean;
+    parentLabel?: string;
+    prefixDisabled?: boolean;
+    typeSelectRef?: React.RefObject<HTMLElement>;
+    onLastInputKeydown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+    folders: SequenceTypeOption[];
+}
+declare const FolderSequence: React.FC<FolderSequenceProps>;
+export default FolderSequence;

package/dist/types/containers/NewEntity/components/FolderSequence.styled.d.ts

@@ -0,0 +1,20 @@
+export declare const FolderSequenceWrapper: 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 SequenceContainer: 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 TaskContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & {
+    as?: import('styled-components').WebTarget | undefined;
+    forwardedAs?: import('styled-components').WebTarget | undefined;
+}, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
+}, never> & Partial<Pick<Omit<import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>> & {
+    as?: import('styled-components').WebTarget | undefined;
+    forwardedAs?: import('styled-components').WebTarget | undefined;
+}, "ref"> & {
+    ref?: ((instance: HTMLDivElement | null) => void | import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof import('react').DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | import('react').RefObject<HTMLDivElement> | null | undefined;
+}, never>>> & string;
+export declare const SequenceForm: 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 InputColumn: 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 Children: 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 RowWrapper: 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 AddButtons: 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 Example: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>> & string;
+export declare const Prefix: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never> & Partial<Pick<import('react').DetailedHTMLProps<import('react').HTMLAttributes<HTMLSpanElement>, HTMLSpanElement>, never>>> & string;

package/dist/types/containers/NewEntity/components/NewEntity.d.ts

@@ -0,0 +1,12 @@
+import { default as React } from 'react';
+import { OperationResponseModel, ProjectModel } from '../../../api';
+import { NewEntityType } from '../context/NewEntityContext';
+export interface NewEntityProps {
+    disabled?: boolean;
+    onNewEntities?: (ops: OperationResponseModel[], stayOpen: boolean) => void;
+    showButton?: boolean;
+    showDialog?: boolean;
+    enableShortcuts?: boolean;
+}
+export declare const NewEntity: React.FC<NewEntityProps>;
+export declare const generateLabel: (type: NewEntityType | null, subType: string, projectInfo: ProjectModel | undefined) => string;

package/dist/types/containers/NewEntity/components/NewEntityForm.d.ts

@@ -0,0 +1,15 @@
+import { default as React, KeyboardEvent } from 'react';
+import { EntityForm } from '../context/NewEntityContext';
+export declare const InputLabel: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.LabelHTMLAttributes<HTMLLabelElement>, HTMLLabelElement>, never>>> & string;
+export declare const InputsContainer: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
+export declare const NameRow: import('styled-components/dist/types').IStyledComponentBase<"web", import('styled-components').FastOmit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
+type NewEntityFormProps = {
+    handleChange: (value: any, id?: keyof EntityForm) => void;
+    entityForm: any;
+    labelRef: any;
+    setNameFocused: (focused: boolean) => void;
+    handleKeyDown: (e: KeyboardEvent, isLabel: boolean) => void;
+    nameInfo?: string;
+};
+export declare const NewEntityForm: React.FC<NewEntityFormProps>;
+export {};

package/dist/types/containers/NewEntity/components/TypeEditor.d.ts

@@ -0,0 +1,18 @@
+import { FolderType, TaskType } from '../../../api';
+import { DropdownRef } from '@ynput/ayon-react-components';
+import { CSSProperties } from 'react';
+interface TypeEditorProps {
+    value: string;
+    options: (FolderType | TaskType)[];
+    onChange: (value: string) => void;
+    style?: CSSProperties;
+    mainStyle?: CSSProperties;
+    disabled?: boolean;
+    placeholder?: string;
+    isChanged?: boolean;
+    align?: string;
+    type: string;
+    [key: string]: any;
+}
+declare const TypeEditor: import('react').ForwardRefExoticComponent<Omit<TypeEditorProps, "ref"> & import('react').RefAttributes<DropdownRef>>;
+export default TypeEditor;

package/dist/types/containers/NewEntity/context/NewEntityContext.d.ts

@@ -0,0 +1,37 @@
+import { default as React, ReactNode } from 'react';
+import { OperationResponseModel, EntityNaming } from '../../../api';
+import { NewEntityType } from '../util/entityDefinitions';
+export type { NewEntityType } from '../util/entityDefinitions';
+export interface EntityForm {
+    label: string;
+    subType: string;
+    name: string;
+}
+export interface NewEntityOpenConfig {
+    isSequence?: boolean;
+    parentFolderIds?: string[];
+}
+interface SequenceForm {
+    active: boolean;
+    increment: string;
+    length: number;
+    prefix: boolean;
+    prefixDepth: number;
+}
+export interface NewEntityContextType {
+    config: EntityNaming;
+    entityType: NewEntityType | null;
+    setEntityType: React.Dispatch<React.SetStateAction<NewEntityType | null>>;
+    entityForm: EntityForm;
+    setEntityForm: React.Dispatch<React.SetStateAction<EntityForm>>;
+    sequenceForm: SequenceForm;
+    setSequenceForm: React.Dispatch<React.SetStateAction<SequenceForm>>;
+    onCreateNew: (selectedFolderIds: string[]) => Promise<OperationResponseModel[]>;
+    onOpenNew: (type: NewEntityType, config?: NewEntityOpenConfig) => void;
+    parentFolderIds: string[] | null;
+}
+interface NewEntityProviderProps {
+    children: ReactNode;
+}
+export declare const NewEntityProvider: React.FC<NewEntityProviderProps>;
+export declare const useNewEntityContext: () => NewEntityContextType;

package/dist/types/containers/NewEntity/context/NewEntityContextInstance.d.ts

@@ -0,0 +1,2 @@
+import { NewEntityContextType } from './NewEntityContext';
+export declare const NewEntityContext: import('react').Context<NewEntityContextType | undefined>;

package/dist/types/containers/NewEntity/hooks/useCreateEntityShortcuts.d.ts

@@ -0,0 +1,21 @@
+import { NewEntityOpenConfig, NewEntityType } from '../context/NewEntityContext';
+interface EntityOption {
+    label: string;
+    value: string;
+    type: NewEntityType;
+    icon: string;
+    shortcut?: string;
+    isSequence?: boolean;
+}
+interface UseCreateEntityShortcutsProps {
+    options: EntityOption[];
+    onOpenNew: (type: NewEntityType, config?: NewEntityOpenConfig) => void;
+    enabled?: boolean;
+}
+/**
+ * Hook to handle keyboard shortcuts for entity creation
+ * @param options Array of entity options with shortcut keys
+ * @param onOpenNew Callback function to open entity creation dialog
+ */
+declare const useCreateEntityShortcuts: ({ options, onOpenNew, enabled, }: UseCreateEntityShortcutsProps) => void;
+export default useCreateEntityShortcuts;

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

@@ -0,0 +1,4 @@
+export * from './context/NewEntityContext';
+export * from './components/NewEntity';
+export * from './components/NewEntityForm';
+export * from './util/entityDefinitions';

package/dist/types/containers/NewEntity/util/entityDefinitions.d.ts

@@ -0,0 +1,7 @@
+import { IconProps } from '@ynput/ayon-react-components';
+export type NewEntityType = 'folder' | 'task';
+export declare const newEntityDefinitions: Record<NewEntityType, {
+    label: string;
+    createLabel: string;
+    icon: IconProps['icon'];
+}>;

package/dist/types/containers/NewEntity/util/getSequence.d.ts

@@ -0,0 +1 @@
+export declare const getSequence: (start: string, next: string, length: number) => string[];

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

@@ -8,6 +8,7 @@ import { BuiltInFieldOptions, MainCountLabels } from './types';
 import { ToggleExpandAll } from './context/ProjectTableContext';
 import { EntityUpdate } from './hooks/useUpdateTableData';
 import { UniqueIdentifier } from '@dnd-kit/core';
+import { NewEntityOpenConfig } from '../NewEntity';
 import { ColumnsConfig } from './types/columnConfig';
 type CellUpdate = (entity: Omit<EntityUpdate, 'id'>, config?: {
     selection?: string[];
@@ -28,7 +29,7 @@ export interface ProjectTreeTableProps extends React.HTMLAttributes<HTMLDivEleme
     scope: string;
     sliceId: string;
     onScrollBottom?: React.HTMLAttributes<HTMLDivElement>['onScroll'];
-    onOpenNew?: (type: 'folder' | 'task') => void;
+    onOpenNew?: (type: 'folder' | 'task', config?: NewEntityOpenConfig) => void;
     readOnly?: (DefaultColumns | string)[];
     excludedColumns?: (DefaultColumns | string)[];
     excludedSorting?: (DefaultColumns | string)[];

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

@@ -136,3 +136,4 @@ export interface ProjectTableProviderProps {
 }
 export declare const ProjectTableProvider: ({ children, foldersMap, tableRows, tasksMap, entitiesMap, tasksByFolderMap, selectedFolders, expanded, showHierarchy, loadingTasks, isLoadingMore, isLoading, error, softError, softErrorAction, isInitialized, users, attribFields, scopes, groups, groupRowFunc, overrideGroupBy, groupCounts, groupCountsComplete, queryFilters, updateShowHierarchy, toggleExpanded, updateExpanded, fetchNextPage, onSyncData, setExpanded, contextMenuItems, powerpack, modules, loadingLinksEntityIds, groupByConfig, hierarchyOptions, hierarchyActive, isFlatFolderView, SubtasksManager, playerOpen, onOpenPlayer, onResetView, useParams, useNavigate, useLocation, useSearchParams, }: ProjectTableProviderProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useProjectTableContext: () => ProjectTableContextType;
+export declare const useOptionalProjectTableContext: () => ProjectTableContextType | undefined;

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

@@ -8,3 +8,4 @@ export interface SelectedRowsContextType {
 }
 export declare const SelectedRowsContext: import('react').Context<SelectedRowsContextType | undefined>;
 export declare const useSelectedRowsContext: () => SelectedRowsContextType;
+export declare const useOptionalSelectedRowsContext: () => SelectedRowsContextType | undefined;

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

@@ -30,3 +30,4 @@ export interface SelectionCellsContextType {
 }
 export declare const SelectionCellsContext: React.Context<SelectionCellsContextType | undefined>;
 export declare const useSelectionCellsContext: () => SelectionCellsContextType;
+export declare const useOptionalSelectionCellsContext: () => SelectionCellsContextType | undefined;

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

@@ -3,6 +3,7 @@ import { ProjectTableAttribute, TableRow } from '../types';
 import { UseHistoryReturn } from './useHistory';
 import { ColumnDef } from '@tanstack/react-table';
 import { EntityMap } from '../utils';
+import { NewEntityOpenConfig } from '../../NewEntity';
 type ContextEvent = React.MouseEvent<HTMLTableSectionElement, MouseEvent>;
 export type HeaderLabel = {
     id: string;
@@ -37,7 +38,7 @@ type CellContextMenuProps = {
     attribs: ProjectTableAttribute[];
     columns?: ColumnDef<TableRow>[];
     headerLabels: HeaderLabel[];
-    onOpenNew?: (type: 'folder' | 'task') => void;
+    onOpenNew?: (type: 'folder' | 'task', config?: NewEntityOpenConfig) => void;
     contextMenuItems?: ContextMenuItemConstructors;
 };
 declare const useCellContextMenu: ({ attribs, headerLabels, onOpenNew, contextMenuItems: propsContextMenuItems, }: CellContextMenuProps) => {

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

@@ -1,14 +1,12 @@
-import { EntityMoveData, MultiEntityMoveData } from '../../../context/MoveEntityContext';
+import { MultiEntityMoveData, OnMoveComplete } from '../../MoveEntityDialog';
 export type EntityType = 'folder' | 'task';
 interface UseMoveEntitiesProps {
     projectName: string;
-}
-export declare const useMoveEntities: ({ projectName }: UseMoveEntitiesProps) => {
     movingEntities: MultiEntityMoveData | null;
-    isEntityPickerOpen: boolean;
-    isDialogOpen: boolean;
-    openMoveDialog: (entityData: EntityMoveData | MultiEntityMoveData) => void;
-    closeMoveDialog: () => void;
+    onClose: () => void;
+    onMoveComplete?: OnMoveComplete;
+}
+export declare const useMoveEntities: ({ projectName, movingEntities, onClose, onMoveComplete, }: UseMoveEntitiesProps) => {
     handleMoveSubmit: (selectedFolderIds: string[]) => Promise<void>;
     handleMoveToRoot: () => Promise<void>;
     getDisabledFolderIds: () => string[];

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

@@ -8,10 +8,6 @@ import { ProjectTableModulesType } from '../../../hooks';
 import { QueryFilter } from './operations';
 import { ReactNode } from 'react';
 import { ProjectInfo } from '../../DetailsPanel/helpers/mergeProjectInfo';
-interface EntityMoveData {
-    entityId: string;
-    entityType: 'folder';
-}
 export interface ProjectOverviewProviderProps {
     children: ReactNode;
     modules: ProjectTableModulesType;
@@ -73,11 +69,12 @@ export interface ProjectOverviewContextType {
     toggleExpanded: (id: string) => void;
     updateExpanded: OnChangeFn<ExpandedState>;
     setExpanded: (expanded: ExpandedState) => void;
-    contextMenuItems: ContextMenuItemConstructors;
     loadingLinksEntityIds: Set<string>;
     setLinksVisible: (visible: boolean) => void;
+    contextMenuItems: ContextMenuItemConstructors;
+    movingEntities: import('../../MoveEntityDialog').MultiEntityMoveData | null;
+    closeMoveDialog: () => void;
     visibleEntityIds: string[];
     setVisibleEntityIds: (entityIds: string[]) => void;
-    openMoveDialog?: (entityData: EntityMoveData) => void;
 }
 export {};

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

@@ -26,4 +26,10 @@ export declare const queryFilterToClientFilter: (queryFilter: QueryFilter | unde
  * and merges them into a single datetime Filter with proper range values.
  */
 export declare const tryMergeDatetimeRange: (nestedFilter: QueryFilter, filterOptions: Option[]) => Filter | null;
+/**
+ * Detects the composite nullness groups produced by clientFilterToQueryFilter for
+ * text fields (isnull OR eq '' / notnull AND ne '') and restores the
+ * noValue/hasValue chip instead of recursing into the group's conditions.
+ */
+export declare const tryMergeTextNullness: (nestedFilter: QueryFilter, filterOptions: Option[]) => Filter | null;
 export default queryFilterToClientFilter;

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

@@ -48,6 +48,7 @@ export type SimpleTableRowContextMenuContext = {
     rowIndex: number;
     row: Row<SimpleTableRow>;
     selectedRows: string[];
+    selectedTableRows: Row<SimpleTableRow>[];
     isSelected: boolean;
 };
 export type SimpleTableRowContextMenuBuilder = (e: React.MouseEvent<HTMLTableRowElement>, context: SimpleTableRowContextMenuContext) => ContextMenuItemType | ContextMenuItemType[] | undefined;
@@ -67,9 +68,11 @@ export interface SimpleTableProps extends Omit<React.HTMLAttributes<HTMLDivEleme
     onScrollBottom?: () => void;
     onRename?: (id: string, row: Row<SimpleTableRow>) => void;
     renamingId?: string | null;
+    renameInitialValue?: string;
     onSubmitRename?: (id: string, value: string) => void;
     onCancelRename?: () => void;
     onRowDoubleClick?: (id: string, row: Row<SimpleTableRow>) => void;
+    onRowOptionClick?: (row: SimpleTableRow, selectedRows: string[]) => void;
     fitContent?: boolean;
     rowContextMenuBuilders?: SimpleTableRowContextMenuBuilder[];
     children?: (props: SimpleTableCellTemplateProps, row: Row<SimpleTableRow>, table: Table<SimpleTableRow>) => JSX.Element;

package/dist/types/containers/SimpleTable/SimpleTableRowTemplate.d.ts

@@ -7,7 +7,7 @@ export type RowExpanderProps = {
     isRowExpanded?: boolean;
     enableNonFolderIndent?: boolean;
     isTableExpandable?: boolean;
-    onExpandClick?: () => void;
+    onExpandClick?: (event: React.MouseEvent) => void;
 };
 export declare const RowExpander: ({ isRowExpandable, isRowExpanded, enableNonFolderIndent, isTableExpandable, onExpandClick, }: RowExpanderProps) => false | import("react/jsx-runtime").JSX.Element | undefined;
 export interface SimpleTableCellTemplateProps extends React.HTMLAttributes<HTMLDivElement> {

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

@@ -1,11 +1,12 @@
 import { FC } from 'react';
 import { SlicerCountsSource } from '../hooks/useSlicerCounts';
-import { SliceType } from '..';
+import { OnAddToList, SliceType } from '..';
 import { SliceTypeField } from '../types';
 export interface SlicerProps {
     sliceFields: SliceTypeField[];
     entityTypes?: string[];
     pinnedSliceType?: SliceType;
     countsSource?: SlicerCountsSource;
+    onAddToList?: OnAddToList;
 }
 export declare const Slicer: FC<SlicerProps>;

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

@@ -9,6 +9,7 @@ import { PinnedSlice, SliceTypeField } from '../types';
 import { ViewSettings } from '../../Views';
 import { UpdateViewSettingsFn } from '../../Views/utils/viewUpdateHelper';
 import { SlicerContext } from './SlicerContextInstance';
+import { OnAddToList, OnOpenViewer } from '../hooks/useHierarchyContextMenuItems';
 export declare const SLICER_PAGES_CONFIG: SlicerConfig;
 export type OnSliceTypeChange = (sliceType: SliceType, pinCurrent?: boolean) => void;
 export type SlicerConfig = {
@@ -41,6 +42,8 @@ export interface SlicerContextValue {
     useExtraSlices: UseExtraSlices;
     isLoadingExtraSlices: boolean;
     SlicerDropdown: ForwardRefExoticComponent<SlicerDropdownFallbackProps & RefAttributes<DropdownRef>>;
+    onOpenViewer?: OnOpenViewer;
+    onAddToList?: OnAddToList;
 }
 interface SlicerProviderProps {
     children: ReactNode;
@@ -55,7 +58,9 @@ interface SlicerProviderProps {
     viewSettings: ViewSettings | undefined;
     isLoadingViews: boolean;
     updateViewSettings: UpdateViewSettingsFn;
+    onOpenViewer?: OnOpenViewer;
+    onAddToList?: OnAddToList;
 }
-export declare const SlicerProvider: ({ children, page, projectName, viewSettings, isLoadingViews, updateViewSettings, ...props }: SlicerProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const SlicerProvider: ({ children, page, projectName, viewSettings, isLoadingViews, updateViewSettings, onOpenViewer, onAddToList, ...props }: SlicerProviderProps) => import("react/jsx-runtime").JSX.Element;
 export declare const useSlicerContext: () => SlicerContextValue;
 export default SlicerContext;

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

@@ -1,4 +1,5 @@
 export * from './useFiltersWithHierarchy';
+export * from './useHierarchyContextMenuItems';
 export * from './useProjectAnatomySlices';
 export * from './useSlicerAttributesData';
 export * from './useSlicerRemotes';

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

@@ -0,0 +1,15 @@
+import { SimpleTableRow, SimpleTableRowContextMenuBuilder } from '../../SimpleTable';
+import { ContextMenuItemType } from '../../ContextMenu';
+import { OpenMoveDialog } from '../../MoveEntityDialog';
+import { SliceMap } from '../types';
+export type OnAddToList = (row: SimpleTableRow, selectedRows: string[]) => ContextMenuItemType | ContextMenuItemType[] | undefined;
+export type OnOpenViewer = (row: SimpleTableRow, projectName: string) => void;
+export declare const useHierarchyContextMenuItems: (onAddToList?: OnAddToList, entityMap?: SliceMap, onOpenViewer?: OnOpenViewer, openMoveDialog?: OpenMoveDialog) => {
+    rowContextMenuBuilders: SimpleTableRowContextMenuBuilder[];
+    onOptionClick: (row: SimpleTableRow, selectedRows?: string[]) => void;
+    onRename: (row: SimpleTableRow) => void;
+    renamingRow: SimpleTableRow | null;
+    renameInitialValue: string;
+    onSubmitRename: (value: string) => void;
+    onCancelRename: () => void;
+};

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

@@ -7,4 +7,5 @@ export * from './DetailsPanel';
 export * from './Actions';
 export * from './Views';
 export * from './EntityPickerDialog';
+export * from './MoveEntityDialog';
 export * from './ListTable';

package/dist/types/context/MenuContext.d.ts

@@ -6,6 +6,7 @@ interface MenuContextType {
     toggleMenuOpen: (menuId: string | false) => void;
     navigate: NavigateFunction;
 }
+export declare const MenuContext: React.Context<MenuContextType | undefined>;
 interface MenuProviderProps {
     children: ReactNode;
     useNavigate: typeof useNavigate;

package/dist/types/context/ProjectFoldersContext.d.ts

@@ -2,6 +2,7 @@ import { FolderListItem, FolderListModel } from '../api';
 export interface ProjectFoldersContextValue {
     folders: FolderListItem[];
     getFolderById: (id: string) => FolderListItem | undefined;
+    findNonInheritedValues: (folderId: string | undefined, attribNames: string[], projectAttrib?: Record<string, any>) => Record<string, any>;
     getParentFolderIds: (folderId: string) => string[];
     getChildFolderIds: (folderIds: string[], includeSelf?: boolean) => string[];
     isLoading: boolean;

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

@@ -7,7 +7,6 @@ export * from './pip';
 export * from './AddonProjectContext';
 export * from './AddonContext';
 export * from './PowerpackContext';
-export * from './MoveEntityContext';
 export * from './MenuContext';
 export * from './WebsocketContext';
 export * from './GlobalContext';