@conecli/cone-render 0.10.1-shop-beta.9 → 0.10.1-shop-beta.10

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -1 +1 @@
1
- import Taro from '@tarojs/taro';
2
1
  dealNativePixelToCssPixel,
3
2
  isAndroidDevice,
4
3
  isIosDevice,
5
4
  isJdAndAndroidDevice,
6
5
  isJdAndHarmonyDevice,
7
6
  isObject,
8
7
  isPc,
9
8
  isString,
10
9
  jdAppVersion,
11
10
  jdAppVersionStr,
12
11
  serialize,
13
12
  draBusinessCustomReport,
14
13
  BUSINESS_TYPE,
15
14
  LoadJsInitLoadEnvType,
16
15
  LoadJsInitLoadType,
17
16
  LoadJsInitTriggerType,
18
17
  MPAAS_CONFIG_APP_LOW_VERSION,
19
18
  MPAAS_CONFIG_APP_VERSION,
20
19
  SECTION_HOME_TAB_NAME_TYPE,
21
20
  SECTION_HOME_TAB_TYPE,
22
21
  TaroEventType,
23
22
  WX_BUSINESS_TYPE,
24
23
  WXAPP_BIZ_KEY,
25
24
  WXAPP_BIZ_SHOP_LIGHT_KEY,
26
25
  JSSDK_APP_WEBVIEW_CODE,
27
26
  getSystemInfos,
28
27
  getTaroStorageKeyValue,
29
28
  ipLoc_djd,
30
29
  setTaroStorage,
31
30
  sgmCustomReport,
32
31
  abTestLabels: {},
33
32
  loginState: false,
34
33
  cookiesStr: '',
35
34
  userInfo: userPinKey,
36
35
  isJingGouMiniViewState: false,
37
36
  isJingxiMiniViewState: false,
38
37
  pageInfo: {
39
38
  wxBusinessType: WX_BUSINESS_TYPE.NO,
40
39
  address: '',
41
40
  addressCommaStr: '',
42
41
  un_area: '',
43
42
  vapptype: '1',
44
43
  pageType: 'home',
45
44
  isExposureState: false,
46
45
  moduleId: '',
47
46
  entrance: '',
48
47
  dataType: BUSINESS_TYPE.ONLINE,
49
48
  floorExposureInfo: {},
50
49
  floorVideInfo: {},
51
50
  productVideInfo: {},
52
51
  tabsLoadAllDataInfo: {
53
52
  [SECTION_HOME_TAB_NAME_TYPE[SECTION_HOME_TAB_TYPE.HOME_WELL_CHOSEN]]: false,
54
53
  },
55
54
  updateShopInfosAllState: false,
56
55
  isVipShop: false,
57
56
  isJdShowNativeImmersivePlayer: false,
58
57
  ...shopConfig,
59
58
  pageScrollTop: 0,
60
59
  pageIdxHeightInfo: {
61
60
  list: [],
62
61
  },
63
62
  shopNavBarHeight: 0,
64
63
  },
65
64
  defaultQueryLogInfo: {
66
65
  sourceType: 'JDshop',
67
66
  sourceValue: '',
68
67
  moduleId: 'none',
69
68
  entrance: 'none',
70
69
  },
71
70
  sysInfo: {
72
71
  windowWidth: isPc ? 375 : 0,
73
72
  containerWidth: isPc ? 375 : 0,
74
73
  windowHeight: 0,
75
74
  netWorkType: '4g',
76
75
  jdBottomBarHeight: 0,
77
76
  jdNativeHeaderHeight: 0,
78
77
  isJdTabletDevice: false,
79
78
  isJdTabletLandscape: false,
80
79
  },
81
80
  queryInfo: {},
82
81
  shopInfo: {},
83
82
  openAppData: {},
84
83
  public info: CommonInterFace.BaseConfigInfo;
85
84
  public config: {
86
85
  [key: string]: any;
87
86
  };
88
87
  public lazyContainer: CommonInterFace.lazyContainer;
89
88
  public renderedIsvComponents: CommonInterFace.renderedIsvComponents;
90
89
  public rootEleNode: HTMLElement | null;
91
90
  public checkStatusAndLoginPromise: object | null;
92
91
  private jmfeRegisterStatePromise: Promise<any> | null;
93
92
  private jdScreenSizeInfoPromise: Promise<any> | null;
94
93
  private rootEleWidthRegisterPromise: Promise<any> | null;
95
94
  private jmfeRegisterState: boolean;
96
95
  public loadJsSdkList: Array<any>;
97
96
  public loadJsSdkListCachePromise: any;
98
97
  public rootEleInitWidth: number;
99
98
  constructor(opt) {
100
99
  this.info = this._getConfig(opt);
101
100
  this.config = {};
102
101
  this.loadJsSdkList = [];
103
102
  this.loadJsSdkListCachePromise = {};
104
103
  this.lazyContainer = {
105
104
  [SECTION_HOME_TAB_NAME_TYPE[SECTION_HOME_TAB_TYPE.HOME_WELL_CHOSEN]]: {
106
105
  appLazyContainerList: [],
107
106
  appLazyFinishContainerList: [],
108
107
  },
109
108
  [SECTION_HOME_TAB_NAME_TYPE[SECTION_HOME_TAB_TYPE.HOME_PROMOTION]]: {
110
109
  appLazyContainerList: [],
111
110
  appLazyFinishContainerList: [],
112
111
  },
113
112
  };
114
113
  this.renderedIsvComponents = {};
115
114
  this.rootEleNode = document.querySelector('body');
116
115
  this.checkStatusAndLoginPromise = null;
117
116
  this.jmfeRegisterStatePromise = null;
118
117
  this.jdScreenSizeInfoPromise = null;
119
118
  this.rootEleWidthRegisterPromise = null;
120
119
  this.rootEleInitWidth = this.getRootEleWindowWidthInfo().getRootEleWidth || -1;
121
120
  this.loadOtherSdk();
122
121
  if (isJdApp) {
123
122
  this.jmfeReayPromise();
124
123
  this._getJdPadMinWidthForListen() && this.getPadWindowRootEleWidthPromise();
125
124
  }
126
125
  }
127
126
  _getConfig(opt) {
128
127
  return Object.assign({}, DefaultConfig, opt);
129
128
  }
130
129
  _getJdPadMinWidthForListen() {
131
130
  return (
132
131
  isJdApp &&
133
132
  Math.min(window.screen.width, window.screen.height) >
134
133
  (window?.shopGlobalSwitch?.checkPadRootEleMinWidth || 600)
135
134
  );
136
135
  }
137
136
 
138
137
  jmfeReayPromise(): Promise<any> {
139
138
  if (isJdApp) {
140
139
  if (this.jmfeRegisterState) {
141
140
  return Promise.resolve(true);
142
141
  } else {
143
142
  !this.jmfeRegisterStatePromise &&
144
143
  (this.jmfeRegisterStatePromise = new Promise((resolve, reject) => {
145
144
  ready('jmfe', 3000)
146
145
  .then(() => {
147
146
  window?.jmfe && window.jmfe.registerCode(JSSDK_APP_WEBVIEW_CODE);
148
147
  this.jmfeRegisterState = true;
149
148
  resolve(true);
150
149
  console.log('松果app内初始化注册jmfe认证完成');
151
150
  })
152
151
  .catch((err) => {
153
152
  console.error('jmfe ready error', err);
154
153
  reject(false);
155
154
  });
156
155
  }));
157
156
  return this.jmfeRegisterStatePromise;
158
157
  }
159
158
  } else {
160
159
  return Promise.reject(false);
161
160
  }
162
161
  }
163
162
 
164
163
  getJdScreenSizeInfoPromise() {
165
164
  !this.jdScreenSizeInfoPromise &&
166
165
  (this.jdScreenSizeInfoPromise = new Promise((resolve) => {
167
166
  const getThisTime = Date.now();
168
167
  this.jmfeReayPromise().then(() => {
169
168
  return Promise.race([
170
169
  window.jmfe.getScreenSize(),
171
170
  this.taskTimeoutPromise(() => {
172
171
  return {
173
172
  status: '-10',
174
173
  msg: '获取大屏信息2s超时',
175
174
  };
176
175
  }),
177
176
  ])
178
177
  .then((res) => {
179
178
  console.warn('===获取app大屏信息====', res);
180
179
  const { status, data } = res;
181
180
  if (status === '0' && data) {
182
181
  const { sizeType, isLandscape, pageHeight, pageWidth } = data;
183
182
  const getPageInfo = dealNativePixelToCssPixel({
184
183
  pageWidth,
185
184
  pageHeight,
186
185
  });
187
186
  this.info.sysInfo.jdScreenSizeType = sizeType;
188
187
  const getUseTime = Date.now() - getThisTime;
189
188
  console.warn(
190
189
  '===计算是否是app大屏信息,需满足宽度最新720===',
191
190
  getPageInfo,
192
191
  '原始数据',
193
192
  data,
194
193
  '是否是横屏isLandscape为1=',
195
194
  isLandscape,
196
195
  '用时',
197
196
  getUseTime,
198
197
  );
199
198
  if (getPageInfo?.pageWidth > 0) {
200
199
  this.rootEleInitWidth = getPageInfo?.pageWidth;
201
200
  draBusinessCustomReport({
202
201
  type: 'rootEle_width_getJdScreenSizeInfo',
203
202
  errMsg: `根元素获取宽度初始化为0,通过getJdScreenSizeInfo获取结果,用时${getUseTime}`,
204
203
  originReqDataStr: JSON.stringify({
205
204
  isJdApp,
206
205
  getPageInfo,
207
206
  originData: res,
208
207
  }),
209
208
  });
210
209
  resolve(getPageInfo);
211
210
  } else {
212
211
  resolve({
213
212
  pageWidth: 0,
214
213
  pageHeight: 0,
215
214
  msg: '转换异常',
216
215
  });
217
216
  }
218
217
  } else {
219
218
  resolve({
220
219
  pageWidth: 0,
221
220
  pageHeight: 0,
222
221
  msg: '获取大屏信息异常或者超时',
223
222
  });
224
223
  }
225
224
  })
226
225
  .catch((err) => {
227
226
  console.log('获取大屏信息异常', err);
228
227
  resolve({
229
228
  pageWidth: 0,
230
229
  pageHeight: 0,
231
230
  msg: '获取大屏信息异常',
232
231
  });
233
232
  });
234
233
  });
235
234
  }));
236
235
  return this.jdScreenSizeInfoPromise;
237
236
  }
238
237
 
239
238
  listenJdTabletScreenChange() {
240
239
  this.jmfeReayPromise().then(() => {
241
240
  try {
242
241
  console.log('初始化监听大屏信息变化', window.jmfe.listenDeviceScreenChange);
243
242
  window.jmfe.listenDeviceScreenChange((event) => {
244
243
  console.log(
245
244
  '监听app大屏信息变化,orientation为landscape表示横屏,multiScreen为1表示android端分屏',
246
245
  event,
247
246
  '通过前端判断是不是横屏',
248
247
  window.matchMedia('(orientation: landscape)')?.matches,
249
248
  );
250
249
  const { orientation } = event?.data;
251
250
  if (orientation) {
252
251
  this.info.sysInfo.isJdTabletLandscape = orientation === 'landscape';
253
252
  Taro.eventCenter.trigger(
254
253
  TaroEventType.TABLE_SCREEN_CHANGE,
255
254
  this.info.sysInfo.isJdTabletLandscape,
256
255
  orientation,
257
256
  );
258
257
  }
259
258
  });
260
259
  } catch (error) {
261
260
  console.log('listenScreenChange的打印error:', error);
262
261
  }
263
262
  });
264
263
  }
265
264
 
266
265
  updateBusinessDomainAndApi(domain, api) {
267
266
  }
268
267
 
269
268
  formatNativeScreenPageData(action) {
270
269
  let getChangePageInfo: any = null;
271
270
  try {
272
271
  const getNativeScreenPageInfoStr = window.XWebView?._callNative(
273
272
  JSON.stringify({
274
273
  plugin: 'JDHybridScreenPlugin',
275
274
  action,
276
275
  sync: '1',
277
276
  }),
278
277
  );
279
278
  const getChangePageInfoData =
280
279
  typeof getNativeScreenPageInfoStr === 'string'
281
280
  ? JSON.parse(getNativeScreenPageInfoStr)
282
281
  : null;
283
282
  if (getChangePageInfoData && typeof getChangePageInfoData === 'object') {
284
283
  const { code, data } = getChangePageInfoData;
285
284
  getChangePageInfo = code && code === '0' ? data : null;
286
285
  }
287
286
  } catch (e) {
288
287
  console.log('JDHybridScreenPlugin转换异常', e);
289
288
  }
290
289
  return getChangePageInfo;
291
290
  }
292
291
 
293
292
  isAndroidFoldScreen() {
294
293
  return this.formatNativeScreenPageData('isFoldScreen') === '1';
295
294
  }
296
295
 
297
296
  getJdAndroidPageChangeScreenInfo() {
298
297
  const getPageScreenInfo = this.formatNativeScreenPageData('getScreenSize');
299
298
  if (getPageScreenInfo && getPageScreenInfo?.pageWidth && getPageScreenInfo?.pageHeight) {
300
299
  const { pageWidth, pageHeight } = dealNativePixelToCssPixel({
301
300
  pageWidth: getPageScreenInfo.pageWidth,
302
301
  pageHeight: getPageScreenInfo.pageHeight,
303
302
  });
304
303
  getPageScreenInfo.pageWidth = pageWidth;
305
304
  getPageScreenInfo.pageHeight = pageHeight;
306
305
  }
307
306
  return getPageScreenInfo;
308
307
  }
309
308
 
310
309
  getRootEleWindowWidthInfo() {
311
310
  const getRootEleWidth = document.documentElement.getBoundingClientRect().width;
312
311
  const getWindowWidth = window.innerWidth;
313
312
  const getScreenWidth = window.screen.width;
314
313
  return {
315
314
  getRootEleWidth,
316
315
  getWindowWidth,
317
316
  getScreenWidth,
318
317
  };
319
318
  }
320
319
 
321
320
  dealRootEleWidthFn(reportParam = {}, timeout = 0) {
322
321
  const { getRootEleWidth, getWindowWidth, getScreenWidth } = this.getRootEleWindowWidthInfo();
323
322
  console.log(
324
323
  '当前获取根元素的宽度',
325
324
  getRootEleWidth,
326
325
  'getWindowWidth',
327
326
  getWindowWidth,
328
327
  'getScreenWidth',
329
328
  getScreenWidth,
330
329
  );
331
330
  const getLastWidth =
332
331
  getRootEleWidth > 0
333
332
  ? Math.round(getRootEleWidth)
334
333
  : Math.round(getWindowWidth > 0 ? getWindowWidth : getScreenWidth);
335
334
  console.warn(
336
335
  `根元素获取宽度初始化为0,通过getJdScreenSizeInfo获取结果超时,超时时间超时时间${timeout}ms,最终兜底再获取一次根元素宽度${getLastWidth}`,
337
336
  );
338
337
  timeout > 0 &&
339
338
  draBusinessCustomReport({
340
339
  type: 'rootEle_width_timeout_getJdScreenSizeInfo',
341
340
  errMsg: `根元素获取宽度初始化为0,通过getJdScreenSizeInfo获取结果超时,超时时间${timeout}ms,最终兜底再获取一次根元素宽度${getLastWidth}`,
342
341
  originReqDataStr: JSON.stringify({
343
342
  isJdApp,
344
343
  getRootEleWidth,
345
344
  getWindowWidth,
346
345
  getScreenWidth,
347
346
  ...reportParam,
348
347
  }),
349
348
  });
350
349
  return getLastWidth;
351
350
  }
352
351
 
353
352
  getPadWindowRootEleWidthPromise() {
354
353
  if (this.rootEleInitWidth > 0) {
355
354
  return Promise.resolve(this.rootEleInitWidth);
356
355
  } else {
357
356
  !this.rootEleWidthRegisterPromise &&
358
357
  (this.rootEleWidthRegisterPromise = new Promise((resolve) => {
359
358
  const getRootEleInitWidth = this.getRootEleWindowWidthInfo().getRootEleWidth;
360
359
  if (getRootEleInitWidth > 0) {
361
360
  console.log('初始化获取根元素宽度正常,为', getRootEleInitWidth);
362
361
  this.rootEleInitWidth = Math.round(getRootEleInitWidth);
363
362
  resolve(this.rootEleInitWidth);
364
363
  } else {
365
364
  const timerPromise = () => {
366
365
  return new Promise((resolve2) => {
367
366
  window.setTimeout(() => {
368
367
  const { getRootEleWidth, getWindowWidth, getScreenWidth } =
369
368
  this.getRootEleWindowWidthInfo();
370
369
  if (getRootEleWidth > 0 || getWindowWidth > 0) {
371
370
  console.warn(
372
371
  `根元素获取宽度初始化为0,200ms后尝试获取最新结果,getRootEleWidth为${getRootEleWidth},getWindowWidth为${getWindowWidth},getScreenWidth为${getScreenWidth}`,
373
372
  );
374
373
  draBusinessCustomReport({
375
374
  type: 'rootEle_width_200_timeout_info',
376
375
  errMsg: `根元素获取宽度初始化为0,200ms后尝试获取最新结果,getRootEleWidth为${getRootEleWidth},getWindowWidth为${getWindowWidth}`,
377
376
  originReqDataStr: JSON.stringify({
378
377
  isJdApp,
379
378
  getRootEleWidth,
380
379
  getWindowWidth,
381
380
  getScreenWidth,
382
381
  }),
383
382
  });
384
383
  const getRes =
385
384
  getRootEleWidth > 0 && getWindowWidth > 0
386
385
  ? Math.min(getRootEleWidth, getWindowWidth)
387
386
  : Math.max(getRootEleWidth, getWindowWidth);
388
387
  resolve2({
389
388
  pageWidth: Math.round(getRes),
390
389
  });
391
390
  }
392
391
  }, 200);
393
392
  });
394
393
  };
395
394
  Promise.race([timerPromise(), this.getJdScreenSizeInfoPromise()]).then((res) => {
396
395
  const { pageWidth } = res;
397
396
  console.log('获取结果Promise.race getJdScreenSizeInfo', res);
398
397
  pageWidth > 0 ? resolve(pageWidth) : resolve(this.dealRootEleWidthFn(res, 2000));
399
398
  });
400
399
  }
401
400
  }));
402
401
  return this.rootEleWidthRegisterPromise;
403
402
  }
404
403
  }
405
404
 
406
405
  async getSystemInfo(params) {
407
406
  const getParams = Object.assign({}, params || {});
408
407
  if (this.rootEleInitWidth > 0) {
409
408
  getParams['rootEleInitWidth'] = this.rootEleInitWidth;
410
409
  console.log('获取当前系统信息的时候已经获取到根元素宽度,值为', this.rootEleInitWidth);
411
410
  } else {
412
411
  if (this._getJdPadMinWidthForListen()) {
413
412
  getParams['rootEleInitWidth'] = await this.getPadWindowRootEleWidthPromise();
414
413
  getParams['replaceSystemWidth'] = true;
415
414
  }
416
415
  }
417
416
  let info: UtilsInterFace.taroGetSystemInfoSyncRes | any = getSystemInfos(getParams);
418
417
  if (isJdAndAndroidDevice && info?.initWindowWidth <= 0) {
419
418
  let _isfoldScreen = false;
420
419
  const getStorageData = getTaroStorageKeyValue('jd_shopx_androidIsFoldScreen');
421
420
  console.info(
422
421
  '获取当前本地存储是否有jd_shopx_androidIsFoldScreen',
423
422
  getStorageData,
424
423
  '通过缓存值第一次判断是否是折叠屏',
425
424
  getStorageData === 'true',
426
425
  );
427
426
  if (!getStorageData) {
428
427
  _isfoldScreen = this.isAndroidFoldScreen();
429
428
  setTaroStorage('jd_shopx_androidIsFoldScreen', `${_isfoldScreen}`);
430
429
  } else {
431
430
  _isfoldScreen = getStorageData === 'true';
432
431
  }
433
432
  if (_isfoldScreen) {
434
433
  const getJdAndroidPageInfo = this.getJdAndroidPageChangeScreenInfo();
435
434
  if (getJdAndroidPageInfo) {
436
435
  info = getSystemInfos(getJdAndroidPageInfo);
437
436
  console.warn(
438
437
  '当前为松果安卓折叠屏app,获取折叠屏信息',
439
438
  getJdAndroidPageInfo,
440
439
  '获取转换后的系统信息',
441
440
  info,
442
441
  );
443
442
  sgmCustomReport({
444
443
  type: 2,
445
444
  code: 'android_jdapp_foldScreen_info',
446
445
  msg: {
447
446
  title: `松果安卓app为折叠屏,重置获取的系统宽高信息,因为获取宽高度信息初始化内部可能存在横竖屏差异`,
448
447
  androidPageInfo: getJdAndroidPageInfo,
449
448
  jdAppVersionStr,
450
449
  taroSysInfo: info,
451
450
  },
452
451
  });
453
452
  }
454
453
  }
455
454
  }
456
455
  if (isJdApp) {
457
456
  info?.isJdTabletDevice && this.listenJdTabletScreenChange();
458
457
  }
459
458
  this.info.sysInfo = {
460
459
  actualNavBarHeight: 0,
461
460
  ...this.info.sysInfo,
462
461
  ...info,
463
462
  safeContentHeight: info?.screenHeight,
464
463
  headerHeight: 0,
465
464
  tabBarHeight: 0,
466
465
  };
467
466
  if (isJdApp) {
468
467
  this.info.sysInfo['hostVersionName'] = jdAppVersionStr;
469
468
  this.info.sysInfo['hostAppVersion'] = jdAppVersion;
470
469
  this.getAddressCachePromise();
471
470
  this.getElderModePromise();
472
471
  this.getJDAppearanceStatePromise();
473
472
  this.createJdAndroidRquestEventForTouchStart();
474
473
  }
475
474
  this.getWifiVideoAutoPlayAsync();
476
475
  this.getMPaasConfigAsync();
477
476
  this.getNetWorkType();
478
477
  }
479
478
 
480
479
  taskTimeoutPromise(callBack, timeout = 2000) {
481
480
  return new Promise((resolve) => {
482
481
  setTimeout(() => {
483
482
  const getCallBackRes = typeof callBack === 'function' && callBack();
484
483
  return resolve(getCallBackRes || false);
485
484
  }, timeout);
486
485
  });
487
486
  }
488
487
 
489
488
  getElderModePromise() {
490
489
  if (this.info.sysInfo.hasOwnProperty('jdAppModeType')) {
491
490
  return Promise.resolve(this.info.sysInfo.jdAppModeType);
492
491
  } else {
493
492
  if (isJdAndAndroidDevice) {
494
493
  this.info.sysInfo.jdAppModeType = '0';
495
494
  return Promise.resolve(this.info.sysInfo.jdAppModeType);
496
495
  } else {
497
496
  return Promise.race([
498
497
  this.taskTimeoutPromise(() => {
499
498
  this.info.sysInfo.jdAppModeType = '0';
500
499
  return this.info.sysInfo.jdAppModeType;
501
500
  }),
502
501
  new Promise((resolve) => {
503
502
  const getCallBackName = `getJdCurrentModeType${Date.now()}`;
504
503
  if (!window[getCallBackName]) {
505
504
  window[getCallBackName] = (res) => {
506
505
  try {
507
506
  const getResJson = typeof res === 'string' ? JSON.parse(res) : res;
508
507
  const { status, data, msg } = getResJson;
509
508
  console.log(`获取松果app展示模式成功,返回结果${data}`);
510
509
  if (status === '0') {
511
510
  this.info.sysInfo.jdAppModeType = data;
512
511
  resolve(data);
513
512
  } else {
514
513
  resolve('0');
515
514
  }
516
515
  } catch (e) {
517
516
  resolve('0');
518
517
  }
519
518
  window[getCallBackName] = null;
520
519
  };
521
520
  }
522
521
  window?.webkit?.messageHandlers?.JDAppUnite?.postMessage({
523
522
  method: 'callSyncRouterModuleWithParams',
524
523
  params: JSON.stringify({
525
524
  routerURL: 'router://JDBModeModule/getCurrentMode',
526
525
  routerParam: {},
527
526
  callBackName: `window.${getCallBackName}`,
528
527
  callBackId: `${getCallBackName}Ios`,
529
528
  }),
530
529
  });
531
530
  }),
532
531
  ]);
533
532
  }
534
533
  }
535
534
  }
536
535
  getAPPUseStraightCorner() {
537
536
  const routerURL = 'router://JDBaseUtilsModule/isUI14Enable';
538
537
  const params = {
539
538
  routerURL,
540
539
  routerParam: {},
541
540
  jdRouter: '1',
542
541
  };
543
542
  if (this.info.sysInfo.hasOwnProperty('jdStraightCorner')) {
544
543
  return Promise.resolve(this.info.sysInfo.jdStraightCorner);
545
544
  } else {
546
545
  return this.jmfeReayPromise()
547
546
  .then(() => {
548
547
  if (isJdAndHarmonyDevice || !isJdApp) {
549
548
  console.log('not APP or is Harmony');
550
549
  return Promise.resolve(false);
551
550
  }
552
551
  console.log('jmfe setShareInfo', params);
553
552
  return Promise.race([
554
553
  window.jmfe.callRouter(params),
555
554
  this.taskTimeoutPromise(() => {
556
555
  return false;
557
556
  }),
558
557
  ]).then(({ status, data }) => {
559
558
  console.log('004 ~ file: index.tsx:133 ~ .then ~ data:', data);
560
559
  console.log('004 ~ file: index.tsx:133 ~ .then ~ status:', status);
561
560
  this.info.sysInfo.jdStraightCorner = status === '0' && Number(data) === 1;
562
561
  return Promise.resolve(status === '0' && Number(data) === 1);
563
562
  });
564
563
  })
565
564
  .catch((e) => {
566
565
  console.log('jmfe error', e);
567
566
  return Promise.resolve(false);
568
567
  });
569
568
  }
570
569
  }
571
570
 
572
571
  getJDAppearanceStatePromise() {
573
572
  if (this.info.sysInfo.hasOwnProperty('jdAppearanceState')) {
574
573
  return Promise.resolve(this.info.sysInfo.jdAppearanceState);
575
574
  } else {
576
575
  return Promise.race([
577
576
  this.taskTimeoutPromise(() => {
578
577
  this.info.sysInfo.jdAppearanceState = '0';
579
578
  return this.info.sysInfo.jdAppearanceState;
580
579
  }),
581
580
  new Promise((resolve) => {
582
581
  const getCallBackName = `getJdCurrentAppearanceState${Date.now()}`;
583
582
  if (!window[getCallBackName]) {
584
583
  window[getCallBackName] = (res) => {
585
584
  try {
586
585
  console.log('getJDAppearanceStatePromise', res);
587
586
  const getResJson = typeof res === 'string' ? JSON.parse(res) : res;
588
587
  const { status, data, msg } = getResJson;
589
588
  console.log(`获取松果app是否开启黑暗模式成功,返回结果${data}`);
590
589
  if (status === '0') {
591
590
  this.info.sysInfo.jdAppearanceState = data;
592
591
  resolve(data);
593
592
  } else {
594
593
  resolve('0');
595
594
  }
596
595
  } catch (e) {
597
596
  resolve('0');
598
597
  }
599
598
  window[getCallBackName] = null;
600
599
  };
601
600
  }
602
601
  if (isAndroidDevice) {
603
602
  const jsonString = JSON.stringify({
604
603
  callBackName: `window.${getCallBackName}`,
605
604
  });
606
605
  console.log('window.JDAppearance', window?.JDAppearance);
607
606
  window?.JDAppearance &&
608
607
  window?.JDAppearance?.getUiState &&
609
608
  window.JDAppearance.getUiState(jsonString);
610
609
  } else {
611
610
  window?.webkit?.messageHandlers?.JDAppUnite?.postMessage({
612
611
  method: 'callSyncRouterModuleWithParams',
613
612
  params: JSON.stringify({
614
613
  routerURL: 'router://JDWebViewBusinessModule/getJDAppearanceState',
615
614
  routerParam: {},
616
615
  callBackName: `window.${getCallBackName}`,
617
616
  callBackId: `${getCallBackName}Ios`,
618
617
  }),
619
618
  });
620
619
  }
621
620
  }),
622
621
  ]);
623
622
  }
624
623
  }
625
624
 
626
625
  createJdAndroidRquestEventForTouchStart() {
627
626
  if (isJdAndAndroidDevice && window?.JdAndroid) {
628
627
  const rootEleNode = document.querySelector('body');
629
628
  if (rootEleNode) {
630
629
  rootEleNode.addEventListener('touchstart', this.jdAndroidAddEventListenerTouchStart, false);
631
630
  }
632
631
  }
633
632
  }
634
633
  jdAndroidAddEventListenerTouchStart(e) {
635
634
  const isH5SwiperCustomEle = e?.target?.closest('.J_h5SwiperCustom');
636
635
  if (!isH5SwiperCustomEle && window?.JdAndroid) {
637
636
  const hasCustomEle = e
638
637
  ? e?.target?.closest('.J_customScroll') || e?.target?.closest('.J_customLayout')
639
638
  : false;
640
639
  if (!hasCustomEle) {
641
640
  window?.JdAndroid?.requestEvent && window.JdAndroid.requestEvent(false);
642
641
  console.log(
643
642
  'createJdAndroidRquestEvent 所有松果安卓APP内的document touch start事件执行检测requestEvent并重置为false',
644
643
  );
645
644
  }
646
645
  }
647
646
  }
648
647
  removeJdAndroidRquestEventForTouchStart() {
649
648
  if (isJdAndAndroidDevice && window.JdAndroid) {
650
649
  const rootEleNode = document.querySelector('body');
651
650
  if (rootEleNode) {
652
651
  rootEleNode.removeEventListener(
653
652
  'touchstart',
654
653
  this.jdAndroidAddEventListenerTouchStart,
655
654
  false,
656
655
  );
657
656
  }
658
657
  }
659
658
  }
660
659
 
661
660
  getNetWorkType() {
662
661
  if (isJdApp) {
663
662
  this.jmfeReayPromise().then(() => {
664
663
  window.jmfe
665
664
  .getNetworkStatus()
666
665
  .then(({ status, data }) => {
667
666
  console.log('在app内初始化通过jmfe对象获取网络状态完成,当前网络状态====', data);
668
667
  if (status === '0') {
669
668
  this.info.sysInfo['netWorkType'] = data;
670
669
  } else {
671
670
  this._taroGetNetworkType();
672
671
  }
673
672
  })
674
673
  .catch((err) => {
675
674
  console.log('在app内初始化通过jmfe对象获取网络状态异常====', err);
676
675
  this._taroGetNetworkType();
677
676
  });
678
677
  });
679
678
  } else {
680
679
  this._taroGetNetworkType();
681
680
  }
682
681
  }
683
682
  _taroGetNetworkType() {
684
683
  Taro.getNetworkType().then((getRes) => {
685
684
  if (getRes && getRes.networkType) {
686
685
  this.info.sysInfo['netWorkType'] = getRes.networkType;
687
686
  console.log(
688
687
  '在app内通过taro对象获取网络状态完成,当前网络状态',
689
688
  this.info.sysInfo['netWorkType'],
690
689
  );
691
690
  }
692
691
  });
693
692
  }
694
693
 
695
694
  getCacheAddressRouter() {
696
695
  if (window.jmfe && isJdApp) {
697
696
  if (!isJdAndHarmonyDevice) {
698
697
  return Promise.race([
699
698
  window.jmfe.callRouter({
700
699
  jdRouter: '1',
701
700
  routerURL: isAndroidDevice
702
701
  ? 'router://JDAddressModule/getCacheAddress'
703
702
  : 'router://JDBAddressCacheManagerModule/getCacheAddress',
704
703
  routerParam: { sceneId: 'basicShoppingProcess' },
705
704
  }),
706
705
  this.taskTimeoutPromise(() => {
707
706
  return {
708
707
  status: '-1000',
709
708
  msg: '原生router协议获取地址信息超时',
710
709
  };
711
710
  }, 3000),
712
711
  ]);
713
712
  } else {
714
713
  return Promise.resolve({
715
714
  status: '-1001',
716
715
  msg: '鸿蒙系统调用jmfe异常,获取失败',
717
716
  });
718
717
  }
719
718
  } else {
720
719
  return Promise.resolve({
721
720
  status: '-1002',
722
721
  msg: 'jmfe不存在,获取失败',
723
722
  });
724
723
  }
725
724
  }
726
725
 
727
726
  getAddressCachePromise() {
728
727
  return new Promise((resolve) => {
729
728
  if (this?.info?.sysInfo?.lat && this?.info?.sysInfo?.lng && this?.info?.sysInfo?.area) {
730
729
  resolve({
731
730
  lat: this.info.sysInfo.lat,
732
731
  lng: this.info.sysInfo.lng,
733
732
  area: this?.info?.sysInfo?.area,
734
733
  });
735
734
  } else {
736
735
  this.jmfeReayPromise()
737
736
  .then(() => {
738
737
  this.getCacheAddressRouter()
739
738
  .then((res) => {
740
739
  const { status, data } = res;
741
740
  console.log('原生端获取经纬度原始数据结果', status, data);
742
741
  if (status === '0' && data) {
743
742
  const { lat, latitude, lng, longitude, provinceId, cityId, countyId, townId } =
744
743
  data || {};
745
744
  let area = '';
746
745
  this.info.sysInfo['lat'] = `${lat || latitude || ''}`;
747
746
  this.info.sysInfo['lng'] = `${lng || longitude || ''}`;
748
747
  if (provinceId) {
749
748
  area = `${provinceId}_${cityId || 0}_${countyId || 0}_${townId || 0}`;
750
749
  this.info.pageInfo['address'] = area;
751
750
  this.info.pageInfo['addressCommaStr'] = area.replace(/_/g, ',');
752
751
  Taro.eventCenter.trigger(
753
752
  TaroEventType.USER_AREA_UPDATE,
754
753
  this.info.pageInfo.address,
755
754
  );
756
755
  }
757
756
  resolve({
758
757
  lat: this.info.sysInfo['lat'],
759
758
  lng: this.info.sysInfo['lng'],
760
759
  area: area,
761
760
  });
762
761
  } else {
763
762
  typeof res === 'object' &&
764
763
  sgmCustomReport({
765
764
  type: 3,
766
765
  code: 'jdapp_getCacheAddress_info',
767
766
  msg: {
768
767
  title: '松果app内通过router协议获取用户地址及经纬度信息异常',
769
768
  jdAppVersion: jdAppVersionStr,
770
769
  ...res,
771
770
  },
772
771
  });
773
772
  resolve({ lat: '', lng: '', area: '' });
774
773
  }
775
774
  })
776
775
  .catch((e) => {
777
776
  console.log(' ~~ file: index.h5.ts:518 ~~ .catch ~~ e:', e);
778
777
  resolve({ lat: '', lng: '', area: '' });
779
778
  console.log('getCacheAddressRouter catch e,获取经纬度信息异常e', e);
780
779
  });
781
780
  })
782
781
  .catch((e) => {
783
782
  resolve({ lat: '', lng: '', area: '' });
784
783
  console.log('判断jmfe不存在,获取经纬度信息异常e', e);
785
784
  });
786
785
  }
787
786
  });
788
787
  }
789
788
 
790
789
  async updateMPaasConfigAsync(isBeforePageReady: boolean) {
791
790
  console.log('updateMPaasConfigAsync isBeforePageReady:', isBeforePageReady);
792
791
  if (!isJdApp) {
793
792
  return;
794
793
  }
795
794
  const avifSwitch = await getMPaasConfigByBussinessKey('avifSwitch', isBeforePageReady);
796
795
  this.info.sysInfo.dynamicConfig['avifSwitch'] = avifSwitch;
797
796
  const hybridHttpSwitch = await getMPaasConfigByBussinessKey(
798
797
  'hybridHttpSwitch',
799
798
  isBeforePageReady,
800
799
  );
801
800
  this.info.sysInfo.dynamicConfig['hybridHttpSwitch'] = hybridHttpSwitch;
802
801
  const isFollowAppVideoPlayStatus = await getMPaasConfigByBussinessKey(
803
802
  'isFollowAppVideoPlayStatus',
804
803
  isBeforePageReady,
805
804
  );
806
805
  console.log(
807
806
  'isBeforePageReady:',
808
807
  isBeforePageReady,
809
808
  'isFollowAppVideoPlayStatus:',
810
809
  isFollowAppVideoPlayStatus,
811
810
  );
812
811
  if (isFollowAppVideoPlayStatus === true || isFollowAppVideoPlayStatus === 'true') {
813
812
  this.info.sysInfo.dynamicConfig['isFollowAppVideoPlayStatus'] = true;
814
813
  }
815
814
  }
816
815
 
817
816
  async getWifiVideoAutoPlayAsync() {
818
817
  this.info.sysInfo['wifiVideoAutoPlay'] = false;
819
818
  if (!isJdApp) {
820
819
  return;
821
820
  }
822
821
  const videoPlayStatus = await getWifiVideoAutoPlay().catch((e) => {
823
822
  return 0;
824
823
  });
825
824
  if (Number(videoPlayStatus) === 1) {
826
825
  this.info.sysInfo['wifiVideoAutoPlay'] = true;
827
826
  }
828
827
  }
829
828
 
830
829
  async getMPaasConfigAsync() {
831
830
  this.info.sysInfo.dynamicConfig = {};
832
831
  this.info.sysInfo.dynamicConfig['avifSwitch'] = {};
833
832
  this.info.sysInfo.dynamicConfig['hybridHttpSwitch'] = {};
834
833
  this.info.sysInfo.dynamicConfig['isFollowAppVideoPlayStatus'] = false;
835
834
  return this.updateMPaasConfigAsync(true);
836
835
  }
837
836
 
838
837
  getDynamicConfig(key: string) {
839
838
  return this.info.sysInfo?.dynamicConfig?.[key];
840
839
  }
841
840
  async updateMPaasConfig() {
842
841
  console.log('updateMPaasConfig');
843
842
  if (
844
843
  isIosDevice &&
845
844
  versionCompare(jdAppVersionStr, MPAAS_CONFIG_APP_VERSION) < 0 &&
846
845
  versionCompare(jdAppVersionStr, MPAAS_CONFIG_APP_LOW_VERSION) >= 0
847
846
  ) {
848
847
  try {
849
848
  await this.updateMPaasConfigAsync(false);
850
849
  } catch (e) {
851
850
  console.log('updateMPaasConfigAsync:', e);
852
851
  }
853
852
  }
854
853
  }
855
854
 
856
855
  toLogin(options) {
857
856
  return this.info.isJingGouMiniViewState || this.info.isJingxiMiniViewState
858
857
  ? this.toWxAppLogin(options)
859
858
  : this.toWebLogin(options);
860
859
  }
861
860
 
862
861
  doLogin(options) {
863
862
  return this.toLogin(options);
864
863
  }
865
864
 
866
865
  doLoginForJdPin(options = {}) {
867
866
  return this.doLogin({
868
867
  loginColor: {
869
868
  biz: WXAPP_BIZ_SHOP_LIGHT_KEY,
870
869
  dpin: 0,
871
870
  },
872
871
  ...options,
873
872
  });
874
873
  }
875
874
 
876
875
  toWebLogin(options) {
877
876
  let params: {
878
877
  returnurl: string;
879
878
  } = {
880
879
  returnurl: '',
881
880
  };
882
881
  const loginUrl = isPc
883
882
  ? `//passport.jd.com/new/login.aspx`
884
883
  : `${domain.mobileLogin}/user/login.action`;
885
884
  const defaultParams = {
886
885
  appid: '100',
887
886
  returnurl: window.location.href,
888
887
  };
889
888
  if (isString(options)) {
890
889
  params = Object.assign({}, defaultParams, {
891
890
  returnurl: options,
892
891
  });
893
892
  } else if (isObject(options)) {
894
893
  const { loginColor, ...otherOptions } = options;
895
894
  params = Object.assign({}, defaultParams, otherOptions);
896
895
  } else {
897
896
  params = defaultParams;
898
897
  }
899
898
  params.returnurl = encodeURIComponent(params.returnurl);
900
899
  let getFullUrl = loginUrl + '?' + serialize(params);
901
900
  if (isPc) {
902
901
  getFullUrl = getFullUrl.replace(/returnurl/, 'ReturnUrl');
903
902
  }
904
903
  return Promise.resolve({
905
904
  h5ToUrl: true,
906
905
  url: getFullUrl,
907
906
  }).then(() => {
908
907
  window.location.href = getFullUrl;
909
908
  });
910
909
  }
911
910
 
912
911
  toWxAppLogin(options = {}) {
913
912
  console.log('微信京购小程序中h5登录跳转', options);
914
913
  return Promise.resolve(true).then(() => {
915
914
  const { loginColor } = Object.assign(
916
915
  {},
917
916
  {
918
917
  loginColor: {
919
918
  biz: WXAPP_BIZ_KEY,
920
919
  dpin: 1,
921
920
  },
922
921
  },
923
922
  options,
924
923
  );
925
924
  window.location.href = `${domain.wq}/pinbind/pintokenredirect?biz=${
926
925
  loginColor.biz
927
926
  }&url=${encodeURIComponent(window.location.href)}`;
928
927
  });
929
928
  }
930
929
 
931
930
  getLoginCookie() {
932
931
  return Promise.resolve({
933
932
  pin: cookie.get('pin') || '',
934
933
  });
935
934
  }
936
935
 
937
936
  clearLoginCookie() {
938
937
  cookie.remove('pin');
939
938
  }
940
939
 
941
940
  checkStatusAndLogin(options = {}) {
942
941
  if (!this.checkStatusAndLoginPromise) {
943
942
  this.checkStatusAndLoginPromise = new Promise(async (resolve, reject) => {
944
943
  try {
945
944
  const getLoginState = await this.doCheckLoginStateAndForApiCheck(options);
946
945
  if (getLoginState) {
947
946
  resolve(true);
948
947
  } else {
949
948
  this.toLogin(options);
950
949
  reject(false);
951
950
  }
952
951
  } catch (e) {
953
952
  this.toLogin(options);
954
953
  reject(false);
955
954
  }
956
955
  });
957
956
  return this.checkStatusAndLoginPromise;
958
957
  } else {
959
958
  return this.checkStatusAndLoginPromise
960
959
  .then(() => {
961
960
  return Promise.resolve(true);
962
961
  })
963
962
  .catch(() => {
964
963
  this.toLogin(options);
965
964
  return Promise.reject(true);
966
965
  });
967
966
  }
968
967
  }
969
968
 
970
969
  checkJdStatusAndLogin(
971
970
  options = {
972
971
  loginColor: {
973
972
  biz: WXAPP_BIZ_SHOP_LIGHT_KEY,
974
973
  dpin: 0,
975
974
  },
976
975
  },
977
976
  ) {
978
977
  return this.checkStatusAndLogin(options);
979
978
  }
980
979
 
981
980
  doCheckLoginStateAndForApiCheck(options) {
982
981
  if (this.info.loginState) {
983
982
  return Promise.resolve(true);
984
983
  } else {
985
984
  return new Promise((resolve, reject) => {
986
985
  if (this.info.isJingGouMiniViewState || this.info.isJingxiMiniViewState) {
987
986
  const getWqAuthToken = cookie.get('wq_auth_token');
988
987
  const getWqSkey = cookie.get('wq_skey');
989
988
  const getWqUin = cookie.get('wq_uin');
990
989
  const isLoginState =
991
990
  options?.loginColor?.dpin === 0 ? getWqAuthToken : getWqSkey && getWqUin;
992
991
  if (isLoginState) {
993
992
  this.info.loginState = true;
994
993
  resolve(true);
995
994
  } else {
996
995
  reject(false);
997
996
  }
998
997
  } else {
999
998
  Taro.request({
1000
999
  url: api.isLogin,
1001
1000
  jsonp: true,
1002
1001
  timeout: 3000,
1003
1002
  success: (res) => {
1004
1003
  const { statusCode, data } = res;
1005
1004
  if (statusCode === 200 && data?.islogin && Number(data.islogin) === 1) {
1006
1005
  this.info.loginState = true;
1007
1006
  resolve(true);
1008
1007
  } else {
1009
1008
  reject(false);
1010
1009
  }
1011
1010
  },
1012
1011
  fail: (err) => {
1013
1012
  console.log('登录检查异常', err);
1014
1013
  reject(false);
1015
1014
  },
1016
1015
  });
1017
1016
  }
1018
1017
  });
1019
1018
  }
1020
1019
  }
1021
1020
 
1022
1021
  checkLoginStatus(options) {
1023
1022
  return new Promise(async (resolve, reject) => {
1024
1023
  try {
1025
1024
  const getLoginState = await this.doCheckLoginStateAndForApiCheck(options);
1026
1025
  if (getLoginState) {
1027
1026
  const { pin } = await this.getLoginCookie();
1028
1027
  this.info.userInfo = {
1029
1028
  pin,
1030
1029
  encodePin: encodeURIComponent(pin),
1031
1030
  ptkey: '',
1032
1031
  };
1033
1032
  resolve(true);
1034
1033
  } else {
1035
1034
  reject(false);
1036
1035
  }
1037
1036
  } catch (e) {
1038
1037
  reject(false);
1039
1038
  }
1040
1039
  });
1041
1040
  }
1042
1041
 
1043
1042
  updatePageAndLogInfo(updateQuery = {}) {
1044
1043
  const createUpdateQueryInfo: {
1045
1044
  query: {
1046
1045
  shopId?: string | number;
1047
1046
  venderId?: string | number;
1048
1047
  };
1049
1048
  updateShopInfoState: boolean;
1050
1049
  } = Object.assign(
1051
1050
  {},
1052
1051
  {
1053
1052
  query: {},
1054
1053
  updateShopInfoState: false,
1055
1054
  },
1056
1055
  updateQuery,
1057
1056
  );
1058
1057
  console.log(
1059
1058
  '获取当前下发的店铺查询参数',
1060
1059
  updateQuery,
1061
1060
  '获取之前保存的shopInfo店铺查询参数',
1062
1061
  this.info?.shopInfo,
1063
1062
  );
1064
1063
  const { query, updateShopInfoState } = createUpdateQueryInfo;
1065
1064
  const { shopId, venderId, un_area } = query;
1066
1065
  if (updateShopInfoState) {
1067
1066
  this.info.queryInfo = {
1068
1067
  ...this.info.queryInfo,
1069
1068
  ...query,
1070
1069
  };
1071
1070
  if (shopId && venderId) {
1072
1071
  this.info.shopInfo = {
1073
1072
  shopId: `${shopId}`,
1074
1073
  venderId: `${venderId}`,
1075
1074
  };
1076
1075
  }
1077
1076
  } else {
1078
1077
  this.info.queryInfo = {
1079
1078
  ...query,
1080
1079
  };
1081
1080
  if (
1082
1081
  this.info.shopInfo?.shopId &&
1083
1082
  this.info.shopInfo?.venderId &&
1084
1083
  (this.info.shopInfo.shopId == shopId || this.info.shopInfo.venderId == venderId)
1085
1084
  ) {
1086
1085
  this.info.queryInfo.shopId = this.info.shopInfo.shopId;
1087
1086
  this.info.queryInfo.venderId = this.info.shopInfo.venderId;
1088
1087
  console.log(
1089
1088
  '当前存储的店铺shopId和venderId与下发的店铺信息shopId或者venderId为同一个,补充shopId或者venderId查询参数',
1090
1089
  this.info.queryInfo,
1091
1090
  );
1092
1091
  }
1093
1092
  }
1094
1093
  this.info.queryInfo['shopId'] &&
1095
1094
  (this.info.queryInfo['shopId'] = `${this.info.queryInfo['shopId']}`);
1096
1095
  this.info.queryInfo['venderId'] &&
1097
1096
  (this.info.queryInfo['venderId'] = `${this.info.queryInfo['venderId']}`);
1098
1097
  console.log(
1099
1098
  'h5==获取店铺下发查询参数\n',
1100
1099
  query,
1101
1100
  '\n获取店铺最后查询参数\n',
1102
1101
  this.info.queryInfo,
1103
1102
  '\n是否为更新店铺状态\n',
1104
1103
  updateShopInfoState,
1105
1104
  );
1106
1105
  const changeArea = un_area && un_area.length > 0 ? un_area : ipLoc_djd ? ipLoc_djd : '';
1107
1106
  if (changeArea) {
1108
1107
  this.info.pageInfo.address = changeArea;
1109
1108
  this.info.pageInfo.un_area = changeArea;
1110
1109
  this.info.pageInfo.addressCommaStr = changeArea.replace(/_/g, ',');
1111
1110
  }
1112
1111
  }
1113
1112
 
1114
1113
  dealLoadSdkList() {
1115
1114
  const globalLoadJsList = window?.shopGlobalSwitch?.asyncLoadJsList ?? [];
1116
1115
  const businessLoadJsList = window?.PAGE_DATA?.businessData?.asyncLoadJsList ?? [];
1117
1116
  const concatLoadJsList = [].concat(globalLoadJsList, businessLoadJsList);
1118
1117
  let mergeLoadJsList = globalLoadJsList;
1119
1118
  try {
1120
1119
  mergeLoadJsList = concatLoadJsList.reduce((accArr: any[], current: any) => {
1121
1120
  const getFindIndex = accArr.findIndex((item) => item?.fileName === current?.fileName);
1122
1121
  getFindIndex !== -1
1123
1122
  ? (accArr[getFindIndex] = { ...accArr[getFindIndex], ...current })
1124
1123
  : accArr.push(current);
1125
1124
  return accArr;
1126
1125
  }, []);
1127
1126
  } catch (e) {
1128
1127
  console.log('LoadJsList合并错误', e);
1129
1128
  }
1130
1129
  console.log(
1131
1130
  'globalLoadJsList',
1132
1131
  globalLoadJsList,
1133
1132
  'businessLoadJsList',
1134
1133
  businessLoadJsList,
1135
1134
  '两个加载jsList集合合并完成',
1136
1135
  mergeLoadJsList,
1137
1136
  );
1138
1137
  this.loadJsSdkList = mergeLoadJsList;
1139
1138
  return this.loadJsSdkList;
1140
1139
  }
1141
1140
 
1142
1141
  renderNextTickLoadSdk() {
1143
1142
  Taro.nextTick(() => {
1144
1143
  console.log(
1145
1144
  '页面渲染的下一帧执行的js加载方法,当前nextTick存在state的渲染问题,先延迟1s=======',
1146
1145
  );
1147
1146
  setTimeout(() => {
1148
1147
  this.loadOtherSdk(LoadJsInitTriggerType.NRXT_TICK, this.loadJsSdkList);
1149
1148
  }, 1000);
1150
1149
  });
1151
1150
  }
1152
1151
 
1153
1152
  loadOtherSdk(triggerType = LoadJsInitTriggerType.NOW, loadJsList: any[] = []) {
1154
1153
  const getLoadJsList =
1155
1154
  Array.isArray(loadJsList) && loadJsList.length > 0 ? loadJsList : this.dealLoadSdkList();
1156
1155
  const getLoadFilterList = getLoadJsList.filter((item) => {
1157
1156
  const getInitLoadEnvType = item?.initLoadEnvType || LoadJsInitLoadEnvType.ALL;
1158
1157
  let getLoastLoadEventState = true;
1159
1158
  if (getInitLoadEnvType === LoadJsInitLoadEnvType.JD_APP) {
1160
1159
  getLoastLoadEventState = isJdApp;
1161
1160
  }
1162
1161
  else if (getInitLoadEnvType === LoadJsInitLoadEnvType.M) {
1163
1162
  getLoastLoadEventState = !isJdApp || !!isJdAndHarmonyDevice;
1164
1163
  }
1165
1164
  const getInitTriggerType =
1166
1165
  isJdApp && item?.initJdAppTriggerType
1167
1166
  ? item?.initTriggerType
1168
1167
  : item?.initTriggerType || LoadJsInitTriggerType.NOW;
1169
1168
  const getInitLinkTriggerWay = window?.PAGE_DATA[item?.initLinkTriggerWay] || false;
1170
1169
  return getLoastLoadEventState && getInitTriggerType === triggerType && getInitLinkTriggerWay;
1171
1170
  });
1172
1171
  console.log(
1173
1172
  '获取当前触发方式',
1174
1173
  triggerType,
1175
1174
  '获取当前最后加载的js集合',
1176
1175
  getLoadFilterList,
1177
1176
  '过滤前的加载集合',
1178
1177
  getLoadJsList,
1179
1178
  );
1180
1179
  getLoadFilterList.length > 0 &&
1181
1180
  getLoadFilterList.forEach((item) => {
1182
1181
  const isLoadState = /sgm/.test(item?.fileName)
1183
1182
  ? window?.shopGlobalSwitch?.openSgm === 'true'
1184
1183
  : true;
1185
1184
  isLoadState &&
1186
1185
  this.loadItemSdkPromise(item)
1187
1186
  .then((res) => {
1188
1187
  console.info('当前js地址' + item?.src, '加载状态', res);
1189
1188
  const isFileNameNewDraSdkJs = res?.fileName === 'newDraSdkJs';
1190
1189
  if (isFileNameNewDraSdkJs && window?.dra?.run) {
1191
1190
  window.dra.run('init', { aid: res?.aid });
1192
1191
  window.dra.run('start');
1193
1192
  }
1194
1193
  })
1195
1194
  .catch((err) => {
1196
1195
  console.info('当前js地址加载异常', item?.src);
1197
1196
  window?.fetchErrorData &&
1198
1197
  window.fetchErrorData({
1199
1198
  title: '公共js加载异常',
1200
1199
  type: 'jsLoad',
1201
1200
  data: err,
1202
1201
  });
1203
1202
  });
1204
1203
  });
1205
1204
  }
1206
1205
  loadScriptEle(jsInfo, resolve, reject) {
1207
1206
  const getFileName = jsInfo?.fileName;
1208
1207
  if (getFileName) {
1209
1208
  const getEleId = `J_loadJs_${getFileName}`;
1210
1209
  const getEle = document.getElementById(getEleId);
1211
1210
  if (!getEle) {
1212
1211
  const jsLoadErrorSgmCode = `jsLoadError_${jsInfo?.fileName || 'customJs'}`;
1213
1212
  const _sgmEle = document.createElement('script');
1214
1213
  _sgmEle.id = getEleId;
1215
1214
  _sgmEle.onload = function () {
1216
1215
  resolve({
1217
1216
  ...jsInfo,
1218
1217
  jsTip: 'js加载成功',
1219
1218
  });
1220
1219
  };
1221
1220
  _sgmEle.onerror = function () {
1222
1221
  reject({
1223
1222
  ...jsInfo,
1224
1223
  env: getSgmCustomCode(jsLoadErrorSgmCode),
1225
1224
  jsReqError: '当前js创建标签触发onerror异常回调,请排查网络络错误或语法错误或运行时错误',
1226
1225
  });
1227
1226
  };
1228
1227
  const dataAttrList = ['timeout', 'fileName', 'env'];
1229
1228
  const getJsInfoKeyList = Object.keys(jsInfo);
1230
1229
  getJsInfoKeyList.forEach((key) => {
1231
1230
  if (key === 'async') {
1232
1231
  _sgmEle.async = jsInfo[key];
1233
1232
  } else if (key === 'crossOrigin') {
1234
1233
  _sgmEle.crossOrigin = jsInfo[key];
1235
1234
  } else if (key === 'src') {
1236
1235
  _sgmEle.src = `${jsInfo[key]}`;
1237
1236
  } else if (dataAttrList.includes(key) || /init/.test(key)) {
1238
1237
  _sgmEle.setAttribute(`data-${key}`, jsInfo[key]);
1239
1238
  } else {
1240
1239
  _sgmEle.setAttribute(key, jsInfo[key]);
1241
1240
  }
1242
1241
  });
1243
1242
  document.head.appendChild(_sgmEle);
1244
1243
  } else {
1245
1244
  console.log(`当前${jsInfo?.fileName || 'js'}已经存在页面中,可以直接调用相关方法`, jsInfo);
1246
1245
  resolve({
1247
1246
  ...jsInfo,
1248
1247
  jsTip: 'js本身已存在页面中',
1249
1248
  });
1250
1249
  }
1251
1250
  } else {
1252
1251
  console.warn('当前js资源信息缺少必要的参数fileName,请关注', jsInfo);
1253
1252
  }
1254
1253
  }
1255
1254
 
1256
1255
  loadItemSdkPromise(jsInfo = {}) {
1257
1256
  if (jsInfo?.src) {
1258
1257
  const getInitLoadType =
1259
1258
  isJdApp && jsInfo?.initJdAppLoadType
1260
1259
  ? jsInfo?.initJdAppLoadType
1261
1260
  : jsInfo?.initLoadType || LoadJsInitLoadType.ALL;
1262
1261
  if (getInitLoadType !== LoadJsInitLoadType.NONE) {
1263
1262
  const getFileKeyName = jsInfo?.fileName || jsInfo?.src;
1264
1263
  if (!this.loadJsSdkListCachePromise[getFileKeyName]) {
1265
1264
  if (getInitLoadType !== LoadJsInitLoadType.INSERT_ELE) {
1266
1265
  this.loadJsSdkListCachePromise[getFileKeyName] = new Promise((resolve, reject) => {
1267
1266
  const jsLoadErrorSgmCode = `jsLoadError_${jsInfo?.fileName || 'customJs'}`;
1268
1267
  try {
1269
1268
  const jsXhrRequest = new XMLHttpRequest();
1270
1269
  jsXhrRequest.timeout = jsInfo?.timeout ?? 2000;
1271
1270
  const jsUrl = `${jsInfo?.src}`;
1272
1271
  jsXhrRequest.open('GET', jsUrl, true);
1273
1272
  jsXhrRequest.onreadystatechange = () => {
1274
1273
  if (jsXhrRequest.readyState === 4) {
1275
1274
  const getReqStatus = jsXhrRequest.status;
1276
1275
  if ((getReqStatus >= 200 && getReqStatus < 300) || getReqStatus === 304) {
1277
1276
  const getInsetHeadState = getInitLoadType === LoadJsInitLoadType.ALL;
1278
1277
  if (getInsetHeadState) {
1279
1278
  this.loadScriptEle(jsInfo, resolve, reject);
1280
1279
  } else {
1281
1280
  resolve({
1282
1281
  ...jsInfo,
1283
1282
  jsTip: 'js请求成功,暂未插入head节点,业务自行单独插入',
1284
1283
  });
1285
1284
  }
1286
1285
  getReqStatus !== 200 &&
1287
1286
  sgmCustomReport({
1288
1287
  type: 3,
1289
1288
  code: 'js_load_special_code',
1290
1289
  msg: {
1291
1290
  msg: '当前js加载成功,状态非200,特殊上报观察',
1292
1291
  jsReqState: getReqStatus,
1293
1292
  env: getSgmCustomCode('js_load_special_code'),
1294
1293
  data: jsInfo,
1295
1294
  },
1296
1295
  });
1297
1296
  } else {
1298
1297
  const getRes = {
1299
1298
  ...jsInfo,
1300
1299
  env: getSgmCustomCode(jsLoadErrorSgmCode),
1301
1300
  jsReqError: `请求状态异常,状态码为${getReqStatus}`,
1302
1301
  jsReqState: getReqStatus,
1303
1302
  };
1304
1303
  console.log('当前js请求状态异常,具体信息见', getRes);
1305
1304
  reject(getRes);
1306
1305
  }
1307
1306
  }
1308
1307
  };
1309
1308
  jsXhrRequest.onerror = () => {
1310
1309
  const getRes = {
1311
1310
  ...jsInfo,
1312
1311
  env: getSgmCustomCode(jsLoadErrorSgmCode),
1313
1312
  jsReqError: '请求错误',
1314
1313
  };
1315
1314
  console.log('当前js请求错误', getRes);
1316
1315
  jsXhrRequest.abort();
1317
1316
  reject(getRes);
1318
1317
  };
1319
1318
  jsXhrRequest.ontimeout = () => {
1320
1319
  const getRes = {
1321
1320
  ...jsInfo,
1322
1321
  env: getSgmCustomCode(jsLoadErrorSgmCode),
1323
1322
  jsReqError: `请求${jsXhrRequest.timeout}ms超时异常`,
1324
1323
  jsReqState: jsXhrRequest.status,
1325
1324
  };
1326
1325
  console.log('当前js请求超时异常', getRes);
1327
1326
  jsXhrRequest.abort();
1328
1327
  reject(getRes);
1329
1328
  };
1330
1329
  jsXhrRequest.send();
1331
1330
  } catch (e) {
1332
1331
  console.log('执行js请求异常', e);
1333
1332
  reject({
1334
1333
  ...jsInfo,
1335
1334
  env: getSgmCustomCode(jsLoadErrorSgmCode),
1336
1335
  jsReqError: '未知异常',
1337
1336
  error: e,
1338
1337
  });
1339
1338
  }
1340
1339
  });
1341
1340
  } else {
1342
1341
  this.loadJsSdkListCachePromise[getFileKeyName] = new Promise((resolve, reject) => {
1343
1342
  return this.loadScriptEle(jsInfo, resolve, reject);
1344
1343
  });
1345
1344
  }
1346
1345
  }
1347
1346
  return this.loadJsSdkListCachePromise[getFileKeyName];
1348
1347
  } else {
1349
1348
  return Promise.resolve({
1350
1349
  ...jsInfo,
1351
1350
  jsTip: 'js加载方式设置为不加载,当前不做处理',
1352
1351
  });
1353
1352
  }
1354
1353
  } else {
1355
1354
  return Promise.reject(jsInfo);
1356
1355
  }
1357
1356
  }
1357
+ import Taro from '@tarojs/taro';
1358
1358
  dealNativePixelToCssPixel,
1359
1359
  isAndroidDevice,
1360
1360
  isIosDevice,
1361
1361
  isJdAndAndroidDevice,
1362
1362
  isJdAndHarmonyDevice,
1363
1363
  isObject,
1364
1364
  isPc,
1365
1365
  isString,
1366
1366
  jdAppVersion,
1367
1367
  jdAppVersionStr,
1368
1368
  serialize,
1369
1369
  draBusinessCustomReport,
1370
1370
  BUSINESS_TYPE,
1371
1371
  LoadJsInitLoadEnvType,
1372
1372
  LoadJsInitLoadType,
1373
1373
  LoadJsInitTriggerType,
1374
1374
  MPAAS_CONFIG_APP_LOW_VERSION,
1375
1375
  MPAAS_CONFIG_APP_VERSION,
1376
1376
  SECTION_HOME_TAB_NAME_TYPE,
1377
1377
  SECTION_HOME_TAB_TYPE,
1378
1378
  TaroEventType,
1379
1379
  WX_BUSINESS_TYPE,
1380
1380
  WXAPP_BIZ_KEY,
1381
1381
  WXAPP_BIZ_SHOP_LIGHT_KEY,
1382
1382
  JSSDK_APP_WEBVIEW_CODE,
1383
1383
  getSystemInfos,
1384
1384
  getTaroStorageKeyValue,
1385
1385
  ipLoc_djd,
1386
1386
  setTaroStorage,
1387
1387
  sgmCustomReport,
1388
1388
  abTestLabels: {},
1389
1389
  nonSellableSkuids: {},
1390
1390
  loginState: false,
1391
1391
  cookiesStr: '',
1392
1392
  userInfo: userPinKey,
1393
1393
  isJingGouMiniViewState: false,
1394
1394
  isJingxiMiniViewState: false,
1395
1395
  pageInfo: {
1396
1396
  wxBusinessType: WX_BUSINESS_TYPE.NO,
1397
1397
  address: '',
1398
1398
  addressCommaStr: '',
1399
1399
  un_area: '',
1400
1400
  vapptype: '1',
1401
1401
  pageType: 'home',
1402
1402
  isExposureState: false,
1403
1403
  moduleId: '',
1404
1404
  entrance: '',
1405
1405
  dataType: BUSINESS_TYPE.ONLINE,
1406
1406
  floorExposureInfo: {},
1407
1407
  floorVideInfo: {},
1408
1408
  productVideInfo: {},
1409
1409
  tabsLoadAllDataInfo: {
1410
1410
  [SECTION_HOME_TAB_NAME_TYPE[SECTION_HOME_TAB_TYPE.HOME_WELL_CHOSEN]]: false,
1411
1411
  },
1412
1412
  updateShopInfosAllState: false,
1413
1413
  isVipShop: false,
1414
1414
  isJdShowNativeImmersivePlayer: false,
1415
1415
  ...shopConfig,
1416
1416
  pageScrollTop: 0,
1417
1417
  pageIdxHeightInfo: {
1418
1418
  list: [],
1419
1419
  },
1420
1420
  shopNavBarHeight: 0,
1421
1421
  },
1422
1422
  defaultQueryLogInfo: {
1423
1423
  sourceType: 'JDshop',
1424
1424
  sourceValue: '',
1425
1425
  moduleId: 'none',
1426
1426
  entrance: 'none',
1427
1427
  },
1428
1428
  sysInfo: {
1429
1429
  windowWidth: isPc ? 375 : 0,
1430
1430
  containerWidth: isPc ? 375 : 0,
1431
1431
  windowHeight: 0,
1432
1432
  netWorkType: '4g',
1433
1433
  jdBottomBarHeight: 0,
1434
1434
  jdNativeHeaderHeight: 0,
1435
1435
  isJdTabletDevice: false,
1436
1436
  isJdTabletLandscape: false,
1437
1437
  },
1438
1438
  queryInfo: {},
1439
1439
  shopInfo: {},
1440
1440
  openAppData: {},
1441
1441
  public info: CommonInterFace.BaseConfigInfo;
1442
1442
  public config: {
1443
1443
  [key: string]: any;
1444
1444
  };
1445
1445
  public lazyContainer: CommonInterFace.lazyContainer;
1446
1446
  public renderedIsvComponents: CommonInterFace.renderedIsvComponents;
1447
1447
  public rootEleNode: HTMLElement | null;
1448
1448
  public checkStatusAndLoginPromise: object | null;
1449
1449
  private jmfeRegisterStatePromise: Promise<any> | null;
1450
1450
  private jdScreenSizeInfoPromise: Promise<any> | null;
1451
1451
  private rootEleWidthRegisterPromise: Promise<any> | null;
1452
1452
  private jmfeRegisterState: boolean;
1453
1453
  public loadJsSdkList: Array<any>;
1454
1454
  public loadJsSdkListCachePromise: any;
1455
1455
  public rootEleInitWidth: number;
1456
1456
  constructor(opt) {
1457
1457
  this.info = this._getConfig(opt);
1458
1458
  this.config = {};
1459
1459
  this.loadJsSdkList = [];
1460
1460
  this.loadJsSdkListCachePromise = {};
1461
1461
  this.lazyContainer = {
1462
1462
  [SECTION_HOME_TAB_NAME_TYPE[SECTION_HOME_TAB_TYPE.HOME_WELL_CHOSEN]]: {
1463
1463
  appLazyContainerList: [],
1464
1464
  appLazyFinishContainerList: [],
1465
1465
  },
1466
1466
  [SECTION_HOME_TAB_NAME_TYPE[SECTION_HOME_TAB_TYPE.HOME_PROMOTION]]: {
1467
1467
  appLazyContainerList: [],
1468
1468
  appLazyFinishContainerList: [],
1469
1469
  },
1470
1470
  };
1471
1471
  this.renderedIsvComponents = {};
1472
1472
  this.rootEleNode = document.querySelector('body');
1473
1473
  this.checkStatusAndLoginPromise = null;
1474
1474
  this.jmfeRegisterStatePromise = null;
1475
1475
  this.jdScreenSizeInfoPromise = null;
1476
1476
  this.rootEleWidthRegisterPromise = null;
1477
1477
  this.rootEleInitWidth = this.getRootEleWindowWidthInfo().getRootEleWidth || -1;
1478
1478
  this.loadOtherSdk();
1479
1479
  if (isJdApp) {
1480
1480
  this.jmfeReayPromise();
1481
1481
  this._getJdPadMinWidthForListen() && this.getPadWindowRootEleWidthPromise();
1482
1482
  }
1483
1483
  }
1484
1484
  _getConfig(opt) {
1485
1485
  return Object.assign({}, DefaultConfig, opt);
1486
1486
  }
1487
1487
  _getJdPadMinWidthForListen() {
1488
1488
  return (
1489
1489
  isJdApp &&
1490
1490
  Math.min(window.screen.width, window.screen.height) >
1491
1491
  (window?.shopGlobalSwitch?.checkPadRootEleMinWidth || 600)
1492
1492
  );
1493
1493
  }
1494
1494
 
1495
1495
  jmfeReayPromise(): Promise<any> {
1496
1496
  if (isJdApp) {
1497
1497
  if (this.jmfeRegisterState) {
1498
1498
  return Promise.resolve(true);
1499
1499
  } else {
1500
1500
  !this.jmfeRegisterStatePromise &&
1501
1501
  (this.jmfeRegisterStatePromise = new Promise((resolve, reject) => {
1502
1502
  ready('jmfe', 3000)
1503
1503
  .then(() => {
1504
1504
  window?.jmfe && window.jmfe.registerCode(JSSDK_APP_WEBVIEW_CODE);
1505
1505
  this.jmfeRegisterState = true;
1506
1506
  resolve(true);
1507
1507
  console.log('松果app内初始化注册jmfe认证完成');
1508
1508
  })
1509
1509
  .catch((err) => {
1510
1510
  console.error('jmfe ready error', err);
1511
1511
  reject(false);
1512
1512
  });
1513
1513
  }));
1514
1514
  return this.jmfeRegisterStatePromise;
1515
1515
  }
1516
1516
  } else {
1517
1517
  return Promise.reject(false);
1518
1518
  }
1519
1519
  }
1520
1520
 
1521
1521
  getJdScreenSizeInfoPromise() {
1522
1522
  !this.jdScreenSizeInfoPromise &&
1523
1523
  (this.jdScreenSizeInfoPromise = new Promise((resolve) => {
1524
1524
  const getThisTime = Date.now();
1525
1525
  this.jmfeReayPromise().then(() => {
1526
1526
  return Promise.race([
1527
1527
  window.jmfe.getScreenSize(),
1528
1528
  this.taskTimeoutPromise(() => {
1529
1529
  return {
1530
1530
  status: '-10',
1531
1531
  msg: '获取大屏信息2s超时',
1532
1532
  };
1533
1533
  }),
1534
1534
  ])
1535
1535
  .then((res) => {
1536
1536
  console.warn('===获取app大屏信息====', res);
1537
1537
  const { status, data } = res;
1538
1538
  if (status === '0' && data) {
1539
1539
  const { sizeType, isLandscape, pageHeight, pageWidth } = data;
1540
1540
  const getPageInfo = dealNativePixelToCssPixel({
1541
1541
  pageWidth,
1542
1542
  pageHeight,
1543
1543
  });
1544
1544
  this.info.sysInfo.jdScreenSizeType = sizeType;
1545
1545
  const getUseTime = Date.now() - getThisTime;
1546
1546
  console.warn(
1547
1547
  '===计算是否是app大屏信息,需满足宽度最新720===',
1548
1548
  getPageInfo,
1549
1549
  '原始数据',
1550
1550
  data,
1551
1551
  '是否是横屏isLandscape为1=',
1552
1552
  isLandscape,
1553
1553
  '用时',
1554
1554
  getUseTime,
1555
1555
  );
1556
1556
  if (getPageInfo?.pageWidth > 0) {
1557
1557
  this.rootEleInitWidth = getPageInfo?.pageWidth;
1558
1558
  draBusinessCustomReport({
1559
1559
  type: 'rootEle_width_getJdScreenSizeInfo',
1560
1560
  errMsg: `根元素获取宽度初始化为0,通过getJdScreenSizeInfo获取结果,用时${getUseTime}`,
1561
1561
  originReqDataStr: JSON.stringify({
1562
1562
  isJdApp,
1563
1563
  getPageInfo,
1564
1564
  originData: res,
1565
1565
  }),
1566
1566
  });
1567
1567
  resolve(getPageInfo);
1568
1568
  } else {
1569
1569
  resolve({
1570
1570
  pageWidth: 0,
1571
1571
  pageHeight: 0,
1572
1572
  msg: '转换异常',
1573
1573
  });
1574
1574
  }
1575
1575
  } else {
1576
1576
  resolve({
1577
1577
  pageWidth: 0,
1578
1578
  pageHeight: 0,
1579
1579
  msg: '获取大屏信息异常或者超时',
1580
1580
  });
1581
1581
  }
1582
1582
  })
1583
1583
  .catch((err) => {
1584
1584
  console.log('获取大屏信息异常', err);
1585
1585
  resolve({
1586
1586
  pageWidth: 0,
1587
1587
  pageHeight: 0,
1588
1588
  msg: '获取大屏信息异常',
1589
1589
  });
1590
1590
  });
1591
1591
  });
1592
1592
  }));
1593
1593
  return this.jdScreenSizeInfoPromise;
1594
1594
  }
1595
1595
 
1596
1596
  listenJdTabletScreenChange() {
1597
1597
  this.jmfeReayPromise().then(() => {
1598
1598
  try {
1599
1599
  console.log('初始化监听大屏信息变化', window.jmfe.listenDeviceScreenChange);
1600
1600
  window.jmfe.listenDeviceScreenChange((event) => {
1601
1601
  console.log(
1602
1602
  '监听app大屏信息变化,orientation为landscape表示横屏,multiScreen为1表示android端分屏',
1603
1603
  event,
1604
1604
  '通过前端判断是不是横屏',
1605
1605
  window.matchMedia('(orientation: landscape)')?.matches,
1606
1606
  );
1607
1607
  const { orientation } = event?.data;
1608
1608
  if (orientation) {
1609
1609
  this.info.sysInfo.isJdTabletLandscape = orientation === 'landscape';
1610
1610
  Taro.eventCenter.trigger(
1611
1611
  TaroEventType.TABLE_SCREEN_CHANGE,
1612
1612
  this.info.sysInfo.isJdTabletLandscape,
1613
1613
  orientation,
1614
1614
  );
1615
1615
  }
1616
1616
  });
1617
1617
  } catch (error) {
1618
1618
  console.log('listenScreenChange的打印error:', error);
1619
1619
  }
1620
1620
  });
1621
1621
  }
1622
1622
 
1623
1623
  updateBusinessDomainAndApi(domain, api) {
1624
1624
  }
1625
1625
 
1626
1626
  formatNativeScreenPageData(action) {
1627
1627
  let getChangePageInfo: any = null;
1628
1628
  try {
1629
1629
  const getNativeScreenPageInfoStr = window.XWebView?._callNative(
1630
1630
  JSON.stringify({
1631
1631
  plugin: 'JDHybridScreenPlugin',
1632
1632
  action,
1633
1633
  sync: '1',
1634
1634
  }),
1635
1635
  );
1636
1636
  const getChangePageInfoData =
1637
1637
  typeof getNativeScreenPageInfoStr === 'string'
1638
1638
  ? JSON.parse(getNativeScreenPageInfoStr)
1639
1639
  : null;
1640
1640
  if (getChangePageInfoData && typeof getChangePageInfoData === 'object') {
1641
1641
  const { code, data } = getChangePageInfoData;
1642
1642
  getChangePageInfo = code && code === '0' ? data : null;
1643
1643
  }
1644
1644
  } catch (e) {
1645
1645
  console.log('JDHybridScreenPlugin转换异常', e);
1646
1646
  }
1647
1647
  return getChangePageInfo;
1648
1648
  }
1649
1649
 
1650
1650
  isAndroidFoldScreen() {
1651
1651
  return this.formatNativeScreenPageData('isFoldScreen') === '1';
1652
1652
  }
1653
1653
 
1654
1654
  getJdAndroidPageChangeScreenInfo() {
1655
1655
  const getPageScreenInfo = this.formatNativeScreenPageData('getScreenSize');
1656
1656
  if (getPageScreenInfo && getPageScreenInfo?.pageWidth && getPageScreenInfo?.pageHeight) {
1657
1657
  const { pageWidth, pageHeight } = dealNativePixelToCssPixel({
1658
1658
  pageWidth: getPageScreenInfo.pageWidth,
1659
1659
  pageHeight: getPageScreenInfo.pageHeight,
1660
1660
  });
1661
1661
  getPageScreenInfo.pageWidth = pageWidth;
1662
1662
  getPageScreenInfo.pageHeight = pageHeight;
1663
1663
  }
1664
1664
  return getPageScreenInfo;
1665
1665
  }
1666
1666
 
1667
1667
  getRootEleWindowWidthInfo() {
1668
1668
  const getRootEleWidth = document.documentElement.getBoundingClientRect().width;
1669
1669
  const getWindowWidth = window.innerWidth;
1670
1670
  const getScreenWidth = window.screen.width;
1671
1671
  return {
1672
1672
  getRootEleWidth,
1673
1673
  getWindowWidth,
1674
1674
  getScreenWidth,
1675
1675
  };
1676
1676
  }
1677
1677
 
1678
1678
  dealRootEleWidthFn(reportParam = {}, timeout = 0) {
1679
1679
  const { getRootEleWidth, getWindowWidth, getScreenWidth } = this.getRootEleWindowWidthInfo();
1680
1680
  console.log(
1681
1681
  '当前获取根元素的宽度',
1682
1682
  getRootEleWidth,
1683
1683
  'getWindowWidth',
1684
1684
  getWindowWidth,
1685
1685
  'getScreenWidth',
1686
1686
  getScreenWidth,
1687
1687
  );
1688
1688
  const getLastWidth =
1689
1689
  getRootEleWidth > 0
1690
1690
  ? Math.round(getRootEleWidth)
1691
1691
  : Math.round(getWindowWidth > 0 ? getWindowWidth : getScreenWidth);
1692
1692
  console.warn(
1693
1693
  `根元素获取宽度初始化为0,通过getJdScreenSizeInfo获取结果超时,超时时间超时时间${timeout}ms,最终兜底再获取一次根元素宽度${getLastWidth}`,
1694
1694
  );
1695
1695
  timeout > 0 &&
1696
1696
  draBusinessCustomReport({
1697
1697
  type: 'rootEle_width_timeout_getJdScreenSizeInfo',
1698
1698
  errMsg: `根元素获取宽度初始化为0,通过getJdScreenSizeInfo获取结果超时,超时时间${timeout}ms,最终兜底再获取一次根元素宽度${getLastWidth}`,
1699
1699
  originReqDataStr: JSON.stringify({
1700
1700
  isJdApp,
1701
1701
  getRootEleWidth,
1702
1702
  getWindowWidth,
1703
1703
  getScreenWidth,
1704
1704
  ...reportParam,
1705
1705
  }),
1706
1706
  });
1707
1707
  return getLastWidth;
1708
1708
  }
1709
1709
 
1710
1710
  getPadWindowRootEleWidthPromise() {
1711
1711
  if (this.rootEleInitWidth > 0) {
1712
1712
  return Promise.resolve(this.rootEleInitWidth);
1713
1713
  } else {
1714
1714
  !this.rootEleWidthRegisterPromise &&
1715
1715
  (this.rootEleWidthRegisterPromise = new Promise((resolve) => {
1716
1716
  const getRootEleInitWidth = this.getRootEleWindowWidthInfo().getRootEleWidth;
1717
1717
  if (getRootEleInitWidth > 0) {
1718
1718
  console.log('初始化获取根元素宽度正常,为', getRootEleInitWidth);
1719
1719
  this.rootEleInitWidth = Math.round(getRootEleInitWidth);
1720
1720
  resolve(this.rootEleInitWidth);
1721
1721
  } else {
1722
1722
  const timerPromise = () => {
1723
1723
  return new Promise((resolve2) => {
1724
1724
  window.setTimeout(() => {
1725
1725
  const { getRootEleWidth, getWindowWidth, getScreenWidth } =
1726
1726
  this.getRootEleWindowWidthInfo();
1727
1727
  if (getRootEleWidth > 0 || getWindowWidth > 0) {
1728
1728
  console.warn(
1729
1729
  `根元素获取宽度初始化为0,200ms后尝试获取最新结果,getRootEleWidth为${getRootEleWidth},getWindowWidth为${getWindowWidth},getScreenWidth为${getScreenWidth}`,
1730
1730
  );
1731
1731
  draBusinessCustomReport({
1732
1732
  type: 'rootEle_width_200_timeout_info',
1733
1733
  errMsg: `根元素获取宽度初始化为0,200ms后尝试获取最新结果,getRootEleWidth为${getRootEleWidth},getWindowWidth为${getWindowWidth}`,
1734
1734
  originReqDataStr: JSON.stringify({
1735
1735
  isJdApp,
1736
1736
  getRootEleWidth,
1737
1737
  getWindowWidth,
1738
1738
  getScreenWidth,
1739
1739
  }),
1740
1740
  });
1741
1741
  const getRes =
1742
1742
  getRootEleWidth > 0 && getWindowWidth > 0
1743
1743
  ? Math.min(getRootEleWidth, getWindowWidth)
1744
1744
  : Math.max(getRootEleWidth, getWindowWidth);
1745
1745
  resolve2({
1746
1746
  pageWidth: Math.round(getRes),
1747
1747
  });
1748
1748
  }
1749
1749
  }, 200);
1750
1750
  });
1751
1751
  };
1752
1752
  Promise.race([timerPromise(), this.getJdScreenSizeInfoPromise()]).then((res) => {
1753
1753
  const { pageWidth } = res;
1754
1754
  console.log('获取结果Promise.race getJdScreenSizeInfo', res);
1755
1755
  pageWidth > 0 ? resolve(pageWidth) : resolve(this.dealRootEleWidthFn(res, 2000));
1756
1756
  });
1757
1757
  }
1758
1758
  }));
1759
1759
  return this.rootEleWidthRegisterPromise;
1760
1760
  }
1761
1761
  }
1762
1762
 
1763
1763
  async getSystemInfo(params) {
1764
1764
  const getParams = Object.assign({}, params || {});
1765
1765
  if (this.rootEleInitWidth > 0) {
1766
1766
  getParams['rootEleInitWidth'] = this.rootEleInitWidth;
1767
1767
  console.log('获取当前系统信息的时候已经获取到根元素宽度,值为', this.rootEleInitWidth);
1768
1768
  } else {
1769
1769
  if (this._getJdPadMinWidthForListen()) {
1770
1770
  getParams['rootEleInitWidth'] = await this.getPadWindowRootEleWidthPromise();
1771
1771
  getParams['replaceSystemWidth'] = true;
1772
1772
  }
1773
1773
  }
1774
1774
  let info: UtilsInterFace.taroGetSystemInfoSyncRes | any = getSystemInfos(getParams);
1775
1775
  if (isJdAndAndroidDevice && info?.initWindowWidth <= 0) {
1776
1776
  let _isfoldScreen = false;
1777
1777
  const getStorageData = getTaroStorageKeyValue('jd_shopx_androidIsFoldScreen');
1778
1778
  console.info(
1779
1779
  '获取当前本地存储是否有jd_shopx_androidIsFoldScreen',
1780
1780
  getStorageData,
1781
1781
  '通过缓存值第一次判断是否是折叠屏',
1782
1782
  getStorageData === 'true',
1783
1783
  );
1784
1784
  if (!getStorageData) {
1785
1785
  _isfoldScreen = this.isAndroidFoldScreen();
1786
1786
  setTaroStorage('jd_shopx_androidIsFoldScreen', `${_isfoldScreen}`);
1787
1787
  } else {
1788
1788
  _isfoldScreen = getStorageData === 'true';
1789
1789
  }
1790
1790
  if (_isfoldScreen) {
1791
1791
  const getJdAndroidPageInfo = this.getJdAndroidPageChangeScreenInfo();
1792
1792
  if (getJdAndroidPageInfo) {
1793
1793
  info = getSystemInfos(getJdAndroidPageInfo);
1794
1794
  console.warn(
1795
1795
  '当前为松果安卓折叠屏app,获取折叠屏信息',
1796
1796
  getJdAndroidPageInfo,
1797
1797
  '获取转换后的系统信息',
1798
1798
  info,
1799
1799
  );
1800
1800
  sgmCustomReport({
1801
1801
  type: 2,
1802
1802
  code: 'android_jdapp_foldScreen_info',
1803
1803
  msg: {
1804
1804
  title: `松果安卓app为折叠屏,重置获取的系统宽高信息,因为获取宽高度信息初始化内部可能存在横竖屏差异`,
1805
1805
  androidPageInfo: getJdAndroidPageInfo,
1806
1806
  jdAppVersionStr,
1807
1807
  taroSysInfo: info,
1808
1808
  },
1809
1809
  });
1810
1810
  }
1811
1811
  }
1812
1812
  }
1813
1813
  if (isJdApp) {
1814
1814
  info?.isJdTabletDevice && this.listenJdTabletScreenChange();
1815
1815
  }
1816
1816
  this.info.sysInfo = {
1817
1817
  actualNavBarHeight: 0,
1818
1818
  ...this.info.sysInfo,
1819
1819
  ...info,
1820
1820
  safeContentHeight: info?.screenHeight,
1821
1821
  headerHeight: 0,
1822
1822
  tabBarHeight: 0,
1823
1823
  };
1824
1824
  if (isJdApp) {
1825
1825
  this.info.sysInfo['hostVersionName'] = jdAppVersionStr;
1826
1826
  this.info.sysInfo['hostAppVersion'] = jdAppVersion;
1827
1827
  this.getAddressCachePromise();
1828
1828
  this.getElderModePromise();
1829
1829
  this.getJDAppearanceStatePromise();
1830
1830
  this.createJdAndroidRquestEventForTouchStart();
1831
1831
  }
1832
1832
  this.getWifiVideoAutoPlayAsync();
1833
1833
  this.getMPaasConfigAsync();
1834
1834
  this.getNetWorkType();
1835
1835
  }
1836
1836
 
1837
1837
  taskTimeoutPromise(callBack, timeout = 2000) {
1838
1838
  return new Promise((resolve) => {
1839
1839
  setTimeout(() => {
1840
1840
  const getCallBackRes = typeof callBack === 'function' && callBack();
1841
1841
  return resolve(getCallBackRes || false);
1842
1842
  }, timeout);
1843
1843
  });
1844
1844
  }
1845
1845
 
1846
1846
  getElderModePromise() {
1847
1847
  if (this.info.sysInfo.hasOwnProperty('jdAppModeType')) {
1848
1848
  return Promise.resolve(this.info.sysInfo.jdAppModeType);
1849
1849
  } else {
1850
1850
  if (isJdAndAndroidDevice) {
1851
1851
  this.info.sysInfo.jdAppModeType = '0';
1852
1852
  return Promise.resolve(this.info.sysInfo.jdAppModeType);
1853
1853
  } else {
1854
1854
  return Promise.race([
1855
1855
  this.taskTimeoutPromise(() => {
1856
1856
  this.info.sysInfo.jdAppModeType = '0';
1857
1857
  return this.info.sysInfo.jdAppModeType;
1858
1858
  }),
1859
1859
  new Promise((resolve) => {
1860
1860
  const getCallBackName = `getJdCurrentModeType${Date.now()}`;
1861
1861
  if (!window[getCallBackName]) {
1862
1862
  window[getCallBackName] = (res) => {
1863
1863
  try {
1864
1864
  const getResJson = typeof res === 'string' ? JSON.parse(res) : res;
1865
1865
  const { status, data, msg } = getResJson;
1866
1866
  console.log(`获取松果app展示模式成功,返回结果${data}`);
1867
1867
  if (status === '0') {
1868
1868
  this.info.sysInfo.jdAppModeType = data;
1869
1869
  resolve(data);
1870
1870
  } else {
1871
1871
  resolve('0');
1872
1872
  }
1873
1873
  } catch (e) {
1874
1874
  resolve('0');
1875
1875
  }
1876
1876
  window[getCallBackName] = null;
1877
1877
  };
1878
1878
  }
1879
1879
  window?.webkit?.messageHandlers?.JDAppUnite?.postMessage({
1880
1880
  method: 'callSyncRouterModuleWithParams',
1881
1881
  params: JSON.stringify({
1882
1882
  routerURL: 'router://JDBModeModule/getCurrentMode',
1883
1883
  routerParam: {},
1884
1884
  callBackName: `window.${getCallBackName}`,
1885
1885
  callBackId: `${getCallBackName}Ios`,
1886
1886
  }),
1887
1887
  });
1888
1888
  }),
1889
1889
  ]);
1890
1890
  }
1891
1891
  }
1892
1892
  }
1893
1893
  getAPPUseStraightCorner() {
1894
1894
  const routerURL = 'router://JDBaseUtilsModule/isUI14Enable';
1895
1895
  const params = {
1896
1896
  routerURL,
1897
1897
  routerParam: {},
1898
1898
  jdRouter: '1',
1899
1899
  };
1900
1900
  if (this.info.sysInfo.hasOwnProperty('jdStraightCorner')) {
1901
1901
  return Promise.resolve(this.info.sysInfo.jdStraightCorner);
1902
1902
  } else {
1903
1903
  return this.jmfeReayPromise()
1904
1904
  .then(() => {
1905
1905
  if (isJdAndHarmonyDevice || !isJdApp) {
1906
1906
  console.log('not APP or is Harmony');
1907
1907
  return Promise.resolve(false);
1908
1908
  }
1909
1909
  console.log('jmfe setShareInfo', params);
1910
1910
  return Promise.race([
1911
1911
  window.jmfe.callRouter(params),
1912
1912
  this.taskTimeoutPromise(() => {
1913
1913
  return false;
1914
1914
  }),
1915
1915
  ]).then(({ status, data }) => {
1916
1916
  console.log('004 ~ file: index.tsx:133 ~ .then ~ data:', data);
1917
1917
  console.log('004 ~ file: index.tsx:133 ~ .then ~ status:', status);
1918
1918
  this.info.sysInfo.jdStraightCorner = status === '0' && Number(data) === 1;
1919
1919
  return Promise.resolve(status === '0' && Number(data) === 1);
1920
1920
  });
1921
1921
  })
1922
1922
  .catch((e) => {
1923
1923
  console.log('jmfe error', e);
1924
1924
  return Promise.resolve(false);
1925
1925
  });
1926
1926
  }
1927
1927
  }
1928
1928
 
1929
1929
  getJDAppearanceStatePromise() {
1930
1930
  if (this.info.sysInfo.hasOwnProperty('jdAppearanceState')) {
1931
1931
  return Promise.resolve(this.info.sysInfo.jdAppearanceState);
1932
1932
  } else {
1933
1933
  return Promise.race([
1934
1934
  this.taskTimeoutPromise(() => {
1935
1935
  this.info.sysInfo.jdAppearanceState = '0';
1936
1936
  return this.info.sysInfo.jdAppearanceState;
1937
1937
  }),
1938
1938
  new Promise((resolve) => {
1939
1939
  const getCallBackName = `getJdCurrentAppearanceState${Date.now()}`;
1940
1940
  if (!window[getCallBackName]) {
1941
1941
  window[getCallBackName] = (res) => {
1942
1942
  try {
1943
1943
  console.log('getJDAppearanceStatePromise', res);
1944
1944
  const getResJson = typeof res === 'string' ? JSON.parse(res) : res;
1945
1945
  const { status, data, msg } = getResJson;
1946
1946
  console.log(`获取松果app是否开启黑暗模式成功,返回结果${data}`);
1947
1947
  if (status === '0') {
1948
1948
  this.info.sysInfo.jdAppearanceState = data;
1949
1949
  resolve(data);
1950
1950
  } else {
1951
1951
  resolve('0');
1952
1952
  }
1953
1953
  } catch (e) {
1954
1954
  resolve('0');
1955
1955
  }
1956
1956
  window[getCallBackName] = null;
1957
1957
  };
1958
1958
  }
1959
1959
  if (isAndroidDevice) {
1960
1960
  const jsonString = JSON.stringify({
1961
1961
  callBackName: `window.${getCallBackName}`,
1962
1962
  });
1963
1963
  console.log('window.JDAppearance', window?.JDAppearance);
1964
1964
  window?.JDAppearance &&
1965
1965
  window?.JDAppearance?.getUiState &&
1966
1966
  window.JDAppearance.getUiState(jsonString);
1967
1967
  } else {
1968
1968
  window?.webkit?.messageHandlers?.JDAppUnite?.postMessage({
1969
1969
  method: 'callSyncRouterModuleWithParams',
1970
1970
  params: JSON.stringify({
1971
1971
  routerURL: 'router://JDWebViewBusinessModule/getJDAppearanceState',
1972
1972
  routerParam: {},
1973
1973
  callBackName: `window.${getCallBackName}`,
1974
1974
  callBackId: `${getCallBackName}Ios`,
1975
1975
  }),
1976
1976
  });
1977
1977
  }
1978
1978
  }),
1979
1979
  ]);
1980
1980
  }
1981
1981
  }
1982
1982
 
1983
1983
  createJdAndroidRquestEventForTouchStart() {
1984
1984
  if (isJdAndAndroidDevice && window?.JdAndroid) {
1985
1985
  const rootEleNode = document.querySelector('body');
1986
1986
  if (rootEleNode) {
1987
1987
  rootEleNode.addEventListener('touchstart', this.jdAndroidAddEventListenerTouchStart, false);
1988
1988
  }
1989
1989
  }
1990
1990
  }
1991
1991
  jdAndroidAddEventListenerTouchStart(e) {
1992
1992
  const isH5SwiperCustomEle = e?.target?.closest('.J_h5SwiperCustom');
1993
1993
  if (!isH5SwiperCustomEle && window?.JdAndroid) {
1994
1994
  const hasCustomEle = e
1995
1995
  ? e?.target?.closest('.J_customScroll') || e?.target?.closest('.J_customLayout')
1996
1996
  : false;
1997
1997
  if (!hasCustomEle) {
1998
1998
  window?.JdAndroid?.requestEvent && window.JdAndroid.requestEvent(false);
1999
1999
  console.log(
2000
2000
  'createJdAndroidRquestEvent 所有松果安卓APP内的document touch start事件执行检测requestEvent并重置为false',
2001
2001
  );
2002
2002
  }
2003
2003
  }
2004
2004
  }
2005
2005
  removeJdAndroidRquestEventForTouchStart() {
2006
2006
  if (isJdAndAndroidDevice && window.JdAndroid) {
2007
2007
  const rootEleNode = document.querySelector('body');
2008
2008
  if (rootEleNode) {
2009
2009
  rootEleNode.removeEventListener(
2010
2010
  'touchstart',
2011
2011
  this.jdAndroidAddEventListenerTouchStart,
2012
2012
  false,
2013
2013
  );
2014
2014
  }
2015
2015
  }
2016
2016
  }
2017
2017
 
2018
2018
  getNetWorkType() {
2019
2019
  if (isJdApp) {
2020
2020
  this.jmfeReayPromise().then(() => {
2021
2021
  window.jmfe
2022
2022
  .getNetworkStatus()
2023
2023
  .then(({ status, data }) => {
2024
2024
  console.log('在app内初始化通过jmfe对象获取网络状态完成,当前网络状态====', data);
2025
2025
  if (status === '0') {
2026
2026
  this.info.sysInfo['netWorkType'] = data;
2027
2027
  } else {
2028
2028
  this._taroGetNetworkType();
2029
2029
  }
2030
2030
  })
2031
2031
  .catch((err) => {
2032
2032
  console.log('在app内初始化通过jmfe对象获取网络状态异常====', err);
2033
2033
  this._taroGetNetworkType();
2034
2034
  });
2035
2035
  });
2036
2036
  } else {
2037
2037
  this._taroGetNetworkType();
2038
2038
  }
2039
2039
  }
2040
2040
  _taroGetNetworkType() {
2041
2041
  Taro.getNetworkType().then((getRes) => {
2042
2042
  if (getRes && getRes.networkType) {
2043
2043
  this.info.sysInfo['netWorkType'] = getRes.networkType;
2044
2044
  console.log(
2045
2045
  '在app内通过taro对象获取网络状态完成,当前网络状态',
2046
2046
  this.info.sysInfo['netWorkType'],
2047
2047
  );
2048
2048
  }
2049
2049
  });
2050
2050
  }
2051
2051
 
2052
2052
  getCacheAddressRouter() {
2053
2053
  if (window.jmfe && isJdApp) {
2054
2054
  if (!isJdAndHarmonyDevice) {
2055
2055
  return Promise.race([
2056
2056
  window.jmfe.callRouter({
2057
2057
  jdRouter: '1',
2058
2058
  routerURL: isAndroidDevice
2059
2059
  ? 'router://JDAddressModule/getCacheAddress'
2060
2060
  : 'router://JDBAddressCacheManagerModule/getCacheAddress',
2061
2061
  routerParam: { sceneId: 'basicShoppingProcess' },
2062
2062
  }),
2063
2063
  this.taskTimeoutPromise(() => {
2064
2064
  return {
2065
2065
  status: '-1000',
2066
2066
  msg: '原生router协议获取地址信息超时',
2067
2067
  };
2068
2068
  }, 3000),
2069
2069
  ]);
2070
2070
  } else {
2071
2071
  return Promise.resolve({
2072
2072
  status: '-1001',
2073
2073
  msg: '鸿蒙系统调用jmfe异常,获取失败',
2074
2074
  });
2075
2075
  }
2076
2076
  } else {
2077
2077
  return Promise.resolve({
2078
2078
  status: '-1002',
2079
2079
  msg: 'jmfe不存在,获取失败',
2080
2080
  });
2081
2081
  }
2082
2082
  }
2083
2083
 
2084
2084
  getAddressCachePromise() {
2085
2085
  return new Promise((resolve) => {
2086
2086
  if (this?.info?.sysInfo?.lat && this?.info?.sysInfo?.lng && this?.info?.sysInfo?.area) {
2087
2087
  resolve({
2088
2088
  lat: this.info.sysInfo.lat,
2089
2089
  lng: this.info.sysInfo.lng,
2090
2090
  area: this?.info?.sysInfo?.area,
2091
2091
  });
2092
2092
  } else {
2093
2093
  this.jmfeReayPromise()
2094
2094
  .then(() => {
2095
2095
  this.getCacheAddressRouter()
2096
2096
  .then((res) => {
2097
2097
  const { status, data } = res;
2098
2098
  console.log('原生端获取经纬度原始数据结果', status, data);
2099
2099
  if (status === '0' && data) {
2100
2100
  const { lat, latitude, lng, longitude, provinceId, cityId, countyId, townId } =
2101
2101
  data || {};
2102
2102
  let area = '';
2103
2103
  this.info.sysInfo['lat'] = `${lat || latitude || ''}`;
2104
2104
  this.info.sysInfo['lng'] = `${lng || longitude || ''}`;
2105
2105
  if (provinceId) {
2106
2106
  area = `${provinceId}_${cityId || 0}_${countyId || 0}_${townId || 0}`;
2107
2107
  this.info.pageInfo['address'] = area;
2108
2108
  this.info.pageInfo['addressCommaStr'] = area.replace(/_/g, ',');
2109
2109
  Taro.eventCenter.trigger(
2110
2110
  TaroEventType.USER_AREA_UPDATE,
2111
2111
  this.info.pageInfo.address,
2112
2112
  );
2113
2113
  }
2114
2114
  resolve({
2115
2115
  lat: this.info.sysInfo['lat'],
2116
2116
  lng: this.info.sysInfo['lng'],
2117
2117
  area: area,
2118
2118
  });
2119
2119
  } else {
2120
2120
  if (typeof res === 'object') {
2121
2121
  sgmCustomReport({
2122
2122
  type: 3,
2123
2123
  code: 'jdapp_getCacheAddress_info',
2124
2124
  msg: {
2125
2125
  title: '松果app内通过router协议获取用户地址及经纬度信息异常',
2126
2126
  jdAppVersion: jdAppVersionStr,
2127
2127
  ...res,
2128
2128
  },
2129
2129
  });
2130
2130
  draBusinessCustomReport({
2131
2131
  type: 'jdapp_getCacheAddress_info_err',
2132
2132
  errMsg: '松果app内通过router协议获取用户地址及经纬度信息异常',
2133
2133
  originReqDataStr: JSON.stringify({
2134
2134
  isJdApp,
2135
2135
  jdAppVersion: jdAppVersionStr,
2136
2136
  ...res,
2137
2137
  }),
2138
2138
  });
2139
2139
  }
2140
2140
  resolve({ lat: '', lng: '', area: '' });
2141
2141
  }
2142
2142
  })
2143
2143
  .catch((e) => {
2144
2144
  console.log('getCacheAddressRouter catch e,获取经纬度信息异常e', e);
2145
2145
  draBusinessCustomReport({
2146
2146
  type: 'jdapp_getCacheAddress_info_catch_err',
2147
2147
  errMsg: '松果app内通过router协议获取用户地址及经纬度信息catch异常',
2148
2148
  originReqDataStr: JSON.stringify({
2149
2149
  isJdApp,
2150
2150
  jdAppVersion: jdAppVersionStr,
2151
2151
  }),
2152
2152
  });
2153
2153
  resolve({ lat: '', lng: '', area: '' });
2154
2154
  });
2155
2155
  })
2156
2156
  .catch((e) => {
2157
2157
  resolve({ lat: '', lng: '', area: '' });
2158
2158
  console.log('判断jmfe不存在,获取经纬度信息异常e', e);
2159
2159
  });
2160
2160
  }
2161
2161
  });
2162
2162
  }
2163
2163
 
2164
2164
  async updateMPaasConfigAsync(isBeforePageReady: boolean) {
2165
2165
  console.log('updateMPaasConfigAsync isBeforePageReady:', isBeforePageReady);
2166
2166
  if (!isJdApp) {
2167
2167
  return;
2168
2168
  }
2169
2169
  const avifSwitch = await getMPaasConfigByBussinessKey('avifSwitch', isBeforePageReady);
2170
2170
  this.info.sysInfo.dynamicConfig['avifSwitch'] = avifSwitch;
2171
2171
  const hybridHttpSwitch = await getMPaasConfigByBussinessKey(
2172
2172
  'hybridHttpSwitch',
2173
2173
  isBeforePageReady,
2174
2174
  );
2175
2175
  this.info.sysInfo.dynamicConfig['hybridHttpSwitch'] = hybridHttpSwitch;
2176
2176
  const isFollowAppVideoPlayStatus = await getMPaasConfigByBussinessKey(
2177
2177
  'isFollowAppVideoPlayStatus',
2178
2178
  isBeforePageReady,
2179
2179
  );
2180
2180
  console.log(
2181
2181
  'isBeforePageReady:',
2182
2182
  isBeforePageReady,
2183
2183
  'isFollowAppVideoPlayStatus:',
2184
2184
  isFollowAppVideoPlayStatus,
2185
2185
  );
2186
2186
  if (isFollowAppVideoPlayStatus === true || isFollowAppVideoPlayStatus === 'true') {
2187
2187
  this.info.sysInfo.dynamicConfig['isFollowAppVideoPlayStatus'] = true;
2188
2188
  }
2189
2189
  }
2190
2190
 
2191
2191
  async getWifiVideoAutoPlayAsync() {
2192
2192
  this.info.sysInfo['wifiVideoAutoPlay'] = false;
2193
2193
  if (!isJdApp) {
2194
2194
  return;
2195
2195
  }
2196
2196
  const videoPlayStatus = await getWifiVideoAutoPlay().catch((e) => {
2197
2197
  return 0;
2198
2198
  });
2199
2199
  if (Number(videoPlayStatus) === 1) {
2200
2200
  this.info.sysInfo['wifiVideoAutoPlay'] = true;
2201
2201
  }
2202
2202
  }
2203
2203
 
2204
2204
  async getMPaasConfigAsync() {
2205
2205
  this.info.sysInfo.dynamicConfig = {};
2206
2206
  this.info.sysInfo.dynamicConfig['avifSwitch'] = {};
2207
2207
  this.info.sysInfo.dynamicConfig['hybridHttpSwitch'] = {};
2208
2208
  this.info.sysInfo.dynamicConfig['isFollowAppVideoPlayStatus'] = false;
2209
2209
  return this.updateMPaasConfigAsync(true);
2210
2210
  }
2211
2211
 
2212
2212
  getDynamicConfig(key: string) {
2213
2213
  return this.info.sysInfo?.dynamicConfig?.[key];
2214
2214
  }
2215
2215
  async updateMPaasConfig() {
2216
2216
  console.log('updateMPaasConfig');
2217
2217
  if (
2218
2218
  isIosDevice &&
2219
2219
  versionCompare(jdAppVersionStr, MPAAS_CONFIG_APP_VERSION) < 0 &&
2220
2220
  versionCompare(jdAppVersionStr, MPAAS_CONFIG_APP_LOW_VERSION) >= 0
2221
2221
  ) {
2222
2222
  try {
2223
2223
  await this.updateMPaasConfigAsync(false);
2224
2224
  } catch (e) {
2225
2225
  console.log('updateMPaasConfigAsync:', e);
2226
2226
  }
2227
2227
  }
2228
2228
  }
2229
2229
 
2230
2230
  toLogin(options) {
2231
2231
  return this.info.isJingGouMiniViewState || this.info.isJingxiMiniViewState
2232
2232
  ? this.toWxAppLogin(options)
2233
2233
  : this.toWebLogin(options);
2234
2234
  }
2235
2235
 
2236
2236
  doLogin(options) {
2237
2237
  return this.toLogin(options);
2238
2238
  }
2239
2239
 
2240
2240
  doLoginForJdPin(options = {}) {
2241
2241
  return this.doLogin({
2242
2242
  loginColor: {
2243
2243
  biz: WXAPP_BIZ_SHOP_LIGHT_KEY,
2244
2244
  dpin: 0,
2245
2245
  },
2246
2246
  ...options,
2247
2247
  });
2248
2248
  }
2249
2249
 
2250
2250
  toWebLogin(options) {
2251
2251
  let params: {
2252
2252
  returnurl: string;
2253
2253
  } = {
2254
2254
  returnurl: '',
2255
2255
  };
2256
2256
  const loginUrl = isPc
2257
2257
  ? `//passport.jd.com/new/login.aspx`
2258
2258
  : `${domain.mobileLogin}/user/login.action`;
2259
2259
  const defaultParams = {
2260
2260
  appid: '100',
2261
2261
  returnurl: window.location.href,
2262
2262
  };
2263
2263
  if (isString(options)) {
2264
2264
  params = Object.assign({}, defaultParams, {
2265
2265
  returnurl: options,
2266
2266
  });
2267
2267
  } else if (isObject(options)) {
2268
2268
  const { loginColor, ...otherOptions } = options;
2269
2269
  params = Object.assign({}, defaultParams, otherOptions);
2270
2270
  } else {
2271
2271
  params = defaultParams;
2272
2272
  }
2273
2273
  params.returnurl = encodeURIComponent(params.returnurl);
2274
2274
  let getFullUrl = loginUrl + '?' + serialize(params);
2275
2275
  if (isPc) {
2276
2276
  getFullUrl = getFullUrl.replace(/returnurl/, 'ReturnUrl');
2277
2277
  }
2278
2278
  return Promise.resolve({
2279
2279
  h5ToUrl: true,
2280
2280
  url: getFullUrl,
2281
2281
  }).then(() => {
2282
2282
  window.location.href = getFullUrl;
2283
2283
  });
2284
2284
  }
2285
2285
 
2286
2286
  toWxAppLogin(options = {}) {
2287
2287
  console.log('微信京购小程序中h5登录跳转', options);
2288
2288
  return Promise.resolve(true).then(() => {
2289
2289
  const { loginColor } = Object.assign(
2290
2290
  {},
2291
2291
  {
2292
2292
  loginColor: {
2293
2293
  biz: WXAPP_BIZ_KEY,
2294
2294
  dpin: 1,
2295
2295
  },
2296
2296
  },
2297
2297
  options,
2298
2298
  );
2299
2299
  window.location.href = `${domain.wq}/pinbind/pintokenredirect?biz=${
2300
2300
  loginColor.biz
2301
2301
  }&url=${encodeURIComponent(window.location.href)}`;
2302
2302
  });
2303
2303
  }
2304
2304
 
2305
2305
  getLoginCookie() {
2306
2306
  return Promise.resolve({
2307
2307
  pin: cookie.get('pin') || '',
2308
2308
  });
2309
2309
  }
2310
2310
 
2311
2311
  clearLoginCookie() {
2312
2312
  cookie.remove('pin');
2313
2313
  }
2314
2314
 
2315
2315
  checkStatusAndLogin(options = {}) {
2316
2316
  if (!this.checkStatusAndLoginPromise) {
2317
2317
  this.checkStatusAndLoginPromise = new Promise(async (resolve, reject) => {
2318
2318
  try {
2319
2319
  const getLoginState = await this.doCheckLoginStateAndForApiCheck(options);
2320
2320
  if (getLoginState) {
2321
2321
  resolve(true);
2322
2322
  } else {
2323
2323
  this.toLogin(options);
2324
2324
  reject(false);
2325
2325
  }
2326
2326
  } catch (e) {
2327
2327
  this.toLogin(options);
2328
2328
  reject(false);
2329
2329
  }
2330
2330
  });
2331
2331
  return this.checkStatusAndLoginPromise;
2332
2332
  } else {
2333
2333
  return this.checkStatusAndLoginPromise
2334
2334
  .then(() => {
2335
2335
  return Promise.resolve(true);
2336
2336
  })
2337
2337
  .catch(() => {
2338
2338
  this.toLogin(options);
2339
2339
  return Promise.reject(true);
2340
2340
  });
2341
2341
  }
2342
2342
  }
2343
2343
 
2344
2344
  checkJdStatusAndLogin(
2345
2345
  options = {
2346
2346
  loginColor: {
2347
2347
  biz: WXAPP_BIZ_SHOP_LIGHT_KEY,
2348
2348
  dpin: 0,
2349
2349
  },
2350
2350
  },
2351
2351
  ) {
2352
2352
  return this.checkStatusAndLogin(options);
2353
2353
  }
2354
2354
 
2355
2355
  doCheckLoginStateAndForApiCheck(options) {
2356
2356
  if (this.info.loginState) {
2357
2357
  return Promise.resolve(true);
2358
2358
  } else {
2359
2359
  return new Promise((resolve, reject) => {
2360
2360
  if (this.info.isJingGouMiniViewState || this.info.isJingxiMiniViewState) {
2361
2361
  const getWqAuthToken = cookie.get('wq_auth_token');
2362
2362
  const getWqSkey = cookie.get('wq_skey');
2363
2363
  const getWqUin = cookie.get('wq_uin');
2364
2364
  const isLoginState =
2365
2365
  options?.loginColor?.dpin === 0 ? getWqAuthToken : getWqSkey && getWqUin;
2366
2366
  if (isLoginState) {
2367
2367
  this.info.loginState = true;
2368
2368
  resolve(true);
2369
2369
  } else {
2370
2370
  reject(false);
2371
2371
  }
2372
2372
  } else {
2373
2373
  Taro.request({
2374
2374
  url: api.isLogin,
2375
2375
  jsonp: true,
2376
2376
  timeout: 3000,
2377
2377
  success: (res) => {
2378
2378
  const { statusCode, data } = res;
2379
2379
  if (statusCode === 200 && data?.islogin && Number(data.islogin) === 1) {
2380
2380
  this.info.loginState = true;
2381
2381
  resolve(true);
2382
2382
  } else {
2383
2383
  reject(false);
2384
2384
  }
2385
2385
  },
2386
2386
  fail: (err) => {
2387
2387
  console.log('登录检查异常', err);
2388
2388
  reject(false);
2389
2389
  },
2390
2390
  });
2391
2391
  }
2392
2392
  });
2393
2393
  }
2394
2394
  }
2395
2395
 
2396
2396
  checkLoginStatus(options) {
2397
2397
  return new Promise(async (resolve, reject) => {
2398
2398
  try {
2399
2399
  const getLoginState = await this.doCheckLoginStateAndForApiCheck(options);
2400
2400
  if (getLoginState) {
2401
2401
  const { pin } = await this.getLoginCookie();
2402
2402
  this.info.userInfo = {
2403
2403
  pin,
2404
2404
  encodePin: encodeURIComponent(pin),
2405
2405
  ptkey: '',
2406
2406
  };
2407
2407
  resolve(true);
2408
2408
  } else {
2409
2409
  reject(false);
2410
2410
  }
2411
2411
  } catch (e) {
2412
2412
  reject(false);
2413
2413
  }
2414
2414
  });
2415
2415
  }
2416
2416
 
2417
2417
  updatePageAndLogInfo(updateQuery = {}) {
2418
2418
  const createUpdateQueryInfo: {
2419
2419
  query: {
2420
2420
  shopId?: string | number;
2421
2421
  venderId?: string | number;
2422
2422
  };
2423
2423
  updateShopInfoState: boolean;
2424
2424
  } = Object.assign(
2425
2425
  {},
2426
2426
  {
2427
2427
  query: {},
2428
2428
  updateShopInfoState: false,
2429
2429
  },
2430
2430
  updateQuery,
2431
2431
  );
2432
2432
  console.log(
2433
2433
  '获取当前下发的店铺查询参数',
2434
2434
  updateQuery,
2435
2435
  '获取之前保存的shopInfo店铺查询参数',
2436
2436
  this.info?.shopInfo,
2437
2437
  );
2438
2438
  const { query, updateShopInfoState } = createUpdateQueryInfo;
2439
2439
  const { shopId, venderId, un_area } = query;
2440
2440
  if (updateShopInfoState) {
2441
2441
  this.info.queryInfo = {
2442
2442
  ...this.info.queryInfo,
2443
2443
  ...query,
2444
2444
  };
2445
2445
  if (shopId && venderId) {
2446
2446
  this.info.shopInfo = {
2447
2447
  shopId: `${shopId}`,
2448
2448
  venderId: `${venderId}`,
2449
2449
  };
2450
2450
  }
2451
2451
  } else {
2452
2452
  this.info.queryInfo = {
2453
2453
  ...query,
2454
2454
  };
2455
2455
  if (
2456
2456
  this.info.shopInfo?.shopId &&
2457
2457
  this.info.shopInfo?.venderId &&
2458
2458
  (this.info.shopInfo.shopId == shopId || this.info.shopInfo.venderId == venderId)
2459
2459
  ) {
2460
2460
  this.info.queryInfo.shopId = this.info.shopInfo.shopId;
2461
2461
  this.info.queryInfo.venderId = this.info.shopInfo.venderId;
2462
2462
  console.log(
2463
2463
  '当前存储的店铺shopId和venderId与下发的店铺信息shopId或者venderId为同一个,补充shopId或者venderId查询参数',
2464
2464
  this.info.queryInfo,
2465
2465
  );
2466
2466
  }
2467
2467
  }
2468
2468
  this.info.queryInfo['shopId'] &&
2469
2469
  (this.info.queryInfo['shopId'] = `${this.info.queryInfo['shopId']}`);
2470
2470
  this.info.queryInfo['venderId'] &&
2471
2471
  (this.info.queryInfo['venderId'] = `${this.info.queryInfo['venderId']}`);
2472
2472
  console.log(
2473
2473
  'h5==获取店铺下发查询参数\n',
2474
2474
  query,
2475
2475
  '\n获取店铺最后查询参数\n',
2476
2476
  this.info.queryInfo,
2477
2477
  '\n是否为更新店铺状态\n',
2478
2478
  updateShopInfoState,
2479
2479
  );
2480
2480
  const changeArea = un_area && un_area.length > 0 ? un_area : isPc && ipLoc_djd ? ipLoc_djd : '';
2481
2481
  if (changeArea) {
2482
2482
  const getBottomAreaStr = changeArea.replace(/-/g, '_');
2483
2483
  this.info.pageInfo.address = getBottomAreaStr;
2484
2484
  this.info.pageInfo.un_area = getBottomAreaStr;
2485
2485
  this.info.pageInfo.addressCommaStr = getBottomAreaStr.replace(/_/g, ',');
2486
2486
  }
2487
2487
  }
2488
2488
 
2489
2489
  dealLoadSdkList() {
2490
2490
  const globalLoadJsList = window?.shopGlobalSwitch?.asyncLoadJsList ?? [];
2491
2491
  const businessLoadJsList = window?.PAGE_DATA?.businessData?.asyncLoadJsList ?? [];
2492
2492
  const concatLoadJsList = [].concat(globalLoadJsList, businessLoadJsList);
2493
2493
  let mergeLoadJsList = globalLoadJsList;
2494
2494
  try {
2495
2495
  mergeLoadJsList = concatLoadJsList.reduce((accArr: any[], current: any) => {
2496
2496
  const getFindIndex = accArr.findIndex((item) => item?.fileName === current?.fileName);
2497
2497
  getFindIndex !== -1
2498
2498
  ? (accArr[getFindIndex] = { ...accArr[getFindIndex], ...current })
2499
2499
  : accArr.push(current);
2500
2500
  return accArr;
2501
2501
  }, []);
2502
2502
  } catch (e) {
2503
2503
  console.log('LoadJsList合并错误', e);
2504
2504
  }
2505
2505
  console.log(
2506
2506
  'globalLoadJsList',
2507
2507
  globalLoadJsList,
2508
2508
  'businessLoadJsList',
2509
2509
  businessLoadJsList,
2510
2510
  '两个加载jsList集合合并完成',
2511
2511
  mergeLoadJsList,
2512
2512
  );
2513
2513
  this.loadJsSdkList = mergeLoadJsList;
2514
2514
  return this.loadJsSdkList;
2515
2515
  }
2516
2516
 
2517
2517
  renderNextTickLoadSdk() {
2518
2518
  Taro.nextTick(() => {
2519
2519
  console.log(
2520
2520
  '页面渲染的下一帧执行的js加载方法,当前nextTick存在state的渲染问题,先延迟1s=======',
2521
2521
  );
2522
2522
  setTimeout(() => {
2523
2523
  this.loadOtherSdk(LoadJsInitTriggerType.NRXT_TICK, this.loadJsSdkList);
2524
2524
  }, 1000);
2525
2525
  });
2526
2526
  }
2527
2527
 
2528
2528
  loadOtherSdk(triggerType = LoadJsInitTriggerType.NOW, loadJsList: any[] = []) {
2529
2529
  const getLoadJsList =
2530
2530
  Array.isArray(loadJsList) && loadJsList.length > 0 ? loadJsList : this.dealLoadSdkList();
2531
2531
  const getLoadFilterList = getLoadJsList.filter((item) => {
2532
2532
  const getInitLoadEnvType = item?.initLoadEnvType || LoadJsInitLoadEnvType.ALL;
2533
2533
  let getLoastLoadEventState = true;
2534
2534
  if (getInitLoadEnvType === LoadJsInitLoadEnvType.JD_APP) {
2535
2535
  getLoastLoadEventState = isJdApp;
2536
2536
  }
2537
2537
  else if (getInitLoadEnvType === LoadJsInitLoadEnvType.M) {
2538
2538
  getLoastLoadEventState = !isJdApp || !!isJdAndHarmonyDevice;
2539
2539
  }
2540
2540
  const getInitTriggerType =
2541
2541
  isJdApp && item?.initJdAppTriggerType
2542
2542
  ? item?.initTriggerType
2543
2543
  : item?.initTriggerType || LoadJsInitTriggerType.NOW;
2544
2544
  const getInitLinkTriggerWay = window?.PAGE_DATA[item?.initLinkTriggerWay] || false;
2545
2545
  return getLoastLoadEventState && getInitTriggerType === triggerType && getInitLinkTriggerWay;
2546
2546
  });
2547
2547
  console.log(
2548
2548
  '获取当前触发方式',
2549
2549
  triggerType,
2550
2550
  '获取当前最后加载的js集合',
2551
2551
  getLoadFilterList,
2552
2552
  '过滤前的加载集合',
2553
2553
  getLoadJsList,
2554
2554
  );
2555
2555
  getLoadFilterList.length > 0 &&
2556
2556
  getLoadFilterList.forEach((item) => {
2557
2557
  const isLoadState = /sgm/.test(item?.fileName)
2558
2558
  ? window?.shopGlobalSwitch?.openSgm === 'true'
2559
2559
  : true;
2560
2560
  isLoadState &&
2561
2561
  this.loadItemSdkPromise(item)
2562
2562
  .then((res) => {
2563
2563
  console.info('当前js地址' + item?.src, '加载状态', res);
2564
2564
  const isFileNameNewDraSdkJs = res?.fileName === 'newDraSdkJs';
2565
2565
  if (isFileNameNewDraSdkJs && window?.dra?.run) {
2566
2566
  window.dra.run('init', { aid: res?.aid });
2567
2567
  window.dra.run('start');
2568
2568
  }
2569
2569
  })
2570
2570
  .catch((err) => {
2571
2571
  console.info('当前js地址加载异常', item?.src);
2572
2572
  window?.fetchErrorData &&
2573
2573
  window.fetchErrorData({
2574
2574
  title: '公共js加载异常',
2575
2575
  type: 'jsLoad',
2576
2576
  data: err,
2577
2577
  });
2578
2578
  });
2579
2579
  });
2580
2580
  }
2581
2581
  loadScriptEle(jsInfo, resolve, reject) {
2582
2582
  const getFileName = jsInfo?.fileName;
2583
2583
  if (getFileName) {
2584
2584
  const getEleId = `J_loadJs_${getFileName}`;
2585
2585
  const getEle = document.getElementById(getEleId);
2586
2586
  if (!getEle) {
2587
2587
  const jsLoadErrorSgmCode = `jsLoadError_${jsInfo?.fileName || 'customJs'}`;
2588
2588
  const _sgmEle = document.createElement('script');
2589
2589
  _sgmEle.id = getEleId;
2590
2590
  _sgmEle.onload = function () {
2591
2591
  resolve({
2592
2592
  ...jsInfo,
2593
2593
  jsTip: 'js加载成功',
2594
2594
  });
2595
2595
  };
2596
2596
  _sgmEle.onerror = function () {
2597
2597
  reject({
2598
2598
  ...jsInfo,
2599
2599
  env: getSgmCustomCode(jsLoadErrorSgmCode),
2600
2600
  jsReqError: '当前js创建标签触发onerror异常回调,请排查网络络错误或语法错误或运行时错误',
2601
2601
  });
2602
2602
  };
2603
2603
  const dataAttrList = ['timeout', 'fileName', 'env'];
2604
2604
  const getJsInfoKeyList = Object.keys(jsInfo);
2605
2605
  getJsInfoKeyList.forEach((key) => {
2606
2606
  if (key === 'async') {
2607
2607
  _sgmEle.async = jsInfo[key];
2608
2608
  } else if (key === 'crossOrigin') {
2609
2609
  _sgmEle.crossOrigin = jsInfo[key];
2610
2610
  } else if (key === 'src') {
2611
2611
  _sgmEle.src = `${jsInfo[key]}`;
2612
2612
  } else if (dataAttrList.includes(key) || /init/.test(key)) {
2613
2613
  _sgmEle.setAttribute(`data-${key}`, jsInfo[key]);
2614
2614
  } else {
2615
2615
  _sgmEle.setAttribute(key, jsInfo[key]);
2616
2616
  }
2617
2617
  });
2618
2618
  document.head.appendChild(_sgmEle);
2619
2619
  } else {
2620
2620
  console.log(`当前${jsInfo?.fileName || 'js'}已经存在页面中,可以直接调用相关方法`, jsInfo);
2621
2621
  resolve({
2622
2622
  ...jsInfo,
2623
2623
  jsTip: 'js本身已存在页面中',
2624
2624
  });
2625
2625
  }
2626
2626
  } else {
2627
2627
  console.warn('当前js资源信息缺少必要的参数fileName,请关注', jsInfo);
2628
2628
  }
2629
2629
  }
2630
2630
 
2631
2631
  loadItemSdkPromise(jsInfo = {}) {
2632
2632
  if (jsInfo?.src) {
2633
2633
  const getInitLoadType =
2634
2634
  isJdApp && jsInfo?.initJdAppLoadType
2635
2635
  ? jsInfo?.initJdAppLoadType
2636
2636
  : jsInfo?.initLoadType || LoadJsInitLoadType.ALL;
2637
2637
  if (getInitLoadType !== LoadJsInitLoadType.NONE) {
2638
2638
  const getFileKeyName = jsInfo?.fileName || jsInfo?.src;
2639
2639
  if (!this.loadJsSdkListCachePromise[getFileKeyName]) {
2640
2640
  if (getInitLoadType !== LoadJsInitLoadType.INSERT_ELE) {
2641
2641
  this.loadJsSdkListCachePromise[getFileKeyName] = new Promise((resolve, reject) => {
2642
2642
  const jsLoadErrorSgmCode = `jsLoadError_${jsInfo?.fileName || 'customJs'}`;
2643
2643
  try {
2644
2644
  const jsXhrRequest = new XMLHttpRequest();
2645
2645
  jsXhrRequest.timeout = jsInfo?.timeout ?? 2000;
2646
2646
  const jsUrl = `${jsInfo?.src}`;
2647
2647
  jsXhrRequest.open('GET', jsUrl, true);
2648
2648
  jsXhrRequest.onreadystatechange = () => {
2649
2649
  if (jsXhrRequest.readyState === 4) {
2650
2650
  const getReqStatus = jsXhrRequest.status;
2651
2651
  if ((getReqStatus >= 200 && getReqStatus < 300) || getReqStatus === 304) {
2652
2652
  const getInsetHeadState = getInitLoadType === LoadJsInitLoadType.ALL;
2653
2653
  if (getInsetHeadState) {
2654
2654
  this.loadScriptEle(jsInfo, resolve, reject);
2655
2655
  } else {
2656
2656
  resolve({
2657
2657
  ...jsInfo,
2658
2658
  jsTip: 'js请求成功,暂未插入head节点,业务自行单独插入',
2659
2659
  });
2660
2660
  }
2661
2661
  getReqStatus !== 200 &&
2662
2662
  sgmCustomReport({
2663
2663
  type: 3,
2664
2664
  code: 'js_load_special_code',
2665
2665
  msg: {
2666
2666
  msg: '当前js加载成功,状态非200,特殊上报观察',
2667
2667
  jsReqState: getReqStatus,
2668
2668
  env: getSgmCustomCode('js_load_special_code'),
2669
2669
  data: jsInfo,
2670
2670
  },
2671
2671
  });
2672
2672
  } else {
2673
2673
  const getRes = {
2674
2674
  ...jsInfo,
2675
2675
  env: getSgmCustomCode(jsLoadErrorSgmCode),
2676
2676
  jsReqError: `请求状态异常,状态码为${getReqStatus}`,
2677
2677
  jsReqState: getReqStatus,
2678
2678
  };
2679
2679
  console.log('当前js请求状态异常,具体信息见', getRes);
2680
2680
  reject(getRes);
2681
2681
  }
2682
2682
  }
2683
2683
  };
2684
2684
  jsXhrRequest.onerror = () => {
2685
2685
  const getRes = {
2686
2686
  ...jsInfo,
2687
2687
  env: getSgmCustomCode(jsLoadErrorSgmCode),
2688
2688
  jsReqError: '请求错误',
2689
2689
  };
2690
2690
  console.log('当前js请求错误', getRes);
2691
2691
  jsXhrRequest.abort();
2692
2692
  reject(getRes);
2693
2693
  };
2694
2694
  jsXhrRequest.ontimeout = () => {
2695
2695
  const getRes = {
2696
2696
  ...jsInfo,
2697
2697
  env: getSgmCustomCode(jsLoadErrorSgmCode),
2698
2698
  jsReqError: `请求${jsXhrRequest.timeout}ms超时异常`,
2699
2699
  jsReqState: jsXhrRequest.status,
2700
2700
  };
2701
2701
  console.log('当前js请求超时异常', getRes);
2702
2702
  jsXhrRequest.abort();
2703
2703
  reject(getRes);
2704
2704
  };
2705
2705
  jsXhrRequest.send();
2706
2706
  } catch (e) {
2707
2707
  console.log('执行js请求异常', e);
2708
2708
  reject({
2709
2709
  ...jsInfo,
2710
2710
  env: getSgmCustomCode(jsLoadErrorSgmCode),
2711
2711
  jsReqError: '未知异常',
2712
2712
  error: e,
2713
2713
  });
2714
2714
  }
2715
2715
  });
2716
2716
  } else {
2717
2717
  this.loadJsSdkListCachePromise[getFileKeyName] = new Promise((resolve, reject) => {
2718
2718
  return this.loadScriptEle(jsInfo, resolve, reject);
2719
2719
  });
2720
2720
  }
2721
2721
  }
2722
2722
  return this.loadJsSdkListCachePromise[getFileKeyName];
2723
2723
  } else {
2724
2724
  return Promise.resolve({
2725
2725
  ...jsInfo,
2726
2726
  jsTip: 'js加载方式设置为不加载,当前不做处理',
2727
2727
  });
2728
2728
  }
2729
2729
  } else {
2730
2730
  return Promise.reject(jsInfo);
2731
2731
  }
2732
2732
  }