@nice2dev/ui-communication 1.0.5 → 1.0.6

package/dist/services/slackImportService.d.ts

@@ -0,0 +1,426 @@
+/**
+ * @fileoverview Slack Import Service for migrating data from Slack
+ * @module @nice2dev/ui-communication/services/slackImportService
+ * @description Provides tools for importing Slack workspace data including
+ *              channels, messages, users, files, and reactions.
+ */
+export type SlackChannelType = 'public' | 'private' | 'dm' | 'mpim';
+export type ImportStatus = 'pending' | 'in_progress' | 'completed' | 'failed' | 'cancelled';
+export interface SlackUser {
+    id: string;
+    team_id: string;
+    name: string;
+    real_name?: string;
+    email?: string;
+    profile?: {
+        display_name?: string;
+        image_72?: string;
+        image_192?: string;
+        title?: string;
+        phone?: string;
+        status_text?: string;
+        status_emoji?: string;
+    };
+    is_admin?: boolean;
+    is_owner?: boolean;
+    is_bot?: boolean;
+    deleted?: boolean;
+    tz?: string;
+    tz_label?: string;
+}
+export interface SlackChannel {
+    id: string;
+    name: string;
+    is_channel?: boolean;
+    is_private?: boolean;
+    is_mpim?: boolean;
+    is_im?: boolean;
+    is_archived?: boolean;
+    created: number;
+    creator?: string;
+    topic?: {
+        value: string;
+        creator: string;
+    };
+    purpose?: {
+        value: string;
+        creator: string;
+    };
+    members?: string[];
+    num_members?: number;
+}
+export interface SlackMessage {
+    type: string;
+    subtype?: string;
+    ts: string;
+    user?: string;
+    text: string;
+    thread_ts?: string;
+    reply_count?: number;
+    reply_users?: string[];
+    reactions?: SlackReaction[];
+    files?: SlackFile[];
+    attachments?: SlackAttachment[];
+    edited?: {
+        user: string;
+        ts: string;
+    };
+    blocks?: unknown[];
+}
+export interface SlackReaction {
+    name: string;
+    users: string[];
+    count: number;
+}
+export interface SlackFile {
+    id: string;
+    name: string;
+    title?: string;
+    mimetype: string;
+    filetype: string;
+    size: number;
+    url_private?: string;
+    url_private_download?: string;
+    created: number;
+    user?: string;
+    thumb_64?: string;
+    thumb_80?: string;
+    thumb_160?: string;
+}
+export interface SlackAttachment {
+    fallback?: string;
+    color?: string;
+    pretext?: string;
+    author_name?: string;
+    author_link?: string;
+    author_icon?: string;
+    title?: string;
+    title_link?: string;
+    text?: string;
+    fields?: Array<{
+        title: string;
+        value: string;
+        short?: boolean;
+    }>;
+    image_url?: string;
+    thumb_url?: string;
+    footer?: string;
+    footer_icon?: string;
+    ts?: number;
+}
+export interface SlackExportData {
+    users: SlackUser[];
+    channels: SlackChannel[];
+    messages: Map<string, SlackMessage[]>;
+    files?: SlackFile[];
+}
+export interface ImportMapping {
+    /** Map Slack user ID to new user ID */
+    users: Map<string, string>;
+    /** Map Slack channel ID to new channel ID */
+    channels: Map<string, string>;
+    /** Map Slack file ID to new file URL */
+    files: Map<string, string>;
+}
+export interface ImportOptions {
+    /** Import users */
+    importUsers?: boolean;
+    /** Import channels */
+    importChannels?: boolean;
+    /** Import messages */
+    importMessages?: boolean;
+    /** Import files */
+    importFiles?: boolean;
+    /** Import reactions */
+    importReactions?: boolean;
+    /** Import threads */
+    importThreads?: boolean;
+    /** Skip archived channels */
+    skipArchived?: boolean;
+    /** Skip direct messages */
+    skipDirectMessages?: boolean;
+    /** Only import specific channels */
+    channelFilter?: string[];
+    /** Import messages after this date */
+    messagesAfter?: Date;
+    /** Import messages before this date */
+    messagesBefore?: Date;
+    /** Download files locally */
+    downloadFiles?: boolean;
+    /** Preserve timestamps */
+    preserveTimestamps?: boolean;
+    /** Batch size for processing */
+    batchSize?: number;
+}
+export interface ImportProgress {
+    /** Current phase */
+    phase: 'users' | 'channels' | 'messages' | 'files' | 'complete';
+    /** Total items in current phase */
+    total: number;
+    /** Processed items */
+    processed: number;
+    /** Failed items */
+    failed: number;
+    /** Current item being processed */
+    current?: string;
+    /** Progress percentage */
+    percentage: number;
+    /** Is complete */
+    isComplete: boolean;
+    /** Errors encountered */
+    errors: ImportError[];
+}
+export interface ImportError {
+    phase: string;
+    itemId?: string;
+    itemType: 'user' | 'channel' | 'message' | 'file';
+    message: string;
+    details?: unknown;
+}
+export interface ImportResult {
+    /** Import status */
+    status: ImportStatus;
+    /** Statistics */
+    stats: {
+        usersImported: number;
+        channelsImported: number;
+        messagesImported: number;
+        filesImported: number;
+        reactionsImported: number;
+        threadsImported: number;
+    };
+    /** Mapping of old IDs to new IDs */
+    mapping: ImportMapping;
+    /** Errors encountered */
+    errors: ImportError[];
+    /** Started timestamp */
+    startedAt: Date;
+    /** Completed timestamp */
+    completedAt?: Date;
+    /** Duration in milliseconds */
+    duration?: number;
+}
+export interface SlackImportConfig {
+    /** Function to create a user in the target system */
+    createUser: (user: MappedUser) => Promise<{
+        success: boolean;
+        id?: string;
+        error?: string;
+    }>;
+    /** Function to create a channel in the target system */
+    createChannel: (channel: MappedChannel) => Promise<{
+        success: boolean;
+        id?: string;
+        error?: string;
+    }>;
+    /** Function to create a message in the target system */
+    createMessage: (message: MappedMessage) => Promise<{
+        success: boolean;
+        id?: string;
+        error?: string;
+    }>;
+    /** Function to upload a file */
+    uploadFile?: (file: SlackFile, content: ArrayBuffer) => Promise<{
+        success: boolean;
+        url?: string;
+        error?: string;
+    }>;
+    /** Function to download files from Slack */
+    downloadFile?: (url: string, token: string) => Promise<ArrayBuffer>;
+    /** Slack API token (for file downloads) */
+    slackToken?: string;
+    /** Rate limit (items per second) */
+    rateLimit?: number;
+}
+export interface MappedUser {
+    /** Original Slack user ID */
+    slackId: string;
+    /** Email */
+    email?: string;
+    /** Display name */
+    displayName: string;
+    /** Real name */
+    realName?: string;
+    /** Avatar URL */
+    avatarUrl?: string;
+    /** Title/role */
+    title?: string;
+    /** Phone */
+    phone?: string;
+    /** Timezone */
+    timezone?: string;
+    /** Is admin */
+    isAdmin: boolean;
+    /** Is bot */
+    isBot: boolean;
+    /** Is deactivated */
+    isDeactivated: boolean;
+}
+export interface MappedChannel {
+    /** Original Slack channel ID */
+    slackId: string;
+    /** Channel name */
+    name: string;
+    /** Channel type */
+    type: SlackChannelType;
+    /** Description/purpose */
+    description?: string;
+    /** Topic */
+    topic?: string;
+    /** Is archived */
+    isArchived: boolean;
+    /** Creator ID (mapped) */
+    creatorId?: string;
+    /** Member IDs (mapped) */
+    memberIds: string[];
+    /** Created timestamp */
+    createdAt?: Date;
+}
+export interface MappedMessage {
+    /** Channel ID (mapped) */
+    channelId: string;
+    /** Sender ID (mapped) */
+    senderId?: string;
+    /** Message content (converted from Slack format) */
+    content: string;
+    /** HTML content */
+    htmlContent?: string;
+    /** Thread parent ID (mapped) */
+    threadId?: string;
+    /** Is thread reply */
+    isThreadReply: boolean;
+    /** Attachments */
+    attachments: Array<{
+        type: 'file' | 'link' | 'image';
+        url?: string;
+        name?: string;
+        size?: number;
+    }>;
+    /** Reactions */
+    reactions: Array<{
+        emoji: string;
+        userIds: string[];
+        count: number;
+    }>;
+    /** Created timestamp */
+    createdAt?: Date;
+    /** Edited timestamp */
+    editedAt?: Date;
+}
+/**
+ * Service for importing Slack workspace data.
+ *
+ * @example
+ * ```tsx
+ * const importService = new SlackImportService({
+ *   createUser: async (user) => { ... },
+ *   createChannel: async (channel) => { ... },
+ *   createMessage: async (message) => { ... },
+ * });
+ *
+ * // Parse Slack export ZIP
+ * const data = await importService.parseSlackExport(zipFile);
+ *
+ * // Preview import
+ * const preview = importService.previewImport(data);
+ *
+ * // Execute import
+ * for await (const progress of importService.import(data, {
+ *   importUsers: true,
+ *   importChannels: true,
+ *   importMessages: true,
+ * })) {
+ *   console.log(`Progress: ${progress.percentage}%`);
+ * }
+ * ```
+ */
+export declare class SlackImportService {
+    private config;
+    private abortController;
+    private mapping;
+    constructor(config: SlackImportConfig);
+    /**
+     * Parses a Slack export ZIP file.
+     */
+    parseSlackExport(zipFile: File | ArrayBuffer): Promise<SlackExportData>;
+    /**
+     * Parses a Slack export from JSON files (alternative to ZIP).
+     */
+    parseSlackExportFromJson(data: {
+        users?: SlackUser[];
+        channels?: SlackChannel[];
+        messages?: Record<string, SlackMessage[]>;
+        files?: SlackFile[];
+    }): SlackExportData;
+    /**
+     * Previews what will be imported without making changes.
+     */
+    previewImport(data: SlackExportData, options?: ImportOptions): {
+        users: {
+            total: number;
+            filtered: number;
+            items: MappedUser[];
+        };
+        channels: {
+            total: number;
+            filtered: number;
+            items: MappedChannel[];
+        };
+        messages: {
+            total: number;
+            perChannel: Map<string, number>;
+        };
+        files: {
+            total: number;
+            totalSize: number;
+        };
+    };
+    /**
+     * Executes the import process.
+     */
+    import(data: SlackExportData, options?: ImportOptions): AsyncGenerator<ImportProgress, ImportResult, unknown>;
+    /**
+     * Cancels an ongoing import.
+     */
+    cancel(): void;
+    private mapUser;
+    private mapChannel;
+    private mapMessage;
+    private convertSlackMessage;
+    private convertEmoji;
+    private filterMessages;
+    private extractZipContents;
+    private escapeHtml;
+    private delay;
+}
+/**
+ * Gets or creates the Slack import service singleton.
+ */
+export declare function getSlackImportService(config?: SlackImportConfig): SlackImportService;
+/**
+ * Disposes the Slack import service singleton.
+ */
+export declare function disposeSlackImportService(): void;
+export interface UseSlackImportOptions {
+    config?: SlackImportConfig;
+}
+export interface UseSlackImportReturn {
+    /** Parse Slack export from JSON */
+    parseJson: (data: Parameters<SlackImportService['parseSlackExportFromJson']>[0]) => SlackExportData;
+    /** Preview import */
+    preview: (data: SlackExportData, options?: ImportOptions) => ReturnType<SlackImportService['previewImport']>;
+    /** Execute import */
+    import: (data: SlackExportData, options?: ImportOptions) => AsyncGenerator<ImportProgress, ImportResult, unknown>;
+    /** Cancel import */
+    cancel: () => void;
+    /** Current progress */
+    progress: ImportProgress | null;
+    /** Is importing */
+    isImporting: boolean;
+    /** Last result */
+    result: ImportResult | null;
+}
+/**
+ * React hook for Slack import functionality.
+ */
+export declare function useSlackImport(options?: UseSlackImportOptions): UseSlackImportReturn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nice2dev/ui-communication",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "description": "NiceCommunication — full-spectrum communication suite: chat bubble, messenger, voice/video calls, multi-party conference, and Teams-style workspace. Provider-agnostic RTC transport.",
   "type": "module",
   "main": "dist/index.cjs",