9184355216

Committed 22 May 2024 02:18AM UTC coverage: 61.327% (-1.7%) from 63.012%

Build # 9184355216

Build Type

Pull #88

github

Committed by

web-flow

Commit Message

Merge 36408970b into 12069874f

Pull Request Pull Request #88: feat: support debug Huawei HarmonyOS App (API 11)

Run Details

1349 of 1526 branches covered (88.4%)

Branch coverage included in aggregate %.

12 of 848 new or added lines in 20 files covered. (1.42%)

10 existing lines in 1 file now uncovered.

5324 of 9355 relevant lines covered (56.91%)

32.17 hits per line

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

0.0

/packages/page-spy-harmony/library/src/main/ets/utils/index.ts

export function getRandomId() {
  return Math.random().toString(36).slice(2);
}
export function getObjectKeys<T extends Record<string, any>>(obj: T) {
  return Object.keys(obj) as (keyof T)[];
}

export function toStringTag(value: any) {
  return Object.prototype.toString.call(value);
}

export function hasOwnProperty(target: Object, key: string) {
  return Object.prototype.hasOwnProperty.call(target, key);
}

export function isString(value: unknown): value is string {
  return typeof value === 'string';
}

export function isNumber(value: unknown): value is number {
  return typeof value === 'number';
}

export function isBigInt(value: unknown): value is bigint {
  return toStringTag(value) === '[object BigInt]';
}

export function isArray(value: unknown): value is unknown[] {
  return value instanceof Array;
}

export function isObjectLike(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null;
}

export function isPlainObject(
  value: unknown,
): value is Record<string, unknown> {
  if (!isObjectLike(value) || toStringTag(value) !== '[object Object]') {
    return false;
  }
  return true;
}

export function isPrototype(value: unknown): value is Object {
  if (
    isObjectLike(value) &&
    hasOwnProperty(value, 'constructor') &&
    typeof value.constructor === 'function'
  ) {
    return true;
  }
  return false;
}

export function isArrayBuffer(value: unknown): value is ArrayBuffer {
  return value instanceof ArrayBuffer;
}

export function isClass(obj: unknown): obj is Function {
  return typeof obj === 'function' && typeof obj.prototype !== 'undefined';
}

type TypedArray =
  | Int8Array
  | Uint8Array
  | Uint8ClampedArray
  | Int16Array
  | Uint16Array
  | Int32Array
  | Uint32Array
  | Float32Array
  | Float64Array
  | BigInt64Array
  | BigUint64Array;
export function isTypedArray(value: unknown): value is TypedArray {
  return ArrayBuffer.isView(value);
}

interface PrimitiveResult {
  ok: boolean;
  value: any;
}

const stringify = (value: any) => `${value}`;
const primitive = (value: any) => ({
  ok: true,
  value,
});

export function makePrimitiveValue(value: unknown): PrimitiveResult {
  if (value === undefined) {
    return primitive(stringify(value));
  }
  if (value === null) {
    return primitive(value);
  }
  if (isNumber(value)) {
    if (value === -Infinity || value === Infinity || Number.isNaN(value)) {
      return primitive(stringify(value));
    }
  }
  if (isBigInt(value)) {
    return primitive(`${value}n`);
  }
  if (typeof value === 'symbol' || typeof value === 'function') {
    return primitive(stringify(value.toString()));
  }
  if (value instanceof Error) {
    return primitive(stringify(value.stack!));
  }
  if (value === Object.prototype) {
    return {
      value: null,
      ok: false,
    };
  }
  if (!(value instanceof Object || typeof value === 'object')) {
    return primitive(value);
  }
  return {
    value,
    ok: false,
  };
}

/**
 * convert `symbol / error / undefined / function` type data to readable string content
 */
export function stringifyData(data: any): any {
  const { ok, value } = makePrimitiveValue(data);
  if (ok) {
    return value;
  }
  return JSON.stringify(data, (key, val) => makePrimitiveValue(val).value, 2);
}

export function getValueType(value: any) {
  if (value === undefined) return 'undefined';
  if (value === null) return 'null';
  if (isBigInt(value)) return 'bigint';
  if (value instanceof Object) {
    if (value instanceof Error) return 'error';
    if (value instanceof Function) return 'function';
    return 'object';
  }
  return typeof value;
}

// Usage 1: `psLog.<fn>` to print system level debug info to developer
interface LogMethods {
  log(...message: any[]): void;
  info(...message: any[]): void;
  warn(...message: any[]): void;
  error(...message: any[]): void;
  debug(...message: any[]): void;
}

interface PSLog extends LogMethods {
  // Usage 2: `psLog.unproxy.<fn>` to print debug info for self debugging.
  unproxy: LogMethods;
}

const unproxyConsole = { ...console };

export const psLog = (
  ['log', 'info', 'error', 'warn', 'debug'] as const
).reduce(
  (result, method) => {
    result[method] = (...message: any[]) => {
      console[method](`[PageSpy] [${method.toLocaleUpperCase()}] `, ...message);
    };
    result.unproxy[method] = (...message: any[]) => {
      unproxyConsole[method](
        `[PageSpy] [${method.toLocaleUpperCase()}] `,
        ...message,
      );
    };
    return result;
  },
  { unproxy: {} } as PSLog,
);

export function getAuthSecret() {
  const secret = Math.floor(Math.random() * 1000000);
  return String(secret).padStart(6, '0');
}

export function isNotEmpty(value: unknown): value is object {
  return value !== null && value !== undefined;
}

1	export function getRandomId() {	×
2	return Math.random().toString(36).slice(2);	×
3	}	×
4	export function getObjectKeys<T extends Record<string, any>>(obj: T) {	×
5	return Object.keys(obj) as (keyof T)[];	×
6	}	×
7		×
8	export function toStringTag(value: any) {	×
9	return Object.prototype.toString.call(value);	×
10	}	×
11		×
12	export function hasOwnProperty(target: Object, key: string) {	×
13	return Object.prototype.hasOwnProperty.call(target, key);	×
14	}	×
15		×
16	export function isString(value: unknown): value is string {	×
17	return typeof value === 'string';	×
18	}	×
19		×
20	export function isNumber(value: unknown): value is number {	×
21	return typeof value === 'number';	×
22	}	×
23		×
24	export function isBigInt(value: unknown): value is bigint {	×
25	return toStringTag(value) === '[object BigInt]';	×
26	}	×
27		×
28	export function isArray(value: unknown): value is unknown[] {	×
29	return value instanceof Array;	×
30	}	×
31		×
32	export function isObjectLike(value: unknown): value is Record<string, unknown> {	×
33	return typeof value === 'object' && value !== null;	×
34	}	×
35		×
36	export function isPlainObject(	×
37	value: unknown,	×
38	): value is Record<string, unknown> {	×
39	if (!isObjectLike(value) \|\| toStringTag(value) !== '[object Object]') {	×
40	return false;	×
41	}	×
42	return true;	×
43	}	×
44		×
45	export function isPrototype(value: unknown): value is Object {	×
46	if (	×
47	isObjectLike(value) &&	×
48	hasOwnProperty(value, 'constructor') &&	×
49	typeof value.constructor === 'function'	×
50	) {	×
51	return true;	×
52	}	×
53	return false;	×
54	}	×
55		×
56	export function isArrayBuffer(value: unknown): value is ArrayBuffer {	×
57	return value instanceof ArrayBuffer;	×
58	}	×
59		×
60	export function isClass(obj: unknown): obj is Function {	×
61	return typeof obj === 'function' && typeof obj.prototype !== 'undefined';	×
62	}	×
63		×
64	type TypedArray =	×
65	\| Int8Array	×
66	\| Uint8Array	×
67	\| Uint8ClampedArray	×
68	\| Int16Array	×
69	\| Uint16Array	×
70	\| Int32Array	×
71	\| Uint32Array	×
72	\| Float32Array	×
73	\| Float64Array	×
74	\| BigInt64Array	×
75	\| BigUint64Array;	×
76	export function isTypedArray(value: unknown): value is TypedArray {	×
77	return ArrayBuffer.isView(value);	×
78	}	×
79		×
80	interface PrimitiveResult {	×
81	ok: boolean;	×
82	value: any;	×
83	}	×
84		×
85	const stringify = (value: any) => `${value}`;	×
86	const primitive = (value: any) => ({	×
87	ok: true,	×
88	value,	×
89	});	×
90		×
91	export function makePrimitiveValue(value: unknown): PrimitiveResult {	×
92	if (value === undefined) {	×
93	return primitive(stringify(value));	×
94	}	×
95	if (value === null) {	×
96	return primitive(value);	×
97	}	×
98	if (isNumber(value)) {	×
99	if (value === -Infinity \|\| value === Infinity \|\| Number.isNaN(value)) {	×
100	return primitive(stringify(value));	×
101	}	×
102	}	×
103	if (isBigInt(value)) {	×
104	return primitive(`${value}n`);	×
105	}	×
106	if (typeof value === 'symbol' \|\| typeof value === 'function') {	×
107	return primitive(stringify(value.toString()));	×
108	}	×
109	if (value instanceof Error) {	×
110	return primitive(stringify(value.stack!));	×
111	}	×
112	if (value === Object.prototype) {	×
113	return {	×
114	value: null,	×
115	ok: false,	×
116	};	×
117	}	×
118	if (!(value instanceof Object \|\| typeof value === 'object')) {	×
119	return primitive(value);	×
120	}	×
121	return {	×
122	value,	×
123	ok: false,	×
124	};	×
125	}	×
126		×
127	/**	×
128	* convert `symbol / error / undefined / function` type data to readable string content	×
129	*/	×
130	export function stringifyData(data: any): any {	×
131	const { ok, value } = makePrimitiveValue(data);	×
132	if (ok) {	×
133	return value;	×
134	}	×
135	return JSON.stringify(data, (key, val) => makePrimitiveValue(val).value, 2);	×
136	}	×
137		×
138	export function getValueType(value: any) {	×
139	if (value === undefined) return 'undefined';	×
140	if (value === null) return 'null';	×
141	if (isBigInt(value)) return 'bigint';	×
142	if (value instanceof Object) {	×
143	if (value instanceof Error) return 'error';	×
144	if (value instanceof Function) return 'function';	×
145	return 'object';	×
146	}	×
147	return typeof value;	×
148	}	×
149		×
NEW 150	// Usage 1: `psLog.<fn>` to print system level debug info to developer	×
NEW 151	interface LogMethods {	×
152	log(...message: any[]): void;	×
153	info(...message: any[]): void;	×
154	warn(...message: any[]): void;	×
155	error(...message: any[]): void;	×
156	debug(...message: any[]): void;	×
157	}	×
158		×
NEW 159	interface PSLog extends LogMethods {	×
NEW 160	// Usage 2: `psLog.unproxy.<fn>` to print debug info for self debugging.	×
NEW 161	unproxy: LogMethods;	×
NEW 162	}	×
163		×
NEW 164	const unproxyConsole = { ...console };	×
NEW 165		×
NEW 166	export const psLog = (	×
NEW 167	['log', 'info', 'error', 'warn', 'debug'] as const	×
NEW 168	).reduce(	×
169	(result, method) => {	×
170	result[method] = (...message: any[]) => {	×
NEW 171	console[method](`[PageSpy] [${method.toLocaleUpperCase()}] `, ...message);	×
NEW 172	};	×
NEW 173	result.unproxy[method] = (...message: any[]) => {	×
NEW 174	unproxyConsole[method](	×
NEW 175	`[PageSpy] [${method.toLocaleUpperCase()}] `,	×
176	...message,	×
177	);	×
178	};	×
179	return result;	×
180	},	×
NEW 181	{ unproxy: {} } as PSLog,	×
182	);	×
NEW 183		×
NEW 184	export function getAuthSecret() {	×
NEW 185	const secret = Math.floor(Math.random() * 1000000);	×
NEW 186	return String(secret).padStart(6, '0');	×
NEW 187	}	×
NEW 188		×
NEW 189	export function isNotEmpty(value: unknown): value is object {	×
NEW 190	return value !== null && value !== undefined;	×
NEW 191	}	×

HuolalaTech / page-spy / 9184355216

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