2057480971

Build # 2057480971

Build Type

github

Committed by GitHub

Commit Message

Merge 5fe85117f into 100537991

Pull Request Pull Request #1706: sync features and bugfixs from 8827ada

Run Details

3106 of 7216 branches covered (43.04%)

Branch coverage included in aggregate %.

200 of 331 new or added lines in 46 files covered. (60.42%)

2 existing lines in 1 file now uncovered.

5257 of 10411 relevant lines covered (50.49%)

212878.77 hits per line

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

66.1

/packages/core/lib/usm-redux/decorators/action.ts

/* eslint-disable func-names */
import { produceWithPatches, produce, Patch } from 'immer';
import { Service, Action } from '../interface';
import { storeKey, identifierKey, usm } from '../constant';
import { getPatchesToggle } from '../createStore';
import { getStagedState, setStagedState } from '../utils/index';
import { checkPatches } from '../checkPatches';

export const action = (
  target: object,
  key: string | symbol,
  descriptor: TypedPropertyDescriptor<(...args: any[]) => void>,
) => {
  const fn = descriptor.value;
  if (typeof fn !== 'function') {
    throw new Error(
      `${String(key)} can only be decorated by '@action' as a class method.`,
    );
  }
  const value = function (this: Service, ...args: unknown[]) {
    let time: number;
    if (process.env.NODE_ENV === 'development') {
      time = Date.now();
    }
    if (typeof getStagedState() === 'undefined') {
      try {
        const lastState = this[storeKey].getState();
        let state: Record<string, any> | undefined;
        let patches: Patch[] = [];
        let inversePatches: Patch[] = [];
        const recipe = (draftState: Record<string, unknown>) => {
          setStagedState(draftState);
          fn.apply(this, args);
        };
        const enablePatches = getPatchesToggle();
        if (enablePatches) {
          [state, patches, inversePatches] = produceWithPatches(
            lastState,
            recipe,
          );
        } else {
          state = produce(lastState, recipe);
        }
        setStagedState(undefined);
        const changed = lastState !== state;
        if (process.env.NODE_ENV === 'development') {
          if (!changed) {
            console.warn(
              `There are no state updates to method '${
                this[identifierKey]
              }.${key.toString()}' with arguments:`,
              ...args,
            );
          }
          // performance checking
          const executionTime = Date.now() - time!;
          if (executionTime > 200)
            console.warn(
              `The execution time of method '${
                this[identifierKey]
              }.${key.toString()}' is ${executionTime} ms, it's recommended to use 'dispatch' API.`,
            );
          // performance detail: https://immerjs.github.io/immer/docs/performance
        }

        if (changed) {
          const action: Action = {
            type: this[identifierKey],
            method: key,
            params: args,
            _state: state,
            _usm: usm,
            ...(enablePatches
              ? {
                  _patches: patches,
                  _inversePatches: inversePatches,
                }
              : {}),
          };
          if (process.env.NODE_ENV === 'development') {
            const requiredWarning = checkPatches(lastState, action);
            if (requiredWarning) {
              console.warn(
                `The state update operation in the method '${this[
                  identifierKey
                ].toString()}.${key.toString()}'  is a replacement update operation. If there is a performance issue, be sure to use mutation updates to ensure the minimum set of update patches.`,
              );
            }
          }
          this[storeKey].dispatch(action);
        }
      } finally {
        setStagedState(undefined);
      }
    } else {
      // enable staged state mode.
      fn.apply(this, args);
    }
  };
  return {
    ...descriptor,
    value,
  };
};

1	/* eslint-disable func-names */
2	import { produceWithPatches, produce, Patch } from 'immer';
3	import { Service, Action } from '../interface';
4	import { storeKey, identifierKey, usm } from '../constant';
5	import { getPatchesToggle } from '../createStore';
6	import { getStagedState, setStagedState } from '../utils/index';
7	import { checkPatches } from '../checkPatches';
8
9	export const action = (	84✔
10	target: object,
11	key: string \| symbol,
12	descriptor: TypedPropertyDescriptor<(...args: any[]) => void>,
13	) => {
14	const fn = descriptor.value;	7,844✔
15	if (typeof fn !== 'function') {	7,844!
16	throw new Error(	×
17	`${String(key)} can only be decorated by '@action' as a class method.`,
18	);
19	}
20	const value = function (this: Service, ...args: unknown[]) {	7,844✔
21	let time: number;
22	if (process.env.NODE_ENV === 'development') {	106,963!
23	time = Date.now();	×
24	}
25	if (typeof getStagedState() === 'undefined') {	106,963✔
26	try {	106,320✔
27	const lastState = this[storeKey].getState();	106,320✔
28	let state: Record<string, any> \| undefined;
29	let patches: Patch[] = [];	106,314✔
30	let inversePatches: Patch[] = [];	106,314✔
31	const recipe = (draftState: Record<string, unknown>) => {	106,314✔
32	setStagedState(draftState);	106,314✔
33	fn.apply(this, args);	106,314✔
34	};
35	const enablePatches = getPatchesToggle();	106,314✔
36	if (enablePatches) {	106,314✔
37	[state, patches, inversePatches] = produceWithPatches(	106,257✔
38	lastState,
39	recipe,
40	);
41	} else {
42	state = produce(lastState, recipe);	57✔
43	}
44	setStagedState(undefined);	106,314✔
45	const changed = lastState !== state;	106,314✔
46	if (process.env.NODE_ENV === 'development') {	106,314!
47	if (!changed) {	×
48	console.warn(	×
49	`There are no state updates to method '${
50	this[identifierKey]
51	}.${key.toString()}' with arguments:`,
52	...args,
53	);
54	}
55	// performance checking
56	const executionTime = Date.now() - time!;	×
NEW 57	if (executionTime > 200)	×
58	console.warn(	×
59	`The execution time of method '${
60	this[identifierKey]
61	}.${key.toString()}' is ${executionTime} ms, it's recommended to use 'dispatch' API.`,
62	);
63	// performance detail: https://immerjs.github.io/immer/docs/performance
64	}
65
66	if (changed) {	106,314✔
67	const action: Action = {	100,252✔
68	type: this[identifierKey],
69	method: key,
70	params: args,
71	_state: state,
72	_usm: usm,
73	...(enablePatches	100,252✔
74	? {
75	_patches: patches,
76	_inversePatches: inversePatches,
77	}
78	: {}),
79	};
80	if (process.env.NODE_ENV === 'development') {	100,252!
81	const requiredWarning = checkPatches(lastState, action);	×
82	if (requiredWarning) {	×
83	console.warn(	×
84	`The state update operation in the method '${this[
85	identifierKey
86	].toString()}.${key.toString()}' is a replacement update operation. If there is a performance issue, be sure to use mutation updates to ensure the minimum set of update patches.`,
87	);
88	}
89	}
90	this[storeKey].dispatch(action);	100,252✔
91	}
92	} finally {
93	setStagedState(undefined);	106,320✔
94	}
95	} else {
96	// enable staged state mode.
97	fn.apply(this, args);	643✔
98	}
99	};
100	return {	7,844✔
101	...descriptor,
102	value,
103	};
104	};

ringcentral / ringcentral-js-widgets / 2057480971

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