@cleanslate/sdk 0.1.0

package/dist/core/lifecycle.js

@@ -0,0 +1,789 @@
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/*
+ * Vendored from microsoft/vscode (vs/base/common/lifecycle.ts) for @cleanslate/sdk.
+ * Changes: see packages/cleanslate-sdk/VENDOR.md.
+ */
+import { compareBy, numberComparator } from './arrays.js';
+import { groupBy } from './collections.js';
+import { SetMap, ResourceMap } from './map.js';
+import { createSingleCallFunction } from './functional.js';
+import { Iterable } from './iterator.js';
+import { BugIndicatingError, onUnexpectedError } from './errors.js';
+// #region Disposable Tracking
+/**
+ * Enables logging of potentially leaked disposables.
+ *
+ * A disposable is considered leaked if it is not disposed or not registered as the child of
+ * another disposable. This tracking is very simple an only works for classes that either
+ * extend Disposable or use a DisposableStore. This means there are a lot of false positives.
+ */
+const TRACK_DISPOSABLES = false;
+let disposableTracker = null;
+export class GCBasedDisposableTracker {
+    constructor() {
+        this._registry = new FinalizationRegistry(heldValue => {
+            console.warn(`[LEAKED DISPOSABLE] ${heldValue}`);
+        });
+    }
+    trackDisposable(disposable) {
+        const stack = new Error('CREATED via:').stack;
+        this._registry.register(disposable, stack, disposable);
+    }
+    setParent(child, parent) {
+        if (parent) {
+            this._registry.unregister(child);
+        }
+        else {
+            this.trackDisposable(child);
+        }
+    }
+    markAsDisposed(disposable) {
+        this._registry.unregister(disposable);
+    }
+    markAsSingleton(disposable) {
+        this._registry.unregister(disposable);
+    }
+}
+export class DisposableTracker {
+    constructor() {
+        this.livingDisposables = new Map();
+    }
+    static { this.idx = 0; }
+    getDisposableData(d) {
+        let val = this.livingDisposables.get(d);
+        if (!val) {
+            val = { parent: null, source: null, isSingleton: false, value: d, idx: DisposableTracker.idx++ };
+            this.livingDisposables.set(d, val);
+        }
+        return val;
+    }
+    trackDisposable(d) {
+        const data = this.getDisposableData(d);
+        if (!data.source) {
+            data.source =
+                new Error().stack;
+        }
+    }
+    setParent(child, parent) {
+        const data = this.getDisposableData(child);
+        data.parent = parent;
+    }
+    markAsDisposed(x) {
+        this.livingDisposables.delete(x);
+    }
+    markAsSingleton(disposable) {
+        this.getDisposableData(disposable).isSingleton = true;
+    }
+    getRootParent(data, cache) {
+        const cacheValue = cache.get(data);
+        if (cacheValue) {
+            return cacheValue;
+        }
+        const result = data.parent ? this.getRootParent(this.getDisposableData(data.parent), cache) : data;
+        cache.set(data, result);
+        return result;
+    }
+    getTrackedDisposables() {
+        const rootParentCache = new Map();
+        const leaking = [...this.livingDisposables.entries()]
+            .filter(([, v]) => v.source !== null && !this.getRootParent(v, rootParentCache).isSingleton)
+            .flatMap(([k]) => k);
+        return leaking;
+    }
+    computeLeakingDisposables(maxReported = 10, preComputedLeaks) {
+        let uncoveredLeakingObjs;
+        if (preComputedLeaks) {
+            uncoveredLeakingObjs = preComputedLeaks;
+        }
+        else {
+            const rootParentCache = new Map();
+            const leakingObjects = [...this.livingDisposables.values()]
+                .filter((info) => info.source !== null && !this.getRootParent(info, rootParentCache).isSingleton);
+            if (leakingObjects.length === 0) {
+                return;
+            }
+            const leakingObjsSet = new Set(leakingObjects.map(o => o.value));
+            // Remove all objects that are a child of other leaking objects. Assumes there are no cycles.
+            uncoveredLeakingObjs = leakingObjects.filter(l => {
+                return !(l.parent && leakingObjsSet.has(l.parent));
+            });
+            if (uncoveredLeakingObjs.length === 0) {
+                throw new Error('There are cyclic diposable chains!');
+            }
+        }
+        if (!uncoveredLeakingObjs) {
+            return undefined;
+        }
+        function getStackTracePath(leaking) {
+            function removePrefix(array, linesToRemove) {
+                while (array.length > 0 && linesToRemove.some(regexp => typeof regexp === 'string' ? regexp === array[0] : array[0].match(regexp))) {
+                    array.shift();
+                }
+            }
+            const lines = leaking.source.split('\n').map(p => p.trim().replace('at ', '')).filter(l => l !== '');
+            removePrefix(lines, ['Error', /^trackDisposable \(.*\)$/, /^DisposableTracker.trackDisposable \(.*\)$/]);
+            return lines.reverse();
+        }
+        const stackTraceStarts = new SetMap();
+        for (const leaking of uncoveredLeakingObjs) {
+            const stackTracePath = getStackTracePath(leaking);
+            for (let i = 0; i <= stackTracePath.length; i++) {
+                stackTraceStarts.add(stackTracePath.slice(0, i).join('\n'), leaking);
+            }
+        }
+        // Put earlier leaks first
+        uncoveredLeakingObjs.sort(compareBy(l => l.idx, numberComparator));
+        let message = '';
+        let i = 0;
+        for (const leaking of uncoveredLeakingObjs.slice(0, maxReported)) {
+            i++;
+            const stackTracePath = getStackTracePath(leaking);
+            const stackTraceFormattedLines = [];
+            for (let i = 0; i < stackTracePath.length; i++) {
+                let line = stackTracePath[i];
+                const starts = stackTraceStarts.get(stackTracePath.slice(0, i + 1).join('\n'));
+                line = `(shared with ${starts.size}/${uncoveredLeakingObjs.length} leaks) at ${line}`;
+                const prevStarts = stackTraceStarts.get(stackTracePath.slice(0, i).join('\n'));
+                const continuations = groupBy([...prevStarts].map(d => getStackTracePath(d)[i]), v => v);
+                delete continuations[stackTracePath[i]];
+                for (const [cont, set] of Object.entries(continuations)) {
+                    if (set) {
+                        stackTraceFormattedLines.unshift(`    - stacktraces of ${set.length} other leaks continue with ${cont}`);
+                    }
+                }
+                stackTraceFormattedLines.unshift(line);
+            }
+            message += `\n\n\n==================== Leaking disposable ${i}/${uncoveredLeakingObjs.length}: ${leaking.value.constructor.name} ====================\n${stackTraceFormattedLines.join('\n')}\n============================================================\n\n`;
+        }
+        if (uncoveredLeakingObjs.length > maxReported) {
+            message += `\n\n\n... and ${uncoveredLeakingObjs.length - maxReported} more leaking disposables\n\n`;
+        }
+        return { leaks: uncoveredLeakingObjs, details: message };
+    }
+}
+export function setDisposableTracker(tracker) {
+    disposableTracker = tracker;
+}
+if (TRACK_DISPOSABLES) {
+    const __is_disposable_tracked__ = '__is_disposable_tracked__';
+    setDisposableTracker(new class {
+        trackDisposable(x) {
+            const stack = new Error('Potentially leaked disposable').stack;
+            setTimeout(() => {
+                // eslint-disable-next-line local/code-no-any-casts
+                if (!x[__is_disposable_tracked__]) {
+                    console.log(stack);
+                }
+            }, 3000);
+        }
+        setParent(child, parent) {
+            if (child && child !== Disposable.None) {
+                try {
+                    // eslint-disable-next-line local/code-no-any-casts
+                    child[__is_disposable_tracked__] = true;
+                }
+                catch {
+                    // noop
+                }
+            }
+        }
+        markAsDisposed(disposable) {
+            if (disposable && disposable !== Disposable.None) {
+                try {
+                    // eslint-disable-next-line local/code-no-any-casts
+                    disposable[__is_disposable_tracked__] = true;
+                }
+                catch {
+                    // noop
+                }
+            }
+        }
+        markAsSingleton(disposable) { }
+    });
+}
+export function trackDisposable(x) {
+    disposableTracker?.trackDisposable(x);
+    return x;
+}
+export function markAsDisposed(disposable) {
+    disposableTracker?.markAsDisposed(disposable);
+}
+function setParentOfDisposable(child, parent) {
+    disposableTracker?.setParent(child, parent);
+}
+function setParentOfDisposables(children, parent) {
+    if (!disposableTracker) {
+        return;
+    }
+    for (const child of children) {
+        disposableTracker.setParent(child, parent);
+    }
+}
+/**
+ * Indicates that the given object is a singleton which does not need to be disposed.
+*/
+export function markAsSingleton(singleton) {
+    disposableTracker?.markAsSingleton(singleton);
+    return singleton;
+}
+/**
+ * Check if `thing` is {@link IDisposable disposable}.
+ */
+export function isDisposable(thing) {
+    // eslint-disable-next-line local/code-no-any-casts
+    return typeof thing === 'object' && thing !== null && typeof thing.dispose === 'function' && thing.dispose.length === 0;
+}
+export function dispose(arg) {
+    if (Iterable.is(arg)) {
+        const errors = [];
+        for (const d of arg) {
+            if (d) {
+                try {
+                    d.dispose();
+                }
+                catch (e) {
+                    errors.push(e);
+                }
+            }
+        }
+        if (errors.length === 1) {
+            throw errors[0];
+        }
+        else if (errors.length > 1) {
+            throw new AggregateError(errors, 'Encountered errors while disposing of store');
+        }
+        return Array.isArray(arg) ? [] : arg;
+    }
+    else if (arg) {
+        arg.dispose();
+        return arg;
+    }
+}
+export function disposeIfDisposable(disposables) {
+    for (const d of disposables) {
+        if (isDisposable(d)) {
+            d.dispose();
+        }
+    }
+    return [];
+}
+/**
+ * Combine multiple disposable values into a single {@link IDisposable}.
+ */
+export function combinedDisposable(...disposables) {
+    const parent = toDisposable(() => dispose(disposables));
+    setParentOfDisposables(disposables, parent);
+    return parent;
+}
+class FunctionDisposable {
+    constructor(fn) {
+        this._isDisposed = false;
+        this._fn = fn;
+        trackDisposable(this);
+    }
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        if (!this._fn) {
+            throw new Error(`Unbound disposable context: Need to use an arrow function to preserve the value of this`);
+        }
+        this._isDisposed = true;
+        markAsDisposed(this);
+        this._fn();
+    }
+}
+/**
+ * Turn a function that implements dispose into an {@link IDisposable}.
+ *
+ * @param fn Clean up function, guaranteed to be called only **once**.
+ */
+export function toDisposable(fn) {
+    return new FunctionDisposable(fn);
+}
+/**
+ * Manages a collection of disposable values.
+ *
+ * This is the preferred way to manage multiple disposables. A `DisposableStore` is safer to work with than an
+ * `IDisposable[]` as it considers edge cases, such as registering the same value multiple times or adding an item to a
+ * store that has already been disposed of.
+ */
+export class DisposableStore {
+    static { this.DISABLE_DISPOSED_WARNING = false; }
+    constructor() {
+        this._toDispose = new Set();
+        this._isDisposed = false;
+        trackDisposable(this);
+    }
+    /**
+     * Dispose of all registered disposables and mark this object as disposed.
+     *
+     * Any future disposables added to this object will be disposed of on `add`.
+     */
+    dispose() {
+        if (this._isDisposed) {
+            return;
+        }
+        markAsDisposed(this);
+        this._isDisposed = true;
+        this.clear();
+    }
+    /**
+     * @return `true` if this object has been disposed of.
+     */
+    get isDisposed() {
+        return this._isDisposed;
+    }
+    /**
+     * Dispose of all registered disposables but do not mark this object as disposed.
+     */
+    clear() {
+        if (this._toDispose.size === 0) {
+            return;
+        }
+        try {
+            dispose(this._toDispose);
+        }
+        finally {
+            this._toDispose.clear();
+        }
+    }
+    /**
+     * Add a new {@link IDisposable disposable} to the collection.
+     */
+    add(o) {
+        if (!o || o === Disposable.None) {
+            return o;
+        }
+        if (o === this) {
+            throw new Error('Cannot register a disposable on itself!');
+        }
+        setParentOfDisposable(o, this);
+        if (this._isDisposed) {
+            if (!DisposableStore.DISABLE_DISPOSED_WARNING) {
+                console.warn(new Error('Trying to add a disposable to a DisposableStore that has already been disposed of. The added object will be leaked!').stack);
+            }
+        }
+        else {
+            this._toDispose.add(o);
+        }
+        return o;
+    }
+    /**
+     * Deletes a disposable from store and disposes of it. This will not throw or warn and proceed to dispose the
+     * disposable even when the disposable is not part in the store.
+     */
+    delete(o) {
+        if (!o) {
+            return;
+        }
+        if (o === this) {
+            throw new Error('Cannot dispose a disposable on itself!');
+        }
+        this._toDispose.delete(o);
+        o.dispose();
+    }
+    /**
+     * Deletes the value from the store, but does not dispose it.
+     */
+    deleteAndLeak(o) {
+        if (!o) {
+            return;
+        }
+        if (this._toDispose.delete(o)) {
+            setParentOfDisposable(o, null);
+        }
+    }
+    assertNotDisposed() {
+        if (this._isDisposed) {
+            onUnexpectedError(new BugIndicatingError('Object disposed'));
+        }
+    }
+}
+/**
+ * Abstract base class for a {@link IDisposable disposable} object.
+ *
+ * Subclasses can {@linkcode _register} disposables that will be automatically cleaned up when this object is disposed of.
+ */
+export class Disposable {
+    /**
+     * A disposable that does nothing when it is disposed of.
+     *
+     * TODO: This should not be a static property.
+     */
+    static { this.None = Object.freeze({ dispose() { } }); }
+    constructor() {
+        this._store = new DisposableStore();
+        trackDisposable(this);
+        setParentOfDisposable(this._store, this);
+    }
+    dispose() {
+        markAsDisposed(this);
+        this._store.dispose();
+    }
+    /**
+     * Adds `o` to the collection of disposables managed by this object.
+     */
+    _register(o) {
+        if (o === this) {
+            throw new Error('Cannot register a disposable on itself!');
+        }
+        return this._store.add(o);
+    }
+}
+/**
+ * Manages the lifecycle of a disposable value that may be changed.
+ *
+ * This ensures that when the disposable value is changed, the previously held disposable is disposed of. You can
+ * also register a `MutableDisposable` on a `Disposable` to ensure it is automatically cleaned up.
+ */
+export class MutableDisposable {
+    constructor() {
+        this._isDisposed = false;
+        trackDisposable(this);
+    }
+    /**
+     * Get the currently held disposable value, or `undefined` if this MutableDisposable has been disposed
+     */
+    get value() {
+        return this._isDisposed ? undefined : this._value;
+    }
+    /**
+     * Set a new disposable value.
+     *
+     * Behaviour:
+     * - If the MutableDisposable has been disposed, the setter is a no-op.
+     * - If the new value is strictly equal to the current value, the setter is a no-op.
+     * - Otherwise the previous value (if any) is disposed and the new value is stored.
+     *
+     * Related helpers:
+     * - clear() resets the value to `undefined` (and disposes the previous value).
+     * - clearAndLeak() returns the old value without disposing it and removes its parent.
+     */
+    set value(value) {
+        if (this._isDisposed || value === this._value) {
+            return;
+        }
+        this._value?.dispose();
+        if (value) {
+            setParentOfDisposable(value, this);
+        }
+        this._value = value;
+    }
+    /**
+     * Resets the stored value and disposed of the previously stored value.
+     */
+    clear() {
+        this.value = undefined;
+    }
+    dispose() {
+        this._isDisposed = true;
+        markAsDisposed(this);
+        this._value?.dispose();
+        this._value = undefined;
+    }
+    /**
+     * Clears the value, but does not dispose it.
+     * The old value is returned.
+    */
+    clearAndLeak() {
+        const oldValue = this._value;
+        this._value = undefined;
+        if (oldValue) {
+            setParentOfDisposable(oldValue, null);
+        }
+        return oldValue;
+    }
+}
+/**
+ * Manages the lifecycle of a disposable value that may be changed like {@link MutableDisposable}, but the value must
+ * exist and cannot be undefined.
+ */
+export class MandatoryMutableDisposable {
+    constructor(initialValue) {
+        this._disposable = new MutableDisposable();
+        this._isDisposed = false;
+        this._disposable.value = initialValue;
+    }
+    get value() {
+        return this._disposable.value;
+    }
+    set value(value) {
+        if (this._isDisposed || value === this._disposable.value) {
+            return;
+        }
+        this._disposable.value = value;
+    }
+    dispose() {
+        this._isDisposed = true;
+        this._disposable.dispose();
+    }
+}
+export class RefCountedDisposable {
+    constructor(_disposable) {
+        this._disposable = _disposable;
+        this._counter = 1;
+    }
+    acquire() {
+        this._counter++;
+        return this;
+    }
+    release() {
+        if (--this._counter === 0) {
+            this._disposable.dispose();
+        }
+        return this;
+    }
+}
+export class ReferenceCollection {
+    constructor() {
+        this.references = new Map();
+    }
+    acquire(key, ...args) {
+        let reference = this.references.get(key);
+        if (!reference) {
+            reference = { counter: 0, object: this.createReferencedObject(key, ...args) };
+            this.references.set(key, reference);
+        }
+        const { object } = reference;
+        const dispose = createSingleCallFunction(() => {
+            if (--reference.counter === 0) {
+                this.destroyReferencedObject(key, reference.object);
+                this.references.delete(key);
+            }
+        });
+        reference.counter++;
+        return { object, dispose };
+    }
+}
+/**
+ * Unwraps a reference collection of promised values. Makes sure
+ * references are disposed whenever promises get rejected.
+ */
+export class AsyncReferenceCollection {
+    constructor(referenceCollection) {
+        this.referenceCollection = referenceCollection;
+    }
+    async acquire(key, ...args) {
+        const ref = this.referenceCollection.acquire(key, ...args);
+        try {
+            const object = await ref.object;
+            return {
+                object,
+                dispose: () => ref.dispose()
+            };
+        }
+        catch (error) {
+            ref.dispose();
+            throw error;
+        }
+    }
+}
+export class ImmortalReference {
+    constructor(object) {
+        this.object = object;
+    }
+    dispose() { }
+}
+export function disposeOnReturn(fn) {
+    const store = new DisposableStore();
+    try {
+        fn(store);
+    }
+    finally {
+        store.dispose();
+    }
+}
+/**
+ * A map the manages the lifecycle of the values that it stores.
+ */
+export class DisposableMap {
+    constructor(store = new Map()) {
+        this._isDisposed = false;
+        this._store = store;
+        trackDisposable(this);
+    }
+    /**
+     * Disposes of all stored values and mark this object as disposed.
+     *
+     * Trying to use this object after it has been disposed of is an error.
+     */
+    dispose() {
+        markAsDisposed(this);
+        this._isDisposed = true;
+        this.clearAndDisposeAll();
+    }
+    /**
+     * Disposes of all stored values and clear the map, but DO NOT mark this object as disposed.
+     */
+    clearAndDisposeAll() {
+        if (!this._store.size) {
+            return;
+        }
+        try {
+            dispose(this._store.values());
+        }
+        finally {
+            this._store.clear();
+        }
+    }
+    has(key) {
+        return this._store.has(key);
+    }
+    get size() {
+        return this._store.size;
+    }
+    get(key) {
+        return this._store.get(key);
+    }
+    set(key, value, skipDisposeOnOverwrite = false) {
+        if (this._isDisposed) {
+            console.warn(new Error('Trying to add a disposable to a DisposableMap that has already been disposed of. The added object will be leaked!').stack);
+        }
+        if (!skipDisposeOnOverwrite) {
+            this._store.get(key)?.dispose();
+        }
+        this._store.set(key, value);
+        setParentOfDisposable(value, this);
+    }
+    /**
+     * Delete the value stored for `key` from this map and also dispose of it.
+     */
+    deleteAndDispose(key) {
+        this._store.get(key)?.dispose();
+        this._store.delete(key);
+    }
+    /**
+     * Delete the value stored for `key` from this map but return it. The caller is
+     * responsible for disposing of the value.
+     */
+    deleteAndLeak(key) {
+        const value = this._store.get(key);
+        if (value) {
+            setParentOfDisposable(value, null);
+        }
+        this._store.delete(key);
+        return value;
+    }
+    keys() {
+        return this._store.keys();
+    }
+    values() {
+        return this._store.values();
+    }
+    [Symbol.iterator]() {
+        return this._store[Symbol.iterator]();
+    }
+}
+/**
+ * A set that manages the lifecycle of the values that it stores.
+ */
+export class DisposableSet {
+    constructor(store = new Set()) {
+        this._isDisposed = false;
+        this._store = store;
+        trackDisposable(this);
+    }
+    /**
+     * Disposes of all stored values and mark this object as disposed.
+     *
+     * Trying to use this object after it has been disposed of is an error.
+     */
+    dispose() {
+        markAsDisposed(this);
+        this._isDisposed = true;
+        this.clearAndDisposeAll();
+    }
+    /**
+     * Disposes of all stored values and clear the set, but DO NOT mark this object as disposed.
+     */
+    clearAndDisposeAll() {
+        if (!this._store.size) {
+            return;
+        }
+        try {
+            dispose(this._store.values());
+        }
+        finally {
+            this._store.clear();
+        }
+    }
+    has(value) {
+        return this._store.has(value);
+    }
+    get size() {
+        return this._store.size;
+    }
+    add(value) {
+        if (this._isDisposed) {
+            console.warn(new Error('Trying to add a disposable to a DisposableSet that has already been disposed of. The added object will be leaked!').stack);
+        }
+        this._store.add(value);
+        setParentOfDisposable(value, this);
+    }
+    /**
+     * Delete the value from this set and also dispose of it.
+     */
+    deleteAndDispose(value) {
+        if (this._store.delete(value)) {
+            value.dispose();
+        }
+    }
+    /**
+     * Delete the value from this set but return it. The caller is
+     * responsible for disposing of the value.
+     */
+    deleteAndLeak(value) {
+        if (this._store.delete(value)) {
+            setParentOfDisposable(value, null);
+            return value;
+        }
+        return undefined;
+    }
+    values() {
+        return this._store.values();
+    }
+    [Symbol.iterator]() {
+        return this._store[Symbol.iterator]();
+    }
+}
+/**
+ * Call `then` on a Promise, unless the returned disposable is disposed.
+ */
+export function thenIfNotDisposed(promise, then) {
+    let disposed = false;
+    promise.then(result => {
+        if (disposed) {
+            return;
+        }
+        then(result);
+    });
+    return toDisposable(() => {
+        disposed = true;
+    });
+}
+/**
+ * Call `then` on a promise that resolves to a {@link IDisposable}, then either register the
+ * disposable or register it to the {@link DisposableStore}, depending on whether the store is
+ * disposed or not.
+ */
+export function thenRegisterOrDispose(promise, store) {
+    return promise.then(disposable => {
+        if (store.isDisposed) {
+            disposable.dispose();
+        }
+        else {
+            store.add(disposable);
+        }
+        return disposable;
+    });
+}
+export class DisposableResourceMap extends DisposableMap {
+    constructor() {
+        super(new ResourceMap());
+    }
+}
+//# sourceMappingURL=lifecycle.js.map