@vscode/markdown-editor 0.0.2-0 → 0.0.2-1

package/dist/_observables/observableInternal/logging/debugger/utils.d.ts

@@ -0,0 +1,13 @@
+import { IDisposable } from '../../../disposables';
+export declare class Debouncer implements IDisposable {
+    private _timeout;
+    debounce(fn: () => void, timeoutMs: number): void;
+    dispose(): void;
+}
+export declare class Throttler implements IDisposable {
+    private _timeout;
+    throttle(fn: () => void, timeoutMs: number): void;
+    dispose(): void;
+}
+export declare function deepAssign<T>(target: T, source: T): void;
+export declare function deepAssignDeleteNulls<T>(target: T, source: T): void;

package/dist/_observables/observableInternal/logging/logging.d.ts

@@ -0,0 +1,30 @@
+import { AutorunObserver } from '../reactions/autorunImpl';
+import { IObservable } from '../base';
+import { TransactionImpl } from '../transaction';
+import type { Derived } from '../observables/derivedImpl';
+import { DebugLocation } from '../debugLocation';
+export declare function addLogger(logger: IObservableLogger): void;
+export declare function getLogger(): IObservableLogger | undefined;
+export declare function setLogObservableFn(fn: (obs: IObservable<any>) => void): void;
+export declare function logObservable(obs: IObservable<any>): void;
+export interface IChangeInformation {
+    oldValue: unknown;
+    newValue: unknown;
+    change: unknown;
+    didChange: boolean;
+    hadValue: boolean;
+}
+export interface IObservableLogger {
+    handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void;
+    handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;
+    handleObservableUpdated(observable: IObservable<any>, info: IChangeInformation): void;
+    handleAutorunCreated(autorun: AutorunObserver, location: DebugLocation): void;
+    handleAutorunDisposed(autorun: AutorunObserver): void;
+    handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;
+    handleAutorunStarted(autorun: AutorunObserver): void;
+    handleAutorunFinished(autorun: AutorunObserver): void;
+    handleDerivedDependencyChanged(derived: Derived<any, any, any>, observable: IObservable<any>, change: unknown): void;
+    handleDerivedCleared(observable: Derived<any, any, any>): void;
+    handleBeginTransaction(transaction: TransactionImpl): void;
+    handleEndTransaction(transaction: TransactionImpl): void;
+}

package/dist/_observables/observableInternal/map.d.ts

@@ -0,0 +1,18 @@
+import { IObservable, ITransaction } from './base';
+export declare class ObservableMap<K, V> implements Map<K, V> {
+    private readonly _data;
+    private readonly _obs;
+    readonly observable: IObservable<Map<K, V>>;
+    get size(): number;
+    has(key: K): boolean;
+    get(key: K): V | undefined;
+    set(key: K, value: V, tx?: ITransaction): this;
+    delete(key: K, tx?: ITransaction): boolean;
+    clear(tx?: ITransaction): void;
+    forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
+    entries(): IterableIterator<[K, V]>;
+    keys(): IterableIterator<K>;
+    values(): IterableIterator<V>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    get [Symbol.toStringTag](): string;
+}

package/dist/_observables/observableInternal/observables/baseObservable.d.ts

@@ -0,0 +1,58 @@
+import { IObservableWithChange, IObserver, IReader, IObservable } from '../base';
+import { DisposableStore } from '../commonFacade/deps';
+import { DebugLocation } from '../debugLocation';
+import { DebugOwner } from '../debugName';
+import { debugGetDependencyGraph } from '../logging/debugGetDependencyGraph';
+import type { keepObserved, recomputeInitiallyAndOnChange } from '../utils/utils';
+import { derivedOpts } from './derived';
+declare let _derived: typeof derivedOpts;
+/**
+ * @internal
+ * This is to allow splitting files.
+*/
+export declare function _setDerivedOpts(derived: typeof _derived): void;
+declare let _recomputeInitiallyAndOnChange: typeof recomputeInitiallyAndOnChange;
+export declare function _setRecomputeInitiallyAndOnChange(recomputeInitiallyAndOnChange: typeof _recomputeInitiallyAndOnChange): void;
+declare let _keepObserved: typeof keepObserved;
+export declare function _setKeepObserved(keepObserved: typeof _keepObserved): void;
+declare let _debugGetDependencyGraph: typeof debugGetDependencyGraph;
+export declare function _setDebugGetDependencyGraph(debugGetDependencyGraph: typeof _debugGetDependencyGraph): void;
+export declare abstract class ConvenientObservable<T, TChange> implements IObservableWithChange<T, TChange> {
+    get TChange(): TChange;
+    abstract get(): T;
+    reportChanges(): void;
+    abstract addObserver(observer: IObserver): void;
+    abstract removeObserver(observer: IObserver): void;
+    /** @sealed */
+    read(reader: IReader | undefined): T;
+    /** @sealed */
+    map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
+    map<TNew>(owner: DebugOwner, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
+    abstract log(): IObservableWithChange<T, TChange>;
+    /**
+     * @sealed
+     * Converts an observable of an observable value into a direct observable of the value.
+    */
+    flatten<TNew>(this: IObservable<IObservableWithChange<TNew, any>>): IObservable<TNew>;
+    recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
+    /**
+     * Ensures that this observable is observed. This keeps the cache alive.
+     * However, in case of deriveds, it does not force eager evaluation (only when the value is read/get).
+     * Use `recomputeInitiallyAndOnChange` for eager evaluation.
+     */
+    keepObserved(store: DisposableStore): IObservable<T>;
+    abstract get debugName(): string;
+    protected get debugValue(): T;
+    debugGetDependencyGraph(): string;
+}
+export declare abstract class BaseObservable<T, TChange = void> extends ConvenientObservable<T, TChange> {
+    protected readonly _observers: Set<IObserver>;
+    constructor(debugLocation: DebugLocation);
+    addObserver(observer: IObserver): void;
+    removeObserver(observer: IObserver): void;
+    protected onFirstObserverAdded(): void;
+    protected onLastObserverRemoved(): void;
+    log(): IObservableWithChange<T, TChange>;
+    debugGetObservers(): Set<IObserver>;
+}
+export {};

package/dist/_observables/observableInternal/observables/constObservable.d.ts

@@ -0,0 +1,5 @@
+import { IObservable } from '../base';
+/**
+ * Represents an efficient observable whose value never changes.
+ */
+export declare function constObservable<T>(value: T): IObservable<T>;

package/dist/_observables/observableInternal/observables/derived.d.ts

@@ -0,0 +1,46 @@
+import { IObservable, IReader, ITransaction, ISettableObservable, IObservableWithChange } from '../base';
+import { IChangeTracker } from '../changeTracker';
+import { DisposableStore, EqualityComparer, IDisposable } from '../commonFacade/deps';
+import { DebugLocation } from '../debugLocation';
+import { DebugOwner, IDebugNameData } from '../debugName';
+import { IDerivedReader } from './derivedImpl';
+/**
+ * Creates an observable that is derived from other observables.
+ * The value is only recomputed when absolutely needed.
+ *
+ * {@link computeFn} should start with a JS Doc using `@description` to name the derived.
+ */
+export declare function derived<T, TChange = void>(computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
+export declare function derived<T, TChange = void>(owner: DebugOwner, computeFn: (reader: IDerivedReader<TChange>) => T): IObservableWithChange<T, TChange>;
+export declare function derivedWithSetter<T>(owner: DebugOwner | undefined, computeFn: (reader: IReader) => T, setter: (value: T, transaction: ITransaction | undefined) => void, debugLocation?: DebugLocation): ISettableObservable<T>;
+export declare function derivedOpts<T>(options: IDebugNameData & {
+    equalsFn?: EqualityComparer<T>;
+    onLastObserverRemoved?: (() => void);
+}, computeFn: (reader: IReader) => T, debugLocation?: DebugLocation): IObservable<T>;
+/**
+ * Represents an observable that is derived from other observables.
+ * The value is only recomputed when absolutely needed.
+ *
+ * {@link computeFn} should start with a JS Doc using `@description` to name the derived.
+ *
+ * Use `createEmptyChangeSummary` to create a "change summary" that can collect the changes.
+ * Use `handleChange` to add a reported change to the change summary.
+ * The compute function is given the last change summary.
+ * The change summary is discarded after the compute function was called.
+ *
+ * @see derived
+ */
+export declare function derivedHandleChanges<T, TDelta, TChangeSummary>(options: IDebugNameData & {
+    changeTracker: IChangeTracker<TChangeSummary>;
+    equalityComparer?: EqualityComparer<T>;
+}, computeFn: (reader: IDerivedReader<TDelta>, changeSummary: TChangeSummary) => T, debugLocation?: DebugLocation): IObservableWithChange<T, TDelta>;
+/**
+ * @deprecated Use `derived(reader => { reader.store.add(...) })` instead!
+*/
+export declare function derivedWithStore<T>(computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;
+/**
+ * @deprecated Use `derived(reader => { reader.store.add(...) })` instead!
+*/
+export declare function derivedWithStore<T>(owner: DebugOwner, computeFn: (reader: IReader, store: DisposableStore) => T): IObservable<T>;
+export declare function derivedDisposable<T extends IDisposable | undefined>(computeFn: (reader: IReader) => T): IObservable<T>;
+export declare function derivedDisposable<T extends IDisposable | undefined>(owner: DebugOwner, computeFn: (reader: IReader) => T): IObservable<T>;

package/dist/_observables/observableInternal/observables/derivedImpl.d.ts

@@ -0,0 +1,83 @@
+import { IObservable, IObservableWithChange, IObserver, IReaderWithStore, ISettableObservable, ITransaction } from '../base';
+import { BaseObservable } from './baseObservable';
+import { DebugNameData } from '../debugName';
+import { DisposableStore, EqualityComparer } from '../commonFacade/deps';
+import { IChangeTracker } from '../changeTracker';
+import { DebugLocation } from '../debugLocation';
+export interface IDerivedReader<TChange = void> extends IReaderWithStore {
+    /**
+     * Call this to report a change delta or to force report a change, even if the new value is the same as the old value.
+    */
+    reportChange(change: TChange): void;
+}
+export declare const enum DerivedState {
+    /** Initial state, no previous value, recomputation needed */
+    initial = 0,
+    /**
+     * A dependency could have changed.
+     * We need to explicitly ask them if at least one dependency changed.
+     */
+    dependenciesMightHaveChanged = 1,
+    /**
+     * A dependency changed and we need to recompute.
+     * After recomputation, we need to check the previous value to see if we changed as well.
+     */
+    stale = 2,
+    /**
+     * No change reported, our cached value is up to date.
+     */
+    upToDate = 3
+}
+export declare class Derived<T, TChangeSummary = any, TChange = void> extends BaseObservable<T, TChange> implements IDerivedReader<TChange>, IObserver {
+    readonly _debugNameData: DebugNameData;
+    readonly _computeFn: (reader: IDerivedReader<TChange>, changeSummary: TChangeSummary) => T;
+    private readonly _changeTracker;
+    private readonly _handleLastObserverRemoved;
+    private readonly _equalityComparator;
+    private _state;
+    private _value;
+    private _updateCount;
+    private _dependencies;
+    private _dependenciesToBeRemoved;
+    private _changeSummary;
+    private _isUpdating;
+    private _isComputing;
+    private _didReportChange;
+    private _isInBeforeUpdate;
+    private _isReaderValid;
+    private _store;
+    private _delayedStore;
+    private _removedObserverToCallEndUpdateOn;
+    get debugName(): string;
+    constructor(_debugNameData: DebugNameData, _computeFn: (reader: IDerivedReader<TChange>, changeSummary: TChangeSummary) => T, _changeTracker: IChangeTracker<TChangeSummary> | undefined, _handleLastObserverRemoved: (() => void) | undefined, _equalityComparator: EqualityComparer<T>, debugLocation: DebugLocation);
+    protected onLastObserverRemoved(): void;
+    get(): T;
+    private _recompute;
+    toString(): string;
+    beginUpdate<T>(_observable: IObservable<T>): void;
+    endUpdate<T>(_observable: IObservable<T>): void;
+    handlePossibleChange<T>(observable: IObservable<T>): void;
+    handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
+    private _ensureReaderValid;
+    readObservable<T>(observable: IObservable<T>): T;
+    reportChange(change: TChange): void;
+    get store(): DisposableStore;
+    get delayedStore(): DisposableStore;
+    addObserver(observer: IObserver): void;
+    removeObserver(observer: IObserver): void;
+    debugGetState(): {
+        state: DerivedState;
+        stateStr: string;
+        updateCount: number;
+        isComputing: boolean;
+        dependencies: Set<IObservable<any>>;
+        value: T | undefined;
+    };
+    debugSetValue(newValue: unknown): void;
+    debugRecompute(): void;
+    setValue(newValue: T, tx: ITransaction, change: TChange): void;
+}
+export declare class DerivedWithSetter<T, TChangeSummary = any, TOutChanges = any> extends Derived<T, TChangeSummary, TOutChanges> implements ISettableObservable<T, TOutChanges> {
+    readonly set: (value: T, tx: ITransaction | undefined, change: TOutChanges) => void;
+    constructor(debugNameData: DebugNameData, computeFn: (reader: IDerivedReader<TOutChanges>, changeSummary: TChangeSummary) => T, changeTracker: IChangeTracker<TChangeSummary> | undefined, handleLastObserverRemoved: (() => void) | undefined, equalityComparator: EqualityComparer<T>, set: (value: T, tx: ITransaction | undefined, change: TOutChanges) => void, debugLocation: DebugLocation);
+}

package/dist/_observables/observableInternal/observables/lazyObservableValue.d.ts

@@ -0,0 +1,27 @@
+import { EqualityComparer } from '../commonFacade/deps';
+import { IObserver, ISettableObservable, ITransaction } from '../base';
+import { DebugNameData } from '../debugName';
+import { BaseObservable } from './baseObservable';
+import { DebugLocation } from '../debugLocation';
+/**
+ * Holds off updating observers until the value is actually read.
+*/
+export declare class LazyObservableValue<T, TChange = void> extends BaseObservable<T, TChange> implements ISettableObservable<T, TChange> {
+    private readonly _debugNameData;
+    private readonly _equalityComparator;
+    protected _value: T;
+    private _isUpToDate;
+    private readonly _deltas;
+    get debugName(): string;
+    constructor(_debugNameData: DebugNameData, initialValue: T, _equalityComparator: EqualityComparer<T>, debugLocation: DebugLocation);
+    get(): T;
+    private _update;
+    private _updateCounter;
+    private _beginUpdate;
+    private _endUpdate;
+    addObserver(observer: IObserver): void;
+    removeObserver(observer: IObserver): void;
+    set(value: T, tx: ITransaction | undefined, change: TChange): void;
+    toString(): string;
+    protected _setValue(newValue: T): void;
+}

package/dist/_observables/observableInternal/observables/observableFromEvent.d.ts

@@ -0,0 +1,37 @@
+import { IObservable, ITransaction } from '../base';
+import { EqualityComparer, Event } from '../commonFacade/deps';
+import { DebugOwner, DebugNameData, IDebugNameData } from '../debugName';
+import { BaseObservable } from './baseObservable';
+import { DebugLocation } from '../debugLocation';
+export declare function observableFromEvent<T, TArgs = unknown>(owner: DebugOwner, event: Event<TArgs>, getValue: (args: TArgs | undefined) => T, debugLocation?: DebugLocation): IObservable<T>;
+export declare function observableFromEvent<T, TArgs = unknown>(event: Event<TArgs>, getValue: (args: TArgs | undefined) => T): IObservable<T>;
+export declare function observableFromEventOpts<T, TArgs = unknown>(options: IDebugNameData & {
+    equalsFn?: EqualityComparer<T>;
+}, event: Event<TArgs>, getValue: (args: TArgs | undefined) => T, debugLocation?: DebugLocation): IObservable<T>;
+export declare class FromEventObservable<TArgs, T> extends BaseObservable<T> {
+    private readonly _debugNameData;
+    private readonly event;
+    readonly _getValue: (args: TArgs | undefined) => T;
+    private readonly _getTransaction;
+    private readonly _equalityComparator;
+    static globalTransaction: ITransaction | undefined;
+    private _value;
+    private _hasValue;
+    private _subscription;
+    constructor(_debugNameData: DebugNameData, event: Event<TArgs>, _getValue: (args: TArgs | undefined) => T, _getTransaction: () => ITransaction | undefined, _equalityComparator: EqualityComparer<T>, debugLocation: DebugLocation);
+    private getDebugName;
+    get debugName(): string;
+    protected onFirstObserverAdded(): void;
+    private readonly handleEvent;
+    protected onLastObserverRemoved(): void;
+    get(): T;
+    debugSetValue(value: unknown): void;
+    debugGetState(): {
+        value: T | undefined;
+        hasValue: boolean;
+    };
+}
+export declare namespace observableFromEvent {
+    const Observer: typeof FromEventObservable;
+    function batchEventsGlobally(tx: ITransaction, fn: () => void): void;
+}

package/dist/_observables/observableInternal/observables/observableSignal.d.ts

@@ -0,0 +1,11 @@
+import { IObservableWithChange, ITransaction } from '../base';
+/**
+ * Creates a signal that can be triggered to invalidate observers.
+ * Signals don't have a value - when they are triggered they indicate a change.
+ * However, signals can carry a delta that is passed to observers.
+ */
+export declare function observableSignal<TDelta = void>(debugName: string): IObservableSignal<TDelta>;
+export declare function observableSignal<TDelta = void>(owner: object): IObservableSignal<TDelta>;
+export interface IObservableSignal<TChange> extends IObservableWithChange<void, TChange> {
+    trigger(tx: ITransaction | undefined, change: TChange): void;
+}

package/dist/_observables/observableInternal/observables/observableSignalFromEvent.d.ts

@@ -0,0 +1,5 @@
+import { IObservable } from '../base';
+import { Event } from '../commonFacade/deps';
+import { DebugOwner } from '../debugName';
+import { DebugLocation } from '../debugLocation';
+export declare function observableSignalFromEvent(owner: DebugOwner | string, event: Event<any>, debugLocation?: DebugLocation): IObservable<void>;

package/dist/_observables/observableInternal/observables/observableValue.d.ts

@@ -0,0 +1,37 @@
+import { ISettableObservable, ITransaction } from '../base';
+import { BaseObservable } from './baseObservable';
+import { EqualityComparer, IDisposable } from '../commonFacade/deps';
+import { DebugNameData } from '../debugName';
+import { DebugLocation } from '../debugLocation';
+/**
+ * Creates an observable value.
+ * Observers get informed when the value changes.
+ * @template TChange An arbitrary type to describe how or why the value changed. Defaults to `void`.
+ * Observers will receive every single change value.
+ */
+export declare function observableValue<T, TChange = void>(name: string, initialValue: T, debugLocation?: DebugLocation): ISettableObservable<T, TChange>;
+export declare function observableValue<T, TChange = void>(owner: object, initialValue: T, debugLocation?: DebugLocation): ISettableObservable<T, TChange>;
+export declare class ObservableValue<T, TChange = void> extends BaseObservable<T, TChange> implements ISettableObservable<T, TChange> {
+    private readonly _debugNameData;
+    private readonly _equalityComparator;
+    protected _value: T;
+    get debugName(): string;
+    constructor(_debugNameData: DebugNameData, initialValue: T, _equalityComparator: EqualityComparer<T>, debugLocation: DebugLocation);
+    get(): T;
+    set(value: T, tx: ITransaction | undefined, change: TChange): void;
+    toString(): string;
+    protected _setValue(newValue: T): void;
+    debugGetState(): {
+        value: T;
+    };
+    debugSetValue(value: unknown): void;
+}
+/**
+ * A disposable observable. When disposed, its value is also disposed.
+ * When a new value is set, the previous value is disposed.
+ */
+export declare function disposableObservableValue<T extends IDisposable | undefined, TChange = void>(nameOrOwner: string | object, initialValue: T, debugLocation?: DebugLocation): ISettableObservable<T, TChange> & IDisposable;
+export declare class DisposableObservableValue<T extends IDisposable | undefined, TChange = void> extends ObservableValue<T, TChange> implements IDisposable {
+    protected _setValue(newValue: T): void;
+    dispose(): void;
+}

package/dist/_observables/observableInternal/observables/observableValueOpts.d.ts

@@ -0,0 +1,8 @@
+import { ISettableObservable } from '../base';
+import { IDebugNameData } from '../debugName';
+import { EqualityComparer } from '../commonFacade/deps';
+import { DebugLocation } from '../debugLocation';
+export declare function observableValueOpts<T, TChange = void>(options: IDebugNameData & {
+    equalsFn?: EqualityComparer<T>;
+    lazy?: boolean;
+}, initialValue: T, debugLocation?: DebugLocation): ISettableObservable<T, TChange>;

package/dist/_observables/observableInternal/reactions/autorun.d.ts

@@ -0,0 +1,56 @@
+import { IReaderWithStore, IReader, IObservable } from '../base';
+import { IChangeTracker } from '../changeTracker';
+import { DisposableStore, IDisposable } from '../commonFacade/deps';
+import { IDebugNameData } from '../debugName';
+import { DebugLocation } from '../debugLocation';
+/**
+ * Runs immediately and whenever a transaction ends and an observed observable changed.
+ * {@link fn} should start with a JS Doc using `@description` to name the autorun.
+ */
+export declare function autorun(fn: (reader: IReaderWithStore) => void, debugLocation?: DebugLocation): IDisposable;
+/**
+ * Runs immediately and whenever a transaction ends and an observed observable changed.
+ * {@link fn} should start with a JS Doc using `@description` to name the autorun.
+ */
+export declare function autorunOpts(options: IDebugNameData & {}, fn: (reader: IReaderWithStore) => void, debugLocation?: DebugLocation): IDisposable;
+/**
+ * Runs immediately and whenever a transaction ends and an observed observable changed.
+ * {@link fn} should start with a JS Doc using `@description` to name the autorun.
+ *
+ * Use `changeTracker.createChangeSummary` to create a "change summary" that can collect the changes.
+ * Use `changeTracker.handleChange` to add a reported change to the change summary.
+ * The run function is given the last change summary.
+ * The change summary is discarded after the run function was called.
+ *
+ * @see autorun
+ */
+export declare function autorunHandleChanges<TChangeSummary>(options: IDebugNameData & {
+    changeTracker: IChangeTracker<TChangeSummary>;
+}, fn: (reader: IReader, changeSummary: TChangeSummary) => void, debugLocation?: DebugLocation): IDisposable;
+/**
+ * @see autorunHandleChanges (but with a disposable store that is cleared before the next run or on dispose)
+ */
+export declare function autorunWithStoreHandleChanges<TChangeSummary>(options: IDebugNameData & {
+    changeTracker: IChangeTracker<TChangeSummary>;
+}, fn: (reader: IReader, changeSummary: TChangeSummary, store: DisposableStore) => void): IDisposable;
+/**
+ * @see autorun (but with a disposable store that is cleared before the next run or on dispose)
+ *
+ * @deprecated Use `autorun(reader => { reader.store.add(...) })` instead!
+ */
+export declare function autorunWithStore(fn: (reader: IReader, store: DisposableStore) => void): IDisposable;
+export declare function autorunDelta<T>(observable: IObservable<T>, handler: (args: {
+    lastValue: T | undefined;
+    newValue: T;
+}) => void): IDisposable;
+export declare function autorunIterableDelta<T>(getValue: (reader: IReader) => Iterable<T>, handler: (args: {
+    addedValues: T[];
+    removedValues: T[];
+}) => void, getUniqueIdentifier?: (value: T) => unknown): IDisposable;
+export interface IReaderWithDispose extends IReaderWithStore, IDisposable {
+}
+/**
+ * An autorun with a `dispose()` method on its `reader` which cancels the autorun.
+ * It it safe to call `dispose()` synchronously.
+ */
+export declare function autorunSelfDisposable(fn: (reader: IReaderWithDispose) => void, debugLocation?: DebugLocation): IDisposable;

package/dist/_observables/observableInternal/reactions/autorunImpl.d.ts

@@ -0,0 +1,53 @@
+import { IObservable, IObservableWithChange, IObserver, IReaderWithStore } from '../base';
+import { DebugNameData } from '../debugName';
+import { DisposableStore, IDisposable } from '../commonFacade/deps';
+import { IChangeTracker } from '../changeTracker';
+import { DebugLocation } from '../debugLocation';
+export declare const enum AutorunState {
+    /**
+     * A dependency could have changed.
+     * We need to explicitly ask them if at least one dependency changed.
+     */
+    dependenciesMightHaveChanged = 1,
+    /**
+     * A dependency changed and we need to recompute.
+     */
+    stale = 2,
+    upToDate = 3
+}
+export declare class AutorunObserver<TChangeSummary = any> implements IObserver, IReaderWithStore, IDisposable {
+    readonly _debugNameData: DebugNameData;
+    readonly _runFn: (reader: IReaderWithStore, changeSummary: TChangeSummary) => void;
+    private readonly _changeTracker;
+    private _state;
+    private _updateCount;
+    private _disposed;
+    private _dependencies;
+    private _dependenciesToBeRemoved;
+    private _changeSummary;
+    private _isRunning;
+    get debugName(): string;
+    constructor(_debugNameData: DebugNameData, _runFn: (reader: IReaderWithStore, changeSummary: TChangeSummary) => void, _changeTracker: IChangeTracker<TChangeSummary> | undefined, debugLocation: DebugLocation);
+    dispose(): void;
+    private _run;
+    toString(): string;
+    beginUpdate(_observable: IObservable<any>): void;
+    endUpdate(_observable: IObservable<any>): void;
+    handlePossibleChange(observable: IObservable<any>): void;
+    handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
+    private _isDependency;
+    private _ensureNoRunning;
+    readObservable<T>(observable: IObservable<T>): T;
+    private _store;
+    get store(): DisposableStore;
+    private _delayedStore;
+    get delayedStore(): DisposableStore;
+    debugGetState(): {
+        isRunning: boolean;
+        updateCount: number;
+        dependencies: Set<IObservable<any>>;
+        state: AutorunState;
+        stateStr: string;
+    };
+    debugRerun(): void;
+}

package/dist/_observables/observableInternal/set.d.ts

@@ -0,0 +1,17 @@
+import { IObservable, ITransaction } from './base';
+export declare class ObservableSet<T> implements Set<T> {
+    private readonly _data;
+    private _obs;
+    readonly observable: IObservable<Set<T>>;
+    get size(): number;
+    has(value: T): boolean;
+    add(value: T, tx?: ITransaction): this;
+    delete(value: T, tx?: ITransaction): boolean;
+    clear(tx?: ITransaction): void;
+    forEach(callbackfn: (value: T, value2: T, set: Set<T>) => void, thisArg?: any): void;
+    entries(): IterableIterator<[T, T]>;
+    keys(): IterableIterator<T>;
+    values(): IterableIterator<T>;
+    [Symbol.iterator](): IterableIterator<T>;
+    get [Symbol.toStringTag](): string;
+}

package/dist/_observables/observableInternal/transaction.d.ts

@@ -0,0 +1,27 @@
+import { IObservable, IObserver, ITransaction } from './base';
+/**
+ * Starts a transaction in which many observables can be changed at once.
+ * {@link fn} should start with a JS Doc using `@description` to give the transaction a debug name.
+ * Reaction run on demand or when the transaction ends.
+ */
+export declare function transaction(fn: (tx: ITransaction) => void, getDebugName?: () => string): void;
+export declare function globalTransaction(fn: (tx: ITransaction) => void): void;
+/** @deprecated */
+export declare function asyncTransaction(fn: (tx: ITransaction) => Promise<void>, getDebugName?: () => string): Promise<void>;
+/**
+ * Allows to chain transactions.
+ */
+export declare function subtransaction(tx: ITransaction | undefined, fn: (tx: ITransaction) => void, getDebugName?: () => string): void;
+export declare class TransactionImpl implements ITransaction {
+    readonly _fn: Function;
+    private readonly _getDebugName?;
+    private _updatingObservers;
+    constructor(_fn: Function, _getDebugName?: (() => string) | undefined);
+    getDebugName(): string | undefined;
+    updateObserver(observer: IObserver, observable: IObservable<any>): void;
+    finish(): void;
+    debugGetUpdatingObservers(): {
+        observer: IObserver;
+        observable: IObservable<any>;
+    }[] | null;
+}

package/dist/_observables/observableInternal/utils/promise.d.ts

@@ -0,0 +1,75 @@
+import { IObservable } from '../base';
+export declare class ObservableLazy<T> {
+    private readonly _computeValue;
+    private readonly _value;
+    /**
+     * The cached value.
+     * Does not force a computation of the value.
+     */
+    get cachedValue(): IObservable<T | undefined>;
+    constructor(_computeValue: () => T);
+    /**
+     * Returns the cached value.
+     * Computes the value if the value has not been cached yet.
+     */
+    getValue(): T;
+}
+/**
+ * A promise whose state is observable.
+ */
+export declare class ObservablePromise<T> {
+    static fromFn<T>(fn: () => Promise<T>): ObservablePromise<T>;
+    private readonly _value;
+    /**
+     * The promise that this object wraps.
+     */
+    readonly promise: Promise<T>;
+    /**
+     * The current state of the promise.
+     * Is `undefined` if the promise didn't resolve yet.
+     */
+    readonly promiseResult: IObservable<PromiseResult<T> | undefined>;
+    constructor(promise: Promise<T>);
+    readonly resolvedValue: import("..").IObservableWithChange<T | undefined, void>;
+}
+export declare class PromiseResult<T> {
+    /**
+     * The value of the resolved promise.
+     * Undefined if the promise rejected.
+     */
+    readonly data: T | undefined;
+    /**
+     * The error in case of a rejected promise.
+     * Undefined if the promise resolved.
+     */
+    readonly error: unknown | undefined;
+    constructor(
+    /**
+     * The value of the resolved promise.
+     * Undefined if the promise rejected.
+     */
+    data: T | undefined, 
+    /**
+     * The error in case of a rejected promise.
+     * Undefined if the promise resolved.
+     */
+    error: unknown | undefined);
+    /**
+     * Returns the value if the promise resolved, otherwise throws the error.
+     */
+    getDataOrThrow(): T;
+}
+/**
+ * A lazy promise whose state is observable.
+ */
+export declare class ObservableLazyPromise<T> {
+    private readonly _computePromise;
+    private readonly _lazyValue;
+    /**
+     * Does not enforce evaluation of the promise compute function.
+     * Is undefined if the promise has not been computed yet.
+     */
+    readonly cachedPromiseResult: import("..").IObservableWithChange<PromiseResult<T> | undefined, void>;
+    constructor(_computePromise: () => Promise<T>);
+    getPromise(): Promise<T>;
+}

package/dist/_observables/observableInternal/utils/runOnChange.d.ts

@@ -0,0 +1,7 @@
+import { IObservableWithChange } from '../base';
+import { CancellationToken } from '../commonFacade/cancellation';
+import { DisposableStore, IDisposable } from '../commonFacade/deps';
+export type RemoveUndefined<T> = T extends undefined ? never : T;
+export declare function runOnChange<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[]) => void): IDisposable;
+export declare function runOnChangeWithStore<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[], store: DisposableStore) => void): IDisposable;
+export declare function runOnChangeWithCancellationToken<T, TChange>(observable: IObservableWithChange<T, TChange>, cb: (value: T, previousValue: T, deltas: RemoveUndefined<TChange>[], token: CancellationToken) => Promise<void>): IDisposable;