9297852260

Committed 30 May 2024 06:09AM UTC coverage: 62.876% (-0.06%) from 62.936%

Build # 9297852260

Build Type

Pull #91

github

Committed by

web-flow

Commit Message

Merge c475fa2e4 into 12415044c

Pull Request Pull Request #91: 新消息类型：client-info

Run Details

1353 of 1531 branches covered (88.37%)

Branch coverage included in aggregate %.

43 of 95 new or added lines in 11 files covered. (45.26%)

42 existing lines in 1 file now uncovered.

5476 of 9330 relevant lines covered (58.69%)

32.58 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

93.29

/packages/mp-base/src/plugins/storage.ts

import { makeMessage } from 'base/src/message';
import type { SpyStorage, PageSpyPlugin } from '@huolala-tech/page-spy-types';
import socketStore from 'mp-base/src/helpers/socket';
import { psLog } from 'base/src';
import { getMPSDK, utilAPI } from '../utils';
import Client from 'base/src/client';

export function mpDataStringify(data: any) {
  const typeOfValue = typeof data;
  let vStr: string = data;
  if (
    typeOfValue === 'string' ||
    typeOfValue === 'boolean' ||
    typeOfValue === 'number'
  ) {
    vStr = String(data);
  } else if (typeOfValue === 'object') {
    if (data instanceof Date) {
      vStr = data.toDateString();
    } else {
      vStr = JSON.stringify(data);
    }
  }
  return vStr;
}

export default class StoragePlugin implements PageSpyPlugin {
  public name = 'StoragePlugin';

  public static hasInitd = false;

  private static originFunctions = {} as MPStorageAPI;

  // eslint-disable-next-line class-methods-use-this
  public onInit() {
    if (StoragePlugin.hasInitd) return;
    StoragePlugin.hasInitd = true;

    StoragePlugin.initStorageProxy();
    StoragePlugin.listenRefreshEvent();
  }

  public onReset() {
    const mp = getMPSDK();
    Object.entries(StoragePlugin.originFunctions).forEach(([key, fn]) => {
      Object.defineProperty(mp, key, {
        value: fn,
      });
    });
    StoragePlugin.hasInitd = false;
  }

  static sendRefresh() {
    const mp = getMPSDK();
    try {
      const info = mp.getStorageInfoSync();

      const data = info.keys.map((key) => {
        return {
          name: key,
          value: mpDataStringify(utilAPI.getStorage(key)),
        };
      });

      const dataItem: SpyStorage.GetTypeDataItem = {
        type: 'mpStorage',
        action: 'get',
        data,
      };
      StoragePlugin.sendStorageItem(dataItem);
    } catch (e) {
      // TODO
    }
  }

  /* c8 ignore start */
  private static listenRefreshEvent() {
    socketStore.addListener('refresh', async ({ source }) => {
      const { data: storageType } = source;
      if (storageType === 'mpStorage') {
        StoragePlugin.sendRefresh();
      }
    });
  }
  /* c8 ignore stop */

  private static initStorageProxy() {
    const mp = getMPSDK();
    const { sendClearItem, sendRemoveItem, sendSetItem } = StoragePlugin;
    const proxyFunctions = [
      'setStorage',
      'setStorageSync',
      'removeStorage',
      'removeStorageSync',
      'clearStorage',
      'clearStorageSync',
      'batchSetStorageSync',
      'batchSetStorage',
    ] as (keyof MPStorageAPI)[];

    proxyFunctions.forEach((name) => {
      if (mp[name]) {
        // @ts-ignore
        StoragePlugin.originFunctions[name] = mp[name];
      }
    });

    Object.defineProperties(mp, {
      setStorage: {
        value(params: Parameters<MPStorageAPI['setStorage']>[0]) {
          return StoragePlugin.originFunctions!.setStorage({
            ...params,
            success(res) {
              sendSetItem(params.key, params.data);
              params.success?.(res);
            },
          });
        },
      },
      setStorageSync: {
        value(keyOrObj: string | { key: string; data: any }, data: any) {
          try {
            let res: any;
            if (
              Client.info.browserType === 'mp-alipay' &&
              (!Client.info.framework || Client.info.framework === 'unknown')
            ) {
              // alipay is so disgusting, here the input is an object
              const obj = keyOrObj as { key: string; data: any };
              res = (StoragePlugin.originFunctions!.setStorageSync as any)(obj);
              sendSetItem(obj.key, obj.data);
            } else {
              const key = keyOrObj as string;
              res = StoragePlugin.originFunctions!.setStorageSync(key, data);
              sendSetItem(key, data);
            }
            return res;
          } catch (e) {
            /* c8 ignore next 3 */
            // TODO e is unknown so we can't use it, for further investigation
            psLog.error(`Failed to set storage synchronously: ${keyOrObj}`);
            throw e;
          }
        },
      },

      removeStorage: {
        value(params: Parameters<MPStorageAPI['removeStorage']>[0]) {
          return StoragePlugin.originFunctions!.removeStorage({
            ...params,
            success(res) {
              sendRemoveItem(params.key);
              params.success?.(res);
            },
          });
        },
      },

      removeStorageSync: {
        // in alipay, the param is an object actually, but it works.
        value(keyOrObj: string) {
          try {
            const res =
              StoragePlugin.originFunctions!.removeStorageSync(keyOrObj);
            sendRemoveItem(res);
            return res;
            /* c8 ignore next 4 */
          } catch (e) {
            psLog.error(`Failed to remove storage synchronously: ${keyOrObj}`);
            throw e;
          }
        },
      },

      clearStorage: {
        value(params: Parameters<MPStorageAPI['clearStorage']>[0]) {
          return StoragePlugin.originFunctions!.clearStorage({
            ...params,
            success(res) {
              sendClearItem();
              params.success?.(res);
            },
          });
        },
      },

      clearStorageSync: {
        value() {
          try {
            const res = StoragePlugin.originFunctions!.clearStorageSync();
            sendClearItem();
            return res;
            /* c8 ignore next 4 */
          } catch (e) {
            psLog.error('Failed to clear storage synchronously');
            throw e;
          }
        },
      },
    });

    if (mp.canIUse('batchSetStorageSync')) {
      Object.defineProperty(mp, 'batchSetStorageSync', {
        value(kvList: KVList) {
          // alipay doesn't have batch action, so do nothing
          try {
            const res =
              StoragePlugin.originFunctions!.batchSetStorageSync(kvList);
            kvList.forEach((kv) => {
              sendSetItem(kv.key, kv.value);
            });
            return res;
            /* c8 ignore next 7 */
          } catch (e) {
            psLog.error(
              `Failed to batch set storage synchronously: ${JSON.stringify(
                kvList.map((kv) => kv.key),
              )}`,
            );
            throw e;
          }
        },
      });
    }
    if (mp.canIUse('batchSetStorage')) {
      Object.defineProperty(mp, 'batchSetStorage', {
        value(params: Parameters<MPStorageAPI['batchSetStorage']>[0]) {
          return StoragePlugin.originFunctions!.batchSetStorage({
            ...params,
            success(res) {
              params.kvList.forEach((kv) => {
                sendSetItem(kv.key, kv.value);
              });
              params.success?.(res);
            },
          });
        },
      });
    }
  }

  private static sendSetItem(key: string, value: any) {
    StoragePlugin.sendStorageItem({
      type: 'mpStorage',
      action: 'set',
      name: key,
      value: mpDataStringify(value),
    } as SpyStorage.SetTypeDataItem);
  }

  private static sendRemoveItem(key: string) {
    StoragePlugin.sendStorageItem({
      type: 'mpStorage',
      action: 'remove',
      name: key,
    } as SpyStorage.RemoveTypeDataItem);
  }

  private static sendClearItem() {
    StoragePlugin.sendStorageItem({
      type: 'mpStorage',
      action: 'clear',
    } as SpyStorage.ClearTypeDataItem);
  }

  private static sendStorageItem(info: Omit<SpyStorage.DataItem, 'id'>) {
    const data = makeMessage('storage', info);
    socketStore.dispatchEvent('public-data', data);
    // The user wouldn't want to get the stale data, so here we set the 2nd parameter to true.
    socketStore.broadcastMessage(data, true);
  }
}

1	import { makeMessage } from 'base/src/message';	2✔
2	import type { SpyStorage, PageSpyPlugin } from '@huolala-tech/page-spy-types';	2✔
3	import socketStore from 'mp-base/src/helpers/socket';	2✔
4	import { psLog } from 'base/src';	2✔
5	import { getMPSDK, utilAPI } from '../utils';	2✔
6	import Client from 'base/src/client';	2✔
7		2✔
8	export function mpDataStringify(data: any) {	38✔
9	const typeOfValue = typeof data;	38✔
10	let vStr: string = data;	38✔
11	if (	38✔
12	typeOfValue === 'string' \|\|	38✔
13	typeOfValue === 'boolean' \|\|	38✔
14	typeOfValue === 'number'	18✔
15	) {	38✔
16	vStr = String(data);	22✔
17	} else if (typeOfValue === 'object') {	38✔
18	if (data instanceof Date) {	14✔
19	vStr = data.toDateString();	2✔
20	} else {	14✔
21	vStr = JSON.stringify(data);	12✔
22	}	12✔
23	}	14✔
24	return vStr;	38✔
25	}	38✔
26		2✔
27	export default class StoragePlugin implements PageSpyPlugin {	2✔
28	public name = 'StoragePlugin';	2✔
29		2✔
30	public static hasInitd = false;	2✔
31		4✔
32	private static originFunctions = {} as MPStorageAPI;	2✔
33		2✔
34	// eslint-disable-next-line class-methods-use-this	2✔
35	public onInit() {	2✔
36	if (StoragePlugin.hasInitd) return;	28✔
37	StoragePlugin.hasInitd = true;	26✔
38		26✔
39	StoragePlugin.initStorageProxy();	26✔
40	StoragePlugin.listenRefreshEvent();	26✔
41	}	26✔
42		2✔
43	public onReset() {	2✔
44	const mp = getMPSDK();	30✔
45	Object.entries(StoragePlugin.originFunctions).forEach(([key, fn]) => {	30✔
46	Object.defineProperty(mp, key, {	224✔
47	value: fn,	224✔
48	});	224✔
49	});	30✔
50	StoragePlugin.hasInitd = false;	30✔
51	}	30✔
52		2✔
53	static sendRefresh() {	2✔
54	const mp = getMPSDK();	2✔
55	try {	2✔
56	const info = mp.getStorageInfoSync();	2✔
57		2✔
58	const data = info.keys.map((key) => {	2✔
59	return {	×
60	name: key,	×
61	value: mpDataStringify(utilAPI.getStorage(key)),	×
62	};	×
63	});	2✔
64		2✔
65	const dataItem: SpyStorage.GetTypeDataItem = {	2✔
66	type: 'mpStorage',	2✔
67	action: 'get',	2✔
68	data,	2✔
69	};	2✔
70	StoragePlugin.sendStorageItem(dataItem);	2✔
71	} catch (e) {	2!
72	// TODO	×
73	}	×
74	}	2✔
75		2✔
76	/* c8 ignore start */	2✔
77	private static listenRefreshEvent() {	2✔
78	socketStore.addListener('refresh', async ({ source }) => {	2✔
79	const { data: storageType } = source;	2✔
80	if (storageType === 'mpStorage') {	2✔
81	StoragePlugin.sendRefresh();	2✔
82	}	2✔
83	});	2✔
84	}	2✔
85	/* c8 ignore stop */	2✔
86		2✔
87	private static initStorageProxy() {	2✔
88	const mp = getMPSDK();	26✔
89	const { sendClearItem, sendRemoveItem, sendSetItem } = StoragePlugin;	26✔
90	const proxyFunctions = [	26✔
91	'setStorage',	26✔
92	'setStorageSync',	26✔
93	'removeStorage',	26✔
94	'removeStorageSync',	26✔
95	'clearStorage',	26✔
96	'clearStorageSync',	26✔
97	'batchSetStorageSync',	26✔
98	'batchSetStorage',	26✔
99	] as (keyof MPStorageAPI)[];	26✔
100		26✔
101	proxyFunctions.forEach((name) => {	26✔
102	if (mp[name]) {	208✔
103	// @ts-ignore	208✔
104	StoragePlugin.originFunctions[name] = mp[name];	208✔
105	}	208✔
106	});	26✔
107		26✔
108	Object.defineProperties(mp, {	26✔
109	setStorage: {	26✔
110	value(params: Parameters<MPStorageAPI['setStorage']>[0]) {	26✔
111	return StoragePlugin.originFunctions!.setStorage({	4✔
112	...params,	4✔
113	success(res) {	4✔
114	sendSetItem(params.key, params.data);	4✔
115	params.success?.(res);	4!
116	},	4✔
117	});	4✔
118	},	26✔
119	},	26✔
120	setStorageSync: {	26✔
121	value(keyOrObj: string \| { key: string; data: any }, data: any) {	26✔
122	try {	12✔
123	let res: any;	12✔
124	if (	12✔
125	Client.info.browserType === 'mp-alipay' &&	12!
NEW 126	(!Client.info.framework \|\| Client.info.framework === 'unknown')	×
127	) {	12!
128	// alipay is so disgusting, here the input is an object	×
129	const obj = keyOrObj as { key: string; data: any };	×
130	res = (StoragePlugin.originFunctions!.setStorageSync as any)(obj);	×
131	sendSetItem(obj.key, obj.data);	×
132	} else {	12✔
133	const key = keyOrObj as string;	12✔
134	res = StoragePlugin.originFunctions!.setStorageSync(key, data);	12✔
135	sendSetItem(key, data);	12✔
136	}	12✔
137	return res;	12✔
138	} catch (e) {	12!
139	/* c8 ignore next 3 */	2✔
140	// TODO e is unknown so we can't use it, for further investigation	2✔
141	psLog.error(`Failed to set storage synchronously: ${keyOrObj}`);	2✔
142	throw e;	2✔
143	}	×
144	},	26✔
145	},	26✔
146		26✔
147	removeStorage: {	26✔
148	value(params: Parameters<MPStorageAPI['removeStorage']>[0]) {	26✔
149	return StoragePlugin.originFunctions!.removeStorage({	4✔
150	...params,	4✔
151	success(res) {	4✔
152	sendRemoveItem(params.key);	4✔
153	params.success?.(res);	4!
154	},	4✔
155	});	4✔
156	},	26✔
157	},	26✔
158		26✔
159	removeStorageSync: {	26✔
160	// in alipay, the param is an object actually, but it works.	26✔
161	value(keyOrObj: string) {	26✔
162	try {	4✔
163	const res =	4✔
164	StoragePlugin.originFunctions!.removeStorageSync(keyOrObj);	4✔
165	sendRemoveItem(res);	4✔
166	return res;	4✔
167	/* c8 ignore next 4 */	2✔
168	} catch (e) {	2✔
169	psLog.error(`Failed to remove storage synchronously: ${keyOrObj}`);	2✔
170	throw e;	2✔
171	}	2✔
172	},	26✔
173	},	26✔
174		26✔
175	clearStorage: {	26✔
176	value(params: Parameters<MPStorageAPI['clearStorage']>[0]) {	26✔
177	return StoragePlugin.originFunctions!.clearStorage({	2✔
178	...params,	2✔
179	success(res) {	2✔
180	sendClearItem();	2✔
181	params.success?.(res);	2!
182	},	2✔
183	});	2✔
184	},	26✔
185	},	26✔
186		26✔
187	clearStorageSync: {	26✔
188	value() {	26✔
189	try {	2✔
190	const res = StoragePlugin.originFunctions!.clearStorageSync();	2✔
191	sendClearItem();	2✔
192	return res;	2✔
193	/* c8 ignore next 4 */	2✔
194	} catch (e) {	2✔
195	psLog.error('Failed to clear storage synchronously');	2✔
196	throw e;	2✔
197	}	2✔
198	},	26✔
199	},	26✔
200	});	26✔
201		26✔
202	if (mp.canIUse('batchSetStorageSync')) {	26✔
203	Object.defineProperty(mp, 'batchSetStorageSync', {	26✔
204	value(kvList: KVList) {	26✔
205	// alipay doesn't have batch action, so do nothing	2✔
206	try {	2✔
207	const res =	2✔
208	StoragePlugin.originFunctions!.batchSetStorageSync(kvList);	2✔
209	kvList.forEach((kv) => {	2✔
210	sendSetItem(kv.key, kv.value);	4✔
211	});	2✔
212	return res;	2✔
213	/* c8 ignore next 7 */	2✔
214	} catch (e) {	2✔
215	psLog.error(	2✔
216	`Failed to batch set storage synchronously: ${JSON.stringify(	2✔
217	kvList.map((kv) => kv.key),	2✔
218	)}`,	2✔
219	);	2✔
220	throw e;	2✔
221	}	×
222	},	26✔
223	});	26✔
224	}	26✔
225	if (mp.canIUse('batchSetStorage')) {	26✔
226	Object.defineProperty(mp, 'batchSetStorage', {	26✔
227	value(params: Parameters<MPStorageAPI['batchSetStorage']>[0]) {	26✔
228	return StoragePlugin.originFunctions!.batchSetStorage({	2✔
229	...params,	2✔
230	success(res) {	2✔
231	params.kvList.forEach((kv) => {	2✔
232	sendSetItem(kv.key, kv.value);	4✔
233	});	2✔
234	params.success?.(res);	2!
235	},	2✔
236	});	2✔
237	},	26✔
238	});	26✔
239	}	26✔
240	}	26✔
241		2✔
242	private static sendSetItem(key: string, value: any) {	2✔
243	StoragePlugin.sendStorageItem({	24✔
244	type: 'mpStorage',	24✔
245	action: 'set',	24✔
246	name: key,	24✔
247	value: mpDataStringify(value),	24✔
248	} as SpyStorage.SetTypeDataItem);	24✔
249	}	24✔
250		2✔
251	private static sendRemoveItem(key: string) {	2✔
252	StoragePlugin.sendStorageItem({	8✔
253	type: 'mpStorage',	8✔
254	action: 'remove',	8✔
255	name: key,	8✔
256	} as SpyStorage.RemoveTypeDataItem);	8✔
257	}	8✔
258		2✔
259	private static sendClearItem() {	2✔
260	StoragePlugin.sendStorageItem({	4✔
261	type: 'mpStorage',	4✔
262	action: 'clear',	4✔
263	} as SpyStorage.ClearTypeDataItem);	4✔
264	}	4✔
265		2✔
266	private static sendStorageItem(info: Omit<SpyStorage.DataItem, 'id'>) {	2✔
267	const data = makeMessage('storage', info);	8✔
268	socketStore.dispatchEvent('public-data', data);	8✔
269	// The user wouldn't want to get the stale data, so here we set the 2nd parameter to true.	8✔
270	socketStore.broadcastMessage(data, true);	8✔
271	}	8✔
272	}	2✔

HuolalaTech / page-spy / 9297852260

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous