tessl/npm-dcloudio--uni-app-plus

A runtime library for uni-app's app-plus platform, which provides mobile app functionality for the uni-app cross-platform framework

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

Securityby

Pending

The risk profile of this skill

Overview

Eval results

Files

Network & Communication APIs

Name: tessl/npm-dcloudio--uni-app-plus
Author: tessl

Comprehensive network communication capabilities including HTTP requests, WebSocket connections, and file transfer operations.

Capabilities

HTTP Requests

Make HTTP requests with comprehensive options and response handling.

/**
 * Make an HTTP request
 * @param options - Request configuration options
 * @returns RequestTask for managing the request
 */
function request(options: RequestOptions): RequestTask;

interface RequestOptions {
  url: string;
  data?: any;
  header?: object;
  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS';
  dataType?: 'json' | 'text' | 'base64';
  responseType?: 'text' | 'arraybuffer';
  timeout?: number;
  success?: (result: RequestResult) => void;
  fail?: (error: RequestError) => void;
  complete?: () => void;
}

interface RequestResult {
  data: any;
  statusCode: number;
  header: object;
  cookies?: string[];
}

interface RequestTask {
  abort(): void;
  onHeadersReceived(callback: (result: HeadersReceivedResult) => void): void;
  offHeadersReceived(callback?: Function): void;
}

Usage Examples:

import uni from "@dcloudio/uni-app-plus";

// GET request
uni.request({
  url: 'https://api.example.com/users',
  method: 'GET',
  success: (res) => {
    console.log('Users:', res.data);
  },
  fail: (err) => {
    console.error('Request failed:', err);
  }
});

// POST request with data
const task = uni.request({
  url: 'https://api.example.com/users',
  method: 'POST',
  data: {
    name: 'John Doe',
    email: 'john@example.com'
  },
  header: {
    'Content-Type': 'application/json'
  },
  success: (res) => {
    console.log('User created:', res.data);
  }
});

// Abort request if needed
setTimeout(() => {
  task.abort();
}, 5000);

File Upload

Upload files to servers with progress tracking.

/**
 * Upload file to server
 * @param options - Upload configuration options
 * @returns UploadTask for managing the upload
 */
function uploadFile(options: UploadFileOptions): UploadTask;

interface UploadFileOptions {
  url: string;
  filePath: string;
  name: string;
  header?: object;
  formData?: object;
  timeout?: number;
  success?: (result: UploadFileResult) => void;
  fail?: (error: any) => void;
  complete?: () => void;
}

interface UploadFileResult {
  data: string;
  statusCode: number;
}

interface UploadTask {
  abort(): void;
  onProgressUpdate(callback: (result: UploadProgressResult) => void): void;
  offProgressUpdate(callback?: Function): void;
  onHeadersReceived(callback: (result: HeadersReceivedResult) => void): void;
  offHeadersReceived(callback?: Function): void;
}

Usage Example:

// Upload image file
uni.chooseImage({
  count: 1,
  success: (res) => {
    const uploadTask = uni.uploadFile({
      url: 'https://api.example.com/upload',
      filePath: res.tempFilePaths[0],
      name: 'image',
      formData: {
        userId: '12345'
      },
      success: (uploadRes) => {
        console.log('Upload successful:', uploadRes.data);
      }
    });

    uploadTask.onProgressUpdate((progress) => {
      console.log('Upload progress:', progress.progress + '%');
    });
  }
});

File Download

Download files from servers with progress tracking.

/**
 * Download file from server
 * @param options - Download configuration options
 * @returns DownloadTask for managing the download
 */
function downloadFile(options: DownloadFileOptions): DownloadTask;

interface DownloadFileOptions {
  url: string;
  header?: object;
  filePath?: string;
  timeout?: number;
  success?: (result: DownloadFileResult) => void;
  fail?: (error: any) => void;
  complete?: () => void;
}

interface DownloadFileResult {
  tempFilePath: string;
  statusCode: number;
}

interface DownloadTask {
  abort(): void;
  onProgressUpdate(callback: (result: DownloadProgressResult) => void): void;
  offProgressUpdate(callback?: Function): void;
  onHeadersReceived(callback: (result: HeadersReceivedResult) => void): void;
  offHeadersReceived(callback?: Function): void;
}

WebSocket Communication

Establish WebSocket connections for real-time communication.

/**
 * Connect to WebSocket server
 * @param options - WebSocket connection options
 * @returns SocketTask for managing the connection
 */
function connectSocket(options: ConnectSocketOptions): SocketTask;

interface ConnectSocketOptions {
  url: string;
  header?: object;
  protocols?: string[];
  timeout?: number;
  success?: (result: any) => void;
  fail?: (error: any) => void;
  complete?: () => void;
}

interface SocketTask {
  send(options: SendSocketMessageOptions): void;
  close(options?: CloseSocketOptions): void;
  onOpen(callback: (result: any) => void): void;
  onClose(callback: (result: CloseSocketResult) => void): void;
  onError(callback: (result: any) => void): void;
  onMessage(callback: (result: SocketMessageResult) => void): void;
}

Usage Example:

// Connect to WebSocket
const socketTask = uni.connectSocket({
  url: 'wss://echo.websocket.org',
  success: () => {
    console.log('WebSocket connected');
  }
});

// Listen for connection open
socketTask.onOpen(() => {
  console.log('WebSocket connection opened');
  
  // Send message
  socketTask.send({
    data: 'Hello WebSocket'
  });
});

// Listen for messages
socketTask.onMessage((res) => {
  console.log('Received message:', res.data);
});

// Listen for connection close
socketTask.onClose((res) => {
  console.log('WebSocket closed:', res.code, res.reason);
});

// Listen for errors
socketTask.onError((error) => {
  console.error('WebSocket error:', error);
});

Global WebSocket Events

Global WebSocket event handlers for simplified usage.

/**
 * Listen for WebSocket connection open
 * @param callback - Callback function
 */
function onSocketOpen(callback: (result: any) => void): void;

/**
 * Listen for WebSocket errors
 * @param callback - Callback function
 */
function onSocketError(callback: (result: any) => void): void;

/**
 * Listen for WebSocket messages
 * @param callback - Callback function
 */
function onSocketMessage(callback: (result: SocketMessageResult) => void): void;

/**
 * Listen for WebSocket connection close
 * @param callback - Callback function
 */
function onSocketClose(callback: (result: CloseSocketResult) => void): void;

/**
 * Send WebSocket message
 * @param options - Message options
 */
function sendSocketMessage(options: SendSocketMessageOptions): void;

/**
 * Close WebSocket connection
 * @param options - Close options
 */
function closeSocket(options?: CloseSocketOptions): void;

Types

Request Types

interface RequestError {
  errMsg: string;
  errno?: number;
}

interface HeadersReceivedResult {
  header: object;
}

Upload Types

interface UploadProgressResult {
  progress: number;
  totalBytesSent: number;
  totalBytesExpectedToSend: number;
}

Download Types

interface DownloadProgressResult {
  progress: number;
  totalBytesWritten: number;
  totalBytesExpectedToWrite: number;
}

WebSocket Types

interface SendSocketMessageOptions {
  data: string | ArrayBuffer;
  success?: (result: any) => void;
  fail?: (error: any) => void;
  complete?: () => void;
}

interface CloseSocketOptions {
  code?: number;
  reason?: string;
  success?: (result: any) => void;
  fail?: (error: any) => void;
  complete?: () => void;
}

interface SocketMessageResult {
  data: string | ArrayBuffer;
}

interface CloseSocketResult {
  code: number;
  reason: string;
}