@ynput/ayon-frontend-shared 0.7.5 → 0.7.6

package/dist/hooks.es.js

@@ -1,5 +1,5 @@
 import { d as P, b as x } from "./chunks/TableExportContextInstance.es.js";
-import { r as ve, p as Ie, q as be, o as Ae, w as He, s as Pe } from "./chunks/TableExportContextInstance.es.js";
+import { r as ve, q as Ie, s as be, p as Ae, w as He, v as Pe } from "./chunks/TableExportContextInstance.es.js";
 import { u as G } from "./chunks/useLoadModule.es.js";
 import { loadRemote as R } from "@module-federation/enhanced/runtime";
 import { useRef as T, useState as S, useEffect as v, useCallback as V } from "react";
@@ -22,7 +22,7 @@ import "react-dom";
 import "react-redux";
 import "react-router-dom";
 import { u as Ke } from "./chunks/EntityPickerDialog.es.js";
-import { u as _e } from "./chunks/useQueryArgumentChangeLoading.es.js";
+import { u as _e } from "./chunks/ProjectFoldersContext.es.js";
 import { u as $e } from "./chunks/useGroupedPagination.es.js";
 import { G as O } from "./chunks/GroupSettingsFallback.es.js";
 import { i as K } from "./chunks/isHTMLElement.es.js";

package/dist/index.es.js

@@ -43,9 +43,9 @@ import "@dnd-kit/sortable";
 import "@dnd-kit/utilities";
 import "./chunks/VersionUploadContextInstance.es.js";
 import "./chunks/EntityTooltip.es.js";
-import "./chunks/ColumnDropIndicator.styled.es.js";
-import "@tanstack/react-table";
+import "./chunks/addonColumnTags.es.js";
 import "@ynput/ayon-addon";
+import "@tanstack/react-table";
 import "./chunks/EntityPickerDialog.es.js";
 import "remark-gfm";
 import "react-markdown";

package/dist/types/EntityPickerDialog.d.ts

@@ -2,14 +2,20 @@ import { DialogProps } from '@ynput/ayon-react-components';
 import { FC } from 'react';
 import { RowSelectionState } from '@tanstack/react-table';
 
+declare type EntityLinkThumbnail = {
+    entityType: string;
+    entityId: string;
+    thumbnailHash?: string;
+};
+
 export declare const EntityPickerDialog: FC<EntityPickerDialogProps>;
 
-declare interface EntityPickerDialogProps extends Pick<DialogProps, 'onClose'> {
+export declare interface EntityPickerDialogProps extends Pick<DialogProps, 'onClose'> {
     projectName: string;
     entityType: PickerEntityType;
     initialSelection?: Partial<PickerSelection>;
     isMultiSelect?: boolean;
-    onSubmit: (selection: string[]) => void;
+    onSubmit: (selection: string[], entities: PickedEntity[]) => void;
     showMoveToRoot?: boolean;
     onMoveToRoot?: () => void;
     disabledIds?: string[];
@@ -22,12 +28,49 @@ declare interface EntityPickerDialogProps extends Pick<DialogProps, 'onClose'> {
     isLoading?: boolean;
 }
 
+declare type FolderListItem = {
+    id: string;
+    path: string;
+    parentId?: string;
+    parents: string[];
+    name: string;
+    label?: string;
+    folderType: string;
+    hasTasks?: boolean;
+    hasChildren?: boolean;
+    hasReviewables?: boolean;
+    thumbnailHash: string;
+    taskNames?: string[];
+    tags?: string[];
+    status: string;
+    attrib?: object;
+    ownAttrib?: string[];
+    createdAt: string;
+    updatedAt: string;
+};
+
+/** a picked entity as the picker loaded it, `undefined` when it isn't loaded (a later page) */
+export declare type PickedEntity = SearchEntityLink | FolderListItem | undefined;
+
 export declare type PickerEntityType = 'folder' | 'task' | 'product' | 'version' | 'representation' | 'workfile';
 
 export declare type PickerSearch = Record<PickerEntityType, string | undefined>;
 
 export declare type PickerSelection = Record<PickerEntityType, RowSelectionState>;
 
+declare type SearchEntityLink = {
+    id: string;
+    name: string;
+    entityType: string;
+    parents: string[];
+    label: string;
+    icon: string | undefined;
+    subType: string | undefined;
+    hasReviewables?: boolean;
+    taskName?: string;
+    thumbnail?: EntityLinkThumbnail;
+};
+
 export { }
 
 

package/dist/types/ProjectTreeTable.d.ts

@@ -105,8 +105,6 @@ export declare type ActivityOperationsResponseModel = {
     success: boolean;
 };
 
-export declare const ADDON_COLUMN_PREFIX = "addon__";
-
 /**
  * Gets the values of every shown addon column for the rows on screen (fetchValues), into the
  * store the cells read. Wraps the table body.
@@ -171,6 +169,22 @@ declare type AddonMenuItem =
     danger?: boolean
 }
 
+/** The signed-in user, as addons see it: in every slot's context (`user`) and from `useUser`. */
+declare interface AddonUser {
+    name: string
+    fullName?: string
+    email?: string
+    /** admins, and service users (the server treats them as admins) */
+    isAdmin: boolean
+    /** managers and admins */
+    isManager: boolean
+    isGuest: boolean
+    /** a service user: an API key session (services, agents, CI) */
+    isService: boolean
+    /** developer mode is on */
+    isDeveloper: boolean
+}
+
 export declare const allowedGroupByFields: string[];
 
 export declare const ALWAYS_VISIBLE_COLUMNS: string[];
@@ -223,6 +237,18 @@ export declare const appliesToPage: (contribution: {
     pages?: ProjectTablePage[];
 }, page: ProjectTablePage) => boolean;
 
+/** Context of a service. */
+declare interface AppServiceContext {
+    /** the project whose page is open, else `null` */
+    projectName: string | null
+}
+
+/** Description of an `app.service` contribution. */
+declare interface AppServiceMeta {
+    /** unique among the addon's services */
+    id: string
+}
+
 declare type AttributeData = {
     /** Type of attribute value */
     type?: 'string' | 'integer' | 'float' | 'boolean' | 'datetime' | 'list_of_strings' | 'list_of_integers' | 'list_of_any' | 'list_of_submodels' | 'dict';
@@ -425,8 +451,20 @@ declare interface ButtonPieces<S extends SlotName> {
     dialog?: Loader<ComponentType<SlotProps<S> & DialogScope>>
     /** the items of a menu the host opens under the button, like the header's help menu */
     menu?: Loader<MenuPiece<S>>
-    /** the addon's own component instead of the host's button: a dropdown, a toggle, anything */
-    component?: Loader<ComponentType<SlotProps<S>>>
+    /**
+     * the content of a popover the host opens under the button, like the header's menus: the host
+     * positions it and closes it on a click outside or Escape (an Escape or click inside a menu or
+     * dialog opened from the popover closes only that). It gets `close`
+     */
+    popover?: Loader<ComponentType<SlotProps<S> & PopoverScope>>
+    /**
+     * the addon's own component instead of the host's button: a dropdown, a toggle, anything. With
+     * `popover`, it is the popover's button (its icon, a badge, a tooltip of its own) and gets
+     * `popoverOpen` and `togglePopover`
+     */
+    component?:
+    | Loader<ComponentType<SlotProps<S>>>
+    | Loader<ComponentType<SlotProps<S> & PopoverButtonScope>>
 }
 
 /** Context of a button's code (`run`, `dialog`, `menu`, `component`) besides the slot's own. */
@@ -842,11 +880,7 @@ export declare interface DetailsPanelEntityProviderProps {
 }
 
 /** Context of a details panel menu item. */
-declare interface DetailsPanelMenuItemContext extends ProjectNameScope {
-    entityType: string
-    /** the entities the panel shows */
-    selectedEntities: EntityRef[]
-}
+declare interface DetailsPanelMenuItemContext extends ProjectNameScope, EntityScope_2 {}
 
 /** Description of a `detailsPanel.menuItem` contribution. */
 declare interface DetailsPanelMenuItemMeta extends MenuItemMeta {
@@ -1150,7 +1184,9 @@ export declare type EntityScope = 'primary' | EntityType;
 
 /** Slots about one or more entities of one type. */
 declare interface EntityScope_2 {
+    /** the type of every entity in `entities` */
     entityType: string
+    /** the entities the slot is about, e.g. the ones the details panel shows */
     entities: EntityRef[]
 }
 
@@ -2679,6 +2715,23 @@ export declare type PatchOperation = Pick<OperationModel, 'entityId' | 'entityTy
     type?: OperationModel['type'];
 };
 
+/**
+ * What a `component` gets besides the slot context when it draws the button of a `popover`. The
+ * host anchors the popover on the component's box.
+ */
+declare interface PopoverButtonScope {
+    /** the popover is open: show the button as active (`aria-expanded`) */
+    popoverOpen: boolean
+    /** opens or closes the popover: the button's `onClick` */
+    togglePopover: () => void
+}
+
+/** What a `popover` piece gets besides the slot context. */
+declare interface PopoverScope {
+    /** closes the popover */
+    close: () => void
+}
+
 declare type PowerpackContextType = {
     selectedPowerPack: PowerpackFeature | null;
     selectedAddon: AddonDialogSelection | null;
@@ -2889,6 +2942,7 @@ declare interface ProjectFolders {
 }
 
 declare interface ProjectFoldersContextValue {
+    projectName: string;
     folders: FolderListItem_2[];
     getFolderById: (id: string) => FolderListItem_2 | undefined;
     findNonInheritedValues: (folderId: string | undefined, attribNames: string[], projectAttrib?: Record<string, any>) => Record<string, any>;
@@ -3611,6 +3665,8 @@ declare interface SlicerMenuItemContext extends ProjectNameScope {
     sliceType: string
     /** the rows it acts on: the selected ones, or the right-clicked one */
     selected: SlicerRowRef[]
+    /** `hierarchy`: the folders and tasks of `selected`; empty for the other slice types */
+    entities: EntityRef[]
     menu: MenuKind
 }
 
@@ -3647,9 +3703,12 @@ declare interface SlicerSelection {
     selection: string[]
 }
 
-/** What the code of a contribution to slot `S` gets: `{ slot: S, ...context }`. */
+/**
+ * What the code of a contribution to slot `S` gets: `{ slot: S, user, ...context }`. The host
+ * passes the slot's own context; `ContributionView` and `runContribution` add `slot` and `user`.
+ */
 declare type SlotContext<S extends SlotName> = S extends SlotName
-? { slot: S } & SlotMap[S]['context']
+? { slot: S } & UserScope & SlotMap[S]['context']
 : never
 
 /**
@@ -3680,8 +3739,9 @@ declare interface SlotMap {
     }
     /**
      * A button in the main header, drawn by the host like its own buttons. What a click does is the
-     * addon's: navigate (`to`), run code (`run`), open a dialog (`dialog`) or a menu (`menu`); or the
-     * addon draws the item itself (`component`, loaded with the header). Set exactly one.
+     * addon's: navigate (`to`), run code (`run`), open a dialog (`dialog`), a menu (`menu`) or a
+     * popover (`popover`); or the addon draws the item itself (`component`, loaded with the header).
+     * Set exactly one, except that `component` may draw the button of a `popover`.
      */
     'header.item': {
         version: 1
@@ -3742,8 +3802,9 @@ declare interface SlotMap {
     /**
      * A button in the project tables' toolbar, before Customize (Overview, Products, Lists), drawn
      * by the host like the toolbar's own. What a click does is the addon's: navigate (`to`), run code
-     * (`run`), open a dialog (`dialog`) or a menu (`menu`); or the addon draws the item itself
-     * (`component`, loaded with the toolbar). Set exactly one.
+     * (`run`), open a dialog (`dialog`), a menu (`menu`) or a popover (`popover`); or the addon draws
+     * the item itself (`component`, loaded with the toolbar). Set exactly one, except that
+     * `component` may draw the button of a `popover`.
      */
     'projectTable.toolbarItem': {
         version: 1
@@ -3766,7 +3827,9 @@ declare interface SlotMap {
      * settings from the description; `cell` and `fetchValues` load with the table. The host draws
      * the cell box (padding, selection, focus), so `cell` renders only its content; selecting, the
      * right-click menu and Copy (the cell's `value` as text) work as in other columns. Not sortable,
-     * and pasting into it changes nothing.
+     * and pasting into it changes nothing. When the values depend on data your mutations change, list
+     * its cache tags in `providesTags` and the column refreshes itself when they are invalidated:
+     * `tableColumn({ id, label, cell, fetchValues, providesTags: [{ type: 'myaddonLog', id: 'LIST' }] })`.
      */
     tableColumn: {
         version: 1
@@ -3790,6 +3853,19 @@ declare interface SlotMap {
         context: TableShortcutContext
         pieces: TableShortcutPieces
     }
+    /**
+     * Code with no UI that runs while AYON is open, whatever the page: keeping a state, listening to
+     * websocket events, registering a store listener. `component` loads at startup and is mounted
+     * once for the whole app, under AYON's providers (store, router, contexts), so it can use hooks;
+     * it renders nothing (`return null`). Clean up in its effects. A crash unmounts it and shows a
+     * toast; the rest of AYON keeps working.
+     */
+    'app.service': {
+        version: 1
+        meta: AppServiceMeta
+        context: AppServiceContext
+        pieces: { component: Loader<ComponentType<SlotProps<'app.service'>>> }
+    }
 }
 
 /** The name of a slot, e.g. `'project.page'`. */
@@ -4013,7 +4089,8 @@ export declare type TableCellContextValue = {
  * Gets a column's values, by entity id; each cell gets its own as `value`. AYON calls it with
  * the rows that come on screen and that it has no value for yet, in batches once scrolling
  * pauses, and keeps what it returns: scrolling back costs nothing. A row whose entity changes
- * (here or by someone else) is asked for again; `refreshTableColumn(id)` asks again for all.
+ * (here or by someone else) is asked for again; for anything else the values depend on, list its
+ * cache tags in the column's `providesTags`, or call `refreshTableColumn(id)` to ask again for all.
  * When it throws, those cells show the error and are tried again when they next come on
  * screen. Fetch through AYON's store (`dispatch(api.endpoints.x.initiate(...))`) to share its
  * cache.
@@ -4048,8 +4125,23 @@ declare interface TableColumnMeta {
      * `false` for the menu's top level
      */
     menu?: string | false
+    /**
+     * cache tags of AYON's api that the values depend on: when one is invalidated (by your
+     * mutations or AYON's), the values are fetched again as with `refreshTableColumn`. Needs
+     * `fetchValues`. Names as you register them (`enhanceEndpoints({ addTagTypes })`, prefixed with
+     * your addon name) or AYON's own. A plain name follows invalidations of the whole type only: to
+     * follow `{ type, id }`, such as a list tag, give that tag
+     */
+    providesTags?: TableColumnTag[]
 }
 
+/**
+ * A cache tag a `tableColumn` depends on (`providesTags`), as in RTK Query: a tag type, or a type
+ * and id. Invalidating `'x'` refreshes columns that list `'x'` or `{ type: 'x', id }`;
+ * invalidating `{ type: 'x', id: 'LIST' }` refreshes only columns that list that tag.
+ */
+declare type TableColumnTag = string | { type: string; id?: string | number }
+
 export declare interface TableGroupBy {
     desc: boolean;
     id: string;
@@ -4103,6 +4195,11 @@ declare interface TableShortcutContext {
     projectName: string | null
     /** the rows it acts on: the selected ones when the key was pressed in one of them, else its row */
     rows: TableRowRef[]
+    /**
+     * the entities of `rows` in the project tables (list items resolve to their entity); empty in
+     * the panels' tables, whose rows are not all entities: read `rows` there
+     */
+    entities: EntityRef[]
     /** where the key was pressed: the row's id, and the column's in the project tables */
     focused: { rowId: string; columnId?: string }
     /** project tables: the selected cells, by row (entity) and column id; empty elsewhere */
@@ -4597,6 +4694,11 @@ declare type UserModel = {
     updatedAt?: string;
 };
 
+/** Every slot: the signed-in user. The host adds it; AYON renders addons only once signed in. */
+declare interface UserScope {
+    user: AddonUser
+}
+
 export declare const useScopedAttributeFields: <T extends AttributeField>({ attribFields, allowedScopes, }: UseScopedAttributeFieldsProps<T>) => T[];
 
 declare interface UseScopedAttributeFieldsProps<T extends AttributeField> {