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

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

@@ -0,0 +1,43 @@
+import { IObservable, IObservableWithChange, IObserver, IReader, ITransaction } from '../base';
+import { DebugOwner } from '../debugName';
+import { DisposableStore, Event, IDisposable } from '../commonFacade/deps';
+export declare function observableFromPromise<T>(promise: Promise<T>): IObservable<{
+    value?: T;
+}>;
+export declare function signalFromObservable<T>(owner: DebugOwner | undefined, observable: IObservable<T>): IObservable<void>;
+/**
+ * @deprecated Use `debouncedObservable` instead.
+ */
+export declare function debouncedObservableDeprecated<T>(observable: IObservable<T>, debounceMs: number, disposableStore: DisposableStore): IObservable<T | undefined>;
+/**
+ * Creates an observable that debounces the input observable.
+ */
+export declare function debouncedObservable<T>(observable: IObservable<T>, debounceMs: number): IObservable<T>;
+export declare function wasEventTriggeredRecently(event: Event<any>, timeoutMs: number, disposableStore: DisposableStore): IObservable<boolean>;
+/**
+ * This makes sure the observable is being observed and keeps its cache alive.
+ */
+export declare function keepObserved<T>(observable: IObservable<T>): IDisposable;
+/**
+ * This converts the given observable into an autorun.
+ */
+export declare function recomputeInitiallyAndOnChange<T>(observable: IObservable<T>, handleValue?: (value: T) => void): IDisposable;
+export declare class KeepAliveObserver implements IObserver {
+    private readonly _forceRecompute;
+    private readonly _handleValue;
+    private _counter;
+    constructor(_forceRecompute: boolean, _handleValue: ((value: any) => void) | undefined);
+    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;
+}
+export declare function derivedObservableWithCache<T>(owner: DebugOwner, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T>;
+export declare function derivedObservableWithWritableCache<T>(owner: object, computeFn: (reader: IReader, lastValue: T | undefined) => T): IObservable<T> & {
+    clearCache(transaction: ITransaction): void;
+    setCache(newValue: T | undefined, tx: ITransaction | undefined): void;
+};
+/**
+ * When the items array changes, referential equal items are not mapped again.
+ */
+export declare function mapObservableArrayCached<TIn, TOut, TKey = TIn>(owner: DebugOwner, items: IObservable<readonly TIn[]>, map: (input: TIn, store: DisposableStore) => TOut, keySelector?: (input: TIn) => TKey): IObservable<readonly TOut[]>;

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

@@ -0,0 +1,10 @@
+import { IReader, IObservable } from '../base';
+import { CancellationToken } from '../commonFacade/cancellation';
+/**
+ * Resolves the promise when the observables state matches the predicate.
+ */
+export declare function waitForState<T>(observable: IObservable<T | null | undefined>): Promise<T>;
+export declare function waitForState<T, TState extends T>(observable: IObservable<T>, predicate: (state: T) => state is TState, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<TState>;
+export declare function waitForState<T>(observable: IObservable<T>, predicate: (state: T) => boolean, isError?: (state: T) => boolean | unknown | undefined, cancellationToken?: CancellationToken): Promise<T>;
+export declare function derivedWithCancellationToken<T>(computeFn: (reader: IReader, cancellationToken: CancellationToken) => T): IObservable<T>;
+export declare function derivedWithCancellationToken<T>(owner: object, computeFn: (reader: IReader, cancellationToken: CancellationToken) => T): IObservable<T>;

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

@@ -0,0 +1,10 @@
+import { IObservable } from '../base';
+import { Event, IValueWithChangeEvent } from '../commonFacade/deps';
+import { DebugOwner } from '../debugName';
+export declare class ValueWithChangeEventFromObservable<T> implements IValueWithChangeEvent<T> {
+    readonly observable: IObservable<T>;
+    constructor(observable: IObservable<T>);
+    get onDidChange(): Event<void>;
+    get value(): T;
+}
+export declare function observableFromValueWithChangeEvent<T>(owner: DebugOwner, value: IValueWithChangeEvent<T>): IObservable<T>;

package/dist/_observables/utils.d.ts

@@ -0,0 +1,15 @@
+import { IDisposable } from "./disposables";
+import { IObservableWithChange } from "./observableInternal/index";
+type ObservableResult<T> = T extends IObservableWithChange<infer U, any> ? U : never;
+type ObservableArrayToChangesData<T extends Record<string, IObservableWithChange<any, any>>> = {
+    [Key in keyof T]: {
+        value: ObservableResult<T[Key]>;
+        changes: T[Key]['TChange'][];
+        /**
+         * The value of the observable before the changes. `undefined` if
+         */
+        previous: ObservableResult<T[Key]> | undefined;
+    };
+};
+export declare function autorunWithChanges<T extends Record<string, IObservableWithChange<any, any>>>(owner: object, observables: T, handler: (data: ObservableArrayToChangesData<T>) => void): IDisposable;
+export {};