@doubao-apps/taro-runtime 0.0.29-rc.0 → 0.0.30

package/dist/api/index.d.ts

@@ -3,6 +3,7 @@ export * from './device/index.js';
 export * from './device/index.js';
 export * from './media/index.js';
 export { request } from './request/index.js';
+export { connectSocket, onSocketOpen, onSocketMessage, onSocketError, onSocketClose } from './request/websocket.js';
 export { exitMiniProgram, navigateBack, navigateTo, getCurrentPages, reLaunch, redirectTo } from './router/index.js';
 export { setStorage, setStorageSync, getStorage, getStorageSync, removeStorage, removeStorageSync, clearStorage, clearStorageSync, getStorageInfo, getStorageInfoSync } from './storage/index.js';
 export * from './system/index.js';

package/dist/api/index.js

@@ -3,6 +3,7 @@ export * from './device/index.js';
 export * from './device/index.js';
 export * from './media/index.js';
 export { request } from './request/index.js';
+export { connectSocket, onSocketOpen, onSocketMessage, onSocketError, onSocketClose } from './request/websocket.js';
 export { exitMiniProgram, navigateBack, navigateTo, getCurrentPages, reLaunch, redirectTo } from './router/index.js';
 export { setStorage, setStorageSync, getStorage, getStorageSync, removeStorage, removeStorageSync, clearStorage, clearStorageSync, getStorageInfo, getStorageInfoSync } from './storage/index.js';
 export * from './system/index.js';

package/dist/api/request/websocket.d.ts

@@ -0,0 +1,14 @@
+import type Taro from '@tarojs/taro';
+import type { connectSocket as taroConnectSocket } from '@tarojs/taro';
+type TaroConnectSocketOption = Parameters<typeof taroConnectSocket>[0];
+type SocketTask = Taro.SocketTask;
+type SocketOpenCallback = Parameters<typeof Taro.onSocketOpen>[0];
+type SocketErrorCallback = Parameters<typeof Taro.onSocketError>[0];
+type SocketCloseCallback = Parameters<typeof Taro.onSocketClose>[0];
+export declare function connectSocket(option: TaroConnectSocketOption): SocketTask;
+export declare function onSocketOpen(callback: SocketOpenCallback): void;
+export declare function onSocketMessage<T = any>(callback: Taro.onSocketMessage.Callback<T>): void;
+export declare function onSocketError(callback: SocketErrorCallback): void;
+export declare function onSocketClose(callback: SocketCloseCallback): void;
+export {};
+//# sourceMappingURL=websocket.d.ts.map

package/dist/api/request/websocket.js

@@ -0,0 +1,135 @@
+import * as appFrameworkApi from '@byted-doubao-apps/framework/api';
+const globalOpenCallbacks = new Set();
+const globalMessageCallbacks = new Set();
+const globalErrorCallbacks = new Set();
+const globalCloseCallbacks = new Set();
+function normalizeHeader(header) {
+    if (!header || typeof header !== 'object') {
+        return undefined;
+    }
+    return Object.entries(header).reduce((result, [key, value]) => {
+        if (key) {
+            result[key] = typeof value === 'string' ? value : String(value);
+        }
+        return result;
+    }, {});
+}
+class RuntimeSocketTask {
+    constructor(appTask) {
+        this.appTask = appTask;
+        this.CONNECTING = this.appTask.CONNECTING;
+        this.OPEN = this.appTask.OPEN;
+        this.CLOSING = this.appTask.CLOSING;
+        this.CLOSED = this.appTask.CLOSED;
+        this.ws = undefined;
+        this.errMsg = 'connectSocket:ok';
+        this.socketTaskId = 0;
+        this.appTask.onOpen((event) => {
+            globalOpenCallbacks.forEach((callback) => callback({ header: event.header }));
+        });
+        this.appTask.onMessage((event) => {
+            globalMessageCallbacks.forEach((callback) => callback({ data: event.data }));
+        });
+        this.appTask.onError((event) => {
+            globalErrorCallbacks.forEach((callback) => callback({ errMsg: event.errMsg }));
+        });
+        this.appTask.onClose((event) => {
+            globalCloseCallbacks.forEach((callback) => callback({
+                code: typeof event.code === 'number' ? event.code : 1000,
+                reason: event.reason ?? event.errMsg ?? ''
+            }));
+        });
+    }
+    get readyState() {
+        return this.appTask.readyState ?? this.CLOSED;
+    }
+    send(option) {
+        if (this.appTask.readyState !== this.appTask.OPEN) {
+            const result = { errMsg: 'SocketTask.send:fail socketTask is not ready' };
+            option.fail?.(result);
+            option.complete?.(result);
+            return;
+        }
+        this.appTask.send({ data: option.data });
+        const result = { errMsg: 'SocketTask.send:ok' };
+        option.success?.(result);
+        option.complete?.(result);
+    }
+    close(option = {}) {
+        if (this.appTask.readyState === this.appTask.CLOSED) {
+            const result = { errMsg: 'SocketTask.close:fail socketTask is already closed' };
+            option.fail?.(result);
+            option.complete?.(result);
+            return;
+        }
+        this.appTask.close({ code: option.code, reason: option.reason });
+        const result = { errMsg: 'SocketTask.close:ok' };
+        option.success?.(result);
+        option.complete?.(result);
+    }
+    onOpen(callback) {
+        this.appTask.onOpen((event) => callback({ header: event.header }));
+    }
+    onClose(callback) {
+        this.appTask.onClose((event) => callback({
+            code: typeof event.code === 'number' ? event.code : 1000,
+            reason: event.reason ?? event.errMsg ?? ''
+        }));
+    }
+    onError(callback) {
+        this.appTask.onError((event) => callback({ errMsg: event.errMsg }));
+    }
+    onMessage(callback) {
+        this.appTask.onMessage((event) => callback({ data: event.data }));
+    }
+}
+export function connectSocket(option) {
+    const { url = '', header, protocols, success, fail, complete } = option ?? {};
+    const appTask = appFrameworkApi.connectSocket({
+        url,
+        header: normalizeHeader(header),
+        protocols: Array.isArray(protocols) ? protocols.filter(Boolean) : undefined
+    });
+    const task = new RuntimeSocketTask(appTask);
+    let settled = false;
+    appTask.onOpen(() => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        const result = { errMsg: 'connectSocket:ok' };
+        success?.(result);
+        complete?.(result);
+    });
+    appTask.onError((event) => {
+        if (settled) {
+            return;
+        }
+        settled = true;
+        const result = { errMsg: `connectSocket:fail ${event.errMsg}` };
+        fail?.(result);
+        complete?.(result);
+    });
+    return task;
+}
+export function onSocketOpen(callback) {
+    if (typeof callback === 'function') {
+        globalOpenCallbacks.add(callback);
+    }
+}
+export function onSocketMessage(callback) {
+    if (typeof callback === 'function') {
+        globalMessageCallbacks.add(callback);
+    }
+}
+export function onSocketError(callback) {
+    if (typeof callback === 'function') {
+        globalErrorCallbacks.add(callback);
+    }
+}
+export function onSocketClose(callback) {
+    if (typeof callback === 'function') {
+        globalCloseCallbacks.add(callback);
+    }
+}
+//# sourceMappingURL=websocket.js.map

package/dist/types/api/index.d.ts

@@ -1,2 +1,2 @@
-export type { RequestOption, RequestSuccessCallbackResult, RequestFailCallbackResult, RequestCompleteCallbackResult, RequestTask, RequestHeader, OnChunkReceivedCallback, OnHeadersReceivedCallback } from './request.js';
+export type { RequestOption, RequestSuccessCallbackResult, RequestFailCallbackResult, RequestCompleteCallbackResult, RequestTask, RequestHeader, OnChunkReceivedCallback, OnHeadersReceivedCallback, ConnectSocketOption, SocketTask, SocketOpenCallback, SocketMessageCallback, SocketErrorCallback, SocketCloseCallback } from './request.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/types/api/request.d.ts

@@ -10,5 +10,11 @@ export type RequestCompleteCallbackResult<T extends string | TaroGeneral.IAnyObj
 export type RequestTask<T = unknown> = Taro.RequestTask<T>;
 export type OnHeadersReceivedCallback = Parameters<Taro.RequestTask<any>['onHeadersReceived']>[0];
 export type OnChunkReceivedCallback = Parameters<Taro.RequestTask<any>['onChunkReceived']>[0];
+export type ConnectSocketOption = Taro.connectSocket.Option;
+export type SocketTask = Taro.SocketTask;
+export type SocketOpenCallback = Taro.onSocketOpen.Callback;
+export type SocketMessageCallback<T = any> = Taro.onSocketMessage.Callback<T>;
+export type SocketErrorCallback = Taro.onSocketError.Callback;
+export type SocketCloseCallback = Taro.onSocketClose.Callback;
 export {};
 //# sourceMappingURL=request.d.ts.map

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export type { RequestOption, RequestSuccessCallbackResult, RequestFailCallbackResult, RequestCompleteCallbackResult, RequestTask, RequestHeader, OnChunkReceivedCallback, OnHeadersReceivedCallback } from './api/request.js';
+export type { RequestOption, RequestSuccessCallbackResult, RequestFailCallbackResult, RequestCompleteCallbackResult, RequestTask, RequestHeader, OnChunkReceivedCallback, OnHeadersReceivedCallback, ConnectSocketOption, SocketTask, SocketOpenCallback, SocketMessageCallback, SocketErrorCallback, SocketCloseCallback } from './api/request.js';
 export type { AppLifecycleRegistry, AppLifecycleType, LifecycleRegistry, PageLifecycleType, WidgetLifecycleType } from './internal/lifecycle-types.js';
 export type { Callback, LoadCallback, LoadOptions, PageNotFoundResult } from './hooks/hook-types.js';
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -37,7 +37,7 @@
     "access": "public",
     "registry": "https://registry.npmjs.org/"
   },
-  "version": "0.0.29-rc.0",
+  "version": "0.0.30",
   "scripts": {
     "dev": "npm run build -- -w",
     "build": "rimraf dist bundle && tsc -p tsconfig.build.json",