@tarojs/taro-rn 4.0.1-alpha.0 → 4.0.1

package/src/__tests__/storage.test.ts

@@ -0,0 +1,202 @@
+import AsyncStorage from '@react-native-async-storage/async-storage'
+import { setStorage } from '../lib/setStorage'
+import { getStorage } from '../lib/getStorage'
+import { clearStorage } from '../lib/clearStorage'
+import { getStorageInfo } from '../lib/getStorageInfo'
+import { removeStorage } from '../lib/removeStorage'
+
+const Taro = {
+  setStorage,
+  getStorage,
+  clearStorage,
+  getStorageInfo,
+  removeStorage,
+}
+
+// NativeModules.RNCAsyncStorage setup mock
+describe('storage', () => {
+  describe('setStorage', () => {
+    test('should set value into storage', async () => {
+      await Taro.clearStorage({})
+      const key = 'bar'
+      const data = 'foo'
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      const res = await Taro.setStorage({
+        key,
+        data,
+        success,
+        fail,
+        complete
+      })
+      const expectMsg = 'setStorage:ok'
+
+      expect.assertions(7)
+
+      expect(success.mock.calls.length).toBe(1)
+      expect(success.mock.calls[0][0]).toEqual({ errMsg: expectMsg })
+      expect(fail.mock.calls.length).toBe(0)
+      expect(complete.mock.calls.length).toBe(1)
+      expect(complete.mock.calls[0][0]).toEqual({ errMsg: expectMsg })
+      expect(res.errMsg).toMatch(expectMsg)
+
+      const getData = await AsyncStorage.getItem(key) || ''
+      expect(JSON.parse(getData)).toBe(data)
+    })
+
+    test('should fail when error occur', async () => {
+      await Taro.clearStorage({})
+      const data = {}
+      const success = jest.fn().mockImplementation(() => {
+        throw new Error('setStorage:fail')
+      })
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      expect.assertions(4)
+      // @ts-ignore
+      return Taro.setStorage({
+        data,
+        success,
+        fail,
+        complete
+      }).catch(err => {
+        const expectErrMsg = err.errMsg
+        expect(fail.mock.calls.length).toBe(1)
+        expect(fail.mock.calls[0][0]).toEqual({ errMsg: expectErrMsg })
+        expect(complete.mock.calls.length).toBe(1)
+        expect(complete.mock.calls[0][0]).toEqual({ errMsg: expectErrMsg })
+      })
+    })
+  })
+
+  describe('getStorage', () => {
+    test('should get value from storage by key', async () => {
+      await Taro.clearStorage({})
+      const key = 'bar'
+      const data = 'foo'
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      await AsyncStorage.setItem(key, JSON.stringify(data))
+      const res = await Taro.getStorage({
+        key,
+        success,
+        fail,
+        complete
+      })
+      const expectMsg = 'getStorage:ok'
+
+      expect.assertions(7)
+
+      expect(success.mock.calls.length).toBe(1)
+      expect(success.mock.calls[0][0]).toEqual(res)
+      expect(fail.mock.calls.length).toBe(0)
+      expect(complete.mock.calls.length).toBe(1)
+      expect(complete.mock.calls[0][0]).toEqual(res)
+      expect(res.errMsg).toMatch(expectMsg)
+      expect(res.data).toBe(data)
+    })
+  })
+
+  describe('removeStorage', () => {
+    test('能根据key删除Storage里的值', async () => {
+      await Taro.clearStorage({})
+      const key = 'bar'
+      const data = 'foo'
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      await AsyncStorage.setItem(key, JSON.stringify(data))
+      const getData = await AsyncStorage.getItem(key) || ''
+
+      expect(JSON.parse(getData)).toBe(data)
+
+      const res = await Taro.removeStorage({
+        key,
+        success,
+        fail,
+        complete
+      })
+      const expectMsg = 'removeStorage:ok'
+
+      expect.assertions(8)
+
+      expect(success.mock.calls.length).toBe(1)
+      expect(success.mock.calls[0][0]).toEqual(res)
+      expect(fail.mock.calls.length).toBe(0)
+      expect(complete.mock.calls.length).toBe(1)
+      expect(complete.mock.calls[0][0]).toEqual(res)
+      expect(res.errMsg).toMatch(expectMsg)
+      // @ts-ignore
+      expect(res.data).toBeUndefined()
+    })
+  })
+
+  describe('getStorageInfo', () => {
+    test('获得正确的StorageInfo', async () => {
+      await Taro.clearStorage({})
+      const key1 = 'bar'
+      const key2 = 'foo'
+      const data = 'data'
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+
+      await AsyncStorage.setItem(key1, JSON.stringify(data))
+      await AsyncStorage.setItem(key2, JSON.stringify(data))
+
+      const res = await Taro.getStorageInfo({
+        success,
+        fail,
+        complete
+      })
+      const expectMsg = 'getStorageInfo:ok'
+
+      expect.assertions(9)
+
+      expect(success.mock.calls.length).toBe(1)
+      expect(success.mock.calls[0][0]).toEqual(res)
+      expect(fail.mock.calls.length).toBe(0)
+      expect(complete.mock.calls.length).toBe(1)
+      expect(complete.mock.calls[0][0]).toEqual(res)
+      expect(res.errMsg).toMatch(expectMsg)
+      // @ts-ignore
+      expect(res.keys).toEqual([key1, key2])
+      // @ts-ignore
+      expect(res.currentSize).toBe(+(12 / 1024).toFixed(2))
+      // @ts-ignore
+      expect(res.limitSize).toBe(Infinity)
+    })
+  })
+
+  describe('clearStorage', () => {
+    test('clearStorage能清楚所有的Storage', async () => {
+      await Taro.clearStorage({})
+      const key1 = 'bar'
+      const key2 = 'foo'
+      const data = 'data'
+
+      await AsyncStorage.setItem(key1, JSON.stringify(data))
+      await AsyncStorage.setItem(key2, JSON.stringify(data))
+
+      const getData1 = await AsyncStorage.getItem(key1) || ''
+      const getData2 = await AsyncStorage.getItem(key2) || ''
+
+      expect(JSON.parse(getData1)).toBe(data)
+      expect(JSON.parse(getData2)).toBe(data)
+
+      await Taro.clearStorage({})
+
+      const res = await AsyncStorage.getAllKeys()
+
+      expect.assertions(3)
+
+      expect(res).toEqual([])
+    })
+  })
+})

package/src/__tests__/system.test.ts

@@ -0,0 +1,69 @@
+import { getSystemInfo } from '../lib/getSystemInfo'
+import { getSystemInfoSync } from '../lib/getSystemInfoSync'
+
+const Taro = { getSystemInfo, getSystemInfoSync }
+
+describe('system', () => {
+  describe('getSystemInfoSync', () => {
+    test('能同步返回正确的系统信息', () => {
+      const expectRes = {
+        brand: expect.any(String),
+        model: expect.any(String),
+        pixelRatio: expect.any(Number),
+        safeArea: expect.any(Object),
+        screenWidth: expect.any(Number),
+        screenHeight: expect.any(Number),
+        windowWidth: expect.any(Number),
+        windowHeight: expect.any(Number),
+        statusBarHeight: expect.any(Number),
+        language: null,
+        version: expect.any(String),
+        system: expect.any(String),
+        platform: expect.any(String),
+        fontSizeSetting: expect.any(Number),
+        SDKVersion: null
+      }
+
+      const res = Taro.getSystemInfoSync()
+      expect(res).toEqual(expect.objectContaining(expectRes))
+    })
+  })
+
+  describe('getSystemInfo', () => {
+    test('能异步返回正确的系统信息', () => {
+      const success = jest.fn()
+      const fail = jest.fn()
+      const complete = jest.fn()
+      const expectRes = {
+        brand: expect.any(String),
+        model: expect.any(String),
+        pixelRatio: expect.any(Number),
+        safeArea: expect.any(Object),
+        screenWidth: expect.any(Number),
+        screenHeight: expect.any(Number),
+        windowWidth: expect.any(Number),
+        windowHeight: expect.any(Number),
+        statusBarHeight: expect.any(Number),
+        language: null,
+        version: expect.any(String),
+        system: expect.any(String),
+        platform: expect.any(String),
+        fontSizeSetting: expect.any(Number),
+        SDKVersion: null
+      }
+
+      expect.assertions(4)
+
+      return Taro.getSystemInfo({
+        success,
+        fail,
+        complete
+      }).then((res) => {
+        expect(success.mock.calls.length).toBe(1)
+        expect(fail.mock.calls.length).toBe(0)
+        expect(complete.mock.calls.length).toBe(1)
+        expect(res).toEqual(expect.objectContaining(expectRes))
+      })
+    })
+  })
+})

package/src/__tests__/vibrate.test.ts

@@ -0,0 +1,27 @@
+import * as vibrate from '../lib/vibrate'
+
+const Taro = Object.assign({}, vibrate)
+
+describe('vibrate', () => {
+  describe('vibrateShort', () => {
+    test('能正常震动', () => {
+      const expectMsg = 'vibrateShort:ok'
+
+      expect.assertions(1)
+      return Taro.vibrateShort().then((res) => {
+        expect(res.errMsg).toMatch(expectMsg)
+      })
+    })
+  })
+
+  describe('vibrateLong', () => {
+    test('能正常震动', () => {
+      const expectMsg = 'vibrateLong:ok'
+
+      expect.assertions(1)
+      return Taro.vibrateLong().then((res) => {
+        expect(res.errMsg).toMatch(expectMsg)
+      })
+    })
+  })
+})

package/src/__tests__/websocket.test.ts

@@ -0,0 +1,169 @@
+import { WebSocket, Server } from 'mock-socket'
+import * as connectSocket from '../lib/connectSocket'
+
+const Taro = Object.assign({}, connectSocket)
+
+describe('websocket', () => {
+  beforeEach(() => {
+    // @ts-ignore
+    global.WebSocket = WebSocket
+  })
+
+  test('url should be string', () => {
+    const success = jest.fn()
+    const fail = jest.fn()
+    const complete = jest.fn()
+
+    expect.assertions(6)
+
+    return Taro.connectSocket({
+      // @ts-ignore
+      url: {},
+      success,
+      fail,
+      complete
+    }).catch(err => {
+      const expectErrMsg = 'connectSocket:fail parameter error: parameter.url should be String'
+      expect(success.mock.calls.length).toBe(0)
+      expect(fail.mock.calls.length).toBe(1)
+      expect(fail.mock.calls[0][0]).toEqual({ errMsg: expectErrMsg })
+      expect(complete.mock.calls.length).toBe(1)
+      expect(complete.mock.calls[0][0]).toEqual({ errMsg: expectErrMsg })
+      expect(err.errMsg).toMatch(expectErrMsg)
+    })
+  })
+
+  test('should not keep more than 2 connection', async () => {
+    const success = jest.fn()
+    const fail = jest.fn()
+    const complete = jest.fn()
+
+    expect.assertions(8)
+
+    const socketTaskOne = await Taro.connectSocket({ url: 'wss://localhost:8080', success })
+    expect(success.mock.calls[0][0])
+      .toEqual({ socketTaskId: 1, socketTask: socketTaskOne, errMsg: 'connectSocket:ok' })
+
+    const socketTaskTwo = await Taro.connectSocket({ url: 'wss://localhost:8090', success })
+    expect(success.mock.calls[1][0])
+      .toEqual({ socketTaskId: 2, socketTask: socketTaskTwo, errMsg: 'connectSocket:ok' })
+
+    await Taro.connectSocket({
+      url: 'wss://localhost:9080',
+      success,
+      complete,
+      fail
+    }).catch(err => {
+      const expectErrMsg = '同时最多发起 2 个 socket 请求，更多请参考文档。'
+      expect(success.mock.calls.length).toBe(2)
+      expect(fail.mock.calls.length).toBe(1)
+      expect(fail.mock.calls[0][0]).toEqual({ errMsg: expectErrMsg })
+      expect(complete.mock.calls.length).toBe(1)
+      expect(complete.mock.calls[0][0]).toEqual({ errMsg: expectErrMsg })
+      expect(err.errMsg).toMatch(expectErrMsg)
+    })
+
+    socketTaskOne.close({})
+    socketTaskTwo.close({})
+  })
+
+  test('connection关闭的时候会重置总的socketTask数量', async () => {
+    const success = jest.fn()
+    const fail = jest.fn()
+    const complete = jest.fn()
+
+    expect.assertions(7)
+
+    const socketTaskOne = await Taro.connectSocket({ url: 'wss://localhost:8080', success })
+    expect(success.mock.calls.length).toBe(1)
+    socketTaskOne.close({})
+
+    const socketTaskTwo = await Taro.connectSocket({ url: 'wss://localhost:8090', success })
+    expect(success.mock.calls.length).toBe(2)
+
+    const socketTaskThree = await Taro.connectSocket({
+      url: 'wss://localhost:9080',
+      success,
+      complete,
+      fail
+    })
+    expect(success.mock.calls.length).toBe(3)
+    expect(fail.mock.calls.length).toBe(0)
+    expect(complete.mock.calls.length).toBe(1)
+    expect(success.mock.calls[2][0])
+      .toEqual(expect.objectContaining({
+        socketTask: socketTaskThree,
+        errMsg: 'connectSocket:ok'
+      }))
+    expect(complete.mock.calls[0][0])
+      .toEqual(expect.objectContaining({
+        socketTask: socketTaskThree,
+        errMsg: 'connectSocket:ok'
+      }))
+
+    socketTaskTwo.close({})
+    socketTaskThree.close({})
+  })
+  // @ts-ignore
+  test('should work basically', async (done) => {
+    const fakeURL = 'wss://localhost:8080'
+    const mockServer = new Server(fakeURL)
+    const connected = jest.fn()
+    const success = jest.fn()
+    const complete = jest.fn()
+    const msg = 'hey gay!'
+    const msg2 = 'hey gay!gay!'
+
+    expect.assertions(11)
+
+    mockServer.on('connection', connected)
+
+    mockServer.on('message', message => {
+      expect(message).toMatch(msg)
+      mockServer.send(msg2)
+    })
+
+    const socketTask = await Taro.connectSocket({
+      url: fakeURL,
+      success,
+      complete
+    })
+
+    const socketTaskSend = jest.spyOn(socketTask.ws, 'send')
+    const socketTaskClose = jest.spyOn(socketTask.ws, 'close')
+    const closeCode = 100
+    const closeReason = 'hey'
+
+    socketTask.onOpen(() => {
+      socketTask.send({
+        data: msg,
+        success: (res) => {
+          expect(socketTaskSend).toHaveBeenCalled()
+          expect(res.errMsg).toMatch('sendSocketMessage:ok')
+        },
+      })
+    })
+
+    socketTask.onMessage(res => {
+      expect(res.data).toMatch(msg2)
+      socketTask.close({
+        code: closeCode,
+        reason: closeReason,
+        success: (res) => {
+          expect(socketTaskClose).toHaveBeenCalled()
+          expect(res.errMsg).toMatch('sendSocketMessage:ok')
+        },
+      })
+    })
+
+    socketTask.onClose(({ code, reason }) => {
+      const expectMsg = 'connectSocket:ok'
+      expect(connected.mock.calls.length).toBe(1)
+      expect(success.mock.calls[0][0].errMsg).toMatch(expectMsg)
+      expect(complete.mock.calls[0][0].errMsg).toMatch(expectMsg)
+      expect(code).toBe(closeCode)
+      expect(reason).toBe(closeReason)
+      done()
+    })
+  })
+})

package/src/api/index.ts

@@ -1,44 +1,44 @@
 export {
   Current,
+  getCurrentInstance,
+  useDidShow,
+  useDidHide,
+  useLoad,
+  useReady,
+  useUnload,
+  useLaunch,
+  usePageNotFound,
+  useRouter,
+  usePullDownRefresh,
+  useReachBottom,
+  usePageScroll,
+  useTabItemTap,
+  useResize,
   eventCenter,
   Events,
-  getApp,
-  getCurrentInstance,
-  getCurrentPages,
-  hideNavigationBarLoading,
-  hideTabBar,
-  hideTabBarRedDot,
-  navigateBack,
   navigateTo,
-  pageScrollTo,
-  pxTransform,
   redirectTo,
+  navigateBack,
+  switchTab,
   reLaunch,
-  removeTabBarBadge,
-  setBackgroundColor,
-  setBackgroundTextStyle,
-  setNavigationBarColor,
-  setNavigationBarTitle,
+  showTabBar,
+  hideTabBar,
+  showTabBarRedDot,
+  hideTabBarRedDot,
   setTabBarBadge,
+  removeTabBarBadge,
   setTabBarItem,
-  setTabBarStyle,
+  setNavigationBarTitle,
+  setNavigationBarColor,
   showNavigationBarLoading,
-  showTabBar,
-  showTabBarRedDot,
+  hideNavigationBarLoading,
+  setTabBarStyle,
+  getApp,
+  pxTransform,
   startPullDownRefresh,
   stopPullDownRefresh,
-  switchTab,
-  useDidHide,
-  useDidShow,
-  useLaunch,
-  useLoad,
-  usePageNotFound,
-  usePageScroll,
-  usePullDownRefresh,
-  useReachBottom,
-  useReady,
-  useResize,
-  useRouter,
-  useTabItemTap,
-  useUnload
+  pageScrollTo,
+  setBackgroundColor,
+  setBackgroundTextStyle,
+  getCurrentPages
 } from '@tarojs/runtime-rn'

package/src/lib/ENV_TYPE/index.ts

@@ -9,4 +9,4 @@ export const ENV_TYPE = {
   RN: 'RN',
   HARMONY: 'HARMONY',
   QUICKAPP: 'QUICKAPP'
-}
+}

package/src/lib/Mask.tsx

@@ -1,7 +1,7 @@
-import { ViewPropTypes } from 'deprecated-react-native-prop-types'
-import PropTypes from 'prop-types'
 import React from 'react'
+import PropTypes from 'prop-types'
 import { StyleSheet, TouchableWithoutFeedback, View } from 'react-native'
+import { ViewPropTypes } from 'deprecated-react-native-prop-types'
 
 const styles = StyleSheet.create({
   mask: {

package/src/lib/Popup.tsx

@@ -1,8 +1,8 @@
-import { ViewPropTypes } from 'deprecated-react-native-prop-types'
-import PropTypes from 'prop-types'
 import React, { Component } from 'react'
-import { Animated, Dimensions, Easing, Modal, StyleSheet, View } from 'react-native'
 
+import PropTypes from 'prop-types'
+import { Modal, View, StyleSheet, Dimensions, Animated, Easing } from 'react-native'
+import { ViewPropTypes } from 'deprecated-react-native-prop-types'
 import { Mask } from './Mask'
 
 const { width, height } = Dimensions.get('window')
@@ -17,7 +17,7 @@ const styles = StyleSheet.create({
 })
 
 interface Props {
-  visible?: boolean
+  visible?: boolean;
 }
 
 class Popup extends Component<any, any> {
@@ -32,14 +32,14 @@ class Popup extends Component<any, any> {
 
   height
   popup
-  timer
-  constructor(props: Props) {
+
+  constructor (props:Props) {
     super(props)
     this.state = { visible: props.visible ?? false, translateY: new Animated.Value(height) }
     this.handleLayout = this.handleLayout.bind(this)
   }
 
-  UNSAFE_componentWillReceiveProps (nextProp: Props): void {
+  UNSAFE_componentWillReceiveProps (nextProp:Props):void {
     if (this.props.visible !== nextProp.visible) {
       if (nextProp.visible) {
         this.setState({ visible: true })
@@ -54,27 +54,20 @@ class Popup extends Component<any, any> {
     }
   }
 
-  componentWillUnmount (): void {
-    this.timer && clearTimeout(this.timer)
-  }
-
-  handleLayout (): void {
-    this.timer = setTimeout(() => {
-      this.popup?.measure((_x, _y, _w, h) => {
-        this.height = h
-        this.setState({ translateY: new Animated.Value(h) }, () => {
-          Animated.timing(this.state.translateY, {
-            toValue: 0,
-            duration: 300,
-            easing: (Easing as any).easeInOut,
-            useNativeDriver: true
-          }).start()
-        })
-      })
-    },) // 处理鸿蒙系统handleLayout 回调 this.popup为空的情况
+  handleLayout ():void {
+    this.popup.measure((_x, _y, _w, h) => {
+      this.height = h
+      this.setState({ translateY: new Animated.Value(h) })
+      Animated.timing(this.state.translateY, {
+        toValue: 0,
+        duration: 300,
+        easing: (Easing as any).easeInOut,
+        useNativeDriver: true
+      }).start()
+    })
   }
 
-  render (): JSX.Element {
+  render ():JSX.Element {
     const {
       style,
       maskStyle,

package/src/lib/StyleSheet.ts

@@ -1,4 +1,4 @@
-import { Platform, StyleSheet } from 'react-native'
+import { StyleSheet, Platform } from 'react-native'
 
 interface Styles {
   [propName: string]: any

package/src/lib/accelerometer.ts

@@ -1,5 +1,4 @@
 import { Accelerometer } from 'expo-sensors'
-
 import { createCallbackManager, errorHandler, successHandler } from '../utils'
 
 const _cbManager = createCallbackManager()
@@ -69,8 +68,8 @@ function stopAccelerometer(opts: Taro.stopAccelerometer.Option = {}): Promise<Ta
 }
 
 export {
-  offAccelerometerChange,
   onAccelerometerChange,
+  offAccelerometerChange,
   startAccelerometer,
   stopAccelerometer
 }

package/src/lib/arrayBufferToBase64/index.ts

@@ -3,4 +3,4 @@ import { fromByteArray } from 'base64-js'
 export function arrayBufferToBase64(arrayBuffer: ArrayBuffer): string {
   const buffer = new Uint8Array(arrayBuffer)
   return fromByteArray(buffer)
-}
+}

package/src/lib/base64ToArrayBuffer/index.ts

@@ -2,4 +2,4 @@ import { toByteArray } from 'base64-js'
 
 export function base64ToArrayBuffer(base64: string): ArrayBuffer {
   return toByteArray(base64)
-}
+}