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

package/dist/_observables/assert.d.ts

@@ -0,0 +1,2 @@
+export declare function assert(condition: boolean): void;
+export declare function assertNonExoticNumber(value: number): void;

package/dist/_observables/deps.d.ts

@@ -0,0 +1,28 @@
+import { IDisposable, DisposableStore } from './disposables';
+export { IDisposable, DisposableStore };
+export declare function toDisposable(fn: () => void): IDisposable;
+export declare function markAsDisposed(_disposable: IDisposable): void;
+export declare function trackDisposable(_disposable: IDisposable): void;
+export declare function assertFn(_fn: () => {}): void;
+export declare class CancellationError extends Error {
+    constructor();
+}
+export interface CancellationToken {
+    /**
+     * A flag signalling is cancellation has been requested.
+     */
+    readonly isCancellationRequested: boolean;
+    /**
+     * An event which fires when cancellation is requested. This event
+     * only ever fires `once` as cancellation can only happen once. Listeners
+     * that are registered after cancellation will be called (next event loop run),
+     * but also only once.
+     *
+     * @event
+     */
+    readonly onCancellationRequested: (listener: (e: any) => any, thisArgs?: any, disposables?: IDisposable[]) => IDisposable;
+}
+export declare function onBugIndicatingError(_error?: any): void;
+export declare class BugIndicatingError extends Error {
+    constructor(message?: string);
+}

package/dist/_observables/disposables.d.ts

@@ -0,0 +1,19 @@
+export interface IDisposable {
+    dispose(): void;
+}
+export declare class DisposableStore implements IDisposable {
+    private disposables;
+    private _isDisposed;
+    get isDisposed(): boolean;
+    dispose(): void;
+    add<T extends IDisposable | undefined>(disposable: T): T;
+    remove<T extends IDisposable | undefined>(disposable: T): T;
+    clear(): void;
+    leakItems(): void;
+}
+export declare abstract class Disposable implements IDisposable {
+    protected readonly _store: DisposableStore;
+    dispose(): void;
+    protected _register<T extends IDisposable>(t: T): T;
+    protected _registerOrDispose<T extends IDisposable | undefined>(t: T): T;
+}

package/dist/_observables/equals.d.ts

@@ -0,0 +1,32 @@
+export type EqualityComparer<T> = (a: T, b: T) => boolean;
+/**
+ * Compares two items for equality using strict equality.
+*/
+export declare const strictEquals: EqualityComparer<any>;
+/**
+ * Two items are considered equal, if their stringified representations are equal.
+*/
+export declare function jsonStringifyEquals<T>(): EqualityComparer<T>;
+/**
+ * Uses `item.equals(other)` to determine equality.
+ */
+export declare function itemEquals<T extends {
+    equals(other: T): boolean;
+}>(): EqualityComparer<T>;
+/**
+ * Checks if two items are both null or undefined, or are equal according to the provided equality comparer.
+*/
+export declare function equalsIfDefined<T>(v1: T | undefined | null, v2: T | undefined | null, equals: EqualityComparer<T>): boolean;
+/**
+ * Returns an equality comparer that checks if two items are both null or undefined, or are equal according to the provided equality comparer.
+*/
+export declare function equalsIfDefined<T>(equals: EqualityComparer<T>): EqualityComparer<T | undefined | null>;
+/**
+ * Drills into arrays (items ordered) and objects (keys unordered) and uses strict equality on everything else.
+*/
+export declare function structuralEquals<T>(a: T, b: T): boolean;
+/**
+ * `getStructuralKey(a) === getStructuralKey(b) <=> structuralEquals(a, b)`
+ * (assuming that a and b are not cyclic structures and nothing extends globalThis Array).
+*/
+export declare function getStructuralKey(t: unknown): string;

package/dist/_observables/index.d.ts

@@ -0,0 +1,2 @@
+export * from './observableInternal/index';
+export * from './disposables';

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

@@ -0,0 +1,172 @@
+import { DisposableStore } from './commonFacade/deps';
+/**
+ * Represents an observable value.
+ *
+ * @template T The type of the values the observable can hold.
+ */
+export interface IObservable<T> extends IObservableWithChange<T, unknown> {
+}
+/**
+ * Represents an observable value.
+ *
+ * @template T The type of the values the observable can hold.
+ * @template TChange The type used to describe value changes
+ * (usually `void` and only used in advanced scenarios).
+ * While observers can miss temporary values of an observable,
+ * they will receive all change values (as long as they are subscribed)!
+ */
+export interface IObservableWithChange<T, TChange = unknown> {
+    /**
+     * Returns the current value.
+     *
+     * Calls {@link IObserver.handleChange} if the observable notices that the value changed.
+     * Must not be called from {@link IObserver.handleChange}!
+     */
+    get(): T;
+    /**
+     * Forces the observable to check for changes and report them.
+     *
+     * Has the same effect as calling {@link IObservable.get}, but does not force the observable
+     * to actually construct the value, e.g. if change deltas are used.
+     * Calls {@link IObserver.handleChange} if the observable notices that the value changed.
+     * Must not be called from {@link IObserver.handleChange}!
+     */
+    reportChanges(): void;
+    /**
+     * Adds the observer to the set of subscribed observers.
+     * This method is idempotent.
+     */
+    addObserver(observer: IObserver): void;
+    /**
+     * Removes the observer from the set of subscribed observers.
+     * This method is idempotent.
+     */
+    removeObserver(observer: IObserver): void;
+    /**
+     * Reads the current value and subscribes the reader to this observable.
+     *
+     * Calls {@link IReader.readObservable} if a reader is given, otherwise {@link IObservable.get}
+     * (see {@link ConvenientObservable.read} for the implementation).
+     */
+    read(reader: IReader | undefined): T;
+    /**
+     * Makes sure this value is computed eagerly.
+     */
+    recomputeInitiallyAndOnChange(store: DisposableStore, handleValue?: (value: T) => void): IObservable<T>;
+    /**
+     * Makes sure this value is cached.
+     */
+    keepObserved(store: DisposableStore): IObservable<T>;
+    /**
+     * Creates a derived observable that depends on this observable.
+     * Use the reader to read other observables
+     * (see {@link ConvenientObservable.map} for the implementation).
+     */
+    map<TNew>(fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
+    map<TNew>(owner: object, fn: (value: T, reader: IReader) => TNew): IObservable<TNew>;
+    flatten<TNew>(this: IObservable<IObservable<TNew>>): IObservable<TNew>;
+    /**
+     * ONLY FOR DEBUGGING!
+     * Logs computations of this derived.
+    */
+    log(): IObservableWithChange<T, TChange>;
+    /**
+     * A human-readable name for debugging purposes.
+     */
+    readonly debugName: string;
+    /**
+     * ONLY FOR DEBUGGING!
+    */
+    debugGetDependencyGraph(): string;
+    /**
+     * This property captures the type of the change object. Do not use it at runtime!
+     */
+    readonly TChange: TChange;
+}
+/**
+ * Represents an observer that can be subscribed to an observable.
+ *
+ * If an observer is subscribed to an observable and that observable didn't signal
+ * a change through one of the observer methods, the observer can assume that the
+ * observable didn't change.
+ * If an observable reported a possible change, {@link IObservable.reportChanges} forces
+ * the observable to report an actual change if there was one.
+ */
+export interface IObserver {
+    /**
+     * Signals that the given observable might have changed and a transaction potentially modifying that observable started.
+     * Before the given observable can call this method again, is must call {@link IObserver.endUpdate}.
+     *
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+     * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.
+     */
+    beginUpdate<T>(observable: IObservable<T>): void;
+    /**
+     * Signals that the transaction that potentially modified the given observable ended.
+     * This is a good place to react to (potential) changes.
+     */
+    endUpdate<T>(observable: IObservable<T>): void;
+    /**
+     * Signals that the given observable might have changed.
+     * The method {@link IObservable.reportChanges} can be used to force the observable to report the changes.
+     *
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+     * The change should be processed lazily or in {@link IObserver.endUpdate}.
+     */
+    handlePossibleChange<T>(observable: IObservable<T>): void;
+    /**
+     * Signals that the given {@link observable} changed.
+     *
+     * Implementations must not get/read the value of other observables, as they might not have received this event yet!
+     * The change should be processed lazily or in {@link IObserver.endUpdate}.
+     *
+     * @param change Indicates how or why the value changed.
+     */
+    handleChange<T, TChange>(observable: IObservableWithChange<T, TChange>, change: TChange): void;
+}
+export interface IReader {
+    /**
+     * Reads the value of an observable and subscribes to it.
+     */
+    readObservable<T>(observable: IObservableWithChange<T, any>): T;
+}
+export interface ISettable<T, TChange = void> {
+    /**
+     * Sets the value of the observable.
+     * Use a transaction to batch multiple changes (with a transaction, observers only react at the end of the transaction).
+     *
+     * @param transaction When given, value changes are handled on demand or when the transaction ends.
+     * @param change Describes how or why the value changed.
+     */
+    set(value: T, transaction: ITransaction | undefined, change: TChange): void;
+}
+export interface ITransaction {
+    /**
+     * Calls {@link Observer.beginUpdate} immediately
+     * and {@link Observer.endUpdate} when the transaction ends.
+     */
+    updateObserver(observer: IObserver, observable: IObservableWithChange<any, any>): void;
+}
+/**
+ * This function is used to indicate that the caller recovered from an error that indicates a bug.
+*/
+export declare function handleBugIndicatingErrorRecovery(message: string): void;
+/**
+ * A settable observable.
+ */
+export interface ISettableObservable<T, TChange = void> extends IObservableWithChange<T, TChange>, ISettable<T, TChange> {
+}
+export interface IReaderWithStore extends IReader {
+    /**
+     * Items in this store get disposed just before the observable recomputes/reruns or when it becomes unobserved.
+    */
+    get store(): DisposableStore;
+    /**
+     * Items in this store get disposed just after the observable recomputes/reruns or when it becomes unobserved.
+     * This is important if the current run needs the undisposed result from the last run.
+     *
+     * Warning: Items in this store might still get disposed before dependents (that read the now disposed value in the past) are recomputed with the new (undisposed) value!
+     * A clean solution for this is ref counting.
+    */
+    get delayedStore(): DisposableStore;
+}

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

@@ -0,0 +1,44 @@
+import { IObservableWithChange, IReader } from './base';
+export interface IChangeTracker<TChangeSummary> {
+    createChangeSummary(previousChangeSummary: TChangeSummary | undefined): TChangeSummary;
+    handleChange(ctx: IChangeContext, change: TChangeSummary): boolean;
+    beforeUpdate?(reader: IReader, change: TChangeSummary): void;
+}
+export interface IChangeContext {
+    readonly changedObservable: IObservableWithChange<any, any>;
+    readonly change: unknown;
+    /**
+     * Returns if the given observable caused the change.
+     */
+    didChange<T, TChange>(observable: IObservableWithChange<T, TChange>): this is {
+        change: TChange;
+    };
+}
+/**
+ * Subscribes to and records changes and the last value of the given observables.
+ * Don't use the key "changes", as it is reserved for the changes array!
+*/
+export declare function recordChanges<TObs extends Record<any, IObservableWithChange<any, any>>>(obs: TObs): IChangeTracker<{
+    [TKey in keyof TObs]: ReturnType<TObs[TKey]['get']>;
+} & {
+    changes: readonly ({
+        [TKey in keyof TObs]: {
+            key: TKey;
+            change: TObs[TKey]['TChange'];
+        };
+    }[keyof TObs])[];
+}>;
+/**
+ * Subscribes to and records changes and the last value of the given observables.
+ * Don't use the key "changes", as it is reserved for the changes array!
+*/
+export declare function recordChangesLazy<TObs extends Record<any, IObservableWithChange<any, any>>>(getObs: () => TObs): IChangeTracker<{
+    [TKey in keyof TObs]: ReturnType<TObs[TKey]['get']>;
+} & {
+    changes: readonly ({
+        [TKey in keyof TObs]: {
+            key: TKey;
+            change: TObs[TKey]['TChange'];
+        };
+    }[keyof TObs])[];
+}>;

package/dist/_observables/observableInternal/commonFacade/cancellation.d.ts

@@ -0,0 +1,24 @@
+export declare class CancellationError extends Error {
+    constructor(message?: string);
+}
+export interface CancellationToken {
+    readonly isCancellationRequested: boolean;
+    readonly onCancellationRequested: (listener: () => void) => {
+        dispose: () => void;
+    };
+}
+export declare class CancellationTokenSource {
+    private _isCancelled;
+    private _listeners;
+    get token(): CancellationToken;
+    cancel(): void;
+    dispose(): void;
+}
+/**
+ * Creates a CancellationToken that is cancelled when the given disposable is disposed.
+ */
+export declare function cancelOnDispose(disposable: {
+    add: (d: {
+        dispose: () => void;
+    }) => void;
+}): CancellationToken;

package/dist/_observables/observableInternal/commonFacade/deps.d.ts

@@ -0,0 +1,24 @@
+import { IDisposable } from '../../disposables';
+export { DisposableStore, IDisposable } from '../../disposables';
+export declare function markAsDisposed(_obj: any): void;
+export declare function trackDisposable(_obj: any): void;
+export declare function assertFn(_condition: () => boolean): void;
+export declare function toDisposable(fn: () => void): IDisposable;
+export declare class BugIndicatingError extends Error {
+    constructor(message?: string);
+}
+export declare function onBugIndicatingError(error: any): void;
+export declare function onUnexpectedError(error: any): void;
+export type EqualityComparer<T> = (a: T, b: T) => boolean;
+/**
+ * Compares two items for equality using strict equality.
+*/
+export declare const strictEquals: EqualityComparer<any>;
+export interface IValueWithChangeEvent<T> {
+    readonly onDidChange: Event<void>;
+    get value(): T;
+}
+export interface Event<T> {
+    (listener: (e: T) => any, thisArgs?: any): IDisposable;
+}
+export declare function isDefined<T>(arg: T | undefined | null): arg is T;

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

@@ -0,0 +1,21 @@
+export type DebugLocation = DebugLocationImpl | undefined;
+export declare namespace DebugLocation {
+    function enable(): void;
+    function ofCaller(): DebugLocation;
+    function ofNthCaller(n: number): DebugLocation;
+}
+declare class DebugLocationImpl implements ILocation {
+    readonly fileName: string;
+    readonly line: number;
+    readonly column: number;
+    readonly id: string;
+    static fromStack(stack: string, parentIdx: number): DebugLocationImpl | undefined;
+    constructor(fileName: string, line: number, column: number, id: string);
+}
+export interface ILocation {
+    fileName: string;
+    line: number;
+    column: number;
+    id: string;
+}
+export {};

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

@@ -0,0 +1,33 @@
+export interface IDebugNameData {
+    /**
+     * The owner object of an observable.
+     * Used for debugging only, such as computing a name for the observable by iterating over the fields of the owner.
+     */
+    readonly owner?: DebugOwner | undefined;
+    /**
+     * A string or function that returns a string that represents the name of the observable.
+     * Used for debugging only.
+     */
+    readonly debugName?: DebugNameSource | undefined;
+    /**
+     * A function that points to the defining function of the object.
+     * Used for debugging only.
+     */
+    readonly debugReferenceFn?: Function | undefined;
+}
+export declare class DebugNameData {
+    readonly owner: DebugOwner | undefined;
+    readonly debugNameSource: DebugNameSource | undefined;
+    readonly referenceFn: Function | undefined;
+    constructor(owner: DebugOwner | undefined, debugNameSource: DebugNameSource | undefined, referenceFn: Function | undefined);
+    getDebugName(target: object): string | undefined;
+}
+/**
+ * The owning object of an observable.
+ * Is only used for debugging purposes, such as computing a name for the observable by iterating over the fields of the owner.
+ */
+export type DebugOwner = object | undefined;
+export type DebugNameSource = string | (() => string | undefined);
+export declare function getDebugName(target: object, data: DebugNameData): string | undefined;
+export declare function getClassName(obj: object): string | undefined;
+export declare function getFunctionName(fn: Function): string | undefined;

package/dist/_observables/observableInternal/experimental/deferUnobserve.d.ts

@@ -0,0 +1,16 @@
+import { IObservable } from '../base';
+import { DisposableStore } from '../commonFacade/deps';
+/**
+ * Wraps an observable so that its source remains observed for a grace period
+ * after the wrapping observable loses all its observers.
+ *
+ * When the wrapping observable has observers, an autorun keeps `obs` observed
+ * and forwards changes. When the last observer is removed, `obs` stays observed
+ * via `keepObserved` for `maxIdleTimeMs` before being released. If a new observer
+ * arrives during the grace period, the keep-alive is cancelled seamlessly.
+ *
+ * @param store - Controls the hard lifetime; disposing it cancels any pending grace period.
+ * @param obs - The source observable to keep alive longer.
+ * @param maxIdleTimeMs - Grace period in milliseconds.
+ */
+export declare function deferUnobserve<T>(store: DisposableStore, obs: IObservable<T>, maxIdleTimeMs: number): IObservable<T>;

package/dist/_observables/observableInternal/experimental/reducer.d.ts

@@ -0,0 +1,37 @@
+import { EqualityComparer } from '../commonFacade/deps';
+import { IObservable, IObservableWithChange, ISettableObservable } from '../base';
+import { IChangeTracker } from '../changeTracker';
+import { DebugOwner } from '../debugName';
+import { IDerivedReader } from '../observables/derivedImpl';
+export interface IReducerOptions<T, TChangeSummary = void, TOutChange = void> {
+    /**
+     * Is called to create the initial value of the observable when it becomes observed.
+    */
+    initial: T | (() => T);
+    /**
+     * Is called to dispose the observable value when it is no longer observed.
+    */
+    disposeFinal?(value: T): void;
+    changeTracker?: IChangeTracker<TChangeSummary>;
+    equalityComparer?: EqualityComparer<T>;
+    /**
+     * Applies the changes to the value.
+     * Use `reader.reportChange` to report change details or to report a change if the same value is returned.
+    */
+    update(reader: IDerivedReader<TOutChange>, previousValue: T, changes: TChangeSummary): T;
+}
+/**
+ * Creates an observable value that is based on values and changes from other observables.
+ * Additionally, a reducer can report how that state changed.
+*/
+export declare function observableReducer<T, TInChanges, TOutChange = void>(owner: DebugOwner, options: IReducerOptions<T, TInChanges, TOutChange>): SimplifyObservableWithChange<T, TOutChange>;
+/**
+ * Creates an observable value that is based on values and changes from other observables.
+ * Additionally, a reducer can report how that state changed.
+*/
+export declare function observableReducerSettable<T, TInChanges, TOutChange = void>(owner: DebugOwner, options: IReducerOptions<T, TInChanges, TOutChange>): ISettableObservable<T, TOutChange>;
+/**
+ * Returns IObservable<T> if TChange is void, otherwise IObservableWithChange<T, TChange>
+*/
+type SimplifyObservableWithChange<T, TChange> = TChange extends void ? IObservable<T> : IObservableWithChange<T, TChange>;
+export {};

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

@@ -0,0 +1,15 @@
+import { IObservable, IReader } from '../base';
+import { DebugOwner } from '../debugName';
+/**
+ * Creates an observable that has the latest changed value of the given observables.
+ * Initially (and when not observed), it has the value of the last observable.
+ * When observed and any of the observables change, it has the value of the last changed observable.
+ * If multiple observables change in the same transaction, the last observable wins.
+*/
+export declare function latestChangedValue<T extends IObservable<any>[]>(owner: DebugOwner, observables: T): IObservable<ReturnType<T[number]['get']>>;
+/**
+ * Works like a derived.
+ * However, if the value is not undefined, it is cached and will not be recomputed anymore.
+ * In that case, the derived will unsubscribe from its dependencies.
+*/
+export declare function derivedConstOnceDefined<T>(owner: DebugOwner, fn: (reader: IReader) => T): IObservable<T | undefined>;

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

@@ -0,0 +1,25 @@
+export { observableValueOpts } from './observables/observableValueOpts';
+export { autorun, autorunDelta, autorunHandleChanges, autorunOpts, autorunWithStore, autorunWithStoreHandleChanges, autorunIterableDelta, autorunSelfDisposable } from './reactions/autorun';
+export { type IObservable, type IObservableWithChange, type IObserver, type IReader, type ISettable, type ISettableObservable, type ITransaction } from './base';
+export { disposableObservableValue } from './observables/observableValue';
+export { derived, derivedDisposable, derivedHandleChanges, derivedOpts, derivedWithSetter, derivedWithStore } from './observables/derived';
+export { type IDerivedReader } from './observables/derivedImpl';
+export { ObservableLazy, ObservableLazyPromise, ObservablePromise, PromiseResult, } from './utils/promise';
+export { derivedWithCancellationToken, waitForState } from './utils/utilsCancellation';
+export { debouncedObservableDeprecated, debouncedObservable, derivedObservableWithCache, derivedObservableWithWritableCache, keepObserved, mapObservableArrayCached, observableFromPromise, recomputeInitiallyAndOnChange, signalFromObservable, wasEventTriggeredRecently, } from './utils/utils';
+export { type DebugOwner } from './debugName';
+export { type IChangeContext, type IChangeTracker, recordChanges, recordChangesLazy } from './changeTracker';
+export { constObservable } from './observables/constObservable';
+export { type IObservableSignal, observableSignal } from './observables/observableSignal';
+export { observableFromEventOpts } from './observables/observableFromEvent';
+export { observableSignalFromEvent } from './observables/observableSignalFromEvent';
+export { asyncTransaction, globalTransaction, subtransaction, transaction, TransactionImpl } from './transaction';
+export { observableFromValueWithChangeEvent, ValueWithChangeEventFromObservable } from './utils/valueWithChangeEvent';
+export { runOnChange, runOnChangeWithCancellationToken, runOnChangeWithStore, type RemoveUndefined } from './utils/runOnChange';
+export { derivedConstOnceDefined, latestChangedValue } from './experimental/utils';
+export { deferUnobserve } from './experimental/deferUnobserve';
+export { observableFromEvent } from './observables/observableFromEvent';
+export { observableValue } from './observables/observableValue';
+export { ObservableSet } from './set';
+export { ObservableMap } from './map';
+export { DebugLocation } from './debugLocation';

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

@@ -0,0 +1,40 @@
+import { IObservable } from '../base';
+import { TransactionImpl } from '../transaction';
+import { IObservableLogger, IChangeInformation } from './logging';
+import { FromEventObservable } from '../observables/observableFromEvent';
+import { Derived } from '../observables/derivedImpl';
+import { AutorunObserver } from '../reactions/autorunImpl';
+export declare function logObservableToConsole(obs: IObservable<any>): void;
+export declare class ConsoleObservableLogger implements IObservableLogger {
+    private indentation;
+    private _filteredObjects;
+    addFilteredObj(obj: unknown): void;
+    private _isIncluded;
+    private textToConsoleArgs;
+    private formatInfo;
+    handleObservableCreated(observable: IObservable<any>): void;
+    handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;
+    handleObservableUpdated(observable: IObservable<unknown>, info: IChangeInformation): void;
+    private readonly changedObservablesSets;
+    formatChanges(changes: Set<IObservable<any>>): ConsoleText | undefined;
+    handleDerivedDependencyChanged(derived: Derived<any>, observable: IObservable<any>, change: unknown): void;
+    _handleDerivedRecomputed(derived: Derived<unknown>, info: IChangeInformation): void;
+    handleDerivedCleared(derived: Derived<unknown>): void;
+    handleFromEventObservableTriggered(observable: FromEventObservable<any, any>, info: IChangeInformation): void;
+    handleAutorunCreated(autorun: AutorunObserver): void;
+    handleAutorunDisposed(autorun: AutorunObserver): void;
+    handleAutorunDependencyChanged(autorun: AutorunObserver, observable: IObservable<any>, change: unknown): void;
+    handleAutorunStarted(autorun: AutorunObserver): void;
+    handleAutorunFinished(autorun: AutorunObserver): void;
+    handleBeginTransaction(transaction: TransactionImpl): void;
+    handleEndTransaction(): void;
+}
+type ConsoleText = (ConsoleText | undefined)[] | {
+    text: string;
+    style: string;
+    data?: unknown[];
+} | {
+    data: unknown[];
+};
+export declare function formatValue(value: unknown, availableLen: number): string;
+export {};

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

@@ -0,0 +1,4 @@
+import { IObservable, IObserver } from '../base';
+export declare function debugGetDependencyGraph(obs: IObservable<any> | IObserver, options?: {
+    debugNamePostProcessor?: (name: string) => string;
+}): string;

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

@@ -0,0 +1,4 @@
+import { API, SimpleTypedRpcConnection, MakeSideAsync } from './rpc';
+export declare function registerDebugChannel<T extends {
+    channelId: string;
+} & API>(channelId: T['channelId'], createClient: () => T['client']): SimpleTypedRpcConnection<MakeSideAsync<T['host']>>;

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

@@ -0,0 +1,43 @@
+import { AutorunObserver } from '../../reactions/autorunImpl';
+import { TransactionImpl } from '../../transaction';
+import { IChangeInformation, IObservableLogger } from '../logging';
+import { IObservable } from '../../base';
+import { Derived } from '../../observables/derivedImpl';
+import { DebugLocation } from '../../debugLocation';
+export declare class DevToolsLogger implements IObservableLogger {
+    private static _instance;
+    static getInstance(): DevToolsLogger;
+    private _declarationId;
+    private _instanceId;
+    private readonly _declarations;
+    private readonly _instanceInfos;
+    private readonly _aliveInstances;
+    private readonly _activeTransactions;
+    private readonly _channel;
+    private getTransactionState;
+    private _getObservableInfo;
+    private _getAutorunInfo;
+    private _getInfo;
+    private _formatObservable;
+    private _formatObserver;
+    private constructor();
+    private _pendingChanges;
+    private readonly _changeThrottler;
+    private readonly _fullState;
+    private _handleChange;
+    private readonly _flushUpdates;
+    private _getDeclarationId;
+    handleObservableCreated(observable: IObservable<any>, location: DebugLocation): void;
+    handleOnListenerCountChanged(observable: IObservable<any>, newCount: number): void;
+    handleObservableUpdated(observable: IObservable<any>, changeInfo: 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>, observable: IObservable<any>, change: unknown): void;
+    _handleDerivedRecomputed(observable: Derived<any>, changeInfo: IChangeInformation): void;
+    handleDerivedCleared(observable: Derived<any>): void;
+    handleBeginTransaction(transaction: TransactionImpl): void;
+    handleEndTransaction(transaction: TransactionImpl): void;
+}

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

@@ -0,0 +1,41 @@
+export type ChannelFactory = (handler: IChannelHandler) => IChannel;
+export interface IChannel {
+    sendNotification(data: unknown): void;
+    sendRequest(data: unknown): Promise<RpcRequestResult>;
+}
+export interface IChannelHandler {
+    handleNotification(notificationData: unknown): void;
+    handleRequest(requestData: unknown): Promise<RpcRequestResult> | RpcRequestResult;
+}
+export type RpcRequestResult = {
+    type: 'result';
+    value: unknown;
+} | {
+    type: 'error';
+    value: unknown;
+};
+export type API = {
+    host: Side;
+    client: Side;
+};
+export type Side = {
+    notifications: Record<string, (...args: any[]) => void>;
+    requests: Record<string, (...args: any[]) => Promise<unknown> | unknown>;
+};
+type MakeAsyncIfNot<TFn> = TFn extends (...args: infer TArgs) => infer TResult ? TResult extends Promise<unknown> ? TFn : (...args: TArgs) => Promise<TResult> : never;
+export type MakeSideAsync<T extends Side> = {
+    notifications: T['notifications'];
+    requests: {
+        [K in keyof T['requests']]: MakeAsyncIfNot<T['requests'][K]>;
+    };
+};
+export declare class SimpleTypedRpcConnection<T extends Side> {
+    private readonly _channelFactory;
+    private readonly _getHandler;
+    static createHost<T extends API>(channelFactory: ChannelFactory, getHandler: () => T['host']): SimpleTypedRpcConnection<MakeSideAsync<T['client']>>;
+    static createClient<T extends API>(channelFactory: ChannelFactory, getHandler: () => T['client']): SimpleTypedRpcConnection<MakeSideAsync<T['host']>>;
+    readonly api: T;
+    private readonly _channel;
+    private constructor();
+}
+export {};