plusui-native-core 0.1.66 → 0.1.69

package/Core/Features/FileDrop/filedrop.ts

@@ -1,283 +1,163 @@
-import { connect } from '../Connection/connect';
-
-/**
- * FileDrop API - Cross-platform drag & drop file handling
- *
- * Enables dragging files into the webview window and from the window to the desktop.
- * Supports all file types cross-platform (Windows, macOS, Linux).
- */
-
-/**
- * Information about a dropped file
- */
-export interface FileInfo {
-  /** Full path to the file */
-  path: string;
-  /** File name with extension */
-  name: string;
-  /** MIME type (e.g., "image/png", "text/plain") */
-  type: string;
-  /** File size in bytes */
-  size: number;
-}
-
-/**
- * Drag event data
- */
-export interface DragEvent {
-  /** X coordinate of drag position */
-  x?: number;
-  /** Y coordinate of drag position */
-  y?: number;
-}
-
-export interface FileDropAPI {
-  on<TData = unknown>(name: string, callback: (payload: TData) => void): () => void;
-  emit<TIn = Record<string, unknown>>(name: string, payload: TIn): void;
-
-  /**
-   * Enable or disable file drop into window
-   * @param enabled - true to allow files to be dropped into the window
-   */
-  setEnabled(enabled: boolean): Promise<void>;
-
-  /**
-   * Check if file drop is currently enabled
-   * @returns true if file drop is enabled
-   */
-  isEnabled(): Promise<boolean>;
-
-  /**
-   * Start a drag operation to drag files out of the window
-   * @param filePaths - Paths to files to be dragged
-   * @returns true if drag operation started successfully
-   */
-  startDrag(filePaths: string[]): Promise<boolean>;
-
-  /**
-   * Clear all callbacks
-   */
-  clearCallbacks(): Promise<void>;
-
-  /**
-   * Listen for files dropped into the window
-   * @param callback - Function called with array of dropped files
-   * @returns Unsubscribe function
-   */
-  onFilesDropped(callback: (files: FileInfo[]) => void): () => void;
-
-  /**
-   * Listen for drag enter events
-   * @param callback - Function called when drag enters the window
-   * @returns Unsubscribe function
-   */
-  onDragEnter(callback: (event: DragEvent) => void): () => void;
-
-  /**
-   * Listen for drag leave events
-   * @param callback - Function called when drag leaves the window
-   * @returns Unsubscribe function
-   */
-  onDragLeave(callback: (event: DragEvent) => void): () => void;
-}
-
-export class FileDrop implements FileDropAPI {
-  public readonly connect = connect.feature('fileDrop');
-  private invokeFn: (name: string, args?: unknown[]) => Promise<unknown>;
-  private onFn: (event: string, callback: (data: unknown) => void) => () => void;
-
-  constructor(
-    invokeFn: (name: string, args?: unknown[]) => Promise<unknown>,
-    onFn: (event: string, callback: (data: unknown) => void) => () => void
-  ) {
-    this.invokeFn = invokeFn;
-    this.onFn = onFn;
-  }
-
-  on<TData = unknown>(name: string, callback: (payload: TData) => void): () => void {
-    return this.connect.on<TData>(name, callback);
-  }
-
-  emit<TIn = Record<string, unknown>>(name: string, payload: TIn): void {
-    this.connect.emit<TIn>(name, payload);
-  }
-
-  /**
-   * Enable or disable file drop into window
-   * @param enabled - true to allow files to be dropped into the window
-   */
-  async setEnabled(enabled: boolean): Promise<void> {
-    await this.invokeFn('fileDrop.setEnabled', [enabled]);
-  }
-
-  /**
-   * Check if file drop is currently enabled
-   * @returns true if file drop is enabled
-   */
-  async isEnabled(): Promise<boolean> {
-    return (await this.invokeFn('fileDrop.isEnabled')) as boolean;
-  }
-
-  /**
-   * Start a drag operation to drag files out of the window
-   * @param filePaths - Paths to files to be dragged
-   * @returns true if drag operation started successfully
-   */
-  async startDrag(filePaths: string[]): Promise<boolean> {
-    if (!filePaths || filePaths.length === 0) {
-      throw new Error('filePaths must be a non-empty array');
-    }
-    return (await this.invokeFn('fileDrop.startDrag', [filePaths])) as boolean;
-  }
-
-  /**
-   * Clear all callbacks
-   */
-  async clearCallbacks(): Promise<void> {
-    await this.invokeFn('fileDrop.clearCallbacks');
-  }
-
-  /**
-   * Listen for files dropped into the window
-   * @param callback - Function called with array of dropped files
-   * @returns Unsubscribe function
-   */
-  onFilesDropped(callback: (files: FileInfo[]) => void): () => void {
-    return this.onFn('fileDrop.filesDropped', (data) => {
-      callback(data as FileInfo[]);
-    });
-  }
-
-  /**
-   * Listen for drag enter events
-   * @param callback - Function called when drag enters the window
-   * @returns Unsubscribe function
-   */
-  onDragEnter(callback: (event: DragEvent) => void): () => void {
-    return this.onFn('fileDrop.dragEnter', (data) => {
-      callback((data as DragEvent) || {});
-    });
-  }
-
-  /**
-   * Listen for drag leave events
-   * @param callback - Function called when drag leaves the window
-   * @returns Unsubscribe function
-   */
-  onDragLeave(callback: (event: DragEvent) => void): () => void {
-    return this.onFn('fileDrop.dragLeave', (data) => {
-      callback((data as DragEvent) || {});
-    });
-  }
-}
-
-// Helper functions for common use cases
-
-/**
- * Read dropped file as text
- * @param filePath - Path to the file
- * @returns File contents as text
- */
-export async function readFileAsText(filePath: string): Promise<string> {
-  const response = await fetch(`file://${filePath}`);
-  return await response.text();
-}
-
-/**
- * Read dropped file as data URL (useful for images)
- * @param filePath - Path to the file
- * @returns File contents as data URL
- */
-export async function readFileAsDataUrl(filePath: string): Promise<string> {
-  const response = await fetch(`file://${filePath}`);
-  const blob = await response.blob();
-  return new Promise((resolve, reject) => {
-    const reader = new FileReader();
-    reader.onload = () => resolve(reader.result as string);
-    reader.onerror = reject;
-    reader.readAsDataURL(blob);
-  });
-}
-
-/**
- * Filter files by extension
- * @param files - Array of file info
- * @param extensions - Array of extensions to filter (e.g., ['.png', '.jpg'])
- * @returns Filtered array of files
- */
-export function filterFilesByExtension(
-  files: FileInfo[],
-  extensions: string[]
-): FileInfo[] {
-  const lowerExtensions = extensions.map((ext) => ext.toLowerCase());
-  return files.filter((file) => {
-    const ext = file.name.substring(file.name.lastIndexOf('.')).toLowerCase();
-    return lowerExtensions.includes(ext);
-  });
-}
-
-/**
- * Filter files by MIME type
- * @param files - Array of file info
- * @param mimeTypes - Array of MIME types to filter (e.g., ['image/png', 'image/jpeg'])
- * @returns Filtered array of files
- */
-export function filterFilesByMimeType(
-  files: FileInfo[],
-  mimeTypes: string[]
-): FileInfo[] {
-  return files.filter((file) => mimeTypes.includes(file.type));
-}
-
-/**
- * Check if file is an image
- * @param file - File info
- * @returns true if file is an image
- */
-export function isImageFile(file: FileInfo): boolean {
-  return file.type.startsWith('image/');
-}
-
-/**
- * Check if file is a video
- * @param file - File info
- * @returns true if file is a video
- */
-export function isVideoFile(file: FileInfo): boolean {
-  return file.type.startsWith('video/');
-}
-
-/**
- * Check if file is audio
- * @param file - File info
- * @returns true if file is audio
- */
-export function isAudioFile(file: FileInfo): boolean {
-  return file.type.startsWith('audio/');
-}
-
-/**
- * Check if file is text
- * @param file - File info
- * @returns true if file is text
- */
-export function isTextFile(file: FileInfo): boolean {
-  return file.type.startsWith('text/') || 
-         file.type === 'application/json' ||
-         file.type === 'application/xml';
-}
-
-/**
- * Format file size for display
- * @param bytes - File size in bytes
- * @returns Formatted string (e.g., "1.5 MB")
- */
-export function formatFileSize(bytes: number): string {
-  if (bytes === 0) return '0 Bytes';
-  
-  const k = 1024;
-  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
-  const i = Math.floor(Math.log(bytes) / Math.log(k));
-  
-  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
-}
+/**
+ * FileDrop API - Cross-platform drag & drop file handling
+ * 
+ * Direct method calls - no .on/.emit
+ * 
+ * Usage:
+ *   import { fileDrop } from '@plusui/api';
+ *   
+ *   await fileDrop.setEnabled(true);
+ *   fileDrop.onFilesDropped((files) => { ... });
+ */
+
+export interface FileInfo {
+  path: string;
+  name: string;
+  type: string;
+  size: number;
+}
+
+export interface DragEvent {
+  x?: number;
+  y?: number;
+}
+
+export interface FileDropAPI {
+  setEnabled(enabled: boolean): Promise<void>;
+  isEnabled(): Promise<boolean>;
+  startDrag(filePaths: string[]): Promise<boolean>;
+  clearCallbacks(): Promise<void>;
+  onFilesDropped(callback: (files: FileInfo[]) => void): () => void;
+  onDragEnter(callback: (event: DragEvent) => void): () => void;
+  onDragLeave(callback: (event: DragEvent) => void): () => void;
+}
+
+let _invoke: ((name: string, args?: unknown[]) => Promise<unknown>) | null = null;
+let _event: ((event: string, callback: (data: unknown) => void) => () => void) | null = null;
+
+export function setInvokeFn(fn: (name: string, args?: unknown[]) => Promise<unknown>) {
+  _invoke = fn;
+}
+
+export function setEventFn(fn: (event: string, callback: (data: unknown) => void) => () => void) {
+  _event = fn;
+}
+
+async function invoke<T = unknown>(name: string, args?: unknown[]): Promise<T> {
+  if (!_invoke) {
+    if (typeof window !== 'undefined' && (window as any).__invoke__) {
+      _invoke = (window as any).__invoke__;
+    } else {
+      throw new Error('FileDrop API not initialized');
+    }
+  }
+  return _invoke!(name, args) as Promise<T>;
+}
+
+function eventHandler(event: string, callback: (data: unknown) => void): () => void {
+  if (!_event) {
+    if (typeof window !== 'undefined' && (window as any).__on__) {
+      _event = (window as any).__on__;
+    } else {
+      return () => {};
+    }
+  }
+  return _event!(event, callback);
+}
+
+export const fileDrop: FileDropAPI = {
+  async setEnabled(enabled: boolean): Promise<void> {
+    await invoke('fileDrop.setEnabled', [enabled]);
+  },
+
+  async isEnabled(): Promise<boolean> {
+    return invoke<boolean>('fileDrop.isEnabled');
+  },
+
+  async startDrag(filePaths: string[]): Promise<boolean> {
+    if (!filePaths || filePaths.length === 0) {
+      throw new Error('filePaths must be a non-empty array');
+    }
+    return invoke<boolean>('fileDrop.startDrag', [filePaths]);
+  },
+
+  async clearCallbacks(): Promise<void> {
+    await invoke('fileDrop.clearCallbacks');
+  },
+
+  onFilesDropped(callback: (files: FileInfo[]) => void): () => void {
+    return eventHandler('fileDrop:filesDropped', callback as (data: unknown) => void);
+  },
+
+  onDragEnter(callback: (event: DragEvent) => void): () => void {
+    return eventHandler('fileDrop:dragEnter', callback as (data: unknown) => void);
+  },
+
+  onDragLeave(callback: (event: DragEvent) => void): () => void {
+    return eventHandler('fileDrop:dragLeave', callback as (data: unknown) => void);
+  },
+};
+
+export async function readFileAsText(filePath: string): Promise<string> {
+  const response = await fetch(`file://${filePath}`);
+  return await response.text();
+}
+
+export async function readFileAsDataUrl(filePath: string): Promise<string> {
+  const response = await fetch(`file://${filePath}`);
+  const blob = await response.blob();
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader();
+    reader.onload = () => resolve(reader.result as string);
+    reader.onerror = reject;
+    reader.readAsDataURL(blob);
+  });
+}
+
+export function filterFilesByExtension(
+  files: FileInfo[],
+  extensions: string[]
+): FileInfo[] {
+  const lowerExtensions = extensions.map((ext) => ext.toLowerCase());
+  return files.filter((file) => {
+    const ext = file.name.substring(file.name.lastIndexOf('.')).toLowerCase();
+    return lowerExtensions.includes(ext);
+  });
+}
+
+export function filterFilesByMimeType(
+  files: FileInfo[],
+  mimeTypes: string[]
+): FileInfo[] {
+  return files.filter((file) => mimeTypes.includes(file.type));
+}
+
+export function isImageFile(file: FileInfo): boolean {
+  return file.type.startsWith('image/');
+}
+
+export function isVideoFile(file: FileInfo): boolean {
+  return file.type.startsWith('video/');
+}
+
+export function isAudioFile(file: FileInfo): boolean {
+  return file.type.startsWith('audio/');
+}
+
+export function isTextFile(file: FileInfo): boolean {
+  return file.type.startsWith('text/') || 
+         file.type === 'application/json' ||
+         file.type === 'application/xml';
+}
+
+export function formatFileSize(bytes: number): string {
+  if (bytes === 0) return '0 Bytes';
+  
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+}
+
+export default fileDrop;