@emailmaker/emailmaker 1.1.65 → 1.1.69

package/file-manager/hooks/core/useNavigation.d.ts

@@ -0,0 +1,12 @@
+import { File as AppFile } from '../../types';
+import { FileManagerHookBase } from './types';
+export declare const useNavigation: () => FileManagerHookBase & {
+    selectedFolder: string | null;
+    pathHistory: Array<{
+        id: string;
+        name: string;
+    }>;
+    handleFolderSelect: (folderId: string) => void;
+    handleBreadcrumbClick: (index: number) => void;
+    handleItemClick: (record: AppFile) => void;
+};

package/file-manager/hooks/core/usePagination.d.ts

@@ -0,0 +1,12 @@
+import { PaginationState } from '../../types';
+import { FileManagerHookBase } from './types';
+export interface UsePaginationState {
+    pagination: PaginationState;
+}
+export interface UsePaginationActions {
+    handlePaginationChange: (page: number, pageSize?: number) => void;
+}
+export declare const usePagination: () => FileManagerHookBase & {
+    state: UsePaginationState;
+    actions: UsePaginationActions;
+};

package/file-manager/hooks/core/useSortAndFilter.d.ts

@@ -0,0 +1,20 @@
+import { FilesQueryParams } from '../../types';
+import { FileManagerHookBase, SortByType, SortOrderType } from './types';
+export interface UseSortAndFilterState {
+    searchTerm: string;
+    sortBy: SortByType;
+    sortOrder: SortOrderType;
+}
+export interface UseSortAndFilterActions {
+    setSearchTerm: (term: string) => void;
+    setSortBy: (sortBy: SortByType) => void;
+    setSortOrder: (sortOrder: SortOrderType) => void;
+    handleSearch: (searchTerm: string) => void;
+    handleSort: (sortBy: SortByType, sortOrder: SortOrderType) => void;
+    handlePaginationChange: (page: number, pageSize?: number) => void;
+    getCurrentQueryParams: () => FilesQueryParams;
+}
+export declare const useSortAndFilter: (fetchFilesFn?: (params?: FilesQueryParams) => Promise<void>) => FileManagerHookBase & {
+    state: UseSortAndFilterState;
+    actions: UseSortAndFilterActions;
+};

package/file-manager/hooks/index.d.ts

@@ -0,0 +1,7 @@
+export * from './core';
+export { useFileActions } from './useFileActions';
+export { usePixieEditor } from './usePixieEditor';
+export { useLastDirectory } from './useLastDirectory';
+export { useControlledImageLoader } from './useControlledImageLoader';
+export { useProxyDisplayFallback } from './useProxyDisplayFallback';
+export { useViewportMetricsSync } from './useViewportMetricsSync';

package/file-manager/hooks/notifications/index.d.ts

@@ -0,0 +1,2 @@
+export * from './types';
+export { useNotifications, useMessage, useModalConfirm, useAppApi } from './useNotificationsBase';

package/file-manager/hooks/notifications/notificationDedupe.d.ts

@@ -0,0 +1,6 @@
+import type { NotifyEvent } from '../../types';
+export declare function getNotificationDedupeKey(event: NotifyEvent): string;
+/** Если то же событие уже показывали недавно — глушим видимость (silent). */
+export declare function suppressIfDuplicateWithinTtl(event: NotifyEvent, ttlMs: number): void;
+/** Вызывать только после фактического показа уведомления пользователю. */
+export declare function recordNotificationShown(event: NotifyEvent, ttlMs: number): void;

package/file-manager/hooks/notifications/types.d.ts

@@ -0,0 +1,40 @@
+import { Notify } from '../../types';
+export type NotifyArgs<Map, Event, K extends keyof Map> = Omit<Event, 'type' | 'id' | 'data'> & {
+    id: K;
+} & (Map[K] extends never ? {} : {
+    data: Map[K];
+});
+export type ErrorPayload<Key extends keyof Notify.ErrorMap = keyof Notify.ErrorMap> = Omit<Notify.ErrorEvent, 'type' | 'id' | 'data'> & {
+    id: Key;
+} & (Notify.ErrorMap[Key] extends never ? {
+    data?: never;
+} : {
+    data: Notify.ErrorMap[Key];
+});
+export type SuccessPayload<Key extends keyof Notify.SuccessMap = keyof Notify.SuccessMap> = Omit<Notify.SuccessEvent, 'type' | 'id' | 'data'> & {
+    id: Key;
+} & (Notify.SuccessMap[Key] extends never ? {
+    data?: never;
+} : {
+    data: Notify.SuccessMap[Key];
+});
+export type WarningPayload<Key extends keyof Notify.WarningMap = keyof Notify.WarningMap> = Omit<Notify.WarningEvent, 'type' | 'id' | 'data'> & {
+    id: Key;
+} & (Notify.WarningMap[Key] extends never ? {
+    data?: never;
+} : {
+    data: Notify.WarningMap[Key];
+});
+export type NotifyPayload<Key extends keyof Notify.ErrorMap | keyof Notify.SuccessMap | keyof Notify.WarningMap = never> = Key extends keyof Notify.ErrorMap ? ErrorPayload<Key> & {
+    type: 'error';
+} : Key extends keyof Notify.SuccessMap ? SuccessPayload<Key> & {
+    type: 'success';
+} : Key extends keyof Notify.WarningMap ? WarningPayload<Key> & {
+    type: 'warning';
+} : never;
+export interface Notification {
+    error<Key extends keyof Notify.ErrorMap>(payload: ErrorPayload<Key>, silent?: boolean): Promise<NotifyPayload<Key>>;
+    success<Key extends keyof Notify.SuccessMap>(payload: SuccessPayload<Key>, silent?: boolean): Promise<NotifyPayload<Key>>;
+    warning<Key extends keyof Notify.WarningMap>(payload: WarningPayload<Key>, silent?: boolean): Promise<NotifyPayload<Key>>;
+    notify<Key extends keyof Notify.ErrorMap | keyof Notify.SuccessMap | keyof Notify.WarningMap>(payload: NotifyPayload<Key>, silent?: boolean): Promise<NotifyPayload<Key>>;
+}

package/file-manager/hooks/notifications/useNotificationsBase.d.ts

@@ -0,0 +1,11 @@
+import type { MessageInstance } from 'antd/es/message/interface';
+import type { ModalStaticFunctions } from 'antd/es/modal/confirm';
+import { Notification } from './types';
+export declare const useNotifications: () => Notification;
+export declare const useAppApi: () => {
+    notification: import("antd/es/notification/interface").NotificationInstance;
+    message: MessageInstance;
+    modal: import("antd/es/modal/useModal").HookAPI;
+};
+export declare const useMessage: () => MessageInstance;
+export declare const useModalConfirm: () => Omit<ModalStaticFunctions, 'warn'>;

package/file-manager/hooks/useControlledImageLoader.d.ts

@@ -0,0 +1,18 @@
+export type ControlledImageStatus = 'idle' | 'queued' | 'loading' | 'loaded' | 'error';
+export interface ControlledImageSnapshot {
+    status: ControlledImageStatus;
+    shouldLoad: boolean;
+}
+export interface ControlledImageLoader {
+    getSnapshot: (id: string, src: string) => ControlledImageSnapshot;
+    subscribe: (id: string, src: string, listener: (snapshot: ControlledImageSnapshot) => void) => (() => void);
+    setActive: (id: string, src: string, active: boolean) => void;
+    markLoaded: (id: string) => void;
+    markError: (id: string) => void;
+    release: (id: string) => void;
+}
+interface UseControlledImageLoaderOptions {
+    maxConcurrent?: number;
+}
+export declare function useControlledImageLoader({ maxConcurrent, }?: UseControlledImageLoaderOptions): ControlledImageLoader;
+export {};

package/file-manager/hooks/useCustomIcons.d.ts

@@ -0,0 +1,34 @@
+import React from 'react';
+import { IconProps } from '../types';
+export declare const useCustomIcons: () => {
+    RootFolderIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    FolderIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    FolderOpenIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    AddFolderIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    FileIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    UploadIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    UploadByUrlIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    ExpandArrowIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    CollapseArrowIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    ExpandFolderIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    CollapseFolderIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    FolderPreviewIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    EmptyFolderIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    GridViewIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    ListViewIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    DropZoneFileIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    BigStockIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    BigAIIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    GifPlayIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    StockBigIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    MixedViewIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    LandscapeViewIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    PortraitViewIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    SquareViewIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    LightModeIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    DarkModeIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    AiIcon_2: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    NoFilesIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    ThumbsUpIcon: (props?: IconProps) => React.ReactElement<unknown, string | React.JSXElementConstructor<any>>;
+    getCustomIcon: (iconName: keyof NonNullable<import("../types").CustomIcons | undefined>, defaultIcon: React.ComponentType<any>, props?: IconProps) => React.ReactElement;
+};

package/file-manager/hooks/useFileActions.d.ts

@@ -0,0 +1,21 @@
+import { File as AppFile, ThumbnailFile } from '../types';
+interface UseFileActionsProps {
+    files: AppFile[];
+    clearSelection: () => void;
+    showRenameModal: (fileId: string) => void;
+    showMoveModal: () => void;
+    showCopyModal: () => void;
+    handleDeleteFile: (fileId: string) => void;
+    handleDeleteFolder: (folderId: string) => void;
+    showDeleteConfirm?: () => void;
+    onEdit: (file?: AppFile | ThumbnailFile) => void;
+}
+export declare const useFileActions: ({ files, clearSelection, showRenameModal, showMoveModal, showCopyModal, handleDeleteFile, handleDeleteFolder, showDeleteConfirm, onEdit, }: UseFileActionsProps) => {
+    handleClearSelection: () => void;
+    handleRename: (selectedFileId?: string) => void;
+    handleDeleteSelected: (file: AppFile | undefined) => void;
+    handleCopy: () => void;
+    handleMove: () => void;
+    handleEdit: () => void;
+};
+export {};

package/file-manager/hooks/useFileUpload.d.ts

@@ -0,0 +1,18 @@
+import { UploadFileItem } from '../components/UploadProgress/UploadProgress';
+import { File } from '../types';
+export interface UseFileUploadReturn {
+    uploadFiles: UploadFileItem[];
+    isUploadVisible: boolean;
+    isUploadMinimized: boolean;
+    totalFiles: number;
+    completedFiles: number;
+    startUpload: (folderId: string | undefined, files: globalThis.File[]) => string[];
+    startUploadByUrl: (folderId: string | undefined, fileName: string) => string;
+    updateProgress: (fileId: string, progress: number) => void;
+    markAsSuccess: (fileId: string, uploadedFile?: File) => void;
+    markAsError: (fileId: string, error: string) => void;
+    getUploadedFile: (fileId: string) => File | undefined;
+    closeUpload: () => void;
+    minimizeUpload: () => void;
+}
+export declare const useFileUpload: () => UseFileUploadReturn;

package/file-manager/hooks/useFolderSelectionMenu.d.ts

@@ -0,0 +1,26 @@
+import React from 'react';
+import type { FormInstance } from 'antd';
+import type { Folder, MenuItem } from '../types';
+interface UseFolderSelectionMenuParams {
+    folders: Folder[];
+    selectedFolder: string | null;
+    EmptyFolderIcon: React.ComponentType<{
+        style?: React.CSSProperties;
+    }>;
+    handleCreateFolderModalOk: (currentForm?: FormInstance) => Promise<Folder | {
+        id?: string;
+    } | undefined>;
+    setIsLoading: (value: boolean) => void;
+    t: (key: string) => string;
+}
+export declare function useFolderSelectionMenu({ folders, selectedFolder, EmptyFolderIcon, handleCreateFolderModalOk, setIsLoading, t, }: UseFolderSelectionMenuParams): {
+    activeFormField: string;
+    setActiveFormField: React.Dispatch<React.SetStateAction<string>>;
+    generateMenuItemsFromFolders: (params: {
+        targetForm: FormInstance;
+        onTreeSelect: (selectedKeys: React.Key[]) => Promise<void>;
+        onComplete: (targetFolder?: string) => void;
+        actionButtonText: string;
+    }) => MenuItem[];
+};
+export {};

package/file-manager/hooks/useHybridSortAndFilter.d.ts

@@ -0,0 +1,24 @@
+import { File, FilesQueryParams, Config } from '../types';
+import { SortByType, SortOrderType } from './core/types';
+interface UseHybridSortAndFilterProps {
+    files: File[];
+    config?: Config;
+    onServerRequest?: (params: FilesQueryParams) => Promise<void>;
+}
+interface UseHybridSortAndFilterReturn {
+    processedFiles: File[];
+    handleSearch: (searchTerm: string) => void;
+    handleSort: (sortBy: SortByType, sortOrder: SortOrderType) => void;
+    handlePaginationChange: (page: number, pageSize?: number) => void;
+    isClientSideProcessing: boolean;
+}
+export declare const useHybridSortAndFilter: ({ files, config, onServerRequest, }: UseHybridSortAndFilterProps) => UseHybridSortAndFilterReturn;
+export declare const useClientSideFileProcessing: (files: File[], searchTerm: string, sortBy: SortByType, sortOrder: SortOrderType, currentPage?: number, pageSize?: number) => {
+    processedFiles: File[];
+    paginatedFiles: File[];
+    totalFiles: number;
+    totalPages: number;
+    hasNextPage: boolean;
+    hasPrevPage: boolean;
+};
+export {};

package/file-manager/hooks/useLastDirectory.d.ts

@@ -0,0 +1,18 @@
+export interface LastDirectoryData {
+    folderId: string | null;
+    pathHistory: Array<{
+        id: string;
+        name: string;
+    }>;
+    timestamp: number;
+}
+export interface UseLastDirectoryResult {
+    getLastDirectory: () => LastDirectoryData | null;
+    saveLastDirectory: (folderId: string | null, pathHistory: Array<{
+        id: string;
+        name: string;
+    }>) => void;
+    clearLastDirectory: () => void;
+    hasValidLastDirectory: () => boolean;
+}
+export declare const useLastDirectory: () => UseLastDirectoryResult;

package/file-manager/hooks/useNotifications.d.ts

@@ -0,0 +1 @@
+export * from './notifications';

package/file-manager/hooks/usePixieEditor.d.ts

@@ -0,0 +1,16 @@
+import type { PixieSavePayload } from '../types';
+import { File as AppFile, FilesQueryParams, ThumbnailFile } from '../types';
+interface UsePixieEditorProps {
+    files: AppFile[];
+    fetchFiles: (params?: FilesQueryParams) => Promise<void>;
+    selectedFolder: string | null;
+}
+export declare const usePixieEditor: ({ files, fetchFiles, selectedFolder }: UsePixieEditorProps) => {
+    isPixieEditorVisible: boolean;
+    editingFile: AppFile | ThumbnailFile | null;
+    handleEdit: (fileForEdit?: ThumbnailFile | AppFile) => void;
+    handlePixieEditorSave: (updatedFile: AppFile, payload: PixieSavePayload) => Promise<AppFile | undefined>;
+    handlePixieEditorSaveCopy: (updatedFile: AppFile, payload: PixieSavePayload) => Promise<AppFile | undefined>;
+    handlePixieEditorClose: () => void;
+};
+export {};

package/file-manager/hooks/useProxyDisplayFallback.d.ts

@@ -0,0 +1,8 @@
+import type { ProxiedUrlTransitionResult } from '../types';
+export declare function useProxyDisplayFallback(originalSources: Array<string | undefined>): {
+    src: string | undefined;
+    hasNextCandidate: boolean;
+    handleError: () => Promise<ProxiedUrlTransitionResult>;
+    handleLoad: () => void;
+    handleChangeSrc: () => Promise<ProxiedUrlTransitionResult>;
+};

package/file-manager/hooks/useViewMode.d.ts

@@ -0,0 +1,7 @@
+export type ViewMode = 'table' | 'grid';
+export interface UseViewModeResult {
+    viewMode: ViewMode;
+    setViewMode: (mode: ViewMode) => void;
+    toggleViewMode: () => void;
+}
+export declare const useViewMode: () => UseViewModeResult;

package/file-manager/hooks/useViewportMetricsSync.d.ts

@@ -0,0 +1,2 @@
+import { getViewportMetrics } from '../presentation/list-core/viewportMetrics';
+export declare function useViewportMetricsSync<TElement extends HTMLElement>(onViewportChange: (metrics: ReturnType<typeof getViewportMetrics>) => void, deps: readonly unknown[]): import("react").RefObject<TElement | null>;

package/file-manager/i18n.d.ts

@@ -0,0 +1,2 @@
+import i18next from 'i18next';
+export default i18next;

package/file-manager/index.d.ts

@@ -0,0 +1,29 @@
+import { init, unmount, FileManagerAppWithContext, initPixieEditor, unmountPixieEditor, initFileManager, PixieOnlyApp } from './file-manager';
+export { init, unmount, FileManagerAppWithContext, PixieOnlyApp, initPixieEditor, unmountPixieEditor, initFileManager };
+declare const _default: {
+    init: typeof init;
+    unmount: typeof unmount;
+    initPixieEditor: typeof initPixieEditor;
+    unmountPixieEditor: typeof unmountPixieEditor;
+    initFileManager: typeof initFileManager;
+};
+export default _default;
+export { FileManagerApp } from './components/FileManagerApp/FileManagerApp';
+export { FileContent } from './components/FileContent/FileContent';
+export { FileModals } from './components/FileModals/FileModals';
+export { FolderSidebar } from './components/FolderSidebar/FolderSidebar';
+export { installResizeObserverErrorHandler, uninstallResizeObserverErrorHandler } from './utils/resizeObserverHandler';
+export { type Folder, type File, type PathItem, type MenuItem, type FileManagerOptions, type FileManagerHookReturn, type FileManagerErrorCode, type IFileManagerApiError, type SortOptionType, type FileManagerItemMeta, } from './types';
+export { FileManagerApiError } from './shared/fileManagerApiError';
+export { mapHttpStatusToErrorCode } from './shared/mapHttpStatusToErrorCode';
+export { buildAssetsPath, joinUrls, getAssetsBase } from './helpers/urls';
+export { FailedRequestCache } from './adapters/FailedRequestCache';
+export { MutationRegistry } from './adapters/MutationRegistry';
+export { compareFileSystemItems, defaultChildrenViewFilterMatch, defaultFileSystemItemComparator, defaultHasSortValue, hasComparableSortValue, matchesChildrenViewFilter, resolveSortParams, resolveViewStrategyOptions, } from './adapters/cacheViewStrategy';
+export { TRASH_FOLDER_ID, createSystemFolderByPathResolver, getTrashFolderLookupCandidates, normalizeSystemFolderPath, type SystemFolderDefinition, } from './adapters/systemFolderPath';
+export { TreeCache, ViewCacheManager, DEFAULT_FILE_MANAGER_CACHE_TTL_MS, defaultIsFolderNotFoundError, type TreeCacheConfig, type QueryResult, type ChildrenQueryParams, type ViewStrategyOptions, } from './adapters/TreeCache';
+export { DataSourceProxyBase, type DataSourceProxyConfig, type DataSourceProxyOptions, type FileManagerProxyOptions, } from './adapters/DataSourceProxyBase';
+export { PathAwareStorageAdapter } from './adapters/PathAwareStorageAdapter';
+export type { StorageProvider, StorageProviderController, FileSystemItem, FileSystemItemUpdate, GetFileDataOptions, BatchResult as StorageBatchResult, OperationResult as StorageOperationResult, FileManagerApiErrorInfo, StorageApiPaginationResponse, StorageSortState, StorageUploadFileItemInput, StorageUploadFilesRequest, MayBePromise, } from './types/storage';
+export { fetchRemoteImageBlobByUrl, type FetchRemoteImageBlobOptions, type RemoteFileFetchHandlers, type RemoteFileFetchIntent, } from './utils/remoteFileFetchPipeline';
+export { type InitPixieEditorOptions, type Options as FileManagerInitOptions, type UniversalInitOptions, } from './file-manager';