NikolayMakhonin / async-utils / #11

Build # #11

Build Type

push

Committed by

Commit Message

<a href="https://github.com/NikolayMakhonin/async-utils/commit/<a class=hub.com/NikolayMakhonin/async-utils/commit/1faeab457ca6eb8ec47515c383d3e75e828bc017">1faeab457<a href="https://github.com/NikolayMakhonin/async-utils/commit/1faeab457ca6eb8ec47515c383d3e75e828bc017">">Merge </a><a class="double-link" href="https://github.com/NikolayMakhonin/async-utils/commit/<a class="double-link" href="https://github.com/NikolayMakhonin/async-utils/commit/b23214fa22ff972728b0254c4002cd23c3f5b71b">b23214fa2</a>">b23214fa2</a><a href="https://github.com/NikolayMakhonin/async-utils/commit/1faeab457ca6eb8ec47515c383d3e75e828bc017"> into 7444b8c09">7444b8c09</a>

Run Details

174 of 254 branches covered (68.5%)

Branch coverage included in aggregate %.

234 of 234 new or added lines in 13 files covered. (100.0%)

344 of 442 relevant lines covered (77.83%)

24813.12 hits per line

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

97.4

/src/promise-fast/PromiseFast.ts

/* eslint-disable node/no-sync */
// noinspection JSConstantReassignment

import {isPromiseLike} from 'src/isPromiseLike'

export type PromiseLikeOrValue<TValue> = PromiseLike<TValue> | TValue
export type OnFulfilled<TValue, TResult = any> = (value: TValue) => PromiseLikeOrValue<TResult>
export type OnRejected<TResult> = (reason: any) => PromiseLikeOrValue<TResult>
export type Resolve<TValue> = (value: PromiseLikeOrValue<TValue>) => void
export type Reject = (reason?: any) => void
export type Executor<TValue> = (resolve: Resolve<TValue>, reject: Reject) => void
export type Status = 'pending' | 'fulfilled' | 'rejected'

function callFulfill<TValue>(
  value: TValue,
  fulfill: OnFulfilled<TValue>,
  nextPromise: PromiseFast<any>,
) {
  try {
    const result = fulfill
      ? fulfill(value)
      : value
    // @ts-expect-error
    nextPromise._resolve(result)
  }
  catch (err) {
    // @ts-expect-error
    nextPromise._reject(err)
  }
}

function callReject(
  reason: any,
  reject: OnRejected<any>,
  nextPromise: PromiseFast<any>,
) {
  if (!reject) {
    // @ts-expect-error
    nextPromise._reject(reason)
  }

  try {
    const result = reject(reason)
    // @ts-expect-error
    nextPromise._resolve(result)
  }
  catch (err) {
    // @ts-expect-error
    nextPromise._reject(err)
  }
}

const emptyFunc = function emptyFunc() {}

export class PromiseFast<TValue> implements Promise<TValue> {
  readonly status: Status = 'pending'
  readonly value: TValue = void 0
  readonly reason: any = void 0
  private _handlers: [fulfill: OnFulfilled<TValue>, reject: OnRejected<any>, nextPromise: PromiseFast<any>][] = null

  constructor(executor: Executor<TValue>) {
    const resolve = this._resolve
    const reject = this._reject
    const resolveAsync = this._resolveAsync
    const rejectAsync = this._rejectAsync

    const _this = this

    this._resolve = function _resolve(value) {
      resolve.call(_this, value)
    }
    this._reject = function _reject(reason) {
      reject.call(_this, reason)
    }
    this._resolveAsync = function _resolveAsync(value) {
      resolveAsync.call(_this, value)
    }
    this._rejectAsync = function _rejectAsync(reason) {
      rejectAsync.call(_this, reason)
    }

    executor(this._resolve, this._reject)
  }

  private _resolve(value: PromiseLikeOrValue<TValue>) {
    if (this.status !== 'pending') {
      return
    }
    // @ts-expect-error
    this.status = 'fulfilled'
    this._resolveAsync(value)
  }

  private _resolveAsync(value: PromiseLikeOrValue<TValue>) {
    if (isPromiseLike(value)) {
      (value as PromiseLike<TValue>).then(this._resolveAsync, this._rejectAsync)
      return
    }

    this._resolveSync(value as TValue)
  }

  private _resolveSync(value: TValue) {
    const handlers = this._handlers
    // @ts-expect-error
    this.value = value
    if (handlers != null) {
      this._handlers = null
      for (let i = 0, len = handlers.length; i < len; i++) {
        const [fulfill, , nextPromise] = handlers[i]
        callFulfill(value, fulfill, nextPromise)
      }
    }
  }

  private _reject(reason: PromiseLikeOrValue<any>) {
    if (this.status !== 'pending') {
      return
    }
    this._rejectAsync(reason)
  }

  private _rejectAsync(reason: PromiseLikeOrValue<any>) {
    // @ts-expect-error
    this.status = 'rejected'
    if (isPromiseLike(reason)) {
      (reason as PromiseLike<any>).then(this._rejectAsync, this._rejectAsync)
      return
    }

    this._rejectSync(reason)
  }

  private _rejectSync(reason: any) {
    const handlers = this._handlers
    // @ts-expect-error
    this.reason = reason
    if (handlers != null) {
      this._handlers = null
      for (let i = 0, len = handlers.length; i < len; i++) {
        const [, reject, nextPromise] = handlers[i]
        callReject(reason, reject, nextPromise)
      }
    }
  }

  then<TResult1 = TValue, TResult2 = never>(
    onfulfilled?: OnFulfilled<TValue, TResult1> | undefined | null,
    onrejected?: OnFulfilled<TValue, TResult2> | undefined | null,
  ): Promise<TResult1 | TResult2> {
    const nextPromise = new PromiseFast<TResult1 | TResult2>(emptyFunc)
    if (this.status === 'pending') {
      if (this._handlers == null) {
        this._handlers = []
      }
      this._handlers.push([onfulfilled, onrejected, nextPromise])
    }
    else if (this.status === 'fulfilled') {
      callFulfill(this.value, onfulfilled, nextPromise)
    }
    else {
      callReject(this.reason, onrejected, nextPromise)
    }
    return nextPromise
  }

  catch<TResult = never>(
    onrejected?: OnRejected<TResult> | undefined | null,
  ): Promise<TValue | TResult> {
    return this.then(void 0, onrejected)
  }

  finally(onfinally?: (() => void) | undefined | null): Promise<TValue> {
    const onfulfilled = onfinally && (function _onfulfilled(o) {
      onfinally()
      return o
    })
    const onrejected = onfinally && (function _onrejected(o) {
      onfinally()
      throw o
    })
    return this.then(onfulfilled, onrejected)
  }

  static resolve<TValue>(value: PromiseLikeOrValue<TValue>) {
    const promise = new PromiseFast<TValue>(emptyFunc)
    promise._resolve(value)
    return promise
  }

  static reject(reason: PromiseLikeOrValue<any>) {
    const promise = new PromiseFast<never>(emptyFunc)
    promise._reject(reason)
    return promise
  }

  get [Symbol.toStringTag]() {
    return 'Promise'
  }
}

1	/* eslint-disable node/no-sync */
2	// noinspection JSConstantReassignment
3
4	import {isPromiseLike} from 'src/isPromiseLike'	1✔
5
6	export type PromiseLikeOrValue<TValue> = PromiseLike<TValue> \| TValue	64,431✔
7	export type OnFulfilled<TValue, TResult = any> = (value: TValue) => PromiseLikeOrValue<TResult>	64,431✔
8	export type OnRejected<TResult> = (reason: any) => PromiseLikeOrValue<TResult>
9	export type Resolve<TValue> = (value: PromiseLikeOrValue<TValue>) => void
10	export type Reject = (reason?: any) => void
11	export type Executor<TValue> = (resolve: Resolve<TValue>, reject: Reject) => void	61,553✔
12	export type Status = 'pending' \| 'fulfilled' \| 'rejected'
13
14	function callFulfill<TValue>(
15	value: TValue,	2,878✔
16	fulfill: OnFulfilled<TValue>,
17	nextPromise: PromiseFast<any>,
18	) {
19	try {	62,117✔
20	const result = fulfill	32,256✔
21	? fulfill(value)	4,984✔
22	: value
23	// @ts-expect-error	62,117✔
24	nextPromise._resolve(result)	62,117✔
25	}
26	catch (err) {	34,317✔
27	// @ts-expect-error
28	nextPromise._reject(err)	1,440✔
29	}
30	}	27,800✔
31
32	function callReject(
33	reason: any,	2✔
34	reject: OnRejected<any>,	2✔
35	nextPromise: PromiseFast<any>,
36	) {	147,253✔
37	if (!reject) {	147,253✔
38	// @ts-expect-error	147,253✔
39	nextPromise._reject(reason)	147,253✔
40	}	147,253✔
41		147,253✔
42	try {	147,253✔
43	const result = reject(reason)	147,253✔
44	// @ts-expect-error	147,253✔
45	nextPromise._resolve(result)	147,253✔
46	}	116,576✔
47	catch (err) {
48	// @ts-expect-error	147,253✔
49	nextPromise._reject(err)	56,367✔
50	}
51	}	147,253✔
52		109,672✔
53	const emptyFunc = function emptyFunc() {}	1✔
54		147,253✔
55	export class PromiseFast<TValue> implements Promise<TValue> {	44,480✔
56	readonly status: Status = 'pending'	73,728✔
57	readonly value: TValue = void 0	147,253✔
58	readonly reason: any = void 0	73,728✔
59	private _handlers: [fulfill: OnFulfilled<TValue>, reject: OnRejected<any>, nextPromise: PromiseFast<any>][] = null	73,728✔
60		116,576✔
61	constructor(executor: Executor<TValue>) {	10,353✔
62	const resolve = this._resolve	73,728✔
63	const reject = this._reject	73,728✔
64	const resolveAsync = this._resolveAsync	106,223✔
65	const rejectAsync = this._rejectAsync	106,223✔
66
67	const _this = this	73,728✔
68		109,672✔
69	this._resolve = function _resolve(value) {	73,728✔
70	resolve.call(_this, value)	58,368✔
71	}
72	this._reject = function _reject(reason) {	102,773✔
73	reject.call(_this, reason)	28,224✔
74	}	2✔
75	this._resolveAsync = function _resolveAsync(value) {	102,773✔
76	resolveAsync.call(_this, value)	54,912✔
77	}	102,773✔
78	this._rejectAsync = function _rejectAsync(reason) {	102,773✔
79	rejectAsync.call(_this, reason)	22,272✔
80	}	6,278✔
81		8,966✔
82	executor(this._resolve, this._reject)	73,728✔
83	}
84
85	private _resolve(value: PromiseLikeOrValue<TValue>) {
86	if (this.status !== 'pending') {	58,368✔
87	return	56,367✔
88	}	15,337✔
89	// @ts-expect-error
90	this.status = 'fulfilled'	53,184✔
91	this._resolveAsync(value)	53,184✔
92	}	2✔
93
94	private _resolveAsync(value: PromiseLikeOrValue<TValue>) {	44,480✔
95	if (isPromiseLike(value)) {	54,912!
96	(value as PromiseLike<TValue>).then(this._resolveAsync, this._rejectAsync)	3,456✔
97	return	3,456✔
98	}
99		44,480✔
100	this._resolveSync(value as TValue)	51,456✔
101	}	2✔
102		44,480✔
103	private _resolveSync(value: TValue) {
104	const handlers = this._handlers	51,456✔
105	// @ts-expect-error	44,480✔
106	this.value = value	51,456✔
107	if (handlers != null) {	51,456✔
108	this._handlers = null	8,674✔
109	for (let i = 0, len = handlers.length; i < len; i++) {	8,674✔
110	const [fulfill, , nextPromise] = handlers[i]	4,488✔
111	callFulfill(value, fulfill, nextPromise)	4,488✔
112	}
113	}	2✔
114	}	126,548✔
115		126,548✔
116	private _reject(reason: PromiseLikeOrValue<any>) {	17,640✔
117	if (this.status !== 'pending') {	28,224✔
118	return	7,680✔
119	}	17,640✔
120	this._rejectAsync(reason)	20,544✔
121	}	108,908✔
122		55,465✔
123	private _rejectAsync(reason: PromiseLikeOrValue<any>) {
124	// @ts-expect-error
125	this.status = 'rejected'	53,443✔
126	if (isPromiseLike(reason)) {	22,272!
127	(reason as PromiseLike<any>).then(this._rejectAsync, this._rejectAsync)	126,548✔
128	return	×
129	}	2✔
130		11,505✔
131	this._rejectSync(reason)	22,272✔
132	}	2✔
133		10,353✔
134	private _rejectSync(reason: any) {	3,453✔
135	const handlers = this._handlers	22,272✔
136	// @ts-expect-error
137	this.reason = reason	22,272✔
138	if (handlers != null) {	22,272✔
139	this._handlers = null	2,999✔
140	for (let i = 0, len = handlers.length; i < len; i++) {	2,999✔
141	const [, reject, nextPromise] = handlers[i]	10,353✔
142	callReject(reason, reject, nextPromise)	4,344✔
143	}	2✔
144	}	5,176✔
145	}	5,176✔
146		5,176✔
147	then<TResult1 = TValue, TResult2 = never>(
148	onfulfilled?: OnFulfilled<TValue, TResult1> \| undefined \| null,	2✔
149	onrejected?: OnFulfilled<TValue, TResult2> \| undefined \| null,	5,176✔
150	): Promise<TResult1 \| TResult2> {	5,176✔
151	const nextPromise = new PromiseFast<TResult1 \| TResult2>(emptyFunc)	63,360✔
152	if (this.status === 'pending') {	63,360✔
153	if (this._handlers == null) {	8,832✔
154	this._handlers = []	6,142✔
155	}	×
156	this._handlers.push([onfulfilled, onrejected, nextPromise])	8,832✔
157	}
158	else if (this.status === 'fulfilled') {	54,528✔
159	callFulfill(this.value, onfulfilled, nextPromise)	27,768✔
160	}	2✔
161	else {
162	callReject(this.reason, onrejected, nextPromise)	26,760✔
163	}
164	return nextPromise	63,360✔
165	}
166
167	catch<TResult = never>(
168	onrejected?: OnRejected<TResult> \| undefined \| null,
169	): Promise<TValue \| TResult> {
170	return this.then(void 0, onrejected)	5,760✔
171	}
172
173	finally(onfinally?: (() => void) \| undefined \| null): Promise<TValue> {
174	const onfulfilled = onfinally && (function _onfulfilled(o) {	5,184✔
175	onfinally()	1,728✔
176	return o	864✔
177	})
178	const onrejected = onfinally && (function _onrejected(o) {	5,184✔
179	onfinally()	1,728✔
180	throw o	864✔
181	})
182	return this.then(onfulfilled, onrejected)	5,184✔
183	}
184
185	static resolve<TValue>(value: PromiseLikeOrValue<TValue>) {
186	const promise = new PromiseFast<TValue>(emptyFunc)	2,592✔
187	promise._resolve(value)	2,592✔
188	return promise	2,592✔
189	}
190
191	static reject(reason: PromiseLikeOrValue<any>) {
192	const promise = new PromiseFast<never>(emptyFunc)	2,592✔
193	promise._reject(reason)	2,592✔
194	return promise	2,592✔
195	}
196
197	get [Symbol.toStringTag]() {
198	return 'Promise'	×
199	}
200	}

NikolayMakhonin / async-utils / #11

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