@ynput/ayon-frontend-shared 0.7.5 → 0.7.6

package/dist/types/components.d.ts

@@ -198,7 +198,7 @@ export declare interface AddonButtonProps<S extends ButtonSlot> {
     context: Omit<SlotMap[S]['context'], 'navigate'>;
     /** the host's button; not called for a `component` item, which draws itself */
     renderButton: (props: AddonButtonRenderProps) => ReactNode;
-    /** dev shell: open the dialog right away */
+    /** dev shell: open the dialog or popover right away */
     autoOpen?: boolean;
     /** dev shell: the context the item's code gets */
     onContext?: (context: object) => void;
@@ -206,7 +206,7 @@ export declare interface AddonButtonProps<S extends ButtonSlot> {
 
 export declare interface AddonButtonRenderProps {
     ref: (element: HTMLElement | null) => void;
-    /** its dialog or menu is open */
+    /** its dialog, menu or popover is open */
     active: boolean;
     onClick: () => void;
     onMouseEnter: () => void;
@@ -224,6 +224,8 @@ export declare interface AddonDialogProps<S extends SlotName> {
     };
 }
 
+export declare const AddonEntityPicker: ({ projectName, entityType, multiSelect, initialSelection, onSubmit, onClose, }: EntityPickerProps) => JSX_2.Element;
+
 /** The addon a contribution came from. */
 declare interface AddonInfo {
     /** addon name, as on the server */
@@ -255,6 +257,28 @@ declare type AddonMenuItem =
     danger?: boolean
 }
 
+export declare const AddonMoreMenu: ({ items, icon, label, tooltip, variant, align, disabled, className, onError, "data-testid": testId, }: HostMoreMenuProps) => JSX_2.Element;
+
+export declare const AddonServices: ({ projectName }: {
+    projectName: string | null;
+}) => JSX_2.Element;
+
+/** 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
+}
+
 declare type AlignType = 'left' | 'right';
 
 declare type Anatomy = {
@@ -288,6 +312,18 @@ declare interface AnyContribution {
     [field: string]: unknown
 }
 
+/** 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
+}
+
 export declare type AttributeData = {
     id: string;
     isExpanded: boolean;
@@ -436,8 +472,11 @@ declare const Button: IStyledComponentBase<"web", FastOmit<Omit< ButtonProps & R
     ref?: ((instance: HTMLButtonElement | null) => void | DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES[keyof DO_NOT_USE_OR_YOU_WILL_BE_FIRED_CALLBACK_REF_RETURN_VALUES]) | RefObject<HTMLButtonElement> | null | undefined;
 }, never>>> & string & Omit< ForwardRefExoticComponent< ButtonProps & RefAttributes<HTMLButtonElement>>, keyof Component<any, {}, any>>;
 
-/** What a button contribution does on click: exactly one is set (checked when the manifest loads). */
-export declare type ButtonAction = 'to' | 'run' | 'dialog' | 'menu' | 'component';
+/**
+ * What a button contribution does on click: exactly one is set (checked when the manifest loads),
+ * except that a `component` may be a `popover`'s button (the action is then `popover`).
+ */
+export declare type ButtonAction = 'to' | 'run' | 'dialog' | 'menu' | 'popover' | 'component';
 
 /** Description fields of a button the host draws (header and toolbar items). */
 declare interface ButtonMeta {
@@ -463,8 +502,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. */
@@ -1024,11 +1075,7 @@ declare type DetailsPanelFolderFragmentFragment = {
 };
 
 /** 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 {}
 
 /** Description of a `detailsPanel.menuItem` contribution. */
 declare interface DetailsPanelMenuItemMeta extends MenuItemMeta {
@@ -1340,6 +1387,30 @@ export declare interface EntityPathProps {
     scope: string;
 }
 
+declare interface EntityPickerProps {
+    /** the project to pick from */
+    projectName: string
+    /**
+     * What to pick. The picker also shows the types above it to narrow the list down, e.g. folders
+     * then tasks for `task`, folders, products then versions for `version`.
+     */
+    entityType: PickableEntityType
+    /** let the user pick several; one by default */
+    multiSelect?: boolean
+    /**
+     * Selected when the picker opens: entities of `entityType`, or of a type above it to narrow the
+     * list (a folder opens the folder tree at it). `EntityRef`s from a slot context fit as they are.
+     */
+    initialSelection?: Pick<EntityRef, 'id' | 'entityType'>[]
+    /**
+     * The picked entities, of `entityType` in this project. `name` and `label` are set when the
+     * picker has loaded them. The picker stays open until you stop rendering it: close it here.
+     */
+    onSubmit: (entities: EntityRef[]) => void
+    /** the user closed the picker without picking (its close button or Escape) */
+    onClose: () => void
+}
+
 /** An entity a slot is about: its id and type, and its name when the host has it. */
 declare interface EntityRef {
     id: string
@@ -1352,7 +1423,9 @@ declare interface EntityRef {
 
 /** Slots about one or more entities of one type. */
 declare interface EntityScope {
+    /** 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[]
 }
 
@@ -2018,6 +2091,12 @@ declare type HeroTemplate = {
     file: string;
 };
 
+/** What the host's `MoreMenu` gets: the addon's props and where to report a failing item. */
+declare interface HostMoreMenuProps extends MoreMenuProps {
+    /** a failing `onClick`: shown as a toast naming the addon */
+    onError: (error: unknown) => void
+}
+
 declare type IconInputPt = Partial<React.ComponentProps<typeof Styled.IconSelect>>;
 
 declare type IconModel = {
@@ -2484,6 +2563,10 @@ declare interface MenuContainerProps {
     targetId?: string;
     align?: AlignType;
     theme?: ThemeType;
+    /** open state kept by the caller instead of the app's one open menu (`menuOpen === id`) */
+    isOpen?: boolean;
+    /** with `isOpen`: called to close it (`onClose` stays the dialog's own event) */
+    onDismiss?: () => void;
     children: ReactNode;
     [key: string]: any;
 }
@@ -2580,6 +2663,26 @@ declare interface MenuProps {
     footer?: string;
 }
 
+declare interface MoreMenuProps {
+    /** the menu's entries: the same items a `menu` piece returns (dividers, submenus, `danger`, ...) */
+    items: AddonMenuItem[]
+    /** a Material Symbols icon name; `more_horiz` (AYON's "more" button) when not set */
+    icon?: string
+    /** shown next to the icon; an icon-only button when not set */
+    label?: string
+    /** shown on hover and read by screen readers; the label, or `More`, when not set */
+    tooltip?: string
+    /** the button's look, as AYON's `Button`: `text` (default), `surface`, `tonal`, `filled`, `nav` */
+    variant?: 'text' | 'surface' | 'tonal' | 'filled' | 'nav' | 'tertiary' | 'danger'
+    /** which edge of the button the menu lines up with: `right` (default) or `left` */
+    align?: 'left' | 'right'
+    disabled?: boolean
+    /** on the button */
+    className?: string
+    /** on the button, for tests */
+    'data-testid'?: string
+}
+
 export declare const NO_DATE = "no-date";
 
 export declare type NormalizedData = {
@@ -2774,12 +2877,32 @@ export declare type PathSegment = {
     id: string;
 };
 
+/** What `EntityPicker` picks. */
+declare type PickableEntityType = 'folder' | 'task' | 'product' | 'version' | 'representation' | 'workfile'
+
 export declare const Placeholder: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick< DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 
 declare const Placeholder_2: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick< DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 
 declare const PlaceholderWrapper: IStyledComponentBase<"web", FastOmit<DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never> & Partial<Pick< DetailedHTMLProps<HTMLAttributes<HTMLDivElement>, HTMLDivElement>, never>>> & string;
 
+/**
+ * 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
+}
+
 export declare const PowerpackButton: ForwardRefExoticComponent<PowerpackButtonProps & RefAttributes<HTMLButtonElement>>;
 
 export declare interface PowerpackButtonProps extends Omit<ButtonProps, 'variant'> {
@@ -3207,6 +3330,12 @@ export declare const renderYouTubeParagraph: (props: {
     node?: HastNode;
 }) => ReactNode | null;
 
+export declare const ReportCrash: ({ contribution, error, onReported, }: {
+    contribution: AnyContribution;
+    error: Error;
+    onReported: () => void;
+}) => null;
+
 export declare interface ReportsLoadingScreenProps extends HTMLAttributes<HTMLDivElement> {
     showSidebar?: boolean;
     sidebarConfig?: SidebarConfig;
@@ -3594,6 +3723,12 @@ export declare interface ShareOptionIconProps {
     withTooltip?: boolean;
 }
 
+/**
+ * The entities of a shortcut's rows: every row of the project tables is one (list items resolve
+ * to theirs). The panels' rows are not all entities (the lists panel's are lists), so none there.
+ */
+export declare const shortcutEntities: (table: ShortcutTable, projectName: string | null, rows: TableRowRef[]) => EntityRef[];
+
 declare type ShortcutKeyEvent = Pick<KeyboardEvent, 'key' | 'code' | 'ctrlKey' | 'metaKey' | 'altKey' | 'shiftKey' | 'repeat'> & {
     preventDefault: () => void;
     stopPropagation: () => void;
@@ -3696,6 +3831,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
 }
 
@@ -3738,9 +3875,12 @@ declare type SlideOut = {
     projectName: 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
 
 /**
@@ -3771,8 +3911,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
@@ -3833,8 +3974,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
@@ -3857,7 +3999,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
@@ -3881,6 +4025,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'`. */
@@ -4100,7 +4257,8 @@ declare interface TableCellContext extends ProjectNameScope {
  * 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.
@@ -4135,8 +4293,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 const TableGridSwitch: ForwardRefExoticComponent<TableGridSwitchProps & RefAttributes<HTMLDivElement>>;
 
 declare interface TableGridSwitchProps extends Omit<React.HTMLAttributes<HTMLDivElement>, 'onChange'> {
@@ -4190,6 +4363,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 */
@@ -4227,6 +4405,9 @@ declare interface TableShortcutPieces {
     dialog?: Loader<ComponentType<SlotProps<'table.shortcut'> & DialogScope>>
 }
 
+/** The context without `entities`: the hook adds them from the rows. */
+export declare type TableShortcutRows = Omit<TableShortcutContext, 'entities'>;
+
 declare interface TabStateByScope {
     [scope: string]: DetailsPanelTab;
 }
@@ -4395,9 +4576,10 @@ export declare const toggleBlockFormat: (editor: LexicalEditor, format: BlockFor
 
 /**
  * An addon's menu entries as the shared Menu's items: `to` and `href` become links (the Menu
- * follows them), and a failing `onClick` is reported as a toast naming the addon.
+ * follows them), and a failing `onClick` goes to `onError` (`reportContributionError`: a toast
+ * naming the addon). Used by `menu` buttons and `MoreMenu`.
  */
-export declare const toMenuItems: (items: AddonMenuItem[], contribution: AnyContribution) => MenuItemType[];
+export declare const toMenuItems: (items: AddonMenuItem[], onError: (error: unknown) => void) => MenuItemType[];
 
 export declare type ToolbarItem = 'h1' | 'h2' | 'h3' | 'bold' | 'italic' | 'strikethrough' | 'code' | 'link' | 'codeBlock' | 'quote' | 'numberList' | 'bulletList' | 'checkList';
 
@@ -4472,8 +4654,8 @@ export declare const useAddonCustomizeSections: (page: ProjectTablePage) => Sett
 /** `table`: which table this is; no shortcuts when not set. */
 export declare const useAddonTableShortcuts: (table: ShortcutTable | undefined) => {
     hasShortcuts: boolean;
-    handleShortcut: (event: ShortcutKeyEvent, getContext: () => Omit<TableShortcutContext, "table"> | undefined) => boolean;
-    runShortcut: (contribution: Contribution<"table.shortcut">, context: TableShortcutContext) => void;
+    handleShortcut: (event: ShortcutKeyEvent, getContext: () => Omit<TableShortcutRows, "table"> | undefined) => boolean;
+    runShortcut: (contribution: Contribution<"table.shortcut">, rowsContext: TableShortcutRows) => void;
     dialog: OpenAddonShortcutDialog | null;
 };
 
@@ -4570,6 +4752,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
+}
+
 declare type UserSuggestionItem = {
     /** The date and time when the suggested entity was created */
     createdAt?: string;

package/dist/types/context.d.ts

@@ -77,6 +77,10 @@ declare interface AddonDevOverride {
 
 export declare type AddonDevState = {
     status: 'off';
+} | {
+    status: 'rejected';
+    request: string;
+    reason: string;
 } | {
     status: 'loading';
     override: AddonDevOverride;
@@ -84,6 +88,7 @@ export declare type AddonDevState = {
     status: 'active';
     override: AddonDevOverride;
     info: AddonDevInfo;
+    error?: string;
 } | {
     status: 'error';
     override: AddonDevOverride;
@@ -1159,6 +1164,7 @@ export declare const ProjectFoldersContext: Context<ProjectFoldersContextValue |
 export declare const ProjectFoldersContextProvider: React.FC<ProjectFoldersProviderProps>;
 
 export declare interface ProjectFoldersContextValue {
+    projectName: string;
     folders: FolderListItem[];
     getFolderById: (id: string) => FolderListItem | undefined;
     findNonInheritedValues: (folderId: string | undefined, attribNames: string[], projectAttrib?: Record<string, any>) => Record<string, any>;
@@ -1990,6 +1996,8 @@ export declare const useMenuContext: () => MenuContextType;
 
 export declare const useOptionalProjectContext: () => ProjectContextValue | undefined;
 
+export declare const useOptionalProjectFoldersContext: () => ProjectFoldersContextValue | undefined;
+
 export declare function usePiPWindow(): PiPContextType;
 
 export declare const usePowerpack: () => PowerpackContextType;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ynput/ayon-frontend-shared",
-  "version": "0.7.5",
+  "version": "0.7.6",
   "description": "Shared React components for AYON frontend",
   "repository": {
     "type": "git",
@@ -104,8 +104,8 @@
     "@reduxjs/toolkit": "2.11.2",
     "@rtk-query/graphql-request-base-query": "2.3.2",
     "@tanstack/react-table": "8.21.3",
-    "@ynput/ayon-addon": "^0.1.1",
-    "@ynput/ayon-react-components": "^1.24.0",
+    "@ynput/ayon-addon": "0.2.0",
+    "@ynput/ayon-react-components": "^1.25.0",
     "graphql-request": "7.4.0",
     "react": "18.3.1",
     "react-dom": "18.3.1",

package/dist/chunks/ProjectContext.es.js

@@ -1,158 +0,0 @@
-import { jsx as P } from "react/jsx-runtime";
-import { useState as M, useCallback as u } from "react";
-import { u as F } from "./useCreateContextMenu.es.js";
-import { T as S, P as _ } from "./TableExportContextInstance.es.js";
-import "./searchTerms.es.js";
-import { ca as w, c7 as B, dI as G } from "./getUris.es.js";
-import "primereact/confirmdialog";
-import "lodash";
-import "react-toastify";
-import { g as m } from "./getEntityTypeIcon.es.js";
-import "uuid";
-import "axios";
-const X = ({
-  children: t,
-  thumbnailInputRef: c,
-  versionsInputRef: e,
-  canUploadVersion: r = !1
-}) => {
-  const [, a] = M(!1), [T] = F(), f = () => a(!1), d = () => {
-    c?.current && (c.current.click(), a(!0));
-  }, i = () => {
-    e?.current && (e.current.click(), a(!0));
-  }, l = (y) => {
-    const s = [
-      {
-        label: "Upload thumbnail",
-        icon: "add_photo_alternate",
-        command: d
-      },
-      ...r ? [
-        {
-          label: "Upload version",
-          icon: "upload",
-          command: i
-        }
-      ] : []
-    ];
-    T(y, s);
-  };
-  return /* @__PURE__ */ P(
-    S.Provider,
-    {
-      value: {
-        resetFileUploadState: f,
-        triggerThumbnailUpload: d,
-        triggerVersionUpload: i,
-        canUploadVersion: r,
-        onContextMenu: l
-      },
-      children: t
-    }
-  );
-}, Q = {
-  name: "",
-  code: "",
-  productTypes: [],
-  folderTypes: [],
-  taskTypes: [],
-  tags: [],
-  statuses: [],
-  createdAt: "",
-  updatedAt: "",
-  active: !0,
-  attrib: {},
-  data: {},
-  config: {},
-  library: !1,
-  linkTypes: [],
-  ownAttrib: []
-};
-function j(t) {
-  if (!t)
-    return { productTypes: [], productBaseTypes: [] };
-  const c = t.productTypes || [], e = /* @__PURE__ */ new Map();
-  return c.forEach((r) => {
-    e.has(r.baseType) || e.set(r.baseType, {
-      name: r.baseType,
-      icon: r.icon,
-      color: r.color
-    });
-  }), {
-    productTypes: c,
-    productBaseTypes: Array.from(e.values())
-  };
-}
-const Y = ({
-  projectName: t,
-  children: c
-}) => {
-  const {
-    data: e,
-    isLoading: r,
-    isFetching: a,
-    isSuccess: T,
-    isUninitialized: f,
-    error: d,
-    refetch: i
-  } = w({ projectName: t }, { skip: !t }), { data: l = {}, refetch: y } = B(
-    { projectName: t },
-    { skip: !t }
-  ), s = l.product_base_types?.default, { data: g } = G(
-    { projectName: t },
-    {
-      skip: !t
-    }
-  ), { productTypes: p, productBaseTypes: b } = j(g), h = u(
-    (n) => e?.folderTypes?.find((o) => o.name === n),
-    [e]
-  ), k = u(
-    (n) => e?.taskTypes?.find((o) => o.name === n),
-    [e]
-  ), v = u(
-    (n) => {
-      const o = p.find((C) => C.name === n);
-      return {
-        icon: o?.icon || s?.icon || m("product"),
-        color: o?.color || s?.color
-      };
-    },
-    [p, s]
-  ), x = u(() => p.map((o) => ({
-    value: o.name,
-    label: o.name,
-    icon: o.icon || s?.icon || m("product"),
-    color: o.color || s?.color || ""
-  })), [p, s]), U = u(() => {
-    i(), y();
-  }, [i, y]), A = {
-    getFolderType: h,
-    getTaskType: k,
-    getProductType: v,
-    getProductTypeOptions: x,
-    refetch: U
-  };
-  return /* @__PURE__ */ P(
-    _.Provider,
-    {
-      value: {
-        ...Q,
-        ...e,
-        projectName: t,
-        productTypes: p,
-        productBaseTypes: b,
-        anatomy: l,
-        isLoading: r || a,
-        isSuccess: T,
-        isUninitialized: f,
-        error: d,
-        ...A
-      },
-      children: c
-    }
-  );
-};
-export {
-  Y as P,
-  X as T
-};

package/dist/chunks/useQueryArgumentChangeLoading.es.js

@@ -1,11 +0,0 @@
-import { useRef as a, useState as c, useEffect as f } from "react";
-const g = (e, n) => {
-  const o = a(null), [u, r] = c(!1);
-  return f(() => {
-    const t = o.current;
-    !t || Object.keys(e).some((s) => t[s] !== e[s]) || Object.keys(t).some((s) => t[s] !== e[s]) ? (o.current = { ...e }, r(n)) : n || r(!1);
-  }, [Object.values(e).join(","), n]), u;
-};
-export {
-  g as u
-};