@edifice.io/react 2.5.15 → 2.5.16

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/UserSearch.d.ts

@@ -0,0 +1,7 @@
+import { UserSearchProps, UserSearchRef } from './types/types';
+/**
+ * User search component with combobox UI. Supports users, groups and bookmarks,
+ * debounced search, and optional sharing/selection tracking.
+ * Loading state is managed internally during getSearchResults calls.
+ */
+export declare const UserSearch: import('react').ForwardRefExoticComponent<UserSearchProps & import('react').RefAttributes<UserSearchRef>>;

package/dist/components/UserSearch/UserSearch.js

@@ -0,0 +1,82 @@
+import { jsx } from "react/jsx-runtime";
+import { forwardRef, useState, useEffect, useCallback, useImperativeHandle } from "react";
+import SvgIconBookmark from "../../modules/icons/components/IconBookmark.js";
+import SvgIconGroupAvatar from "../../modules/icons/components/IconGroupAvatar.js";
+import SvgIconUser from "../../modules/icons/components/IconUser.js";
+import { VisibleType } from "./types/visible.js";
+import useDebounce from "../../hooks/useDebounce/useDebounce.js";
+import Combobox from "../Combobox/Combobox.js";
+function buildSharedItemsCacheFromInitialSharings(initialSharings) {
+  return new Map(initialSharings.map((item) => [item.recipientId, {
+    id: item.recipientId,
+    displayName: item.displayName,
+    type: item.recipientType === "user" ? VisibleType.User : item.recipientType === "group" ? VisibleType.Group : VisibleType.ShareBookmark
+  }]));
+}
+const UserSearch = /* @__PURE__ */ forwardRef(({
+  placeholder = "Rechercher un utilisateur",
+  isAdmlcOrAdmc = !1,
+  bookmarks = [],
+  initialSharings = [],
+  getSearchResults,
+  onSearchResultsChange
+}, ref) => {
+  const [searchResults, setSearchResults] = useState(bookmarks), [searchInputValue, setSearchInputValue] = useState(""), debouncedSearchInputValue = useDebounce(searchInputValue, 500), [sharingsIds, setSharingsIds] = useState(new Set(initialSharings.map((item) => item.recipientId))), [sharedItemsCache, setSharedItemsCache] = useState(() => buildSharedItemsCacheFromInitialSharings(initialSharings)), [isLoading, setIsLoading] = useState(!1), searchMinLength = isAdmlcOrAdmc ? 3 : 1, getIcon = (type) => {
+    switch (type) {
+      case VisibleType.User:
+        return /* @__PURE__ */ jsx(SvgIconUser, {});
+      case VisibleType.Group:
+      case VisibleType.BroadcastGroup:
+        return /* @__PURE__ */ jsx(SvgIconGroupAvatar, {});
+      case VisibleType.ShareBookmark:
+        return /* @__PURE__ */ jsx(SvgIconBookmark, {});
+      default:
+        return null;
+    }
+  }, searchResultsToOptions = (searchResults2) => searchResults2.map((result) => ({
+    value: result.id,
+    label: result.displayName,
+    icon: getIcon(result.type)
+  })), filterResults = (results) => results.filter((result) => !sharingsIds.has(result.id));
+  useEffect(() => {
+    let cancelled = !1;
+    async function getResults() {
+      setIsLoading(!0);
+      try {
+        const response = await getSearchResults(debouncedSearchInputValue);
+        if (!cancelled) {
+          const rawResults = [...bookmarks, ...response.results];
+          setSearchResults(filterResults(rawResults));
+        }
+      } catch {
+        cancelled || setSearchResults(filterResults(bookmarks));
+      } finally {
+        cancelled || setIsLoading(!1);
+      }
+    }
+    return debouncedSearchInputValue.length >= searchMinLength ? getResults() : setSearchResults(filterResults(bookmarks)), () => {
+      cancelled = !0, setIsLoading(!1);
+    };
+  }, [debouncedSearchInputValue]);
+  const handleSearchInputChange = (event) => {
+    setSearchInputValue(event.target.value);
+  }, handleRemoveSharing = useCallback((recipientId) => {
+    setSharingsIds((prev) => {
+      const next = new Set(prev);
+      return next.delete(recipientId), next;
+    });
+    const cached = sharedItemsCache.get(recipientId);
+    cached && setSearchResults((prev) => prev.some((r) => r.id === recipientId) ? prev : [...prev, cached]);
+  }, [sharedItemsCache]);
+  useImperativeHandle(ref, () => ({
+    removeSharing: handleRemoveSharing
+  }), [handleRemoveSharing]);
+  const handleSearchResultsChange = (model) => {
+    const searchResultId = model[0], searchResult = searchResults.find((result) => result.id === searchResultId);
+    searchResult && (setSharingsIds((prev) => /* @__PURE__ */ new Set([...prev, searchResult.id])), setSharedItemsCache((prev) => new Map(prev).set(searchResult.id, searchResult)), setSearchResults((prev) => prev.filter((result) => result.id !== searchResult.id)), onSearchResultsChange == null || onSearchResultsChange(searchResult));
+  };
+  return /* @__PURE__ */ jsx(Combobox, { "data-testid": "common-user-search-input-search", value: searchInputValue, placeholder, isLoading, noResult: searchResults.length === 0, options: searchResultsToOptions(searchResults), searchMinLength, onSearchInputChange: handleSearchInputChange, onSearchResultsChange: handleSearchResultsChange });
+});
+export {
+  UserSearch
+};

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

@@ -0,0 +1,3 @@
+export * from './UserSearch';
+export * from './types/types';
+export * from './types/visible';

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

@@ -0,0 +1,24 @@
+import { ReactNode } from 'react';
+import { SearchResultType, SharingItem } from '../../../types';
+import { Visible } from './visible';
+export type { SearchResultType, SharingItem };
+export interface UserSearchProps {
+    placeholder?: string;
+    isAdmlcOrAdmc?: boolean;
+    bookmarks?: Visible[];
+    initialSharings?: SharingItem[];
+    getSearchResults: (searchInputValue: string) => Promise<SearchResponse>;
+    onSearchResultsChange?: (searchResult: Visible) => void;
+}
+export interface UserSearchRef {
+    removeSharing: (recipientId: string) => void;
+}
+export interface SearchResponse {
+    results: Visible[];
+}
+export interface SearchResultBase {
+    id: string;
+    displayName: string;
+    icon: ReactNode;
+    type: SearchResultType;
+}

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

@@ -0,0 +1,24 @@
+export declare enum VisibleType {
+    User = "User",
+    Group = "Group",
+    ShareBookmark = "ShareBookmark",
+    BroadcastGroup = "BroadcastGroup"
+}
+export type Visible = {
+    id: string;
+    displayName: string;
+    type: VisibleType;
+    children?: {
+        id: string;
+        displayName: string;
+    }[];
+    groupType?: string;
+    nbUsers?: number;
+    profile?: string;
+    relatives?: {
+        id: string;
+        displayName: string;
+    }[];
+    structureName?: string;
+    usedIn?: ('TO' | 'CC' | 'CCI')[];
+};

package/dist/components/UserSearch/types/visible.js

@@ -0,0 +1,4 @@
+var VisibleType = /* @__PURE__ */ ((VisibleType2) => (VisibleType2.User = "User", VisibleType2.Group = "Group", VisibleType2.ShareBookmark = "ShareBookmark", VisibleType2.BroadcastGroup = "BroadcastGroup", VisibleType2))(VisibleType || {});
+export {
+  VisibleType
+};

package/dist/components/index.d.ts

@@ -52,4 +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/hooks/useDropzone/useDropzone.js

@@ -35,11 +35,11 @@ const useDropzone = (props) => {
   }, convertHEICImages = async (files2) => {
     if (files2 === null || files2.length === 0)
       return [];
-    let heic2any;
-    return files2.some((file) => HEIC_MIME_TYPES.includes(file.type)) && (heic2any = (await import("heic2any")).default), Promise.all(files2.map(async (file) => {
-      if (HEIC_MIME_TYPES.includes(file.type) && heic2any)
+    let heicToLib;
+    return files2.some((file) => HEIC_MIME_TYPES.includes(file.type)) && (heicToLib = await import("heic-to")), Promise.all(files2.map(async (file) => {
+      if (heicToLib && heicToLib.isHeic(file))
         try {
-          const converted = await heic2any({
+          const converted = await heicToLib.heicTo({
             blob: file,
             toType: "image/jpeg"
           });