@microsoft/windows-admin-center-sdk/core/data/disposable.js

Microsoft - Windows Admin Center Shell

function checkDisposeFunc(disposable, executeDispose) {
    if (typeof disposable.dispose === 'function') {
        // NOTE : Don't null the lifetime manager or in race conditions registerForDispose() will throw a
        //        null exception. Internal logic in the triggerable lifetime manager handles being disposed
        //        and having disposables added to it.
        if (executeDispose) {
            disposable.dispose();
        }
    }
    else if (typeof disposable === 'function') {
        if (executeDispose) {
            disposable();
        }
    }
    else {
        return false;
    }
    return true;
}
/**
 * An object that tracks and invokes disposal callbacks. This can be used
 * in other classes that wish to implement LifetimeManager.
 */
export class TriggerableLifetimeManager {
    disposables = [];
    isDisposedInternal = false;
    isDisposing = false;
    container = null;
    children = [];
    /**
     * Gets a value indicating whether or not the lifetime is disposed.
     */
    isDisposed() {
        return this.isDisposedInternal;
    }
    /**
     * See interface.
     */
    registerForDispose(disposable) {
        let disposables;
        if (Array.isArray(disposable)) {
            disposables = disposable;
        }
        else {
            disposables = [disposable];
        }
        disposables.forEach((item) => {
            this.registerForDisposeInternal(item);
        });
        return this;
    }
    /**
     * See interface.
     */
    createChildLifetime() {
        const triggerableLifeTimeManager = new TriggerableLifetimeManager();
        triggerableLifeTimeManager.container = this;
        this.children.push(triggerableLifeTimeManager);
        return triggerableLifeTimeManager;
    }
    /**
     * Causes the instance to regard itself as disposed, and to trigger any
     * callbacks that were already registered.
     */
    dispose() {
        if (!this.isDisposedInternal) {
            this.isDisposedInternal = true;
            this.isDisposing = true;
            // remove all children and _disposable
            [this.disposables, this.children].forEach((disposables) => {
                while (disposables.length) {
                    const disposable = disposables.pop();
                    try {
                        checkDisposeFunc(disposable, true);
                    }
                    catch (err) {
                        // ignore errors when running the check dispose function
                    }
                }
            });
            // check if we need to remove self from container
            const container = this.container;
            if (container) {
                this.container = null; // break the back link
                container.unregisterChildForDispose(this);
            }
            this.isDisposing = false;
        }
    }
    unregisterChildForDispose(disposable) {
        const children = this.children;
        if (!this.isDisposing) {
            const index = children.lastIndexOf(disposable);
            if (index === (children.length - 1)) {
                children.pop();
            }
            else {
                // take it self out of the container.
                children.splice(index, 1);
            }
        }
    }
    isRegistered(disposable) {
        return (this.disposables.lastIndexOf(disposable) >= 0 || this.children.lastIndexOf(disposable) >= 0);
    }
    registerForDisposeInternal(disposable) {
        let valid = !this.isDisposedInternal;
        if (!disposable) {
            valid = false;
        }
        if (valid) {
            this.disposables.push(disposable);
        }
    }
}
/**
 * Auto disposer class used with lifetime manager.
 */
export class Disposer {
    callback;
    /**
     * Initializes a new instance of the Disposer class.
     *
     * @param callback the callback function.
     */
    constructor(callback) {
        this.callback = callback;
    }
    /**
     * dispose function called when lifetime is gone.
     */
    dispose() {
        this.callback();
    }
}

//# sourceMappingURL=disposable.js.map