@codingame/monaco-vscode-api 17.2.1 → 18.0.0

package/vscode/src/vs/base/common/observableInternal/utils.js

@@ -1,486 +0,0 @@
-
-import { autorun, autorunOpts, autorunWithStoreHandleChanges } from './autorun.js';
-import { ConvenientObservable, observableValue, BaseObservable, subtransaction, transaction, _setKeepObserved, _setRecomputeInitiallyAndOnChange } from './base.js';
-import { DebugNameData, getDebugName } from './debugName.js';
-import { BugIndicatingError } from '../errors.js';
-import { strictEquals } from '../equals.js';
-import { Event } from '../event.js';
-import { toDisposable, DisposableStore } from '../lifecycle.js';
-import { derivedOpts, derived } from './derived.js';
-import { getLogger } from './logging/logging.js';
-import { cancelOnDispose } from '../cancellation.js';
-
-function constObservable(value) {
-    return ( new ConstObservable(value));
-}
-class ConstObservable extends ConvenientObservable {
-    constructor(value) {
-        super();
-        this.value = value;
-    }
-    get debugName() {
-        return ( this.toString());
-    }
-    get() {
-        return this.value;
-    }
-    addObserver(observer) {
-    }
-    removeObserver(observer) {
-    }
-    log() {
-        return this;
-    }
-    toString() {
-        return `Const: ${this.value}`;
-    }
-}
-function observableFromPromise(promise) {
-    const observable = observableValue('promiseValue', {});
-    promise.then((value) => {
-        observable.set({ value }, undefined);
-    });
-    return observable;
-}
-function observableFromEvent(...args) {
-    let owner;
-    let event;
-    let getValue;
-    if (args.length === 3) {
-        [owner, event, getValue] = args;
-    }
-    else {
-        [event, getValue] = args;
-    }
-    return ( new FromEventObservable(( new DebugNameData(owner, undefined, getValue)), event, getValue, () => FromEventObservable.globalTransaction, strictEquals));
-}
-function observableFromEventOpts(options, event, getValue) {
-    return ( new FromEventObservable(( new DebugNameData(options.owner, options.debugName, options.debugReferenceFn ?? getValue)), event, getValue, () => FromEventObservable.globalTransaction, options.equalsFn ?? strictEquals));
-}
-class FromEventObservable extends BaseObservable {
-    constructor(_debugNameData, event, _getValue, _getTransaction, _equalityComparator) {
-        super();
-        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 {
-            const value = this._getValue(undefined);
-            return value;
-        }
-    }
-    debugSetValue(value) {
-        this._value = value;
-    }
-}
-(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 = {}));
-function observableSignalFromEvent(owner, event) {
-    return ( new FromEventObservableSignal(typeof owner === 'string' ? owner : ( new DebugNameData(owner, undefined, undefined)), event));
-}
-class FromEventObservableSignal extends BaseObservable {
-    constructor(debugNameDataOrName, event) {
-        super();
-        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() {
-    }
-}
-function observableSignal(debugNameOrOwner) {
-    if (typeof debugNameOrOwner === 'string') {
-        return ( new ObservableSignal(debugNameOrOwner));
-    }
-    else {
-        return ( new ObservableSignal(undefined, debugNameOrOwner));
-    }
-}
-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) {
-        super();
-        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() {
-    }
-}
-function debouncedObservable(observable, debounceMs) {
-    let hasValue = false;
-    let lastValue;
-    let timeout = undefined;
-    return observableFromEvent(cb => {
-        const d = autorun(reader => {
-            const value = observable.read(reader);
-            if (!hasValue) {
-                hasValue = true;
-                lastValue = value;
-            }
-            else {
-                if (timeout) {
-                    clearTimeout(timeout);
-                }
-                timeout = setTimeout(() => {
-                    lastValue = value;
-                    cb();
-                }, debounceMs);
-            }
-        });
-        return {
-            dispose() {
-                d.dispose();
-                hasValue = false;
-                lastValue = undefined;
-            },
-        };
-    }, () => {
-        if (hasValue) {
-            return lastValue;
-        }
-        else {
-            return observable.get();
-        }
-    });
-}
-function wasEventTriggeredRecently(event, timeoutMs, disposableStore) {
-    const observable = observableValue('triggeredRecently', false);
-    let timeout = undefined;
-    disposableStore.add(event(() => {
-        observable.set(true, undefined);
-        if (timeout) {
-            clearTimeout(timeout);
-        }
-        timeout = setTimeout(() => {
-            observable.set(false, undefined);
-        }, timeoutMs);
-    }));
-    return observable;
-}
-function keepObserved(observable) {
-    const o = ( new KeepAliveObserver(false, undefined));
-    observable.addObserver(o);
-    return toDisposable(() => {
-        observable.removeObserver(o);
-    });
-}
-_setKeepObserved(keepObserved);
-function recomputeInitiallyAndOnChange(observable, handleValue) {
-    const o = ( new KeepAliveObserver(true, handleValue));
-    observable.addObserver(o);
-    try {
-        o.beginUpdate(observable);
-    }
-    finally {
-        o.endUpdate(observable);
-    }
-    return toDisposable(() => {
-        observable.removeObserver(o);
-    });
-}
-_setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange);
-class KeepAliveObserver {
-    constructor(_forceRecompute, _handleValue) {
-        this._forceRecompute = _forceRecompute;
-        this._handleValue = _handleValue;
-        this._counter = 0;
-    }
-    beginUpdate(observable) {
-        this._counter++;
-    }
-    endUpdate(observable) {
-        if (this._counter === 1 && this._forceRecompute) {
-            if (this._handleValue) {
-                this._handleValue(observable.get());
-            }
-            else {
-                observable.reportChanges();
-            }
-        }
-        this._counter--;
-    }
-    handlePossibleChange(observable) {
-    }
-    handleChange(observable, change) {
-    }
-}
-function derivedObservableWithCache(owner, computeFn) {
-    let lastValue = undefined;
-    const observable = derivedOpts({ owner, debugReferenceFn: computeFn }, reader => {
-        lastValue = computeFn(reader, lastValue);
-        return lastValue;
-    });
-    return observable;
-}
-function derivedObservableWithWritableCache(owner, computeFn) {
-    let lastValue = undefined;
-    const onChange = observableSignal('derivedObservableWithWritableCache');
-    const observable = derived(owner, reader => {
-        onChange.read(reader);
-        lastValue = computeFn(reader, lastValue);
-        return lastValue;
-    });
-    return Object.assign(observable, {
-        clearCache: (tx) => {
-            lastValue = undefined;
-            onChange.trigger(tx);
-        },
-        setCache: (newValue, tx) => {
-            lastValue = newValue;
-            onChange.trigger(tx);
-        }
-    });
-}
-function mapObservableArrayCached(owner, items, map, keySelector) {
-    let m = ( new ArrayMap(map, keySelector));
-    const self = derivedOpts({
-        debugReferenceFn: map,
-        owner,
-        onLastObserverRemoved: () => {
-            m.dispose();
-            m = ( new ArrayMap(map));
-        }
-    }, (reader) => {
-        m.setItems(items.read(reader));
-        return m.getItems();
-    });
-    return self;
-}
-class ArrayMap {
-    constructor(_map, _keySelector) {
-        this._map = _map;
-        this._keySelector = _keySelector;
-        this._cache = ( new Map());
-        this._items = [];
-    }
-    dispose() {
-        this._cache.forEach(entry => entry.store.dispose());
-        this._cache.clear();
-    }
-    setItems(items) {
-        const newItems = [];
-        const itemsToRemove = ( new Set(( this._cache.keys())));
-        for (const item of items) {
-            const key = this._keySelector ? this._keySelector(item) : item;
-            let entry = this._cache.get(key);
-            if (!entry) {
-                const store = ( new DisposableStore());
-                const out = this._map(item, store);
-                entry = { out, store };
-                this._cache.set(key, entry);
-            }
-            else {
-                itemsToRemove.delete(key);
-            }
-            newItems.push(entry.out);
-        }
-        for (const item of itemsToRemove) {
-            const entry = this._cache.get(item);
-            entry.store.dispose();
-            this._cache.delete(item);
-        }
-        this._items = newItems;
-    }
-    getItems() {
-        return this._items;
-    }
-}
-class ValueWithChangeEventFromObservable {
-    constructor(observable) {
-        this.observable = observable;
-    }
-    get onDidChange() {
-        return Event.fromObservableLight(this.observable);
-    }
-    get value() {
-        return this.observable.get();
-    }
-}
-function observableFromValueWithChangeEvent(owner, value) {
-    if (value instanceof ValueWithChangeEventFromObservable) {
-        return value.observable;
-    }
-    return observableFromEvent(owner, value.onDidChange, () => value.value);
-}
-function latestChangedValue(owner, observables) {
-    if (observables.length === 0) {
-        throw ( new BugIndicatingError());
-    }
-    let hasLastChangedValue = false;
-    let lastChangedValue = undefined;
-    const result = observableFromEvent(owner, cb => {
-        const store = ( new DisposableStore());
-        for (const o of observables) {
-            store.add(autorunOpts({ debugName: () => getDebugName(result, ( new DebugNameData(owner, undefined, undefined))) + '.updateLastChangedValue' }, reader => {
-                hasLastChangedValue = true;
-                lastChangedValue = o.read(reader);
-                cb();
-            }));
-        }
-        store.add({
-            dispose() {
-                hasLastChangedValue = false;
-                lastChangedValue = undefined;
-            },
-        });
-        return store;
-    }, () => {
-        if (hasLastChangedValue) {
-            return lastChangedValue;
-        }
-        else {
-            return observables[observables.length - 1].get();
-        }
-    });
-    return result;
-}
-function derivedConstOnceDefined(owner, fn) {
-    return derivedObservableWithCache(owner, (reader, lastValue) => lastValue ?? fn(reader));
-}
-function runOnChange(observable, cb) {
-    let _previousValue;
-    return autorunWithStoreHandleChanges({
-        changeTracker: {
-            createChangeSummary: () => ({ deltas: [], didChange: false }),
-            handleChange: (context, changeSummary) => {
-                if (context.didChange(observable)) {
-                    const e = context.change;
-                    if (e !== undefined) {
-                        changeSummary.deltas.push(e);
-                    }
-                    changeSummary.didChange = true;
-                }
-                return true;
-            },
-        }
-    }, (reader, changeSummary) => {
-        const value = observable.read(reader);
-        const previousValue = _previousValue;
-        if (changeSummary.didChange) {
-            _previousValue = value;
-            cb(value, previousValue, changeSummary.deltas);
-        }
-    });
-}
-function runOnChangeWithStore(observable, cb) {
-    const store = ( new DisposableStore());
-    const disposable = runOnChange(observable, (value, previousValue, deltas) => {
-        store.clear();
-        cb(value, previousValue, deltas, store);
-    });
-    return {
-        dispose() {
-            disposable.dispose();
-            store.dispose();
-        }
-    };
-}
-function runOnChangeWithCancellationToken(observable, cb) {
-    return runOnChangeWithStore(observable, (value, previousValue, deltas, store) => {
-        cb(value, previousValue, deltas, cancelOnDispose(store));
-    });
-}
-
-export { FromEventObservable, KeepAliveObserver, ValueWithChangeEventFromObservable, constObservable, debouncedObservable, derivedConstOnceDefined, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, latestChangedValue, mapObservableArrayCached, observableFromEvent, observableFromEventOpts, observableFromPromise, observableFromValueWithChangeEvent, observableSignal, observableSignalFromEvent, recomputeInitiallyAndOnChange, runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore, wasEventTriggeredRecently };

package/vscode/src/vs/editor/common/core/offsetEdit.d.ts

@@ -1,43 +0,0 @@
-import { OffsetRange } from "./offsetRange.js";
-export declare class OffsetEdit {
-    readonly edits: readonly SingleOffsetEdit[];
-    static join(edits: readonly OffsetEdit[]): OffsetEdit;
-    static readonly empty: OffsetEdit;
-    static fromJson(data: IOffsetEdit): OffsetEdit;
-    static replace(range: OffsetRange, newText: string): OffsetEdit;
-    static insert(offset: number, insertText: string): OffsetEdit;
-    constructor(edits: readonly SingleOffsetEdit[]);
-    normalize(): OffsetEdit;
-    toString(): string;
-    apply(str: string): string;
-    compose(other: OffsetEdit): OffsetEdit;
-    inverse(originalStr: string): OffsetEdit;
-    getNewTextRanges(): OffsetRange[];
-    get isEmpty(): boolean;
-    tryRebase(base: OffsetEdit): OffsetEdit;
-    tryRebase(base: OffsetEdit, noOverlap: true): OffsetEdit | undefined;
-    applyToOffset(originalOffset: number): number;
-    applyToOffsetRange(originalRange: OffsetRange): OffsetRange;
-    applyInverseToOffset(postEditsOffset: number): number;
-    equals(other: OffsetEdit): boolean;
-}
-export type IOffsetEdit = ISingleOffsetEdit[];
-export interface ISingleOffsetEdit {
-    txt: string;
-    pos: number;
-    len: number;
-}
-export declare class SingleOffsetEdit {
-    readonly replaceRange: OffsetRange;
-    readonly newText: string;
-    static fromJson(data: ISingleOffsetEdit): SingleOffsetEdit;
-    static insert(offset: number, text: string): SingleOffsetEdit;
-    static replace(range: OffsetRange, text: string): SingleOffsetEdit;
-    constructor(replaceRange: OffsetRange, newText: string);
-    toString(): string;
-    get isEmpty(): boolean;
-    apply(str: string): string;
-    getRangeAfterApply(): OffsetRange;
-    equals(other: SingleOffsetEdit): boolean;
-}
-export declare function applyEditsToRanges(sortedRanges: OffsetRange[], edits: OffsetEdit): OffsetRange[];