@edifice.io/react 2.5.15-develop-pedago.20260324175543 → 2.5.15-develop-pedago.20260327124327

package/dist/components/Tree/components/SortableTree.js

@@ -11,6 +11,7 @@ import SvgIconRafterRight from "../../../modules/icons/components/IconRafterRigh
 import { useTree } from "../hooks/useTree.js";
 import { useTreeSortable } from "../hooks/useTreeSortable.js";
 import { flattenNodes } from "../utilities/tree-sortable.js";
+import { getRotateTransitionStyle } from "../../../utilities/rotate-transition-style/get-rotate-transition-style.js";
 import { mergeRefs } from "../../../utilities/refs/ref.js";
 const SortableTree = ({
   nodes,
@@ -113,9 +114,9 @@ const SortableTree = ({
     ...style,
     marginLeft: spaceGestion()
   }, ...listeners, children: /* @__PURE__ */ jsx("div", { children: /* @__PURE__ */ jsxs("div", { className: treeItemClasses.action, children: [
-    node.haveChilds && /* @__PURE__ */ jsx("div", { tabIndex: 0, role: "button", onClick: () => onToggleNode == null ? void 0 : onToggleNode(node.id), onKeyDown: handleItemToggleKeyDown, "aria-label": t("foldUnfold"), children: /* @__PURE__ */ jsx(SvgIconRafterRight, { width: 16, style: {
-      transform: expanded ? "rotate(90deg)" : ""
-    } }) }),
+    node.haveChilds && /* @__PURE__ */ jsx("div", { tabIndex: 0, role: "button", onClick: () => onToggleNode == null ? void 0 : onToggleNode(node.id), onKeyDown: handleItemToggleKeyDown, "aria-label": t("foldUnfold"), children: /* @__PURE__ */ jsx(SvgIconRafterRight, { width: 16, style: getRotateTransitionStyle(expanded, {
+      degrees: 90
+    }) }) }),
     node.children && showIcon ? /* @__PURE__ */ jsx(SvgIconFolder, { title: "folder", width: 20, height: 20 }) : null,
     /* @__PURE__ */ jsx("div", { tabIndex: 0, role: "button", className: treeItemClasses.button, onClick: () => onTreeItemClick(node.id), onKeyDown: handleItemKeyDown, children: renderNode ? renderNode({
       node,

package/dist/components/Tree/components/Tree.js

@@ -5,6 +5,7 @@ import { useTranslation } from "react-i18next";
 import SvgIconFolder from "../../../modules/icons/components/IconFolder.js";
 import SvgIconRafterRight from "../../../modules/icons/components/IconRafterRight.js";
 import { useTree } from "../hooks/useTree.js";
+import { getRotateTransitionStyle } from "../../../utilities/rotate-transition-style/get-rotate-transition-style.js";
 const Tree = ({
   nodes,
   selectedNodeId: externalSelectedNodeId,
@@ -66,9 +67,9 @@ const Tree = ({
   };
   return /* @__PURE__ */ createElement("li", { ...restProps, ref, key: node.id, id: `treeitem-${node.id}`, role: "treeitem", "aria-selected": selected, "aria-expanded": expanded }, /* @__PURE__ */ jsxs("div", { children: [
     /* @__PURE__ */ jsxs("div", { className: treeItemClasses.action, children: [
-      node.children && node.children.length > 0 ? /* @__PURE__ */ jsx("div", { className: treeItemClasses.arrow, tabIndex: 0, role: "button", onClick: () => onToggleNode == null ? void 0 : onToggleNode(node.id), onKeyDown: handleItemToggleKeyDown, "aria-label": t("foldUnfold"), children: /* @__PURE__ */ jsx(SvgIconRafterRight, { width: 16, style: {
-        transform: expanded ? "rotate(90deg)" : ""
-      } }) }) : /* @__PURE__ */ jsx("div", { className: "py-8 invisible" }),
+      node.children && node.children.length > 0 ? /* @__PURE__ */ jsx("div", { className: treeItemClasses.arrow, tabIndex: 0, role: "button", onClick: () => onToggleNode == null ? void 0 : onToggleNode(node.id), onKeyDown: handleItemToggleKeyDown, "aria-label": t("foldUnfold"), children: /* @__PURE__ */ jsx(SvgIconRafterRight, { width: 16, style: getRotateTransitionStyle(expanded, {
+        degrees: 90
+      }) }) }) : /* @__PURE__ */ jsx("div", { className: "py-8 invisible" }),
       node.children && showIcon ? /* @__PURE__ */ jsx(SvgIconFolder, { title: "folder", width: 20, height: 20 }) : null,
       /* @__PURE__ */ jsx("div", { tabIndex: 0, role: "button", className: treeItemClasses.button, onClick: () => onTreeItemClick(node.id), onKeyDown: handleItemKeyDown, children: renderNode ? renderNode({
         node,

package/dist/components/UserRightsList/SaveBookmark.d.ts

@@ -0,0 +1,5 @@
+interface SaveBookmarkProps {
+    onSave: (bookmarkName: string) => Promise<void>;
+}
+export declare const SaveBookmark: ({ onSave }: SaveBookmarkProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/components/UserRightsList/SaveBookmark.js

@@ -0,0 +1,29 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useState } from "react";
+import { useTranslation } from "react-i18next";
+import SvgIconSave from "../../modules/icons/components/IconSave.js";
+import FormControl from "../Form/FormControl.js";
+import Button from "../Button/Button.js";
+const SaveBookmark = ({
+  onSave
+}) => {
+  const [bookmarkName, setBookmarkName] = useState(""), [isSaving, setIsSaving] = useState(!1), {
+    t
+  } = useTranslation(), handleBookmarkNameChange = (e) => {
+    setBookmarkName(e.target.value);
+  }, handleSaveClick = async () => {
+    setIsSaving(!0);
+    try {
+      await onSave(bookmarkName), setBookmarkName("");
+    } finally {
+      setIsSaving(!1);
+    }
+  };
+  return /* @__PURE__ */ jsx("div", { className: "mt-16", children: /* @__PURE__ */ jsxs(FormControl, { id: "bookmarkName", className: "d-flex flex-wrap align-items-center gap-16", children: [
+    /* @__PURE__ */ jsx("div", { className: "flex-fill", children: /* @__PURE__ */ jsx(FormControl.Input, { "data-testid": "common-save-bookmark-name-input", value: bookmarkName, onChange: handleBookmarkNameChange, placeholder: t("explorer.modal.share.sharebookmark.placeholder"), size: "sm", type: "text" }) }),
+    /* @__PURE__ */ jsx(Button, { "data-testid": "common-save-bookmark-save-button", color: "primary", variant: "ghost", disabled: bookmarkName.length === 0 || isSaving, leftIcon: /* @__PURE__ */ jsx(SvgIconSave, {}), onClick: handleSaveClick, className: "text-nowrap", isLoading: isSaving, children: t("explorer.modal.share.sharebookmark.save") })
+  ] }) });
+};
+export {
+  SaveBookmark
+};

package/dist/components/UserRightsList/UserRightsBookmarkRow.d.ts

@@ -0,0 +1,11 @@
+import { BookmarkState, ResourceRightName, ResourceRights } from './types/types';
+interface UserRightsBookmarkRowProps {
+    bookmark: BookmarkState;
+    resourceRights: ResourceRights;
+    isReadOnly: boolean;
+    onToggleRight: (bookmarkId: string, rightName: ResourceRightName) => void;
+    onDelete: (bookmarkId: string) => void;
+    onToggleExpand: (bookmarkId: string) => void;
+}
+declare const UserRightsBookmarkRow: ({ bookmark, resourceRights, isReadOnly, onToggleRight, onDelete, onToggleExpand, }: UserRightsBookmarkRowProps) => import("react/jsx-runtime").JSX.Element;
+export default UserRightsBookmarkRow;

package/dist/components/UserRightsList/UserRightsBookmarkRow.js

@@ -0,0 +1,30 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useTranslation } from "react-i18next";
+import SvgIconBookmark from "../../modules/icons/components/IconBookmark.js";
+import SvgIconClose from "../../modules/icons/components/IconClose.js";
+import SvgIconRafterDown from "../../modules/icons/components/IconRafterDown.js";
+import Button from "../Button/Button.js";
+import Checkbox from "../Checkbox/Checkbox.js";
+import IconButton from "../Button/IconButton.js";
+import { getRotateTransitionStyle } from "../../utilities/rotate-transition-style/get-rotate-transition-style.js";
+const UserRightsBookmarkRow = ({
+  bookmark,
+  resourceRights,
+  isReadOnly,
+  onToggleRight,
+  onDelete,
+  onToggleExpand
+}) => {
+  const {
+    t
+  } = useTranslation();
+  return /* @__PURE__ */ jsxs("tr", { "data-testid": "user-rights-list-bookmark-row", children: [
+    /* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(SvgIconBookmark, {}) }),
+    /* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(Button, { color: "tertiary", variant: "ghost", className: "fw-normal ps-0", "aria-expanded": bookmark.isExpanded, rightIcon: /* @__PURE__ */ jsx(SvgIconRafterDown, { title: bookmark.isExpanded ? t("hide") : t("show"), className: "w-16 min-w-0", style: getRotateTransitionStyle(bookmark.isExpanded) }), onClick: () => onToggleExpand(bookmark.id), children: bookmark.name }) }),
+    Object.entries(resourceRights).map(([rightName]) => /* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(Checkbox, { checked: bookmark.permission.includes(rightName), onChange: () => onToggleRight(bookmark.id, rightName), disabled: isReadOnly, "aria-label": `${bookmark.name} - ${rightName}`, "data-testid": `user-rights-list-bookmark-${rightName}-checkbox` }) }, rightName)),
+    /* @__PURE__ */ jsx("td", { children: !isReadOnly && /* @__PURE__ */ jsx(IconButton, { "data-testid": "user-rights-list-bookmark-close-button", color: "tertiary", onClick: () => onDelete(bookmark.id), icon: /* @__PURE__ */ jsx(SvgIconClose, {}), title: `${t("close")} ${bookmark.name}`, variant: "ghost" }) })
+  ] });
+};
+export {
+  UserRightsBookmarkRow as default
+};

package/dist/components/UserRightsList/UserRightsItem.d.ts

@@ -0,0 +1,13 @@
+import { ResourceRightName, ResourceRights, SharingItem } from './types/types';
+interface UserRightsItemProps {
+    item: SharingItem;
+    resourceRights: ResourceRights;
+    isReadOnly: boolean;
+    isDeletable?: boolean;
+    rowClassName?: string;
+    bookmarkName?: string;
+    onChange?: (item: SharingItem, rightName: ResourceRightName) => void;
+    onDeleteItem?: (item: SharingItem) => void;
+}
+declare const UserRightsItem: ({ item, resourceRights, isReadOnly, isDeletable, rowClassName, bookmarkName, onChange, onDeleteItem, }: UserRightsItemProps) => import("react/jsx-runtime").JSX.Element;
+export default UserRightsItem;

package/dist/components/UserRightsList/UserRightsItem.js

@@ -0,0 +1,36 @@
+import { jsxs, jsx } from "react/jsx-runtime";
+import { useTranslation } from "react-i18next";
+import SvgIconClose from "../../modules/icons/components/IconClose.js";
+import useDirectory from "../../hooks/useDirectory/useDirectory.js";
+import Avatar from "../Avatar/Avatar.js";
+import Checkbox from "../Checkbox/Checkbox.js";
+import IconButton from "../Button/IconButton.js";
+const UserRightsItem = ({
+  item,
+  resourceRights,
+  isReadOnly,
+  isDeletable = !0,
+  rowClassName,
+  bookmarkName,
+  onChange,
+  onDeleteItem
+}) => {
+  const {
+    getAvatarURL
+  } = useDirectory(), {
+    t
+  } = useTranslation(), handleChange = (rightName) => {
+    onChange == null || onChange(item, rightName);
+  }, handleDeleteItem = () => {
+    onDeleteItem == null || onDeleteItem(item);
+  };
+  return /* @__PURE__ */ jsxs("tr", { "data-testid": "user-rights-list-item-row", className: rowClassName, "aria-label": bookmarkName ? `${item.displayName} - ${bookmarkName}` : void 0, children: [
+    /* @__PURE__ */ jsx("td", { children: /* @__PURE__ */ jsx(Avatar, { src: getAvatarURL(item.recipientId, item.recipientType), size: "xs", alt: item.displayName, variant: "circle" }) }),
+    /* @__PURE__ */ jsx("td", { children: item.displayName }),
+    Object.entries(resourceRights).map(([rightName]) => /* @__PURE__ */ jsx("td", { "data-testid": `user-rights-list-item-${rightName}-checkbox`, children: /* @__PURE__ */ jsx(Checkbox, { checked: item.permission.includes(rightName), onChange: () => handleChange(rightName), disabled: isReadOnly, "aria-label": `${item.displayName} - ${rightName}` }) }, rightName)),
+    /* @__PURE__ */ jsx("td", { children: !isReadOnly && isDeletable && /* @__PURE__ */ jsx(IconButton, { "data-testid": "user-rights-list-close-button", color: "tertiary", onClick: () => handleDeleteItem(), icon: /* @__PURE__ */ jsx(SvgIconClose, {}), title: `${t("close")} ${item.displayName}`, variant: "ghost", type: "button" }) })
+  ] });
+};
+export {
+  UserRightsItem as default
+};

package/dist/components/UserRightsList/UserRightsList.d.ts

@@ -0,0 +1,19 @@
+import { SharingItem } from '../../types';
+import { BookmarkInput, ResourceRights } from './types/types';
+interface UserRightsListProps {
+    resourceRights: ResourceRights;
+    isReadOnly: boolean;
+    isLoading: boolean;
+    ownerId: string;
+    isCreating: boolean;
+    initialSharings?: SharingItem[];
+    onChange: (value: SharingItem[]) => void;
+    onAddItems: (value: SharingItem[]) => void;
+    onDeleteItems: (value: SharingItem[]) => void;
+    onSaveBookmark?: (bookmarkName: string, items: SharingItem[]) => Promise<void>;
+}
+export interface UserRightsListRef {
+    addItem: (item: SharingItem | BookmarkInput) => void;
+}
+export declare const UserRightsList: import('react').ForwardRefExoticComponent<UserRightsListProps & import('react').RefAttributes<UserRightsListRef>>;
+export {};

package/dist/components/UserRightsList/UserRightsList.js

@@ -0,0 +1,94 @@
+import { jsx, jsxs, Fragment } from "react/jsx-runtime";
+import { forwardRef, useState, useRef, useMemo, useImperativeHandle, Fragment as Fragment$1 } from "react";
+import { useTranslation } from "react-i18next";
+import SvgIconBookmark from "../../modules/icons/components/IconBookmark.js";
+import SvgIconRafterDown from "../../modules/icons/components/IconRafterDown.js";
+import { createRightsHelpers } from "./helpers/rightsHelpers.js";
+import { useBookmarkEntries } from "./hooks/useBookmarkEntries.js";
+import { useSharingItems } from "./hooks/useSharingItems.js";
+import { SaveBookmark } from "./SaveBookmark.js";
+import { isBookmarkInput } from "./types/types.js";
+import UserRightsBookmarkRow from "./UserRightsBookmarkRow.js";
+import UserRightsItem from "./UserRightsItem.js";
+import LoadingScreen from "../LoadingScreen/LoadingScreen.js";
+import VisuallyHidden from "../VisuallyHidden/VisuallyHidden.js";
+import Button from "../Button/Button.js";
+import { useEdificeClient } from "../../providers/EdificeClientProvider/EdificeClientProvider.hook.js";
+import { getRotateTransitionStyle } from "../../utilities/rotate-transition-style/get-rotate-transition-style.js";
+const UserRightsList = /* @__PURE__ */ forwardRef(({
+  resourceRights,
+  isReadOnly = !0,
+  isLoading = !1,
+  ownerId,
+  isCreating = !1,
+  initialSharings = [],
+  onChange,
+  onAddItems,
+  onDeleteItems,
+  onSaveBookmark
+}, ref) => {
+  const [showBookmarkInput, setBookmarkInput] = useState(!1), tableRef = useRef(null), {
+    t
+  } = useTranslation(), {
+    user
+  } = useEdificeClient(), {
+    applyRight,
+    toggleRight,
+    getOwnerItem
+  } = useMemo(() => createRightsHelpers(resourceRights), [resourceRights]), ownerItem = getOwnerItem(ownerId, user, isCreating), sharingItems = useSharingItems({
+    initialSharings,
+    toggleRight,
+    applyRight,
+    onChange,
+    onAddItems,
+    onDeleteItems
+  }), itemsByRecipientId = useMemo(() => new Map(sharingItems.items.map((item) => [item.recipientId, item])), [sharingItems.items]), existingRecipientIds = useMemo(() => new Set(itemsByRecipientId.keys()), [itemsByRecipientId]), bookmarks = useBookmarkEntries({
+    resourceRights,
+    existingRecipientIds,
+    toggleRight,
+    addItems: sharingItems.addItems,
+    deleteItemsByIds: sharingItems.deleteItemsByIds,
+    applyRightToIds: sharingItems.applyRightToIds
+  }), regularItems = useMemo(() => sharingItems.items.filter((item) => !bookmarks.bookmarkUserIds.has(item.recipientId)), [sharingItems.items, bookmarks.bookmarkUserIds]), focusTable = () => {
+    var _a;
+    (_a = tableRef.current) == null || _a.focus();
+  }, handleAddItem = (item) => {
+    isBookmarkInput(item) ? bookmarks.addBookmark(item) : sharingItems.addItem(item);
+  }, handleDeleteItem = (item) => {
+    sharingItems.deleteItem(item), focusTable();
+  }, handleDeleteBookmark = (bookmarkId) => {
+    bookmarks.deleteBookmark(bookmarkId), focusTable();
+  }, handleOnSaveBookmark = (bookmarkName) => onSaveBookmark ? onSaveBookmark(bookmarkName, sharingItems.items) : Promise.resolve(), toggleBookmarkInput = () => {
+    setBookmarkInput((prev) => !prev);
+  };
+  return useImperativeHandle(ref, () => ({
+    addItem: handleAddItem
+  })), /* @__PURE__ */ jsx("div", { className: "user-rights-list", children: isLoading ? /* @__PURE__ */ jsx(LoadingScreen, {}) : /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx("div", { className: "table-responsive", children: /* @__PURE__ */ jsxs("table", { ref: tableRef, tabIndex: -1, className: "table border align-middle", children: [
+      /* @__PURE__ */ jsx("thead", { children: /* @__PURE__ */ jsxs("tr", { children: [
+        /* @__PURE__ */ jsx("th", { scope: "col", className: "w-32", children: /* @__PURE__ */ jsx(VisuallyHidden, { children: t("explorer.modal.share.avatar.shared.alt") }) }),
+        /* @__PURE__ */ jsx("th", { scope: "col", children: /* @__PURE__ */ jsx(VisuallyHidden, { children: t("explorer.modal.share.search.placeholder") }) }),
+        Object.entries(resourceRights).map(([rightName]) => /* @__PURE__ */ jsx("th", { children: rightName }, rightName)),
+        !isReadOnly && /* @__PURE__ */ jsx("th", { scope: "col", children: /* @__PURE__ */ jsx(VisuallyHidden, { children: t("close") }) })
+      ] }) }),
+      /* @__PURE__ */ jsxs("tbody", { children: [
+        /* @__PURE__ */ jsx(UserRightsItem, { item: ownerItem, resourceRights, isReadOnly: !0 }, ownerItem == null ? void 0 : ownerItem.recipientId),
+        bookmarks.bookmarkEntries.map((bookmark) => /* @__PURE__ */ jsxs(Fragment$1, { children: [
+          /* @__PURE__ */ jsx(UserRightsBookmarkRow, { bookmark, resourceRights, isReadOnly, onToggleRight: bookmarks.toggleBookmarkRight, onDelete: handleDeleteBookmark, onToggleExpand: bookmarks.toggleExpand }),
+          bookmark.isExpanded && bookmark.userIds.map((userId) => {
+            const item = itemsByRecipientId.get(userId);
+            return item ? /* @__PURE__ */ jsx(UserRightsItem, { item, resourceRights, isReadOnly, isDeletable: !1, rowClassName: "bg-light", bookmarkName: bookmark.name, onChange: sharingItems.changeRight }, item.recipientId) : null;
+          })
+        ] }, bookmark.id)),
+        regularItems.map((item) => /* @__PURE__ */ jsx(UserRightsItem, { item, resourceRights, isReadOnly: isReadOnly || (ownerItem == null ? void 0 : ownerItem.recipientId) === item.recipientId, onChange: sharingItems.changeRight, onDeleteItem: handleDeleteItem }, item.recipientId))
+      ] })
+    ] }) }),
+    onSaveBookmark && /* @__PURE__ */ jsxs("div", { className: "mt-16", children: [
+      /* @__PURE__ */ jsx(Button, { "data-testid": "common-user-rights-list-share-bookmark-show-button", color: "tertiary", leftIcon: /* @__PURE__ */ jsx(SvgIconBookmark, {}), rightIcon: /* @__PURE__ */ jsx(SvgIconRafterDown, { title: t("show"), className: "w-16 min-w-0", style: getRotateTransitionStyle(showBookmarkInput) }), type: "button", variant: "ghost", className: "fw-normal", onClick: () => toggleBookmarkInput(), children: t("share.save.sharebookmark") }),
+      showBookmarkInput && /* @__PURE__ */ jsx(SaveBookmark, { onSave: handleOnSaveBookmark })
+    ] })
+  ] }) });
+});
+export {
+  UserRightsList
+};

package/dist/components/UserRightsList/helpers/rightsHelpers.d.ts

@@ -0,0 +1,9 @@
+import { IUserInfo } from '@edifice.io/client';
+import { SharingItem } from '../../../types';
+import { ResourceRightName, ResourceRights } from '../types/types';
+export declare const createRightsHelpers: (resourceRights: ResourceRights) => {
+    applyRight: (item: SharingItem, rightName: ResourceRightName, add: boolean) => SharingItem;
+    toggleRight: (item: SharingItem, rightName: ResourceRightName) => SharingItem;
+    createOwnerItem: (user: IUserInfo) => SharingItem;
+    getOwnerItem: (ownerId: string, user: IUserInfo | undefined, isCreating: boolean) => SharingItem;
+};

package/dist/components/UserRightsList/helpers/rightsHelpers.js

@@ -0,0 +1,53 @@
+const createRightsHelpers = (resourceRights) => {
+  const getOwnerItem = (ownerId, user, isCreating) => {
+    if (!ownerId && user && isCreating || user && ownerId === user.userId)
+      return createOwnerItem(user);
+    if (!ownerId)
+      throw new Error("Owner ID or user is required");
+    return {
+      recipientId: ownerId,
+      recipientType: "user",
+      displayName: "owner",
+      permission: Object.keys(resourceRights)
+    };
+  }, createOwnerItem = (user) => ({
+    recipientId: user.userId ?? "",
+    recipientType: "user",
+    displayName: user.username,
+    permission: Object.keys(resourceRights)
+  }), applyRight = (item, rightName, add) => {
+    const {
+      requires,
+      excludes
+    } = resourceRights[rightName];
+    let newPermission;
+    if (add)
+      newPermission = [.../* @__PURE__ */ new Set([...item.permission.filter((perm) => !excludes.includes(perm)), ...requires, rightName])];
+    else {
+      const toRemove = /* @__PURE__ */ new Set([rightName]);
+      let changed = !0;
+      for (; changed; ) {
+        changed = !1;
+        for (const [name, definition] of Object.entries(resourceRights))
+          !toRemove.has(name) && definition.requires.some((required) => toRemove.has(required)) && (toRemove.add(name), changed = !0);
+      }
+      newPermission = item.permission.filter((perm) => !toRemove.has(perm));
+    }
+    return {
+      ...item,
+      permission: newPermission
+    };
+  };
+  return {
+    applyRight,
+    toggleRight: (item, rightName) => {
+      const hasRight = item.permission.includes(rightName);
+      return applyRight(item, rightName, !hasRight);
+    },
+    createOwnerItem,
+    getOwnerItem
+  };
+};
+export {
+  createRightsHelpers
+};

package/dist/components/UserRightsList/hooks/useBookmarkEntries.d.ts

@@ -0,0 +1,19 @@
+import { SharingItem } from '../../../types';
+import { BookmarkInput, BookmarkState, ResourceRightName, ResourceRights } from '../types/types';
+interface UseBookmarkEntriesParams {
+    resourceRights: ResourceRights;
+    existingRecipientIds: Set<string>;
+    toggleRight: (item: SharingItem, rightName: ResourceRightName) => SharingItem;
+    addItems: (items: SharingItem[]) => void;
+    deleteItemsByIds: (ids: Set<string>) => void;
+    applyRightToIds: (ids: Set<string>, rightName: ResourceRightName, shouldAdd: boolean) => void;
+}
+export declare const useBookmarkEntries: ({ resourceRights, existingRecipientIds, toggleRight, addItems, deleteItemsByIds, applyRightToIds, }: UseBookmarkEntriesParams) => {
+    bookmarkEntries: BookmarkState[];
+    bookmarkUserIds: Set<string>;
+    addBookmark: (bookmark: BookmarkInput) => void;
+    deleteBookmark: (bookmarkId: string) => void;
+    toggleBookmarkRight: (bookmarkId: string, rightName: ResourceRightName) => void;
+    toggleExpand: (bookmarkId: string) => void;
+};
+export {};

package/dist/components/UserRightsList/hooks/useBookmarkEntries.js

@@ -0,0 +1,58 @@
+import { useState, useMemo } from "react";
+const useBookmarkEntries = ({
+  resourceRights,
+  existingRecipientIds,
+  toggleRight,
+  addItems,
+  deleteItemsByIds,
+  applyRightToIds
+}) => {
+  const [bookmarkEntries, setBookmarkEntries] = useState([]), bookmarkUserIds = useMemo(() => new Set(bookmarkEntries.flatMap((entry) => entry.userIds)), [bookmarkEntries]), getDefaultPermissions = () => Object.entries(resourceRights).filter(([, definition]) => definition.default).map(([name]) => name);
+  return {
+    bookmarkEntries,
+    bookmarkUserIds,
+    addBookmark: (bookmark) => {
+      if (bookmarkEntries.some((entry) => entry.id === bookmark.id)) return;
+      const defaultPermissions = getDefaultPermissions(), newBookmarkUsers = bookmark.users.filter((bookmarkUser) => !existingRecipientIds.has(bookmarkUser.id)), newUsers = newBookmarkUsers.map((bookmarkUser) => ({
+        recipientId: bookmarkUser.id,
+        recipientType: "user",
+        displayName: bookmarkUser.displayName,
+        permission: [...defaultPermissions]
+      })), bookmarkState = {
+        id: bookmark.id,
+        name: bookmark.name,
+        permission: [...defaultPermissions],
+        userIds: newBookmarkUsers.map((bookmarkUser) => bookmarkUser.id),
+        isExpanded: !1
+      };
+      setBookmarkEntries((prev) => [...prev, bookmarkState]), addItems(newUsers);
+    },
+    deleteBookmark: (bookmarkId) => {
+      const bookmark = bookmarkEntries.find((entry) => entry.id === bookmarkId);
+      bookmark && (setBookmarkEntries((prev) => prev.filter((entry) => entry.id !== bookmarkId)), deleteItemsByIds(new Set(bookmark.userIds)));
+    },
+    toggleBookmarkRight: (bookmarkId, rightName) => {
+      const bookmark = bookmarkEntries.find((entry) => entry.id === bookmarkId);
+      if (!bookmark) return;
+      const shouldAdd = !bookmark.permission.includes(rightName), bookmarkAsSharingItem = {
+        recipientId: bookmark.id,
+        recipientType: "bookmark",
+        displayName: bookmark.name,
+        permission: bookmark.permission
+      }, toggledBookmark = toggleRight(bookmarkAsSharingItem, rightName);
+      setBookmarkEntries((prev) => prev.map((entry) => entry.id === bookmarkId ? {
+        ...entry,
+        permission: toggledBookmark.permission
+      } : entry)), applyRightToIds(new Set(bookmark.userIds), rightName, shouldAdd);
+    },
+    toggleExpand: (bookmarkId) => {
+      setBookmarkEntries((prev) => prev.map((entry) => entry.id === bookmarkId ? {
+        ...entry,
+        isExpanded: !entry.isExpanded
+      } : entry));
+    }
+  };
+};
+export {
+  useBookmarkEntries
+};

package/dist/components/UserRightsList/hooks/useSharingItems.d.ts

@@ -0,0 +1,20 @@
+import { SharingItem } from '../../../types';
+import { ResourceRightName } from '../types/types';
+interface UseSharingItemsParams {
+    initialSharings: SharingItem[];
+    toggleRight: (item: SharingItem, rightName: ResourceRightName) => SharingItem;
+    applyRight: (item: SharingItem, rightName: ResourceRightName, add: boolean) => SharingItem;
+    onChange: (value: SharingItem[]) => void;
+    onAddItems: (value: SharingItem[]) => void;
+    onDeleteItems: (value: SharingItem[]) => void;
+}
+export declare const useSharingItems: ({ initialSharings, toggleRight, applyRight, onChange, onAddItems, onDeleteItems, }: UseSharingItemsParams) => {
+    items: SharingItem[];
+    addItem: (item: SharingItem) => void;
+    addItems: (newItems: SharingItem[]) => void;
+    deleteItem: (item: SharingItem) => void;
+    deleteItemsByIds: (ids: Set<string>) => void;
+    changeRight: (item: SharingItem, rightName: ResourceRightName) => void;
+    applyRightToIds: (ids: Set<string>, rightName: ResourceRightName, shouldAdd: boolean) => void;
+};
+export {};

package/dist/components/UserRightsList/hooks/useSharingItems.js

@@ -0,0 +1,57 @@
+import { useState } from "react";
+const useSharingItems = ({
+  initialSharings,
+  toggleRight,
+  applyRight,
+  onChange,
+  onAddItems,
+  onDeleteItems
+}) => {
+  const [items, setItems] = useState(initialSharings ?? []);
+  return {
+    items,
+    addItem: (item) => {
+      setItems((prev) => {
+        if (new Set(prev.map((sharing) => sharing.recipientId)).has(item.recipientId)) return prev;
+        const nextItems = [...prev, item];
+        return onChange(nextItems), onAddItems([item]), nextItems;
+      });
+    },
+    addItems: (newItems) => {
+      setItems((prev) => {
+        const existingIds = new Set(prev.map((sharing) => sharing.recipientId)), uniqueItems = newItems.filter((newItem) => !existingIds.has(newItem.recipientId));
+        if (uniqueItems.length === 0) return prev;
+        const nextItems = [...prev, ...uniqueItems];
+        return onChange(nextItems), onAddItems(uniqueItems), nextItems;
+      });
+    },
+    deleteItem: (item) => {
+      setItems((prev) => {
+        const nextItems = prev.filter((sharing) => sharing.recipientId !== item.recipientId);
+        return nextItems.length === prev.length ? prev : (onChange(nextItems), onDeleteItems([item]), nextItems);
+      });
+    },
+    deleteItemsByIds: (ids) => {
+      setItems((prev) => {
+        const nextItems = prev.filter((sharing) => !ids.has(sharing.recipientId)), removedItems = prev.filter((sharing) => ids.has(sharing.recipientId));
+        return onChange(nextItems), onDeleteItems(removedItems), nextItems;
+      });
+    },
+    changeRight: (item, rightName) => {
+      const updatedItem = toggleRight(item, rightName);
+      setItems((prevItems) => {
+        const nextItems = prevItems.map((prevItem) => prevItem.recipientId === item.recipientId ? updatedItem : prevItem);
+        return onChange(nextItems), nextItems;
+      });
+    },
+    applyRightToIds: (ids, rightName, shouldAdd) => {
+      setItems((prev) => {
+        const nextItems = prev.map((sharing) => ids.has(sharing.recipientId) ? applyRight(sharing, rightName, shouldAdd) : sharing);
+        return onChange(nextItems), nextItems;
+      });
+    }
+  };
+};
+export {
+  useSharingItems
+};

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

@@ -0,0 +1,2 @@
+export * from './UserRightsList';
+export type { BookmarkInput, BookmarkUser } from './types/types';

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

@@ -0,0 +1,34 @@
+import { SharingItem } from '../../../types';
+export type { SearchResultType, SharingItem } from '../../../types';
+export type ResourceRightName = 'read' | 'contrib' | 'publish' | 'manager' | 'comment';
+export type ResourceRightDefinition = {
+    priority: number;
+    default: boolean;
+    requires: ResourceRightName[];
+    excludes: ResourceRightName[];
+};
+export type ResourceRights = Record<ResourceRightName, ResourceRightDefinition>;
+export interface BookmarkUser {
+    id: string;
+    displayName: string;
+    profile?: string;
+    activationCode?: boolean;
+}
+export interface BookmarkInput {
+    id: string;
+    name: string;
+    notVisibleCount?: number;
+    groups?: {
+        id: string;
+        displayName: string;
+    }[];
+    users: BookmarkUser[];
+}
+export interface BookmarkState {
+    id: string;
+    name: string;
+    permission: string[];
+    userIds: string[];
+    isExpanded: boolean;
+}
+export declare function isBookmarkInput(item: SharingItem | BookmarkInput): item is BookmarkInput;

package/dist/components/UserRightsList/types/types.js

@@ -0,0 +1,6 @@
+function isBookmarkInput(item) {
+  return "users" in item && Array.isArray(item.users);
+}
+export {
+  isBookmarkInput
+};

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

@@ -1,5 +1,7 @@
 import { ReactNode } from 'react';
+import { SearchResultType, SharingItem } from '../../../types';
 import { Visible } from './visible';
+export type { SearchResultType, SharingItem };
 export interface UserSearchProps {
     placeholder?: string;
     isAdmlcOrAdmc?: boolean;
@@ -14,16 +16,9 @@ export interface UserSearchRef {
 export interface SearchResponse {
     results: Visible[];
 }
-export type SearchResultType = 'user' | 'group' | 'bookmark';
 export interface SearchResultBase {
     id: string;
     displayName: string;
     icon: ReactNode;
     type: SearchResultType;
 }
-export interface SharingItem {
-    recipientId: string;
-    recipientType: SearchResultType;
-    permission: string[];
-    displayName: string;
-}

package/dist/components/index.d.ts

@@ -52,5 +52,6 @@ export * from './Toolbar';
 export * from './Tooltip';
 export * from './Tree';
 export * from './TreeView';
+export * from './UserRightsList';
 export * from './UserSearch';
 export * from './VisuallyHidden';

package/dist/hooks/useDirectory/useDirectory.d.ts

@@ -1,6 +1,7 @@
 import { ID } from '@edifice.io/client';
+import { AvatarType } from '../../types';
 declare const useDirectory: () => {
-    getAvatarURL: (userId: ID, type: "user" | "group") => string | undefined;
-    getUserbookURL: (userId: ID, type: "user" | "group") => string;
+    getAvatarURL: (userId: ID, type: AvatarType) => string | undefined;
+    getUserbookURL: (userId: ID, type: AvatarType) => string;
 };
 export default useDirectory;

package/dist/index.js

@@ -133,11 +133,13 @@ import { Toolbar } from "./components/Toolbar/Toolbar.js";
 import { TreeNode } from "./components/TreeView/TreeNode.js";
 import { TreeNodeFolderWrapper, addNode, arrayUnique, deleteNode, findNodeById, findParentNode, findPathById, findTreeNode, getAncestors, hasChildren, modifyNode, moveNode, updateNode, wrapTreeNode } from "./components/TreeView/utilities/treeview.js";
 import { Upload } from "./modules/multimedia/MediaLibrary/innertabs/Upload.js";
+import { UserRightsList } from "./components/UserRightsList/UserRightsList.js";
 import { UserSearch } from "./components/UserSearch/UserSearch.js";
 import { VisibleType } from "./components/UserSearch/types/visible.js";
 import { buildTree, determineNewParentId, findItemIndexInTree, flattenNodes, flattenTree, generateUpdateData, getActiveAndOverNodes, getDragDepth, getIndicesToUpdate, getProjection, updateParentIds } from "./components/Tree/utilities/tree-sortable.js";
 import { checkUserRight } from "./utilities/check-user-rights/check-user-rights.js";
 import { emptyScreenMapping } from "./utilities/emptyscreen-mapping/emptyscreen-mapping.js";
+import { getRotateTransitionStyle } from "./utilities/rotate-transition-style/get-rotate-transition-style.js";
 import { invalidateQueriesWithFirstPage } from "./utilities/react-query/react-query-utils.js";
 import { mergeRefs, setRef } from "./utilities/refs/ref.js";
 import { useCheckable } from "./hooks/useCheckable/useCheckable.js";
@@ -243,6 +245,7 @@ export {
   Upload,
   default67 as UploadCard,
   default68 as UploadFiles,
+  UserRightsList,
   UserSearch,
   default69 as VideoEmbed,
   default70 as VideoRecorder,
@@ -272,6 +275,7 @@ export {
   getDragDepth,
   getIndicesToUpdate,
   getProjection,
+  getRotateTransitionStyle,
   hasChildren,
   invalidateQueriesWithFirstPage,
   mergeRefs,

package/dist/types/index.d.ts

@@ -2,3 +2,4 @@ export { type Size } from './size';
 export { type Status } from './status';
 export { type TreeData } from './treedata';
 export { type Color } from './color';
+export { type AvatarType, type SearchResultType, type SharingItem, } from './sharing';

package/dist/types/sharing.d.ts

@@ -0,0 +1,8 @@
+export type AvatarType = 'user' | 'group';
+export type SearchResultType = AvatarType | 'bookmark';
+export interface SharingItem {
+    recipientId: string;
+    recipientType: SearchResultType;
+    permission: string[];
+    displayName: string;
+}

package/dist/utilities/index.d.ts

@@ -2,3 +2,4 @@ export * from './check-user-rights';
 export * from './emptyscreen-mapping';
 export * from './react-query';
 export * from './refs';
+export * from './rotate-transition-style';

package/dist/utilities/rotate-transition-style/get-rotate-transition-style.d.ts

@@ -0,0 +1,5 @@
+import { CSSProperties } from 'react';
+export declare function getRotateTransitionStyle(isOpen: boolean, { degrees, duration, }?: {
+    degrees?: number;
+    duration?: number;
+}): CSSProperties;

package/dist/utilities/rotate-transition-style/get-rotate-transition-style.js

@@ -0,0 +1,12 @@
+function getRotateTransitionStyle(isOpen, {
+  degrees = -180,
+  duration = 0.2
+} = {}) {
+  return {
+    transition: `rotate ${duration}s ease-out`,
+    rotate: isOpen ? `${degrees}deg` : "0deg"
+  };
+}
+export {
+  getRotateTransitionStyle
+};

package/dist/utilities/rotate-transition-style/index.d.ts

@@ -0,0 +1 @@
+export * from './get-rotate-transition-style';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@edifice.io/react",
-  "version": "2.5.15-develop-pedago.20260324175543",
+  "version": "2.5.15-develop-pedago.20260327124327",
   "description": "Edifice React Library",
   "keywords": [
     "react",
@@ -135,9 +135,9 @@
     "swiper": "^10.1.0",
     "ua-parser-js": "^1.0.36",
     "react-pdf": "10.2.0",
-    "@edifice.io/bootstrap": "2.5.15-develop-pedago.20260324175543",
-    "@edifice.io/tiptap-extensions": "2.5.15-develop-pedago.20260324175543",
-    "@edifice.io/utilities": "2.5.15-develop-pedago.20260324175543"
+    "@edifice.io/bootstrap": "2.5.15-develop-pedago.20260327124327",
+    "@edifice.io/tiptap-extensions": "2.5.15-develop-pedago.20260327124327",
+    "@edifice.io/utilities": "2.5.15-develop-pedago.20260327124327"
   },
   "devDependencies": {
     "@babel/plugin-transform-react-pure-annotations": "^7.23.3",
@@ -168,8 +168,8 @@
     "vite": "^5.4.11",
     "vite-plugin-dts": "^4.1.0",
     "vite-tsconfig-paths": "^5.0.1",
-    "@edifice.io/client": "2.5.15-develop-pedago.20260324175543",
-    "@edifice.io/config": "2.5.15-develop-pedago.20260324175543"
+    "@edifice.io/client": "2.5.15-develop-pedago.20260327124327",
+    "@edifice.io/config": "2.5.15-develop-pedago.20260327124327"
   },
   "peerDependencies": {
     "@react-spring/web": "^9.7.5",