reactive-vscode 0.1.0 → 0.2.0-beta.2

package/dist/index.d.ts

@@ -1,12 +1,11 @@
 /// <reference types="vscode" />
 
-import { Awaited as Awaited_2 } from '@vue/shared';
 import { ColorTheme } from 'vscode';
 import { CommentController } from 'vscode';
-import { ComputedRef } from '@vue/reactivity';
+import { ComputedRef } from '@reactive-vscode/reactivity';
+import { ComputedRef as ComputedRef_2 } from '@vue/reactivity';
 import { ConfigurationScope } from 'vscode';
 import { ConfigurationTarget } from 'vscode';
-import { DebuggerOptions } from '@vue/reactivity';
 import { DebugSession } from 'vscode';
 import { DecorationOptions } from 'vscode';
 import { DecorationRenderOptions } from 'vscode';
@@ -14,22 +13,24 @@ import { Disposable as Disposable_2 } from 'vscode';
 import { DocumentSelector } from 'vscode';
 import { EffectScope } from '@vue/reactivity';
 import { Event as Event_2 } from 'vscode';
+import { EventEmitter } from 'vscode';
 import { Extension } from 'vscode';
 import { ExtensionContext } from 'vscode';
 import { ExtensionTerminalOptions } from 'vscode';
 import { FoldingRangeProvider } from 'vscode';
 import { GlobPattern } from 'vscode';
 import { LogLevel } from 'vscode';
-import { MaybeRef } from '@vue/reactivity';
-import { MaybeRefOrGetter } from '@vue/reactivity';
+import { MaybeRef } from '@reactive-vscode/reactivity';
+import { MaybeRefOrGetter } from '@reactive-vscode/reactivity';
 import { NotebookEditor } from 'vscode';
 import { NotebookRange } from 'vscode';
 import { OutputChannel } from 'vscode';
 import { Range } from 'vscode';
-import { Ref } from '@vue/reactivity';
+import { Ref } from '@reactive-vscode/reactivity';
 import { Selection } from 'vscode';
 import { ShallowReactive } from '@vue/reactivity';
 import { ShallowRef } from '@vue/reactivity';
+import { ShallowRef as ShallowRef_2 } from '@reactive-vscode/reactivity';
 import { StatusBarAlignment } from 'vscode';
 import { StatusBarItem } from 'vscode';
 import { Task } from 'vscode';
@@ -44,15 +45,18 @@ import { TextEditorDecorationType } from 'vscode';
 import { TextEditorEdit } from 'vscode';
 import { TextEditorSelectionChangeKind } from 'vscode';
 import { TreeDataProvider } from 'vscode';
+import { TreeItem } from 'vscode';
 import { TreeView } from 'vscode';
 import { TreeViewOptions } from 'vscode';
 import { Uri } from 'vscode';
 import { ViewBadge } from 'vscode';
 import { ViewColumn } from 'vscode';
+import { WatchSource } from '@reactive-vscode/reactivity';
 import { WebviewOptions } from 'vscode';
 import { WebviewView } from 'vscode';
 import { WorkspaceFolder } from 'vscode';
 import { WritableComputedRef } from '@vue/reactivity';
+import { WritableComputedRef as WritableComputedRef_2 } from '@reactive-vscode/reactivity';
 
 /* Excluded from this release type: activateCbs */
 
@@ -60,7 +64,7 @@ export declare interface Commands extends Record<string, (...args: any[]) => any
     'vscode.open': (uri: Uri) => void;
 }
 
-export declare interface ConfigRef<T> extends ShallowRef<T> {
+export declare interface ConfigRef<T> extends ShallowRef_2<T> {
     update: (value: T, configurationTarget?: ConfigurationTarget | boolean | null, overrideInLanguage?: boolean) => Promise<void>;
 }
 
@@ -92,8 +96,6 @@ export declare function createSingletonComposable<T>(fn: () => T): () => T;
 
 /* Excluded from this release type: deactivateCbs */
 
-declare function defaultGetPrefix(type: string): string;
-
 /**
  * Define configurations of an extension. See `vscode::workspace.getConfiguration`.
  *
@@ -111,6 +113,40 @@ export declare function defineExtension(setup: () => void): {
     deactivate: () => void;
 };
 
+/**
+ * Define a logger which is usable before activation.
+ *
+ * @category view
+ */
+export declare function defineLogger(name: string, options?: UseLoggerOptions): {
+    logger: ShallowRef<    {
+    outputChannel: OutputChannel;
+    createLoggerFunc: (type: string) => (...message: any[]) => void;
+    info: (...message: any[]) => void;
+    warn: (...message: any[]) => void;
+    error: (...message: any[]) => void;
+    append: (value: string) => void;
+    appendLine: (value: string) => void;
+    replace: (value: string) => void;
+    clear: () => void;
+    show: {
+    (preserveFocus?: boolean | undefined): void;
+    (column?: ViewColumn | undefined, preserveFocus?: boolean | undefined): void;
+    };
+    hide: () => void;
+    } | null>;
+    outputChannel: ComputedRef_2<OutputChannel | undefined>;
+    info: (...args: any[]) => void | null;
+    warn: (...args: any[]) => void | null;
+    error: (...args: any[]) => void | null;
+    append: (value: string) => void | null;
+    appendLine: (value: string) => void | null;
+    replace: (value: string) => void | null;
+    clear: () => void | null;
+    show: (column?: ViewColumn | undefined, preserveFocus?: boolean | undefined) => void | null;
+    hide: () => void | null;
+};
+
 /**
  * Execute a command, with type checking. See `vscode::commands.executeCommand`.
  *
@@ -122,30 +158,10 @@ export declare const extensionContext: ShallowRef<ExtensionContext | null>;
 
 /* Excluded from this release type: extensionScope */
 
-declare type MapSources<T, Immediate> = {
-    [K in keyof T]: T[K] extends WatchSource<infer V>
-    ? Immediate extends true
-    ? V | undefined
-    : V
-    : T[K] extends object
-    ? Immediate extends true
-    ? T[K] | undefined
-    : T[K]
-    : never
-}
+export declare function getDefaultLoggerPrefix(type: string): string;
 
 export declare type MaybeNullableRefOrGetter<T> = T | Ref<Nullable<T>> | (() => Nullable<T>);
 
-declare type MultiWatchSources = (WatchSource<unknown> | object)[]
-
-export declare function nextTick<T = void, R = void>(
-this: T,
-fn?: (this: T) => R,
-): Promise<Awaited_2<R>> {
-    const p = currentFlushPromise || resolvedPromise
-    return fn ? p.then(this ? fn.bind(this) : fn) : p
-}
-
 export declare type Nullable<T> = T | null | undefined;
 
 /**
@@ -157,8 +173,6 @@ export declare function onActivate(fn: OnActivateCb): void;
 
 declare type OnActivateCb = (context: ExtensionContext) => void;
 
-declare type OnCleanup = (cleanupFn: () => void) => void
-
 /**
  * Registers a callback to be called when the extension is deactivated.
  *
@@ -178,6 +192,7 @@ export declare type TextEditorCommandCallback = (textEditor: TextEditor, edit: T
 
 export declare interface TreeViewNode {
     readonly children?: this[];
+    readonly treeItem: TreeItem | Thenable<TreeItem>;
 }
 
 /**
@@ -203,7 +218,7 @@ export declare const useActiveColorTheme: () => ShallowRef<ColorTheme>;
 /**
  * @reactive `debug.activeDebugSession`
  */
-export declare const useActiveDebugSession: () => ComputedRef<DebugSession | undefined>;
+export declare const useActiveDebugSession: () => ComputedRef_2<DebugSession | undefined>;
 
 /**
  * Reactively set decorations on the active editor. See `vscode::window.activeTextEditor`.
@@ -233,7 +248,7 @@ export declare const useActiveTextEditor: () => ShallowRef<TextEditor | undefine
 /**
  * @reactive `extensions.all`
  */
-export declare const useAllExtensions: () => ComputedRef<readonly Extension<any>[]>;
+export declare const useAllExtensions: () => ComputedRef_2<readonly Extension<any>[]>;
 
 /**
  * Register a command. See `vscode::commands.registerCommand`.
@@ -277,7 +292,7 @@ declare interface UseControlledTerminalReturn {
 /**
  * @reactive `env.shell`
  */
-export declare const useDefaultShell: () => ComputedRef<string>;
+export declare const useDefaultShell: () => ComputedRef_2<string>;
 
 /**
  * Dispose the disposable when the current scope is disposed. See `vscode::Disposable`.
@@ -309,16 +324,20 @@ export declare function useEvent<T>(event: Event_2<T>, listeners?: ((e: T) => an
  * @category utilities
  * @reactive `EventEmitter`
  */
-export declare function useEventEmitter<T>(listeners?: ((e: T) => any)[]): {
+export declare function useEventEmitter<T>(eventEmitter?: EventEmitter<T>, listeners?: ((e: T) => any)[]): UseEventEmitterReturn<T>;
+
+export declare function useEventEmitter<T>(listeners?: ((e: T) => any)[]): UseEventEmitterReturn<T>;
+
+declare interface UseEventEmitterReturn<T> {
     event: Event_2<T>;
     fire: (data: T) => void;
-    addListener: Event_2<T>;
-};
+    addListener: (listener: (e: T) => any) => void;
+}
 
 /**
  * @reactive `tasks.fetchTasks`
  */
-export declare function useFetchTasks(filter?: MaybeRefOrGetter<TaskFilter | undefined>): ComputedRef<Thenable<Task[]>>;
+export declare function useFetchTasks(filter?: MaybeRefOrGetter<TaskFilter | undefined>): ComputedRef_2<Thenable<Task[]>>;
 
 /**
  * @reactive `Uri.file`
@@ -364,12 +383,12 @@ export declare function useFsWatcher(globPattern: GlobPattern, ignoreCreateEvent
  *
  * @category window
  */
-export declare const useIsDarkTheme: () => ComputedRef<boolean>;
+export declare const useIsDarkTheme: () => ComputedRef_2<boolean>;
 
 /**
  * @reactive `env.isTelemetryEnabled`
  */
-export declare const useIsTelemetryEnabled: () => ComputedRef<boolean>;
+export declare const useIsTelemetryEnabled: () => ComputedRef_2<boolean>;
 
 /**
  * @reactive `l10n.t`
@@ -383,7 +402,7 @@ export declare function useL10nText(message: MaybeRefOrGetter<string>, args: Rec
  *
  * @category view
  */
-export declare function useLogger(name: string, getPrefix?: typeof defaultGetPrefix): {
+export declare function useLogger(name: string, options?: UseLoggerOptions): {
     outputChannel: OutputChannel;
     createLoggerFunc: (type: string) => (...message: any[]) => void;
     info: (...message: any[]) => void;
@@ -400,10 +419,15 @@ export declare function useLogger(name: string, getPrefix?: typeof defaultGetPre
     hide: () => void;
 };
 
+export declare interface UseLoggerOptions {
+    outputChannel?: OutputChannel;
+    getPrefix?: ((type: string) => string) | null;
+}
+
 /**
  * @reactive `env.logLevel`
  */
-export declare const useLogLevel: () => ComputedRef<LogLevel>;
+export declare const useLogLevel: () => ComputedRef_2<LogLevel>;
 
 /**
  * @reactive `NotebookEditor.selection`
@@ -421,7 +445,7 @@ export declare function useNotebookEditorSelections(notebookEditor: MaybeNullabl
  * @reactive `NotebookEditor.visibleRanges`
  * @category editor
  */
-export declare function useNotebookEditorVisibleRanges(notebookEditor: MaybeNullableRefOrGetter<NotebookEditor>): ComputedRef<readonly NotebookRange[]>;
+export declare function useNotebookEditorVisibleRanges(notebookEditor: MaybeNullableRefOrGetter<NotebookEditor>): ComputedRef_2<readonly NotebookRange[]>;
 
 /**
  * @reactive `window.terminals`
@@ -456,7 +480,7 @@ export declare interface UseStatusBarItemOptions {
 /**
  * @reactive `tasks.taskExecutions`
  */
-export declare const useTaskExecutions: () => ComputedRef<readonly TaskExecution[]>;
+export declare const useTaskExecutions: () => ComputedRef_2<readonly TaskExecution[]>;
 
 /**
  * @category terminal
@@ -477,7 +501,7 @@ declare interface UseTerminalReturn extends Omit<Terminal, 'state' | 'dispose'>
  * @reactive `Terminal.state`
  * @category terminal
  */
-export declare function useTerminalState(terminal: MaybeNullableRefOrGetter<Terminal>): ComputedRef<TerminalState | undefined>;
+export declare function useTerminalState(terminal: MaybeNullableRefOrGetter<Terminal>): ComputedRef_2<TerminalState | undefined>;
 
 /**
  * Register a text editor command. See `vscode::commands.registerTextEditorCommand`.
@@ -509,25 +533,29 @@ export declare function useTextEditorSelections(textEditor: MaybeNullableRefOrGe
  * @reactive `TextEditor.viewColumn`
  * @category editor
  */
-export declare function useTextEditorViewColumn(textEditor: MaybeNullableRefOrGetter<TextEditor>): ComputedRef<ViewColumn | undefined>;
+export declare function useTextEditorViewColumn(textEditor: MaybeNullableRefOrGetter<TextEditor>): ComputedRef_2<ViewColumn | undefined>;
 
 /**
  * @reactive `TextEditor.visibleRanges`
  * @category editor
  */
-export declare function useTextEditorVisibleRanges(textEditor: MaybeNullableRefOrGetter<TextEditor>): ComputedRef<readonly Range[]>;
+export declare function useTextEditorVisibleRanges(textEditor: MaybeNullableRefOrGetter<TextEditor>): ComputedRef_2<readonly Range[]>;
 
 /**
  * Register a tree view. See `vscode::window.createTreeView`.
  *
  * @category view
  */
-export declare const useTreeView: <T extends TreeViewNode>(viewId: string, treeData: MaybeRefOrGetter<T[]>, options: UseTreeViewOptions<T>) => TreeView<T>;
+export declare const useTreeView: <T extends TreeViewNode>(viewId: string, treeData: MaybeRefOrGetter<T[]>, options?: UseTreeViewOptions<T> | undefined) => TreeView<T>;
 
-export declare type UseTreeViewOptions<T> = (Omit<TreeViewOptions<T>, 'treeDataProvider'> & Pick<TreeDataProvider<T>, 'getTreeItem' | 'resolveTreeItem'> & {
+export declare type UseTreeViewOptions<T> = Omit<TreeViewOptions<T>, 'treeDataProvider'> & Pick<TreeDataProvider<T>, 'resolveTreeItem'> & {
     title?: MaybeRefOrGetter<string | undefined>;
     badge?: MaybeRefOrGetter<ViewBadge | undefined>;
-}) | TreeDataProvider<T>['getTreeItem'];
+    /**
+     * Additional watch source to trigger a change event. Useful when `treeItem` is a promise.
+     */
+    watchSource?: WatchSource<any>;
+};
 
 /**
  * @reactive `Uri`
@@ -586,7 +614,7 @@ export declare const useVisibleTextEditors: () => ShallowRef<readonly TextEditor
 
 export declare function useVscodeContext<T>(name: string, value: ComputedRef<T> | (() => T), shouldUpdate?: MaybeRefOrGetter<boolean>): ComputedRef<T>;
 
-export declare function useVscodeContext<T>(name: string, value: WritableComputedRef<T>, shouldUpdate?: MaybeRefOrGetter<boolean>): WritableComputedRef<T>;
+export declare function useVscodeContext<T>(name: string, value: WritableComputedRef_2<T>, shouldUpdate?: MaybeRefOrGetter<boolean>): WritableComputedRef_2<T>;
 
 export declare function useVscodeContext<T>(name: string, value: MaybeRef<T>, shouldUpdate?: MaybeRefOrGetter<boolean>): Ref<T>;
 
@@ -595,33 +623,25 @@ export declare function useVscodeContext<T>(name: string, value: MaybeRef<T>, sh
  *
  * @category view
  */
-export declare const useWebviewView: (viewId: string, html: MaybeRefOrGetter<string>, options?: ({
-    readonly webviewOptions?: {
-        readonly retainContextWhenHidden?: boolean | undefined;
-    } | undefined;
-} & {
-    onDidReceiveMessage?: ((message: any) => void) | undefined;
-    webviewOptions?: MaybeRefOrGetter<WebviewOptions> | undefined;
-    title?: MaybeRefOrGetter<string | undefined>;
-    badge?: MaybeRefOrGetter<ViewBadge | undefined>;
-}) | undefined) => {
+export declare const useWebviewView: (viewId: string, html: MaybeRefOrGetter<string>, options?: WebviewRegisterOptions | undefined) => {
     view: ShallowRef<WebviewView | undefined>;
     context: ShallowRef<unknown>;
     postMessage: (message: any) => Thenable<boolean> | undefined;
+    forceRefresh: () => void;
 };
 
 /**
  * @reactive `window.state`
  */
 export declare const useWindowState: () => {
-    focused: ComputedRef<boolean>;
-    active: ComputedRef<boolean>;
+    focused: ComputedRef_2<boolean>;
+    active: ComputedRef_2<boolean>;
 };
 
 /**
  * @reactive `workspace.workspaceFolders`
  */
-export declare const useWorkspaceFolders: () => ComputedRef<readonly WorkspaceFolder[] | undefined>;
+export declare const useWorkspaceFolders: () => ComputedRef_2<readonly WorkspaceFolder[] | undefined>;
 
 declare type ViewWithBadge = Pick<TreeView<unknown> | WebviewView, 'badge'>;
 
@@ -629,95 +649,15 @@ declare type ViewWithTitle = Pick<TreeView<unknown> | WebviewView, 'title'>;
 
 declare type ViewWithVisibility = Pick<TreeView<unknown> | WebviewView, 'visible' | 'onDidChangeVisibility'>;
 
-export declare function watch<T, Immediate extends Readonly<boolean> = false>(
-source: WatchSource<T>,
-cb: WatchCallback<T, Immediate extends true ? T | undefined : T>,
-options?: WatchOptions<Immediate>,
-): WatchStopHandle
-
-export declare function watch<
-T extends MultiWatchSources,
-Immediate extends Readonly<boolean> = false,
->(
-sources: [...T],
-cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>,
-options?: WatchOptions<Immediate>,
-): WatchStopHandle
-
-export declare function watch<
-T extends Readonly<MultiWatchSources>,
-Immediate extends Readonly<boolean> = false,
->(
-source: T,
-cb: WatchCallback<MapSources<T, false>, MapSources<T, Immediate>>,
-options?: WatchOptions<Immediate>,
-): WatchStopHandle
-
-export declare function watch<
-T extends object,
-Immediate extends Readonly<boolean> = false,
->(
-source: T,
-cb: WatchCallback<T, Immediate extends true ? T | undefined : T>,
-options?: WatchOptions<Immediate>,
-): WatchStopHandle
-
-export declare function watch<T = any, Immediate extends Readonly<boolean> = false>(
-source: T | WatchSource<T>,
-cb: any,
-options?: WatchOptions<Immediate>,
-): WatchStopHandle {
-    if (__DEV__ && !isFunction(cb)) {
-        warn(
-        `\`watch(fn, options?)\` signature has been moved to a separate API. ` +
-        `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` +
-        `supports \`watch(source, cb, options?) signature.`,
-        )
-    }
-    return doWatch(source as any, cb, options)
-}
-
-export declare type WatchCallback<V = any, OV = any> = (
-value: V,
-oldValue: OV,
-onCleanup: OnCleanup,
-) => any
-
-export declare type WatchEffect = (onCleanup: OnCleanup) => void
-
-export declare function watchEffect(
-effect: WatchEffect,
-options?: WatchOptionsBase,
-): WatchStopHandle {
-    return doWatch(effect, null, options)
-}
-
-export declare interface WatchOptions<Immediate = boolean> extends WatchOptionsBase {
-    immediate?: Immediate
-    deep?: boolean
-    once?: boolean
-}
-
-export declare interface WatchOptionsBase extends DebuggerOptions {
-    flush?: 'pre' | 'post' | 'sync'
-}
-
-export declare type WatchSource<T = any> = Ref<T> | ComputedRef<T> | (() => T)
-
-export declare type WatchStopHandle = () => void
-
-export declare function watchSyncEffect(
-effect: WatchEffect,
-options?: DebuggerOptions,
-) {
-    return doWatch(
-    effect,
-    null,
-    __DEV__ ? extend({}, options as any, { flush: 'sync' }) : { flush: 'sync' },
-    )
+declare interface WebviewRegisterOptions {
+    retainContextWhenHidden?: boolean;
+    onDidReceiveMessage?: (message: any) => void;
+    webviewOptions?: MaybeRefOrGetter<WebviewOptions>;
+    title?: MaybeRefOrGetter<string | undefined>;
+    badge?: MaybeRefOrGetter<ViewBadge | undefined>;
 }
 
 
-export * from "@vue/reactivity";
+export * from "@reactive-vscode/reactivity";
 
 export { }