@nice2dev/ui-communication 1.0.8 → 1.0.10

package/dist/__tests__/encryptionService.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file encryptionService.test.ts
+ * @description Phase A1.5 baseline coverage for the EncryptionService and the
+ * pure base64 / key-helper functions exported alongside it. Uses Node's
+ * built-in WebCrypto (`crypto.subtle`) — no network, no DOM beyond what jsdom
+ * already provides.
+ */
+export {};

package/dist/__tests__/helpers.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file helpers.test.ts
+ * @description Phase A1.5 — pure-function helper coverage for `useCommunication.ts`:
+ * `buildOptimisticMessage`, `findConversationPartner`, `getUnreadCount`,
+ * `getMentionCount`, `getDefaultMode`.
+ */
+export {};

package/dist/__tests__/setup.d.ts

@@ -0,0 +1 @@
+

package/dist/__tests__/storageService.test.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @file storageService.test.ts
+ * @description Phase A1.5 — StorageService coverage via the LocalStorage
+ * adapter (jsdom provides `localStorage`; we deliberately avoid the IndexedDB
+ * branch which would require `fake-indexeddb`).
+ */
+export {};

package/dist/__tests__/transport.test.d.ts

@@ -0,0 +1,8 @@
+/**
+ * @file transport.test.ts
+ * @description Phase A1.5 — coverage for the framework-agnostic transport
+ * factory + MockTransport event flow. Avoids real WebRTC / MediaRecorder /
+ * AudioContext APIs (not available in jsdom), focuses on the event-emitter
+ * surface and lifecycle.
+ */
+export {};

package/dist/collaboration/collaborative-datagrid.d.ts

@@ -0,0 +1,95 @@
+import { CollaborationConfig } from './yjs-integration';
+/**
+ * @file Collaborative DataGrid with CRDT
+ * @description Real-time collaborative data grid editing
+ */
+import * as Y from 'yjs';
+export interface CollaborativeDataGridConfig<T> extends CollaborationConfig {
+    /** Initial rows data */
+    initialData?: T[];
+    /** Column definitions */
+    columns: CollaborativeColumnDef<T>[];
+    /** Row ID field */
+    rowIdField: keyof T;
+}
+export interface CollaborativeColumnDef<T> {
+    field: keyof T;
+    header: string;
+    editable?: boolean;
+    width?: number;
+    type?: 'text' | 'number' | 'boolean' | 'date' | 'select';
+    options?: {
+        value: string;
+        label: string;
+    }[];
+}
+export interface CellEdit<T> {
+    rowId: string;
+    field: keyof T;
+    value: unknown;
+    userId: string;
+    timestamp: number;
+}
+export interface ActiveEdit {
+    rowId: string;
+    field: string;
+    user: {
+        id: string;
+        name: string;
+        color: string;
+    };
+}
+/**
+ * Hook for collaborative DataGrid editing
+ */
+export declare function useCollaborativeDataGrid<T extends Record<string, unknown>>(config: CollaborativeDataGridConfig<T>): {
+    rows: T[];
+    columns: CollaborativeColumnDef<T>[];
+    collaborators: import('./yjs-integration').CollaborationUser[];
+    isConnected: boolean;
+    isSynced: boolean;
+    activeEdits: ActiveEdit[];
+    startCellEdit: (rowId: string, field: keyof T) => void;
+    endCellEdit: () => void;
+    updateCell: (rowIndex: number, field: keyof T, value: unknown) => void;
+    addRow: (row: T) => void;
+    removeRow: (rowIndex: number) => void;
+    isCellLocked: (rowId: string, field: keyof T) => ActiveEdit | undefined;
+    getRowById: (id: string) => {
+        row: T;
+        index: number;
+    } | undefined;
+};
+export interface ConflictResolution<T> {
+    strategy: 'lastWriteWins' | 'firstWriteWins' | 'merge' | 'custom';
+    mergeFunction?: (local: T, remote: T) => T;
+}
+/**
+ * Hook for conflict resolution in collaborative editing
+ */
+export declare function useConflictResolution<T>(resolution: ConflictResolution<T>): {
+    resolve: (local: T, remote: T, timestamp: {
+        local: number;
+        remote: number;
+    }) => T;
+};
+export interface ChangeHistoryEntry<T> {
+    id: string;
+    type: 'insert' | 'update' | 'delete';
+    rowId: string;
+    field?: keyof T;
+    oldValue?: unknown;
+    newValue?: unknown;
+    user: {
+        id: string;
+        name: string;
+    };
+    timestamp: number;
+}
+/**
+ * Hook for tracking change history
+ */
+export declare function useChangeHistory<T>(ydoc: Y.Doc | null, rowIdField: keyof T): {
+    history: ChangeHistoryEntry<T>[];
+    clearHistory: () => void;
+};

package/dist/collaboration/collaborative-form.d.ts

@@ -0,0 +1,75 @@
+import { CollaborationConfig, CollaborationUser } from './yjs-integration';
+
+export interface CollaborativeFormConfig<T extends Record<string, unknown>> extends CollaborationConfig {
+    /** Initial form values */
+    initialValues?: Partial<T>;
+    /** Field validation rules */
+    validation?: FormValidation<T>;
+    /** Debounce delay for syncing (ms) */
+    syncDelay?: number;
+}
+export type FormValidation<T> = {
+    [K in keyof T]?: (value: T[K], formValues: Partial<T>) => string | undefined;
+};
+export interface FieldFocus {
+    fieldName: string;
+    user: CollaborationUser;
+}
+export interface FormState<T> {
+    values: Partial<T>;
+    errors: Partial<Record<keyof T, string>>;
+    touched: Partial<Record<keyof T, boolean>>;
+    isDirty: boolean;
+    isValid: boolean;
+    focusedFields: FieldFocus[];
+}
+/**
+ * Hook for collaborative form editing
+ */
+export declare function useCollaborativeForm<T extends Record<string, unknown>>(config: CollaborativeFormConfig<T>): {
+    values: Partial<T>;
+    errors: Partial<Record<keyof T, string>>;
+    touched: Partial<Record<keyof T, boolean>>;
+    isDirty: boolean;
+    isValid: boolean;
+    focusedFields: FieldFocus[];
+    collaborators: CollaborationUser[];
+    isConnected: boolean;
+    isSynced: boolean;
+    setFieldValue: <K extends keyof T>(fieldName: K, value: T[K]) => void;
+    setFieldTouched: (fieldName: keyof T, isTouched?: boolean) => void;
+    handleFieldFocus: (fieldName: keyof T) => void;
+    handleFieldBlur: (fieldName: keyof T) => void;
+    isFieldFocused: (fieldName: keyof T) => FieldFocus | undefined;
+    validateField: (fieldName: keyof T, value: T[typeof fieldName]) => string | undefined;
+    validateForm: () => boolean;
+    resetForm: () => void;
+    handleSubmit: (onSubmit: (values: Partial<T>) => void | Promise<void>) => (e?: React.FormEvent) => Promise<void>;
+};
+export interface CollaborativeFieldProps {
+    name: string;
+    focusedBy?: FieldFocus;
+    children: React.ReactNode;
+}
+/**
+ * Wrapper component showing collaborative field state
+ */
+export declare function CollaborativeFieldWrapper({ name, focusedBy, children }: CollaborativeFieldProps): import("react/jsx-runtime").JSX.Element;
+/**
+ * Convenience hook for individual form field
+ */
+export declare function useCollaborativeField<T extends Record<string, unknown>, K extends keyof T>(form: ReturnType<typeof useCollaborativeForm<T>>, fieldName: K): {
+    value: Partial<T>[K];
+    error: Partial<Record<keyof T, string>>[K] | undefined;
+    touched: Partial<Record<keyof T, boolean>>[K];
+    focusedBy: FieldFocus | undefined;
+    onChange: (newValue: T[K]) => void;
+    onFocus: () => void;
+    onBlur: () => void;
+    inputProps: {
+        value: string | NonNullable<Partial<T>[K]>;
+        onFocus: () => void;
+        onBlur: () => void;
+        onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    };
+};

package/dist/collaboration/yjs-integration.d.ts

@@ -0,0 +1,135 @@
+/**
+ * @file Nice2Dev Real-time Collaboration - Yjs/CRDT Integration
+ * @description Real-time collaborative editing using Yjs CRDTs
+ * @packageDocumentation
+ */
+import * as Y from 'yjs';
+export interface CollaborationConfig {
+    /** Document ID */
+    documentId: string;
+    /** User information */
+    user: CollaborationUser;
+    /** Server URL for WebSocket */
+    serverUrl?: string;
+    /** Enable WebRTC for peer-to-peer */
+    useWebRTC?: boolean;
+    /** Enable offline persistence */
+    persistence?: boolean;
+    /** Awareness features */
+    awareness?: AwarenessConfig;
+}
+export interface CollaborationUser {
+    id: string;
+    name: string;
+    color: string;
+    avatar?: string;
+}
+export interface AwarenessConfig {
+    /** Update interval in ms */
+    updateInterval?: number;
+    /** Show cursors */
+    showCursors?: boolean;
+    /** Show selections */
+    showSelections?: boolean;
+    /** Show user presence */
+    showPresence?: boolean;
+}
+export interface AwarenessState {
+    user: CollaborationUser;
+    cursor?: {
+        x: number;
+        y: number;
+    };
+    selection?: {
+        start: number;
+        end: number;
+    };
+    field?: string;
+    lastActive: number;
+}
+export interface CollaborationState {
+    isConnected: boolean;
+    isSynced: boolean;
+    users: CollaborationUser[];
+    awareness: Map<number, AwarenessState>;
+}
+/**
+ * Main collaboration hook - creates and manages a Yjs document
+ */
+export declare function useCollaboration(config: CollaborationConfig): {
+    ydoc: Y.Doc | null;
+    state: CollaborationState;
+    updateAwareness: (update: Partial<AwarenessState>) => void;
+};
+/**
+ * Hook for collaborative text editing
+ */
+export declare function useCollaborativeText(ydoc: Y.Doc | null, fieldName: string): {
+    value: string;
+    insert: (index: number, text: string) => void;
+    delete: (index: number, length: number) => void;
+    replace: (newValue: string) => void;
+    ytext: Y.Text | null;
+};
+/**
+ * Hook for collaborative arrays (e.g., table rows, list items)
+ */
+export declare function useCollaborativeArray<T>(ydoc: Y.Doc | null, arrayName: string): {
+    items: T[];
+    push: (...newItems: T[]) => void;
+    insert: (index: number, ...newItems: T[]) => void;
+    delete: (index: number, length?: number) => void;
+    update: (index: number, value: T) => void;
+    move: (fromIndex: number, toIndex: number) => void;
+    yarray: Y.Array<T> | null;
+};
+/**
+ * Hook for collaborative maps (e.g., form fields)
+ */
+export declare function useCollaborativeMap<T extends Record<string, unknown>>(ydoc: Y.Doc | null, mapName: string): {
+    data: Partial<T>;
+    set: <K extends keyof T>(key: K, value: T[K]) => void;
+    get: <K extends keyof T>(key: K) => T[K] | undefined;
+    delete: (key: keyof T) => void;
+    setMultiple: (updates: Partial<T>) => void;
+    ymap: Y.Map<unknown> | null;
+};
+/**
+ * Hook for tracking and displaying user cursors
+ */
+export declare function useCursorTracking(updateAwareness: (update: Partial<AwarenessState>) => void, enabled?: boolean): void;
+/**
+ * Hook for tracking text selection
+ */
+export declare function useSelectionTracking(updateAwareness: (update: Partial<AwarenessState>) => void, fieldName: string, enabled?: boolean): void;
+/**
+ * Hook for collaborative undo/redo
+ */
+export declare function useCollaborativeHistory(ydoc: Y.Doc | null): {
+    undo: () => void;
+    redo: () => void;
+    canUndo: boolean;
+    canRedo: boolean;
+};
+export interface PresenceAvatarsProps {
+    users: CollaborationUser[];
+    maxDisplay?: number;
+    size?: 'sm' | 'md' | 'lg';
+    className?: string;
+}
+/**
+ * Component displaying active collaborators
+ */
+export declare function PresenceAvatars({ users, maxDisplay, size, className, }: PresenceAvatarsProps): import("react/jsx-runtime").JSX.Element;
+export interface CursorOverlayProps {
+    awareness: Map<number, AwarenessState>;
+    localClientId: number;
+}
+/**
+ * Component displaying other users' cursors
+ */
+export declare function CursorOverlay({ awareness, localClientId }: CursorOverlayProps): import("react/jsx-runtime").JSX.Element;
+export * from 'yjs';
+export { WebsocketProvider } from 'y-websocket';
+export { WebrtcProvider } from 'y-webrtc';
+export { IndexeddbPersistence } from 'y-indexeddb';