OpenHarmony-v5.1.0-Release/s

/*
 * Copyright (c) 2022-2024 Huawei Device Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package std.core;

/**
 * Interface for objects with 'then' method.
 */
export interface PromiseLike<out T> {
    then<U, E = never>(onFulfilled?: (value: T) => U|PromiseLike<U>,
            onRejected?: (error: NullishType) => E|PromiseLike<E>): PromiseLike<U|E>;
}

/**
 * Base class for Promise.allSettled return type.
 */
class PromiseSettledResultBase {
    status: string = "";
}

/**
 * The class describes fulfillment result of Promise.allSettled's argument.
 */
export class PromiseFulfilledResult<T> extends PromiseSettledResultBase {
    value: T;
}

/**
 * The class describes rejection result of Promise.allSettled's argument.
 */
export class PromiseRejectedResult extends PromiseSettledResultBase {
    reason: NullishType;
}

export type PromiseSettledResult<T> = PromiseFulfilledResult<T>|PromiseRejectedResult

/**
 * Class represents a result of an asynchronous operation in the future.
 */
export final class Promise<out T> implements PromiseLike<T> {
    private constructor() {
    }

    constructor(callback: (resolve: (value: T|PromiseLike<T>) => void) => void) {
        try {
            callback((value: T|PromiseLike<T>): void => {
                this.doResolve<T>(value);
            });
        } catch (error) {
            this.rejectImpl(error);
        }
    }

    constructor(callback: (resolve: (value: T|PromiseLike<T>) => void,
            reject: (error: NullishType) => void) => void) {
        try {
            callback((value: T|PromiseLike<T>): void => {
                this.doResolve<T>(value);
            }, (error: NullishType): void => {
                this.rejectImpl(error);
            });
        } catch (error) {
            this.rejectImpl(error);
        }
    }

    then<U>(onFulfilled: () => U|PromiseLike<U>): Promise<U> {
        let promise = new Promise<U>();
        let fn: () => void = (): void => {
            try {
                if (this.state == Promise.STATE_RESOLVED) {
                    promise.doResolve<U>(onFulfilled());
                } else {
                    promise.rejectImpl(this.value);
                }
            } catch (error) {
                promise.rejectImpl(error);
            }
        }
        this.submitCallback(fn as Object);
        return promise;
    }

    then<U>(onFulfilled: (value: T) => U|PromiseLike<U>): Promise<U> {
        let promise = new Promise<U>();
        let fn: () => void = (): void => {
            try {
                if (this.state == Promise.STATE_RESOLVED) {
                    promise.doResolve<U>(onFulfilled(this.value!));
                } else {
                    promise.rejectImpl(this.value! as Object);
                }
            } catch (e) {
                promise.rejectImpl(e);
            }
        }
        this.submitCallback(fn as Object);
        return promise;
    }

    then<U, E = never>(onFulfilled?: (value: T) => U|PromiseLike<U>,
            onRejected?: (error: NullishType) => E|PromiseLike<E>): Promise<U|E> {
        let promise = new Promise<U|E>();
        let fn: () => void = (): void => {
            try {
                if (this.state == Promise.STATE_RESOLVED) {
                    if (onFulfilled) {
                        promise.doResolve<U>(onFulfilled(this.value!));
                    } else {
                        promise.resolveImpl(this.value!);
                    }
                } else {
                    if (onRejected) {
                        promise.rejectImpl(onRejected(this.value! as Object));
                    } else {
                        promise.rejectImpl(this.value!);
                    }
                }
            } catch (e) {
                promise.rejectImpl(e);
            }
        }
        this.submitCallback(fn as Object);
        return promise;
    }

    // NOTE(audovichenko): Add '?' to onRejection param. Issue #20001
    catch<U = never>(onRejected: () => U|PromiseLike<U>): Promise<T|U> {
        let promise = new Promise<T|U>();
        let fn: () => void = (): void => {
            try {
                if (this.state == Promise.STATE_REJECTED) {
                    let res: U|PromiseLike<U> = onRejected();
                    promise.doResolve<U>(res);
                } else {
                    promise.doResolve<T>(this.value!);
                }
            } catch (e) {
                promise.rejectImpl(e);
            }
        }
        this.submitCallback(fn as Object);
        return promise;
    }

    catch<U = never>(onRejected?: (error: NullishType) => U|PromiseLike<U>): Promise<T|U> {
        let promise = new Promise<T|U>();
        let fn: () => void = (): void => {
            try {
                if (this.state == Promise.STATE_REJECTED) {
                    if (onRejected) {
                        let res: U|PromiseLike<U> = onRejected(this.value);
                        promise.doResolve<U>(res);
                    } else {
                        promise.rejectImpl(this.value!);
                    }
                } else {
                    promise.doResolve<T>(this.value!);
                }
            } catch (e) {
                promise.rejectImpl(e);
            }
        }
        this.submitCallback(fn as Object);
        return promise;
    }

    finally(onFinally?: () => void): Promise<T> {
        let promise = new Promise<T>();
        let fn: () => void = (): void => {
            try {
                if (onFinally) {
                    try {
                        onFinally();
                    } catch(error) {
                        promise.rejectImpl(error);
                    }
                }
                if (this.state == Promise.STATE_RESOLVED) {
                    promise.resolveImpl(this.value!);
                } else {
                    promise.rejectImpl(this.value! as Object);
                }
            } catch (e) {
                promise.rejectImpl(e);
            }
        }
        this.submitCallback(fn as Object);
        return promise;
    }

    static resolve(): Promise<void> {
        let p = new Promise<void>();
        p.resolveImpl(undefined);
        return p;
    }

    static resolve<U>(value: U|PromiseLike<U>): Promise<U> {
        if (value instanceof Promise) {
            return value as Promise<U>;
        }
        let p = new Promise<U>();
        p.doResolve(value);
        return p;
    }

    static reject(): Promise<void> {
        let p = new Promise<void>();
        p.rejectImpl(null);
        return p;
    }

    static reject<U = never>(value: NullishType): Promise<U> {
        let p = new Promise<U>();
        p.rejectImpl(value);
        return p;
    }

    static all<U>(promises: (U|PromiseLike<U>)[]): Promise<Array<U>> {
        return new Promise<Array<U>>((resolve: (value: Array<U>) => void, reject: (error: NullishType) => void): void => {
            new AllPromiseConcurrency<U>(resolve, reject).all(promises);
        });
    }

    static all<U>(promises: Iterable<U|PromiseLike<U>>): Promise<Array<U>> {
        try {
            return Promise.all<U>(Promise.toArray(promises));
        } catch (e: Error) {
            return Promise.reject<Array<U>>(e);
        }
    }

    static allSettled<U>(promises: (U|PromiseLike<U>)[]): Promise<PromiseSettledResult<U>[]> {
        return new Promise<PromiseSettledResult<U>[]>((resolve: (value: PromiseSettledResult<U>[]) => void, reject: (error: NullishType) => void): void => {
            // This temp object is needed because es2panda cannot change captured primitives
            new AllSettledPromiseConcurrency<U>(resolve, reject).allSettled(promises);
        });
    }

    static allSettled<U>(promises: Iterable<U|PromiseLike<U>>): Promise<PromiseSettledResult<U>[]> {
        try {
            return Promise.allSettled<U>(Promise.toArray(promises));
        } catch (e: Error) {
            return Promise.reject<PromiseSettledResult<U>[]>(e);
        }
    }

    static any<U>(promises: (U|PromiseLike<U>)[]): Promise<U> {
        return new Promise<U>((resolve: (value: U) => void, reject: (error: NullishType) => void): void => {
            // This temp object is needed because es2panda cannot change captured primitives
            new AnyPromiseConcurrency<U>(resolve, reject).any(promises);
        });
    }

    static any<U>(promises: Iterable<U|PromiseLike<U>>): Promise<U> {
        try {
            return Promise.any<U>(Promise.toArray(promises));
        } catch (e: Error) {
            return Promise.reject<U>(e);
        }
    }

    static race<U>(promises: (U|PromiseLike<U>)[]): Promise<U> {
        return new Promise<U>((resolve: (value: U) => void, reject: (error: NullishType) => void): void => {
            // This temp object is needed because es2panda cannot change captured primitives
            new RacePromiseConcurrency<U>(resolve, reject).race(promises);
        });
    }

    static race<U>(promises: Iterable<U|PromiseLike<U>>): Promise<U> {
        try {
            return Promise.race<U>(Promise.toArray(promises));
        } catch (e: Error) {
            return Promise.reject<U>(e);
        }
    }

    private static toArray<U>(values: Iterable<U>): U[] {
        let it = values.$_iterator();
        let v = it.next();
        if (v.done) {
            return new U[0];
        }
        let array: U[] = new U[1];
        array[0] = v.value!;
        let len = 1;
        while (true) {
            v = it.next();
            if (v.done) {
                return Promise.trim(array, len);
            }
            array = Promise.ensureCapacity(array, len + 1);
            array[len] = v.value!;
            ++len;
        }
    }

    private static trim<U>(array: U[], length: int): U[] {
        if (array.length == length) {
            return array;
        }
        let result = new U[length];
        for (let i = 0; i < length; ++i) {
            result[i] = array[i];
        }
        return result;
    }

    private static ensureCapacity<U>(queue: U[], size: int): U[] {
        if (size <= queue.length) {
            return queue;
        }
        let newQueue = new U[size * 2];
        for (let i = 0; i < queue.length; ++i) {
            newQueue[i] = queue[i];
        }
        return newQueue;
    }

    private subscribeOnAnotherPromise<U>(internalPromise: PromiseLike<U>): void {
        let thisPromise = this;
        internalPromise.then<void, void>((value: U): void => {
            thisPromise.resolveImpl(value);
        }, (error: NullishType): void => {
            thisPromise.rejectImpl(error);
        });
    }

    private doResolve<U>(value: U|PromiseLike<U>): void {
        if (value instanceof PromiseLike) {
            this.subscribeOnAnotherPromise<U>(value as PromiseLike<U>);
        } else {
            this.resolveImpl(value);
        }
    }

    public native awaitResolution(): T;

    private native resolveImpl<U>(value: U): void;
    private native rejectImpl(error: NullishType): void;
    private native submitCallback(callback: Object): void;

    private static STATE_PENDING = 0;
    private static STATE_RESOLVED = 1;
    private static STATE_REJECTED = 2;
    private static EMPTY_QUEUE = new Object[0];

    // Order of fields should be the following
    // 1. Reference fields
    // 2. Primitive fields in mostly size decreasing order
    // filling alignment holes
    private value: T | null = null;
    private mutex = new Mutex();
    private event = new Event();
    private callbackQueue: Object[] | null = null;
    private launchModeQueue: int[] | null = null;
    private interopObject: Object|null = null;
    private linkedPromise: Object | null = null;
    private queueSize: int = 0;
    private remotePromiseResolver: long = 0;
    private state: int = Promise.STATE_PENDING;
}

class PromiseConcurrencyBase<T> {
    toPromiseLike(value: T|PromiseLike<T>): PromiseLike<T> {
        if (value instanceof PromiseLike) {
            let p = value as PromiseLike<T>;
            return p;
        } else {
            let p = Promise.resolve<T>(value as T);
            return p;
        }
    }
}

class AllPromiseConcurrency<T> extends PromiseConcurrencyBase<T> {
    constructor(resolve: (value: Array<T>) => void, reject: (error: NullishType) => void) {
        this.resolve = resolve;
        this.reject = reject;
    }

    all(promises: (T|PromiseLike<T>)[]): void {
        if (promises.length == 0) {
            this.resolve(this.values);
            return;
        } else {
            this.values = new Array<T>(promises.length);
        }
        for (let i = 0; i < promises.length; ++i) {
            let idx = i;
            this.toPromiseLike(promises[idx]).then<void, void>((value: T): void => {
                this.resolveImpl(value, idx);
            }, (error: NullishType): void => {
                this.reject(error);
            });
        }
    }

    private resolveImpl(value: T, idx: int): void {
        this.values[idx] = value;
        ++this.resolvedCnt;
        if (this.resolvedCnt == this.values!.length) {
            this.resolve(this.values!);
        }
    }

    private resolvedCnt = 0;
    private rejectedCnt = 0;
    private values: Array<T> = new Array<T>();
    private resolve: (value: Array<T>) => void;
    private reject: (error: NullishType) => void;
}

class AllSettledPromiseConcurrency<T> extends PromiseConcurrencyBase<T> {
    constructor(resolve: (value: PromiseSettledResult<T>[]) => void, reject: (error: NullishType) => void) {
        this.resolve = resolve;
        this.reject = reject;
    }

    allSettled(promises: (T|PromiseLike<T>)[]): void {
        this.values = new PromiseSettledResultBase[promises.length];
        if (promises.length == 0) {
            this.resolve(this.getValues());
            return;
        }
        for (let i = 0; i < promises.length; ++i) {
            let idx = i;
            this.toPromiseLike(promises[idx]).then<void, void>((value: T): void => {
                this.resolveImpl(value as T, idx);
            }, (error: NullishType): void => {
                this.rejectImpl(error, idx);
            });
        }
    }

    private resolveImpl(value: T, idx: int): void {
        let res = new PromiseFulfilledResult<T>();
        res.status = "fulfilled";
        res.value = value;
        this.values![idx] = res;
        ++this.resolvedCnt;
        if (this.resolvedCnt == this.values!.length) {
            this.resolve(this.getValues());
        }
    }

    private rejectImpl(error: NullishType, idx: int): void {
        let res = new PromiseRejectedResult();
        res.status = "rejected";
        res.reason = error;
        this.values![idx] = res;
        ++this.resolvedCnt;
        if (this.resolvedCnt == this.values!.length) {
            this.resolve(this.getValues());
        }
    }

    private getValues(): PromiseSettledResult<T>[] {
        return (this.values as Object) as PromiseSettledResult<T>[];
    }

    private resolvedCnt = 0;
    private rejectedCnt = 0;
    private values: PromiseSettledResultBase[]|null = null;
    private resolve: (value: PromiseSettledResult<T>[]) => void;
    private reject: (error: NullishType) => void;
}

class AnyPromiseConcurrency<T> extends PromiseConcurrencyBase<T> {
    constructor(resolve: (value: T) => void, reject: (error: NullishType) => void) {
        this.resolve = resolve;
        this.reject = reject;
    }

    any(promises: (T|PromiseLike<T>)[]): void {
        this.errors = new Error[promises.length];
        if (promises.length == 0) {
            this.reject(new AggregateError(this.errors!, "All promises are rejected"));
            return;
        }
        for (let i = 0; i < promises.length; ++i) {
            let idx = i;
            this.toPromiseLike(promises[idx]).then<void, void>((value: T): void => {
                this.resolveImpl(value as T);
            }, (error: NullishType): void => {
                this.rejectImpl(error, idx);
            });
        }
    }

    private resolveImpl(value: T) {
        ++this.resolvedCnt;
        if (this.resolvedCnt == 1) {
            this.resolve(value);
        }
    }

    private rejectImpl(error: NullishType, idx: int) {
        ++this.rejectedCnt;
        if (error == null || error instanceof Error) {
            this.errors![idx] = error as Error;
        } else {
            this.errors![idx] = new Error(error!.toString());
        }
        if (this.rejectedCnt == this.errors!.length) {
            this.reject(new AggregateError(this.errors!, "All promises are rejected"));
        }
    }

    private resolvedCnt = 0;
    private rejectedCnt = 0;
    private errors: Error[]|null = null;
    private resolve: (value: T) => void;
    private reject: (error: NullishType) => void;
}

class RacePromiseConcurrency<T> extends PromiseConcurrencyBase<T> {
    constructor(resolve: (value: T) => void, reject: (error: NullishType) => void) {
        this.resolve = resolve;
        this.reject = reject;
    }

    race(promises: (T|PromiseLike<T>)[]): void {
        for (let i = 0; i < promises.length; ++i) {
            let idx = i;
            this.toPromiseLike(promises[idx]).then<void, void>((value: T): void => {
                this.resolveImpl(value as T);
            }, (error: NullishType): void => {
                this.rejectImpl(error);
            });
        }
    }

    private resolveImpl(value: T) {
        if (!this.settled) {
            this.resolve(value)
            this.settled = true;
        }
    }

    private rejectImpl(error: NullishType) {
        if (!this.settled) {
            this.reject(error);
            this.settled = true;
        }
    }

    private settled = false;
    private resolve: (value: T) => void;
    private reject: (error: NullishType) => void;
}

export type NullablePromise<out T> = Promise<T> | null;