monaco-editor11 1.1.0 → 1.1.2

package/dist/workers/observableCodeEditor.js

@@ -0,0 +1,373 @@
+import { equalsIfDefined, itemsEquals } from '../../base/common/equals.js';
+import { Disposable, DisposableStore, toDisposable } from '../../base/common/lifecycle.js';
+import '../../base/common/observableInternal/index.js';
+import { LineRange } from '../common/core/ranges/lineRange.js';
+import { OffsetRange } from '../common/core/ranges/offsetRange.js';
+import { Position } from '../common/core/position.js';
+import { Selection } from '../common/core/selection.js';
+import { Point } from '../common/core/2d/point.js';
+import { TransactionImpl } from '../../base/common/observableInternal/transaction.js';
+import { derivedOpts, derivedWithSetter, derived } from '../../base/common/observableInternal/observables/derived.js';
+import { observableValue } from '../../base/common/observableInternal/observables/observableValue.js';
+import { observableFromEvent } from '../../base/common/observableInternal/observables/observableFromEvent.js';
+import { observableValueOpts } from '../../base/common/observableInternal/observables/observableValueOpts.js';
+import { observableSignal } from '../../base/common/observableInternal/observables/observableSignal.js';
+import { DebugLocation } from '../../base/common/observableInternal/debugLocation.js';
+import { autorunOpts, autorun } from '../../base/common/observableInternal/reactions/autorun.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+/**
+ * Returns a facade for the code editor that provides observables for various states/events.
+*/
+function observableCodeEditor(editor) {
+    return ObservableCodeEditor.get(editor);
+}
+class ObservableCodeEditor extends Disposable {
+    static { this._map = new Map(); }
+    /**
+     * Make sure that editor is not disposed yet!
+    */
+    static get(editor) {
+        let result = ObservableCodeEditor._map.get(editor);
+        if (!result) {
+            result = new ObservableCodeEditor(editor);
+            ObservableCodeEditor._map.set(editor, result);
+            const d = editor.onDidDispose(() => {
+                const item = ObservableCodeEditor._map.get(editor);
+                if (item) {
+                    ObservableCodeEditor._map.delete(editor);
+                    item.dispose();
+                    d.dispose();
+                }
+            });
+        }
+        return result;
+    }
+    _beginUpdate() {
+        this._updateCounter++;
+        if (this._updateCounter === 1) {
+            this._currentTransaction = new TransactionImpl(() => {
+                /** @description Update editor state */
+            });
+        }
+    }
+    _endUpdate() {
+        this._updateCounter--;
+        if (this._updateCounter === 0) {
+            const t = this._currentTransaction;
+            this._currentTransaction = undefined;
+            t.finish();
+        }
+    }
+    constructor(editor) {
+        super();
+        this.editor = editor;
+        this._updateCounter = 0;
+        this._currentTransaction = undefined;
+        this._model = observableValue(this, this.editor.getModel());
+        this.model = this._model;
+        this.isReadonly = observableFromEvent(this, this.editor.onDidChangeConfiguration, () => this.editor.getOption(104 /* EditorOption.readOnly */));
+        this._versionId = observableValueOpts({ owner: this, lazy: true }, this.editor.getModel()?.getVersionId() ?? null);
+        this.versionId = this._versionId;
+        this._selections = observableValueOpts({ owner: this, equalsFn: equalsIfDefined(itemsEquals(Selection.selectionsEqual)), lazy: true }, this.editor.getSelections() ?? null);
+        this.selections = this._selections;
+        this.positions = derivedOpts({ owner: this, equalsFn: equalsIfDefined(itemsEquals(Position.equals)) }, reader => this.selections.read(reader)?.map(s => s.getStartPosition()) ?? null);
+        this.isFocused = observableFromEvent(this, e => {
+            const d1 = this.editor.onDidFocusEditorWidget(e);
+            const d2 = this.editor.onDidBlurEditorWidget(e);
+            return {
+                dispose() {
+                    d1.dispose();
+                    d2.dispose();
+                }
+            };
+        }, () => this.editor.hasWidgetFocus());
+        this.isTextFocused = observableFromEvent(this, e => {
+            const d1 = this.editor.onDidFocusEditorText(e);
+            const d2 = this.editor.onDidBlurEditorText(e);
+            return {
+                dispose() {
+                    d1.dispose();
+                    d2.dispose();
+                }
+            };
+        }, () => this.editor.hasTextFocus());
+        this.inComposition = observableFromEvent(this, e => {
+            const d1 = this.editor.onDidCompositionStart(() => {
+                e(undefined);
+            });
+            const d2 = this.editor.onDidCompositionEnd(() => {
+                e(undefined);
+            });
+            return {
+                dispose() {
+                    d1.dispose();
+                    d2.dispose();
+                }
+            };
+        }, () => this.editor.inComposition);
+        this.value = derivedWithSetter(this, reader => { this.versionId.read(reader); return this.model.read(reader)?.getValue() ?? ''; }, (value, tx) => {
+            const model = this.model.get();
+            if (model !== null) {
+                if (value !== model.getValue()) {
+                    model.setValue(value);
+                }
+            }
+        });
+        this.valueIsEmpty = derived(this, reader => { this.versionId.read(reader); return this.editor.getModel()?.getValueLength() === 0; });
+        this.cursorSelection = derivedOpts({ owner: this, equalsFn: equalsIfDefined(Selection.selectionsEqual) }, reader => this.selections.read(reader)?.[0] ?? null);
+        this.cursorPosition = derivedOpts({ owner: this, equalsFn: Position.equals }, reader => this.selections.read(reader)?.[0]?.getPosition() ?? null);
+        this.cursorLineNumber = derived(this, reader => this.cursorPosition.read(reader)?.lineNumber ?? null);
+        this.onDidType = observableSignal(this);
+        this.onDidPaste = observableSignal(this);
+        this.scrollTop = observableFromEvent(this.editor.onDidScrollChange, () => this.editor.getScrollTop());
+        this.scrollLeft = observableFromEvent(this.editor.onDidScrollChange, () => this.editor.getScrollLeft());
+        this.layoutInfo = observableFromEvent(this.editor.onDidLayoutChange, () => this.editor.getLayoutInfo());
+        this.layoutInfoContentLeft = this.layoutInfo.map(l => l.contentLeft);
+        this.layoutInfoDecorationsLeft = this.layoutInfo.map(l => l.decorationsLeft);
+        this.layoutInfoWidth = this.layoutInfo.map(l => l.width);
+        this.layoutInfoHeight = this.layoutInfo.map(l => l.height);
+        this.layoutInfoMinimap = this.layoutInfo.map(l => l.minimap);
+        this.layoutInfoVerticalScrollbarWidth = this.layoutInfo.map(l => l.verticalScrollbarWidth);
+        this.contentWidth = observableFromEvent(this.editor.onDidContentSizeChange, () => this.editor.getContentWidth());
+        this.contentHeight = observableFromEvent(this.editor.onDidContentSizeChange, () => this.editor.getContentHeight());
+        this._widgetCounter = 0;
+        this.openedPeekWidgets = observableValue(this, 0);
+        this._register(this.editor.onBeginUpdate(() => this._beginUpdate()));
+        this._register(this.editor.onEndUpdate(() => this._endUpdate()));
+        this._register(this.editor.onDidChangeModel(() => {
+            this._beginUpdate();
+            try {
+                this._model.set(this.editor.getModel(), this._currentTransaction);
+                this._forceUpdate();
+            }
+            finally {
+                this._endUpdate();
+            }
+        }));
+        this._register(this.editor.onDidType((e) => {
+            this._beginUpdate();
+            try {
+                this._forceUpdate();
+                this.onDidType.trigger(this._currentTransaction, e);
+            }
+            finally {
+                this._endUpdate();
+            }
+        }));
+        this._register(this.editor.onDidPaste((e) => {
+            this._beginUpdate();
+            try {
+                this._forceUpdate();
+                this.onDidPaste.trigger(this._currentTransaction, e);
+            }
+            finally {
+                this._endUpdate();
+            }
+        }));
+        this._register(this.editor.onDidChangeModelContent(e => {
+            this._beginUpdate();
+            try {
+                this._versionId.set(this.editor.getModel()?.getVersionId() ?? null, this._currentTransaction, e);
+                this._forceUpdate();
+            }
+            finally {
+                this._endUpdate();
+            }
+        }));
+        this._register(this.editor.onDidChangeCursorSelection(e => {
+            this._beginUpdate();
+            try {
+                this._selections.set(this.editor.getSelections(), this._currentTransaction, e);
+                this._forceUpdate();
+            }
+            finally {
+                this._endUpdate();
+            }
+        }));
+        this.domNode = derived(reader => {
+            this.model.read(reader);
+            return this.editor.getDomNode();
+        });
+    }
+    forceUpdate(cb) {
+        this._beginUpdate();
+        try {
+            this._forceUpdate();
+            if (!cb) {
+                return undefined;
+            }
+            return cb(this._currentTransaction);
+        }
+        finally {
+            this._endUpdate();
+        }
+    }
+    _forceUpdate() {
+        this._beginUpdate();
+        try {
+            this._model.set(this.editor.getModel(), this._currentTransaction);
+            this._versionId.set(this.editor.getModel()?.getVersionId() ?? null, this._currentTransaction, undefined);
+            this._selections.set(this.editor.getSelections(), this._currentTransaction, undefined);
+        }
+        finally {
+            this._endUpdate();
+        }
+    }
+    getOption(id, debugLocation = DebugLocation.ofCaller()) {
+        return observableFromEvent(this, cb => this.editor.onDidChangeConfiguration(e => {
+            if (e.hasChanged(id)) {
+                cb(undefined);
+            }
+        }), () => this.editor.getOption(id), debugLocation);
+    }
+    setDecorations(decorations) {
+        const d = new DisposableStore();
+        const decorationsCollection = this.editor.createDecorationsCollection();
+        d.add(autorunOpts({ owner: this, debugName: () => `Apply decorations from ${decorations.debugName}` }, reader => {
+            const d = decorations.read(reader);
+            decorationsCollection.set(d);
+        }));
+        d.add({
+            dispose: () => {
+                decorationsCollection.clear();
+            }
+        });
+        return d;
+    }
+    createOverlayWidget(widget) {
+        const overlayWidgetId = 'observableOverlayWidget' + (this._widgetCounter++);
+        const w = {
+            getDomNode: () => widget.domNode,
+            getPosition: () => widget.position.get(),
+            getId: () => overlayWidgetId,
+            allowEditorOverflow: widget.allowEditorOverflow,
+            getMinContentWidthInPx: () => widget.minContentWidthInPx.get(),
+        };
+        this.editor.addOverlayWidget(w);
+        const d = autorun(reader => {
+            widget.position.read(reader);
+            widget.minContentWidthInPx.read(reader);
+            this.editor.layoutOverlayWidget(w);
+        });
+        return toDisposable(() => {
+            d.dispose();
+            this.editor.removeOverlayWidget(w);
+        });
+    }
+    createContentWidget(widget) {
+        const contentWidgetId = 'observableContentWidget' + (this._widgetCounter++);
+        const w = {
+            getDomNode: () => widget.domNode,
+            getPosition: () => widget.position.get(),
+            getId: () => contentWidgetId,
+            allowEditorOverflow: widget.allowEditorOverflow,
+        };
+        this.editor.addContentWidget(w);
+        const d = autorun(reader => {
+            widget.position.read(reader);
+            this.editor.layoutContentWidget(w);
+        });
+        return toDisposable(() => {
+            d.dispose();
+            this.editor.removeContentWidget(w);
+        });
+    }
+    observeLineOffsetRange(lineRange, store) {
+        const start = this.observePosition(lineRange.map(r => new Position(r.startLineNumber, 1)), store);
+        const end = this.observePosition(lineRange.map(r => new Position(r.endLineNumberExclusive + 1, 1)), store);
+        return derived(reader => {
+            start.read(reader);
+            end.read(reader);
+            const range = lineRange.read(reader);
+            const lineCount = this.model.read(reader)?.getLineCount();
+            const s = ((typeof lineCount !== 'undefined' && range.startLineNumber > lineCount
+                ? this.editor.getBottomForLineNumber(lineCount)
+                : this.editor.getTopForLineNumber(range.startLineNumber))
+                - this.scrollTop.read(reader));
+            const e = range.isEmpty ? s : (this.editor.getBottomForLineNumber(range.endLineNumberExclusive - 1) - this.scrollTop.read(reader));
+            return new OffsetRange(s, e);
+        });
+    }
+    observePosition(position, store) {
+        let pos = position.get();
+        const result = observableValueOpts({ owner: this, debugName: () => `topLeftOfPosition${pos?.toString()}`, equalsFn: equalsIfDefined(Point.equals) }, new Point(0, 0));
+        const contentWidgetId = `observablePositionWidget` + (this._widgetCounter++);
+        const domNode = document.createElement('div');
+        const w = {
+            getDomNode: () => domNode,
+            getPosition: () => {
+                return pos ? { preference: [0 /* ContentWidgetPositionPreference.EXACT */], position: position.get() } : null;
+            },
+            getId: () => contentWidgetId,
+            allowEditorOverflow: false,
+            afterRender: (position, coordinate) => {
+                const model = this._model.get();
+                if (model && pos && pos.lineNumber > model.getLineCount()) {
+                    // the position is after the last line
+                    result.set(new Point(0, this.editor.getBottomForLineNumber(model.getLineCount()) - this.scrollTop.get()), undefined);
+                }
+                else {
+                    result.set(coordinate ? new Point(coordinate.left, coordinate.top) : null, undefined);
+                }
+            },
+        };
+        this.editor.addContentWidget(w);
+        store.add(autorun(reader => {
+            pos = position.read(reader);
+            this.editor.layoutContentWidget(w);
+        }));
+        store.add(toDisposable(() => {
+            this.editor.removeContentWidget(w);
+        }));
+        return result;
+    }
+    isTargetHovered(predicate, store) {
+        const isHovered = observableValue('isInjectedTextHovered', false);
+        store.add(this.editor.onMouseMove(e => {
+            const val = predicate(e);
+            isHovered.set(val, undefined);
+        }));
+        store.add(this.editor.onMouseLeave(E => {
+            isHovered.set(false, undefined);
+        }));
+        return isHovered;
+    }
+    observeLineHeightForPosition(position) {
+        return derived(reader => {
+            const pos = position instanceof Position ? position : position.read(reader);
+            if (pos === null) {
+                return null;
+            }
+            this.getOption(75 /* EditorOption.lineHeight */).read(reader);
+            return this.editor.getLineHeightForPosition(pos);
+        });
+    }
+    observeLineHeightForLine(lineNumber) {
+        if (typeof lineNumber === 'number') {
+            return this.observeLineHeightForPosition(new Position(lineNumber, 1));
+        }
+        return derived(reader => {
+            const line = lineNumber.read(reader);
+            if (line === null) {
+                return null;
+            }
+            return this.observeLineHeightForPosition(new Position(line, 1)).read(reader);
+        });
+    }
+    observeLineHeightsForLineRange(lineNumber) {
+        return derived(reader => {
+            const range = lineNumber instanceof LineRange ? lineNumber : lineNumber.read(reader);
+            const heights = [];
+            for (let i = range.startLineNumber; i < range.endLineNumberExclusive; i++) {
+                heights.push(this.observeLineHeightForLine(i).read(reader));
+            }
+            return heights;
+        });
+    }
+}
+
+export { ObservableCodeEditor, observableCodeEditor };

package/dist/workers/observableFromEvent.js

@@ -0,0 +1,123 @@
+import { subtransaction } from '../transaction.js';
+import { strictEquals } from '../../equals.js';
+import '../../event.js';
+import '../../lifecycle.js';
+import { DebugNameData } from '../debugName.js';
+import { getLogger } from '../logging/logging.js';
+import { BaseObservable } from './baseObservable.js';
+import { DebugLocation } from '../debugLocation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function observableFromEvent(...args) {
+    let owner;
+    let event;
+    let getValue;
+    let debugLocation;
+    if (args.length === 2) {
+        [event, getValue] = args;
+    }
+    else {
+        [owner, event, getValue, debugLocation] = args;
+    }
+    return new FromEventObservable(new DebugNameData(owner, undefined, getValue), event, getValue, () => FromEventObservable.globalTransaction, strictEquals, debugLocation ?? DebugLocation.ofCaller());
+}
+function observableFromEventOpts(options, event, getValue, debugLocation = DebugLocation.ofCaller()) {
+    return new FromEventObservable(new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? getValue), event, getValue, () => FromEventObservable.globalTransaction, options.equalsFn ?? strictEquals, debugLocation);
+}
+class FromEventObservable extends BaseObservable {
+    constructor(_debugNameData, event, _getValue, _getTransaction, _equalityComparator, debugLocation) {
+        super(debugLocation);
+        this._debugNameData = _debugNameData;
+        this.event = event;
+        this._getValue = _getValue;
+        this._getTransaction = _getTransaction;
+        this._equalityComparator = _equalityComparator;
+        this._hasValue = false;
+        this.handleEvent = (args) => {
+            const newValue = this._getValue(args);
+            const oldValue = this._value;
+            const didChange = !this._hasValue || !(this._equalityComparator(oldValue, newValue));
+            let didRunTransaction = false;
+            if (didChange) {
+                this._value = newValue;
+                if (this._hasValue) {
+                    didRunTransaction = true;
+                    subtransaction(this._getTransaction(), (tx) => {
+                        getLogger()?.handleObservableUpdated(this, { oldValue, newValue, change: undefined, didChange, hadValue: this._hasValue });
+                        for (const o of this._observers) {
+                            tx.updateObserver(o, this);
+                            o.handleChange(this, undefined);
+                        }
+                    }, () => {
+                        const name = this.getDebugName();
+                        return 'Event fired' + (name ? `: ${name}` : '');
+                    });
+                }
+                this._hasValue = true;
+            }
+            if (!didRunTransaction) {
+                getLogger()?.handleObservableUpdated(this, { oldValue, newValue, change: undefined, didChange, hadValue: this._hasValue });
+            }
+        };
+    }
+    getDebugName() {
+        return this._debugNameData.getDebugName(this);
+    }
+    get debugName() {
+        const name = this.getDebugName();
+        return 'From Event' + (name ? `: ${name}` : '');
+    }
+    onFirstObserverAdded() {
+        this._subscription = this.event(this.handleEvent);
+    }
+    onLastObserverRemoved() {
+        this._subscription.dispose();
+        this._subscription = undefined;
+        this._hasValue = false;
+        this._value = undefined;
+    }
+    get() {
+        if (this._subscription) {
+            if (!this._hasValue) {
+                this.handleEvent(undefined);
+            }
+            return this._value;
+        }
+        else {
+            // no cache, as there are no subscribers to keep it updated
+            const value = this._getValue(undefined);
+            return value;
+        }
+    }
+    debugSetValue(value) {
+        // eslint-disable-next-line local/code-no-any-casts
+        this._value = value;
+    }
+    debugGetState() {
+        return { value: this._value, hasValue: this._hasValue };
+    }
+}
+(function (observableFromEvent) {
+    observableFromEvent.Observer = FromEventObservable;
+    function batchEventsGlobally(tx, fn) {
+        let didSet = false;
+        if (FromEventObservable.globalTransaction === undefined) {
+            FromEventObservable.globalTransaction = tx;
+            didSet = true;
+        }
+        try {
+            fn();
+        }
+        finally {
+            if (didSet) {
+                FromEventObservable.globalTransaction = undefined;
+            }
+        }
+    }
+    observableFromEvent.batchEventsGlobally = batchEventsGlobally;
+})(observableFromEvent || (observableFromEvent = {}));
+
+export { FromEventObservable, observableFromEvent, observableFromEventOpts };

package/dist/workers/observableSignal.js

@@ -0,0 +1,47 @@
+import { transaction } from '../transaction.js';
+import { DebugNameData } from '../debugName.js';
+import { BaseObservable } from './baseObservable.js';
+import { DebugLocation } from '../debugLocation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function observableSignal(debugNameOrOwner, debugLocation = DebugLocation.ofCaller()) {
+    if (typeof debugNameOrOwner === 'string') {
+        return new ObservableSignal(debugNameOrOwner, undefined, debugLocation);
+    }
+    else {
+        return new ObservableSignal(undefined, debugNameOrOwner, debugLocation);
+    }
+}
+class ObservableSignal extends BaseObservable {
+    get debugName() {
+        return new DebugNameData(this._owner, this._debugName, undefined).getDebugName(this) ?? 'Observable Signal';
+    }
+    toString() {
+        return this.debugName;
+    }
+    constructor(_debugName, _owner, debugLocation) {
+        super(debugLocation);
+        this._debugName = _debugName;
+        this._owner = _owner;
+    }
+    trigger(tx, change) {
+        if (!tx) {
+            transaction(tx => {
+                this.trigger(tx, change);
+            }, () => `Trigger signal ${this.debugName}`);
+            return;
+        }
+        for (const o of this._observers) {
+            tx.updateObserver(o, this);
+            o.handleChange(this, change);
+        }
+    }
+    get() {
+        // NO OP
+    }
+}
+
+export { observableSignal };

package/dist/workers/observableSignalFromEvent.js

@@ -0,0 +1,41 @@
+import { transaction } from '../transaction.js';
+import { DebugNameData } from '../debugName.js';
+import { BaseObservable } from './baseObservable.js';
+import { DebugLocation } from '../debugLocation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function observableSignalFromEvent(owner, event, debugLocation = DebugLocation.ofCaller()) {
+    return new FromEventObservableSignal(typeof owner === 'string' ? owner : new DebugNameData(owner, undefined, undefined), event, debugLocation);
+}
+class FromEventObservableSignal extends BaseObservable {
+    constructor(debugNameDataOrName, event, debugLocation) {
+        super(debugLocation);
+        this.event = event;
+        this.handleEvent = () => {
+            transaction((tx) => {
+                for (const o of this._observers) {
+                    tx.updateObserver(o, this);
+                    o.handleChange(this, undefined);
+                }
+            }, () => this.debugName);
+        };
+        this.debugName = typeof debugNameDataOrName === 'string'
+            ? debugNameDataOrName
+            : debugNameDataOrName.getDebugName(this) ?? 'Observable Signal From Event';
+    }
+    onFirstObserverAdded() {
+        this.subscription = this.event(this.handleEvent);
+    }
+    onLastObserverRemoved() {
+        this.subscription.dispose();
+        this.subscription = undefined;
+    }
+    get() {
+        // NO OP
+    }
+}
+
+export { observableSignalFromEvent };

package/dist/workers/observableValue.js

@@ -0,0 +1,105 @@
+import { TransactionImpl } from '../transaction.js';
+import { BaseObservable } from './baseObservable.js';
+import { strictEquals } from '../../equals.js';
+import '../../event.js';
+import '../../lifecycle.js';
+import { DebugNameData } from '../debugName.js';
+import { getLogger } from '../logging/logging.js';
+import { DebugLocation } from '../debugLocation.js';
+
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+function observableValue(nameOrOwner, initialValue, debugLocation = DebugLocation.ofCaller()) {
+    let debugNameData;
+    if (typeof nameOrOwner === 'string') {
+        debugNameData = new DebugNameData(undefined, nameOrOwner, undefined);
+    }
+    else {
+        debugNameData = new DebugNameData(nameOrOwner, undefined, undefined);
+    }
+    return new ObservableValue(debugNameData, initialValue, strictEquals, debugLocation);
+}
+class ObservableValue extends BaseObservable {
+    get debugName() {
+        return this._debugNameData.getDebugName(this) ?? 'ObservableValue';
+    }
+    constructor(_debugNameData, initialValue, _equalityComparator, debugLocation) {
+        super(debugLocation);
+        this._debugNameData = _debugNameData;
+        this._equalityComparator = _equalityComparator;
+        this._value = initialValue;
+        getLogger()?.handleObservableUpdated(this, { hadValue: false, newValue: initialValue, change: undefined, didChange: true, oldValue: undefined });
+    }
+    get() {
+        return this._value;
+    }
+    set(value, tx, change) {
+        if (change === undefined && this._equalityComparator(this._value, value)) {
+            return;
+        }
+        let _tx;
+        if (!tx) {
+            tx = _tx = new TransactionImpl(() => { }, () => `Setting ${this.debugName}`);
+        }
+        try {
+            const oldValue = this._value;
+            this._setValue(value);
+            getLogger()?.handleObservableUpdated(this, { oldValue, newValue: value, change, didChange: true, hadValue: true });
+            for (const observer of this._observers) {
+                tx.updateObserver(observer, this);
+                observer.handleChange(this, change);
+            }
+        }
+        finally {
+            if (_tx) {
+                _tx.finish();
+            }
+        }
+    }
+    toString() {
+        return `${this.debugName}: ${this._value}`;
+    }
+    _setValue(newValue) {
+        this._value = newValue;
+    }
+    debugGetState() {
+        return {
+            value: this._value,
+        };
+    }
+    debugSetValue(value) {
+        this._value = value;
+    }
+}
+/**
+ * A disposable observable. When disposed, its value is also disposed.
+ * When a new value is set, the previous value is disposed.
+ */
+function disposableObservableValue(nameOrOwner, initialValue, debugLocation = DebugLocation.ofCaller()) {
+    let debugNameData;
+    if (typeof nameOrOwner === 'string') {
+        debugNameData = new DebugNameData(undefined, nameOrOwner, undefined);
+    }
+    else {
+        debugNameData = new DebugNameData(nameOrOwner, undefined, undefined);
+    }
+    return new DisposableObservableValue(debugNameData, initialValue, strictEquals, debugLocation);
+}
+class DisposableObservableValue extends ObservableValue {
+    _setValue(newValue) {
+        if (this._value === newValue) {
+            return;
+        }
+        if (this._value) {
+            this._value.dispose();
+        }
+        this._value = newValue;
+    }
+    dispose() {
+        this._value?.dispose();
+    }
+}
+
+export { DisposableObservableValue, ObservableValue, disposableObservableValue, observableValue };