alovajs / scene / #32

Committed 15 Dec 2023 09:30AM UTC coverage: 98.007%. Remained the same

Build # #32

Build Type

push

github

Committed by

JOU-amjs

Commit Message

Merge branch 'main' of https://github.com/alovajs/scene

Run Details

735 of 782 branches covered (0.0%)

Branch coverage included in aggregate %.

295 of 297 new or added lines in 5 files covered. (99.33%)

1 existing line in 1 file now uncovered.

4231 of 4285 relevant lines covered (98.74%)

94.09 hits per line

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

91.92

/src/helper/index.ts

import { CacheExpire, LocalCacheConfig, Method } from 'alova';
import { BackoffPolicy } from '~/typings/general';
import { falseValue, nullValue, ObjectCls, PromiseCls, StringCls, trueValue, undefinedValue } from './variables';

export const promiseResolve = <T>(value?: T) => PromiseCls.resolve(value),
  promiseReject = <T>(value: T) => PromiseCls.reject(value),
  promiseThen = <T, T2 = never>(
    promise: Promise<T>,
    onFulfilled?: ((value: T) => T | PromiseLike<T>) | undefined | null,
    onrejected?: ((reason: any) => T2 | PromiseLike<T2>) | undefined | null
  ): Promise<T | T2> => promise.then(onFulfilled, onrejected),
  promiseCatch = <T, O>(promise: Promise<T>, onrejected: (reason: any) => O) => promise.catch(onrejected),
  forEach = <T>(ary: T[], fn: (item: T, index: number, ary: T[]) => void) => ary.forEach(fn),
  pushItem = <T>(ary: T[], ...item: T[]) => ary.push(...item),
  filterItem = <T, R>(ary: T[], fn: (item: T, index: number, ary: T[]) => R) => ary.filter(fn),
  map = <T, R>(ary: T[], fn: (item: T, index: number, ary: T[]) => R) => ary.map(fn),
  includes = <T>(ary: T[], target: T) => ary.includes(target),
  len = (data: any[] | Uint8Array | string | string) => data.length,
  isArray = (target: any) => Array.isArray(target),
  shift = <T>(ary: T[]) => ary.shift(),
  splice = <T>(ary: T[], start: number, deleteCount = 0, ...items: T[]) => ary.splice(start, deleteCount, ...items),
  getConfig = <S, E, R, T, RC, RE, RH>(methodInstance: Method<S, E, R, T, RC, RE, RH>) => methodInstance.config,
  getContext = <S, E, R, T, RC, RE, RH>(methodInstance: Method<S, E, R, T, RC, RE, RH>) => methodInstance.context,
  JSONStringify = (
    value: any,
    replacer?: ((this: any, key: string, value: any) => any) | undefined,
    space?: string | number | undefined
  ) => JSON.stringify(value, replacer, space),
  JSONParse = (text: string, reviver?: ((this: any, key: string, value: any) => any) | undefined) =>
    JSON.parse(text, reviver),
  objectKeys = (obj: any) => ObjectCls.keys(obj),
  objectValues = (obj: any) => ObjectCls.values(obj),
  setTimeoutFn = (fn: GeneralFn, delay = 0) => setTimeout(fn, delay),
  clearTimeoutFn = (timeoutId?: string | number | NodeJS.Timeout) => clearTimeout(timeoutId),
  regexpTest = (reg: RegExp, str: string) => reg.test(str);

/**
 * 创建同步多次调用只在异步执行一次的执行器
 */
export const createSyncOnceRunner = (delay = 0) => {
  let timer: NodeJS.Timeout | number | undefined = undefinedValue;

  /**
   * 执行多次调用此函数将异步执行一次
   */
  return (fn: () => void) => {
    if (timer) {
      clearTimeoutFn(timer);
    }
    timer = setTimeoutFn(fn, delay);
  };
};

/**
 * 创建uuid简易版
 * @returns uuid
 */
export const uuid = () => {
  const timestamp = new Date().getTime();
  return Math.floor(Math.random() * timestamp).toString(36);
};

const referenceList = [] as { id: string; ref: any }[];
/**
 * 获取唯一的引用类型id，如果是非引用类型则返回自身
 * @param {reference} 引用类型数据
 * @returns uniqueId
 */
export const getUniqueReferenceId = (reference: any) => {
  const refType = typeof reference;
  if (!['object', 'function', 'symbol'].includes(refType)) {
    return reference;
  }

  let existedRef = referenceList.find(({ ref }) => ref === reference);
  if (!existedRef) {
    const uniqueId = uuid();
    existedRef = {
      id: uniqueId,
      ref: reference
    };
    referenceList.push(existedRef);
  }
  return existedRef.id;
};

/**
 * 兼容函数
 */
export const noop = () => {};

/**
 * 兼容函数，返回自身
 * @param value 任意值
 * @returns 自身
 */
export const __self = <T>(value: T) => value;

// 判断是否为某个类的实例
export const instanceOf = <T>(arg: any, cls: new (...args: any[]) => T): arg is T => arg instanceof cls;

/**
 * 构建格式化的错误消息
 * @param prefix 错误前缀
 * @param msg 错误消息
 * @returns 格式化的错误消息
 */
export const buildErrorMsg = (prefix: string, msg: string) => `[alova/${prefix}]${msg}`;

/**
 * 自定义断言函数，表达式为false时抛出错误
 * @param expression 判断表达式，true或false
 * @param msg 断言消息
 */
export const createAssert = (prefix: string) => {
  return (expression: boolean, msg: string) => {
    if (!expression) {
      throw newInstance(Error, buildErrorMsg(prefix, msg));
    }
  };
};

export const valueObject = <T>(value: T, writable = falseValue) => ({
  value,
  writable
});

/**
 * 定义obj属性
 * @param o 对象
 * @param attrs 值对象
 */
export const defineProperty = (o: object, key: string | symbol, value: any, writable = falseValue) => {
  ObjectCls.defineProperty(o, key, valueObject(value, writable));
};

export type GeneralFn = (...args: any[]) => any;
/**
 * 批量执行时间回调函数，并将args作为参数传入
 * @param handlers 事件回调数组
 * @param args 函数参数
 */
export const runArgsHandler = (handlers: GeneralFn[], ...args: any[]) => {
  let ret: any = undefinedValue;
  forEach(handlers, handler => {
    const retInner = handler(...args);
    ret = retInner !== undefinedValue ? retInner : ret;
  });
  return ret;
};

/**
 * typof冗余函数
 * @param arg 任意参数
 * @returns 参数类型
 */
export const typeOf = (arg: any) => typeof arg;

/**
 * 判断参数是否为函数
 * @param fn 任意参数
 * @returns 该参数是否为函数
 */
export const isFn = (arg: any): arg is GeneralFn => typeOf(arg) === 'function';

/**
 * 判断参数是否为字符串
 * @param arg 任意参数
 * @returns 该参数是否为字符串
 */
export const isString = (arg: any): arg is string => typeOf(arg) === 'string';

/**
 * 判断参数是否为对象
 * @param arg 任意参数
 * @returns 该参数是否为对象
 */
export const isObject = <T = any>(arg: any): arg is T => arg !== nullValue && typeOf(arg) === 'object';

/**
 * 判断是否为纯对象或自定义类的对象
 * @param arg 任意参数
 * @returns 该参数是否为纯对象或自定义类的对象
 */
export const isPlainOrCustomObject = <T = any>(arg: any): arg is T =>
  ObjectCls.prototype.toString.call(arg) === '[object Object]';

/**
 * 深层遍历目标对象
 * @param target 目标对象
 * @param callback 遍历回调
 * @param preorder 是否前序遍历，默认为true
 * @param key 当前遍历的key
 * @param parent 当前遍历的父节点
 */
type AttrKey = string | number | symbol;
export const walkObject = (
  target: any,
  callback: (value: any, key: string | number | symbol, parent: any) => void,
  preorder = trueValue,
  key?: AttrKey,
  parent?: any
) => {
  const callCallback = () => {
    if (parent && key) {
      target = callback(target, key, parent);
      if (target !== parent[key]) {
        parent[key] = target;
      }
    }
  };

  // 前序遍历
  preorder && callCallback();
  if (isObject(target)) {
    for (const i in target) {
      if (!instanceOf(target, StringCls)) {
        walkObject(target[i], callback, preorder, i, target);
      }
    }
  }
  // 后序遍历
  !preorder && callCallback();
  return target;
};

/**
 * 创建类实例
 * @param cls 构造函数
 * @param args 构造函数参数
 * @returns 类实例
 */
export const newInstance = <T extends { new (...args: any[]): InstanceType<T> }>(
  cls: T,
  ...args: ConstructorParameters<T>
) => new cls(...args);

/**
 * 统一配置
 * @param 数据
 * @returns 统一的配置
 */
export const sloughConfig = <T>(config: T | ((...args: any[]) => T), args: any[] = []) =>
  isFn(config) ? config(...args) : config;

export const getTime = (date?: Date | null) => (date ? date.getTime() : Date.now());

/**
 * 判断参数是否为数字
 * @param arg 任意参数
 * @returns 该参数是否为数字
 */
export const isNumber = (arg: any): arg is number => typeof arg === 'number' && !isNaN(arg);

/** 三种缓存模式 */
// 只在内存中缓存，默认是此选项
const MEMORY = 'memory',
  // 缓存会持久化，但当内存中没有缓存时，持久化缓存只会作为响应数据的占位符，且还会发送请求更新缓存

  STORAGE_PLACEHOLDER = 'placeholder',
  // 缓存会持久化，且每次刷新会读取持久化缓存到内存中，这意味着内存一直会有缓存
  STORAGE_RESTORE = 'restore';
/**
 * 获取缓存的配置参数，固定返回{ e: number, m: number, s: boolean, t: string }格式的对象
 * e为expire缩写，表示缓存失效时间点（时间戳），单位为毫秒
 * m为mode缩写，存储模式
 * s为storage缩写，是否存储到本地
 * t为tag缩写，持久化存储标签
 * @param localCache 本地缓存参数
 * @returns 统一的缓存参数对象
 */
export const getLocalCacheConfigParam = <S, E, R, T, RC, RE, RH>(
  methodInstance?: Method<S, E, R, T, RC, RE, RH>,
  localCache?: LocalCacheConfig
) => {
  const _localCache =
    localCache !== undefinedValue ? localCache : methodInstance ? getConfig(methodInstance).localCache : undefinedValue;

  const getCacheExpireTs = (_localCache: CacheExpire) =>
    isNumber(_localCache) ? getTime() + _localCache : getTime(_localCache);
  let cacheMode = MEMORY;
  let expire = 0;
  let storage = falseValue;
  let tag: undefined | string = undefinedValue;
  if (!isFn(_localCache)) {
    if (isNumber(_localCache) || instanceOf(_localCache, Date)) {
      expire = getCacheExpireTs(_localCache);
    } else {
      const { mode = MEMORY, expire: configExpire = 0, tag: configTag } = _localCache || {};
      cacheMode = mode;
      expire = getCacheExpireTs(configExpire);
      storage = [STORAGE_PLACEHOLDER, STORAGE_RESTORE].includes(mode);
      tag = configTag ? configTag.toString() : undefinedValue;
    }
  }
  return {
    e: expire,
    m: cacheMode,
    s: storage,
    t: tag
  };
};

/**
 * 根据避让策略和重试次数计算重试延迟时间
 * @param backoff 避让参数
 * @param retryTimes 重试次数
 * @returns 重试延迟时间
 */
export const delayWithBackoff = (backoff: BackoffPolicy, retryTimes: number) => {
  let { delay, multiplier = 1, startQuiver, endQuiver } = backoff;
  let retryDelayFinally = (delay || 0) * Math.pow(multiplier, retryTimes - 1);
  // 如果startQuiver或endQuiver有值，则需要增加指定范围的随机抖动值
  if (startQuiver || endQuiver) {
    startQuiver = startQuiver || 0;
    endQuiver = endQuiver || 1;
    retryDelayFinally +=
      retryDelayFinally * startQuiver + Math.random() * retryDelayFinally * (endQuiver - startQuiver);
    retryDelayFinally = Math.floor(retryDelayFinally); // 取整数延迟
  }
  return retryDelayFinally;
};

1	import { CacheExpire, LocalCacheConfig, Method } from 'alova';	1✔
2	import { BackoffPolicy } from '~/typings/general';	1✔
3	import { falseValue, nullValue, ObjectCls, PromiseCls, StringCls, trueValue, undefinedValue } from './variables';	1✔
4		1✔
5	export const promiseResolve = <T>(value?: T) => PromiseCls.resolve(value),	1✔
6	promiseReject = <T>(value: T) => PromiseCls.reject(value),	1✔
7	promiseThen = <T, T2 = never>(	1✔
8	promise: Promise<T>,	180✔
9	onFulfilled?: ((value: T) => T \| PromiseLike<T>) \| undefined \| null,	180✔
10	onrejected?: ((reason: any) => T2 \| PromiseLike<T2>) \| undefined \| null	180✔
11	): Promise<T \| T2> => promise.then(onFulfilled, onrejected),	1✔
12	promiseCatch = <T, O>(promise: Promise<T>, onrejected: (reason: any) => O) => promise.catch(onrejected),	1✔
13	forEach = <T>(ary: T[], fn: (item: T, index: number, ary: T[]) => void) => ary.forEach(fn),	1✔
14	pushItem = <T>(ary: T[], ...item: T[]) => ary.push(...item),	1✔
15	filterItem = <T, R>(ary: T[], fn: (item: T, index: number, ary: T[]) => R) => ary.filter(fn),	1✔
16	map = <T, R>(ary: T[], fn: (item: T, index: number, ary: T[]) => R) => ary.map(fn),	1✔
17	includes = <T>(ary: T[], target: T) => ary.includes(target),	1✔
18	len = (data: any[] \| Uint8Array \| string \| string) => data.length,	1✔
19	isArray = (target: any) => Array.isArray(target),	1✔
20	shift = <T>(ary: T[]) => ary.shift(),	1✔
21	splice = <T>(ary: T[], start: number, deleteCount = 0, ...items: T[]) => ary.splice(start, deleteCount, ...items),	1✔
22	getConfig = <S, E, R, T, RC, RE, RH>(methodInstance: Method<S, E, R, T, RC, RE, RH>) => methodInstance.config,	1✔
23	getContext = <S, E, R, T, RC, RE, RH>(methodInstance: Method<S, E, R, T, RC, RE, RH>) => methodInstance.context,	1✔
24	JSONStringify = (	1✔
25	value: any,	×
26	replacer?: ((this: any, key: string, value: any) => any) \| undefined,	×
27	space?: string \| number \| undefined	×
28	) => JSON.stringify(value, replacer, space),	1✔
29	JSONParse = (text: string, reviver?: ((this: any, key: string, value: any) => any) \| undefined) =>	1✔
30	JSON.parse(text, reviver),	1✔
31	objectKeys = (obj: any) => ObjectCls.keys(obj),	1✔
32	objectValues = (obj: any) => ObjectCls.values(obj),	1✔
33	setTimeoutFn = (fn: GeneralFn, delay = 0) => setTimeout(fn, delay),	1✔
34	clearTimeoutFn = (timeoutId?: string \| number \| NodeJS.Timeout) => clearTimeout(timeoutId),	1✔
35	regexpTest = (reg: RegExp, str: string) => reg.test(str);	1✔
36		1✔
37	/**	1✔
38	* 创建同步多次调用只在异步执行一次的执行器	1✔
39	*/	1✔
40	export const createSyncOnceRunner = (delay = 0) => {	1✔
41	let timer: NodeJS.Timeout \| number \| undefined = undefinedValue;	479✔
42		479✔
43	/**	479✔
44	* 执行多次调用此函数将异步执行一次	479✔
45	*/	479✔
46	return (fn: () => void) => {	479✔
47	if (timer) {	110✔
48	clearTimeoutFn(timer);	69✔
49	}	69✔
50	timer = setTimeoutFn(fn, delay);	110✔
51	};	479✔
52	};	479✔
53		1✔
54	/**	1✔
55	* 创建uuid简易版	1✔
56	* @returns uuid	1✔
57	*/	1✔
58	export const uuid = () => {	1✔
59	const timestamp = new Date().getTime();	20,154✔
60	return Math.floor(Math.random() * timestamp).toString(36);	20,154✔
61	};	20,154✔
62		1✔
63	const referenceList = [] as { id: string; ref: any }[];	1✔
64	/**	1✔
65	* 获取唯一的引用类型id，如果是非引用类型则返回自身	1✔
66	* @param {reference} 引用类型数据	1✔
67	* @returns uniqueId	1✔
68	*/	1✔
69	export const getUniqueReferenceId = (reference: any) => {	1✔
70	const refType = typeof reference;	×
71	if (!['object', 'function', 'symbol'].includes(refType)) {	×
72	return reference;	×
73	}	×
74		×
75	let existedRef = referenceList.find(({ ref }) => ref === reference);	×
76	if (!existedRef) {	×
77	const uniqueId = uuid();	×
78	existedRef = {	×
79	id: uniqueId,	×
80	ref: reference	×
81	};	×
82	referenceList.push(existedRef);	×
83	}	×
84	return existedRef.id;	×
85	};	×
86		1✔
87	/**	1✔
88	* 兼容函数	1✔
89	*/	1✔
90	export const noop = () => {};	1✔
91		1✔
92	/**	1✔
93	* 兼容函数，返回自身	1✔
94	* @param value 任意值	1✔
95	* @returns 自身	1✔
96	*/	1✔
97	export const __self = <T>(value: T) => value;	1✔
98		1✔
99	// 判断是否为某个类的实例	1✔
100	export const instanceOf = <T>(arg: any, cls: new (...args: any[]) => T): arg is T => arg instanceof cls;	1✔
101		1✔
102	/**	1✔
103	* 构建格式化的错误消息	1✔
104	* @param prefix 错误前缀	1✔
105	* @param msg 错误消息	1✔
106	* @returns 格式化的错误消息	1✔
107	*/	1✔
108	export const buildErrorMsg = (prefix: string, msg: string) => `[alova/${prefix}]${msg}`;	1✔
109		1✔
110	/**	1✔
111	* 自定义断言函数，表达式为false时抛出错误	1✔
112	* @param expression 判断表达式，true或false	1✔
113	* @param msg 断言消息	1✔
114	*/	1✔
115	export const createAssert = (prefix: string) => {	1✔
116	return (expression: boolean, msg: string) => {	99✔
117	if (!expression) {	453✔
118	throw newInstance(Error, buildErrorMsg(prefix, msg));	25✔
119	}	25✔
120	};	99✔
121	};	99✔
122		1✔
123	export const valueObject = <T>(value: T, writable = falseValue) => ({	1✔
124	value,	690✔
125	writable	690✔
126	});	1✔
127		1✔
128	/**	1✔
129	* 定义obj属性	1✔
130	* @param o 对象	1✔
131	* @param attrs 值对象	1✔
132	*/	1✔
133	export const defineProperty = (o: object, key: string \| symbol, value: any, writable = falseValue) => {	1✔
134	ObjectCls.defineProperty(o, key, valueObject(value, writable));	642✔
135	};	642✔
136		1✔
137	export type GeneralFn = (...args: any[]) => any;	1✔
138	/**	1✔
139	* 批量执行时间回调函数，并将args作为参数传入	1✔
140	* @param handlers 事件回调数组	1✔
141	* @param args 函数参数	1✔
142	*/	1✔
143	export const runArgsHandler = (handlers: GeneralFn[], ...args: any[]) => {	1✔
144	let ret: any = undefinedValue;	354✔
145	forEach(handlers, handler => {	354✔
146	const retInner = handler(...args);	122✔
147	ret = retInner !== undefinedValue ? retInner : ret;	122✔
148	});	354✔
149	return ret;	354✔
150	};	354✔
151		1✔
152	/**	1✔
153	* typof冗余函数	1✔
154	* @param arg 任意参数	1✔
155	* @returns 参数类型	1✔
156	*/	1✔
157	export const typeOf = (arg: any) => typeof arg;	1✔
158		1✔
159	/**	1✔
160	* 判断参数是否为函数	1✔
161	* @param fn 任意参数	1✔
162	* @returns 该参数是否为函数	1✔
163	*/	1✔
164	export const isFn = (arg: any): arg is GeneralFn => typeOf(arg) === 'function';	1✔
165		1✔
166	/**	1✔
167	* 判断参数是否为字符串	1✔
168	* @param arg 任意参数	1✔
169	* @returns 该参数是否为字符串	1✔
170	*/	1✔
171	export const isString = (arg: any): arg is string => typeOf(arg) === 'string';	1✔
172		1✔
173	/**	1✔
174	* 判断参数是否为对象	1✔
175	* @param arg 任意参数	1✔
176	* @returns 该参数是否为对象	1✔
177	*/	1✔
178	export const isObject = <T = any>(arg: any): arg is T => arg !== nullValue && typeOf(arg) === 'object';	1✔
179		1✔
180	/**	1✔
181	* 判断是否为纯对象或自定义类的对象	1✔
182	* @param arg 任意参数	1✔
183	* @returns 该参数是否为纯对象或自定义类的对象	1✔
184	*/	1✔
185	export const isPlainOrCustomObject = <T = any>(arg: any): arg is T =>	1✔
186	ObjectCls.prototype.toString.call(arg) === '[object Object]';	1✔
187		1✔
188	/**	1✔
189	* 深层遍历目标对象	1✔
190	* @param target 目标对象	1✔
191	* @param callback 遍历回调	1✔
192	* @param preorder 是否前序遍历，默认为true	1✔
193	* @param key 当前遍历的key	1✔
194	* @param parent 当前遍历的父节点	1✔
195	*/	1✔
196	type AttrKey = string \| number \| symbol;	1✔
197	export const walkObject = (	1✔
198	target: any,	3,510✔
199	callback: (value: any, key: string \| number \| symbol, parent: any) => void,	3,510✔
200	preorder = trueValue,	3,510✔
201	key?: AttrKey,	3,510✔
202	parent?: any	3,510✔
203	) => {	3,510✔
204	const callCallback = () => {	3,510✔
205	if (parent && key) {	3,510✔
206	target = callback(target, key, parent);	3,227✔
207	if (target !== parent[key]) {	3,227✔
208	parent[key] = target;	661✔
209	}	661✔
210	}	3,227✔
211	};	3,510✔
212		3,510✔
213	// 前序遍历	3,510✔
214	preorder && callCallback();	3,510✔
215	if (isObject(target)) {	3,510✔
216	for (const i in target) {	1,336✔
217	if (!instanceOf(target, StringCls)) {	3,258✔
218	walkObject(target[i], callback, preorder, i, target);	3,227✔
219	}	3,227✔
220	}	3,258✔
221	}	1,336✔
222	// 后序遍历	3,510✔
223	!preorder && callCallback();	3,510✔
224	return target;	3,510✔
225	};	3,510✔
226		1✔
227	/**	1✔
228	* 创建类实例	1✔
229	* @param cls 构造函数	1✔
230	* @param args 构造函数参数	1✔
231	* @returns 类实例	1✔
232	*/	1✔
233	export const newInstance = <T extends { new (...args: any[]): InstanceType<T> }>(	1✔
234	cls: T,	235✔
235	...args: ConstructorParameters<T>	235✔
236	) => new cls(...args);	1✔
237		1✔
238	/**	1✔
239	* 统一配置	1✔
240	* @param 数据	1✔
241	* @returns 统一的配置	1✔
242	*/	1✔
243	export const sloughConfig = <T>(config: T \| ((...args: any[]) => T), args: any[] = []) =>	1✔
244	isFn(config) ? config(...args) : config;	1✔
245		1✔
246	export const getTime = (date?: Date \| null) => (date ? date.getTime() : Date.now());	1!
247		1✔
248	/**	1✔
249	* 判断参数是否为数字	1✔
250	* @param arg 任意参数	1✔
251	* @returns 该参数是否为数字	1✔
252	*/	1✔
253	export const isNumber = (arg: any): arg is number => typeof arg === 'number' && !isNaN(arg);	1✔
254		1✔
255	/** 三种缓存模式 */	1✔
256	// 只在内存中缓存，默认是此选项	1✔
257	const MEMORY = 'memory',	1✔
258	// 缓存会持久化，但当内存中没有缓存时，持久化缓存只会作为响应数据的占位符，且还会发送请求更新缓存	1✔
259		1✔
260	STORAGE_PLACEHOLDER = 'placeholder',	1✔
261	// 缓存会持久化，且每次刷新会读取持久化缓存到内存中，这意味着内存一直会有缓存	1✔
262	STORAGE_RESTORE = 'restore';	1✔
263	/**	1✔
264	* 获取缓存的配置参数，固定返回{ e: number, m: number, s: boolean, t: string }格式的对象	1✔
265	* e为expire缩写，表示缓存失效时间点（时间戳），单位为毫秒	1✔
266	* m为mode缩写，存储模式	1✔
267	* s为storage缩写，是否存储到本地	1✔
268	* t为tag缩写，持久化存储标签	1✔
269	* @param localCache 本地缓存参数	1✔
270	* @returns 统一的缓存参数对象	1✔
271	*/	1✔
272	export const getLocalCacheConfigParam = <S, E, R, T, RC, RE, RH>(	1✔
273	methodInstance?: Method<S, E, R, T, RC, RE, RH>,	200✔
274	localCache?: LocalCacheConfig	200✔
275	) => {	200✔
276	const _localCache =	200✔
277	localCache !== undefinedValue ? localCache : methodInstance ? getConfig(methodInstance).localCache : undefinedValue;	200!
278		200✔
279	const getCacheExpireTs = (_localCache: CacheExpire) =>	200✔
280	isNumber(_localCache) ? getTime() + _localCache : getTime(_localCache);	200!
281	let cacheMode = MEMORY;	200✔
282	let expire = 0;	200✔
283	let storage = falseValue;	200✔
284	let tag: undefined \| string = undefinedValue;	200✔
285	if (!isFn(_localCache)) {	200✔
286	if (isNumber(_localCache) \|\| instanceOf(_localCache, Date)) {	200!
287	expire = getCacheExpireTs(_localCache);	200✔
288	} else {	200!
UNCOV 289	const { mode = MEMORY, expire: configExpire = 0, tag: configTag } = _localCache \|\| {};	×
290	cacheMode = mode;	×
291	expire = getCacheExpireTs(configExpire);	×
292	storage = [STORAGE_PLACEHOLDER, STORAGE_RESTORE].includes(mode);	×
293	tag = configTag ? configTag.toString() : undefinedValue;	×
294	}	×
295	}	200✔
296	return {	200✔
297	e: expire,	200✔
298	m: cacheMode,	200✔
299	s: storage,	200✔
300	t: tag	200✔
301	};	200✔
302	};	200✔
303		1✔
304	/**	1✔
305	* 根据避让策略和重试次数计算重试延迟时间	1✔
306	* @param backoff 避让参数	1✔
307	* @param retryTimes 重试次数	1✔
308	* @returns 重试延迟时间	1✔
309	*/	1✔
310	export const delayWithBackoff = (backoff: BackoffPolicy, retryTimes: number) => {	1✔
311	let { delay, multiplier = 1, startQuiver, endQuiver } = backoff;	58✔
312	let retryDelayFinally = (delay \|\| 0) * Math.pow(multiplier, retryTimes - 1);	58!
313	// 如果startQuiver或endQuiver有值，则需要增加指定范围的随机抖动值	58✔
314	if (startQuiver \|\| endQuiver) {	58✔
315	startQuiver = startQuiver \|\| 0;	12✔
316	endQuiver = endQuiver \|\| 1;	12✔
317	retryDelayFinally +=	12✔
318	retryDelayFinally * startQuiver + Math.random() * retryDelayFinally * (endQuiver - startQuiver);	12✔
319	retryDelayFinally = Math.floor(retryDelayFinally); // 取整数延迟	12✔
320	}	12✔
321	return retryDelayFinally;	58✔
322	};	58✔

alovajs / scene / #32

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

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