reactive-vscode 0.0.1-beta.6 → 0.1.0

package/dist/index.d.ts

@@ -16,8 +16,11 @@ import { EffectScope } from '@vue/reactivity';
 import { Event as Event_2 } 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 { NotebookEditor } from 'vscode';
 import { NotebookRange } from 'vscode';
@@ -33,6 +36,7 @@ import { Task } from 'vscode';
 import { TaskExecution } from 'vscode';
 import { TaskFilter } from 'vscode';
 import { Terminal } from 'vscode';
+import { TerminalOptions } from 'vscode';
 import { TerminalState } from 'vscode';
 import { TextDocument } from 'vscode';
 import { TextEditor } from 'vscode';
@@ -250,6 +254,26 @@ export declare function useCommands(commands: Partial<Commands>): void;
  */
 export declare function useCommentController(id: string, label: string): CommentController;
 
+/**
+ * Create terminal, and allows you to control the terminal lifecycle.
+ *
+ * @category terminal
+ */
+export declare function useControlledTerminal(name?: string, shellPath?: string, shellArgs?: readonly string[] | string): UseControlledTerminalReturn;
+
+export declare function useControlledTerminal(options: TerminalOptions): UseControlledTerminalReturn;
+
+export declare function useControlledTerminal(options: ExtensionTerminalOptions): UseControlledTerminalReturn;
+
+declare interface UseControlledTerminalReturn {
+    terminal: Ref<Terminal | null>;
+    getIsActive: () => boolean;
+    show: () => void;
+    sendText: (text: string) => void;
+    close: () => void;
+    state: ComputedRef<TerminalState | undefined>;
+}
+
 /**
  * @reactive `env.shell`
  */
@@ -323,6 +347,18 @@ toJSON(): any;
  */
 export declare function useFoldingRangeProvider(selector: DocumentSelector, provideFoldingRanges: MaybeRefOrGetter<FoldingRangeProvider['provideFoldingRanges']>): void;
 
+/**
+ * @reactive `workspace.createFileSystemWatcher`
+ */
+export declare function useFsWatcher(globPattern: GlobPattern, ignoreCreateEvents?: boolean | undefined, ignoreChangeEvents?: boolean | undefined, ignoreDeleteEvents?: boolean | undefined): {
+    onDidCreate: Event_2<Uri>;
+    onDidChange: Event_2<Uri>;
+    onDidDelete: Event_2<Uri>;
+    ignoreCreateEvents: boolean;
+    ignoreChangeEvents: boolean;
+    ignoreDeleteEvents: boolean;
+};
+
 /**
  * Determines if the current color theme is dark. See `vscode::ColorTheme.kind`.
  *
@@ -422,11 +458,26 @@ export declare interface UseStatusBarItemOptions {
  */
 export declare const useTaskExecutions: () => ComputedRef<readonly TaskExecution[]>;
 
+/**
+ * @category terminal
+ * @reactive `window.createTerminal()`
+ */
+export declare function useTerminal(name?: string, shellPath?: string, shellArgs?: readonly string[] | string): UseTerminalReturn;
+
+export declare function useTerminal(options: TerminalOptions): UseTerminalReturn;
+
+export declare function useTerminal(options: ExtensionTerminalOptions): UseTerminalReturn;
+
+declare interface UseTerminalReturn extends Omit<Terminal, 'state' | 'dispose'> {
+    terminal: Terminal;
+    state: ComputedRef<TerminalState>;
+}
+
 /**
  * @reactive `Terminal.state`
  * @category terminal
  */
-export declare const useTerminalState: (terminal: Terminal) => ComputedRef<TerminalState>;
+export declare function useTerminalState(terminal: MaybeNullableRefOrGetter<Terminal>): ComputedRef<TerminalState | undefined>;
 
 /**
  * Register a text editor command. See `vscode::commands.registerTextEditorCommand`.
@@ -473,7 +524,10 @@ export declare function useTextEditorVisibleRanges(textEditor: MaybeNullableRefO
  */
 export declare const useTreeView: <T extends TreeViewNode>(viewId: string, treeData: MaybeRefOrGetter<T[]>, options: UseTreeViewOptions<T>) => TreeView<T>;
 
-export declare type UseTreeViewOptions<T> = (Omit<TreeViewOptions<T>, 'treeDataProvider'> & Pick<TreeDataProvider<T>, 'getTreeItem' | 'resolveTreeItem'>) | TreeDataProvider<T>['getTreeItem'];
+export declare type UseTreeViewOptions<T> = (Omit<TreeViewOptions<T>, 'treeDataProvider'> & Pick<TreeDataProvider<T>, 'getTreeItem' | 'resolveTreeItem'> & {
+    title?: MaybeRefOrGetter<string | undefined>;
+    badge?: MaybeRefOrGetter<ViewBadge | undefined>;
+}) | TreeDataProvider<T>['getTreeItem'];
 
 /**
  * @reactive `Uri`
@@ -502,7 +556,7 @@ toJSON(): any;
  *
  * @category view
  */
-export declare function useViewBadge(view: MaybeRefOrGetter<Nullable<ViewWithBadge>>, title: MaybeRefOrGetter<ViewBadge | undefined>): void;
+export declare function useViewBadge(view: MaybeRefOrGetter<Nullable<ViewWithBadge>>, badge: MaybeRefOrGetter<ViewBadge | undefined>): void;
 
 /**
  * Reactively set the title of a view (`vscode::TreeView` or `vscode::WebviewView`).
@@ -534,19 +588,22 @@ export declare function useVscodeContext<T>(name: string, value: 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: Ref<T>, shouldUpdate?: MaybeRefOrGetter<boolean>): Ref<T>;
+export declare function useVscodeContext<T>(name: string, value: MaybeRef<T>, shouldUpdate?: MaybeRefOrGetter<boolean>): Ref<T>;
 
 /**
  * Register a webview view. See `vscode::window.registerWebviewViewProvider`.
  *
  * @category view
  */
-export declare const useWebviewView: (viewId: string, html: MaybeRefOrGetter<string>, webviewOptions?: MaybeRefOrGetter<WebviewOptions> | undefined, registerOptions?: ({
+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) => {
     view: ShallowRef<WebviewView | undefined>;
     context: ShallowRef<unknown>;