reactive-vscode 0.0.0

package/dist/composables/index.d.ts

@@ -0,0 +1,50 @@
+export * from './useAbsolutePath';
+export * from './useActiveColorTheme';
+export * from './useActiveDebugSession';
+export * from './useActiveEditorDecorations';
+export * from './useActiveNotebookEditor';
+export * from './useActiveTerminal';
+export * from './useActiveTextEditor';
+export * from './useAllExtensions';
+export * from './useCommand';
+export * from './useCommands';
+export * from './useCommentController';
+export * from './useDefaultShell';
+export * from './useDisposable';
+export * from './useDocumentText';
+export * from './useEditorDecorations';
+export * from './useEvent';
+export * from './useEventEmitter';
+export * from './useFetchTasks';
+export * from './useFileUri';
+export * from './useFoldingRangeProvider';
+export * from './useIsDarkTheme';
+export * from './useIsTelemetryEnabled';
+export * from './useL10nText';
+export * from './useLogLevel';
+export * from './useLogger';
+export * from './useNotebookEditorSelection';
+export * from './useNotebookEditorSelections';
+export * from './useNotebookEditorVisibleRanges';
+export * from './useOpenedTerminals';
+export * from './useOutputChannel';
+export * from './useTaskExecutions';
+export * from './useTerminalState';
+export * from './useTextEditorCommand';
+export * from './useTextEditorCommands';
+export * from './useTextEditorSelection';
+export * from './useTextEditorSelections';
+export * from './useTextEditorViewColumn';
+export * from './useTextEditorVisibleRanges';
+export * from './useTreeView';
+export * from './useTreeViewWithParent';
+export * from './useUri';
+export * from './useViewBadge';
+export * from './useViewTitle';
+export * from './useViewVisibility';
+export * from './useVisibleNotebookEditors';
+export * from './useVisibleTextEditors';
+export * from './useVscodeContext';
+export * from './useWebviewView';
+export * from './useWindowState';
+export * from './useWorkspaceFolders';

package/dist/composables/index.mjs

@@ -0,0 +1,50 @@
+export * from "./useAbsolutePath.mjs";
+export * from "./useActiveColorTheme.mjs";
+export * from "./useActiveDebugSession.mjs";
+export * from "./useActiveEditorDecorations.mjs";
+export * from "./useActiveNotebookEditor.mjs";
+export * from "./useActiveTerminal.mjs";
+export * from "./useActiveTextEditor.mjs";
+export * from "./useAllExtensions.mjs";
+export * from "./useCommand.mjs";
+export * from "./useCommands.mjs";
+export * from "./useCommentController.mjs";
+export * from "./useDefaultShell.mjs";
+export * from "./useDisposable.mjs";
+export * from "./useDocumentText.mjs";
+export * from "./useEditorDecorations.mjs";
+export * from "./useEvent.mjs";
+export * from "./useEventEmitter.mjs";
+export * from "./useFetchTasks.mjs";
+export * from "./useFileUri.mjs";
+export * from "./useFoldingRangeProvider.mjs";
+export * from "./useIsDarkTheme.mjs";
+export * from "./useIsTelemetryEnabled.mjs";
+export * from "./useL10nText.mjs";
+export * from "./useLogLevel.mjs";
+export * from "./useLogger.mjs";
+export * from "./useNotebookEditorSelection.mjs";
+export * from "./useNotebookEditorSelections.mjs";
+export * from "./useNotebookEditorVisibleRanges.mjs";
+export * from "./useOpenedTerminals.mjs";
+export * from "./useOutputChannel.mjs";
+export * from "./useTaskExecutions.mjs";
+export * from "./useTerminalState.mjs";
+export * from "./useTextEditorCommand.mjs";
+export * from "./useTextEditorCommands.mjs";
+export * from "./useTextEditorSelection.mjs";
+export * from "./useTextEditorSelections.mjs";
+export * from "./useTextEditorViewColumn.mjs";
+export * from "./useTextEditorVisibleRanges.mjs";
+export * from "./useTreeView.mjs";
+export * from "./useTreeViewWithParent.mjs";
+export * from "./useUri.mjs";
+export * from "./useViewBadge.mjs";
+export * from "./useViewTitle.mjs";
+export * from "./useViewVisibility.mjs";
+export * from "./useVisibleNotebookEditors.mjs";
+export * from "./useVisibleTextEditors.mjs";
+export * from "./useVscodeContext.mjs";
+export * from "./useWebviewView.mjs";
+export * from "./useWindowState.mjs";
+export * from "./useWorkspaceFolders.mjs";

package/dist/composables/useAbsolutePath.d.ts

@@ -0,0 +1,7 @@
+import type { ComputedRef, MaybeRefOrGetter } from '@vue/runtime-core';
+/**
+ * @category utilities
+ * @reactive `ExtensionContext.asAbsolutePath`
+ */
+export declare function useAbsolutePath(relativePath: MaybeRefOrGetter<string>, slient: true): ComputedRef<string | undefined>;
+export declare function useAbsolutePath(relativePath: MaybeRefOrGetter<string>, slient?: false): ComputedRef<string>;

package/dist/composables/useAbsolutePath.mjs

@@ -0,0 +1,10 @@
+import { computed, toValue } from "@vue/runtime-core";
+import { extensionContext } from "../utils/index.mjs";
+export function useAbsolutePath(relativePath, slient = false) {
+  return computed(() => {
+    const extCtx = extensionContext.value;
+    if (!extCtx && !slient)
+      throw new Error("useAbsolutePath() must be called in extension activation callback.");
+    return extCtx?.asAbsolutePath(toValue(relativePath));
+  });
+}

package/dist/composables/useActiveColorTheme.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="vscode" />
+/**
+ * @reactive `window.activeColorTheme`
+ */
+export declare const useActiveColorTheme: () => import("@vue/reactivity").ShallowRef<import("vscode").ColorTheme>;

package/dist/composables/useActiveColorTheme.mjs

@@ -0,0 +1,11 @@
+import { shallowRef } from "@vue/runtime-core";
+import { window } from "vscode";
+import { createSingletonComposable } from "../utils/index.mjs";
+import { useDisposable } from "./useDisposable.mjs";
+export const useActiveColorTheme = createSingletonComposable(() => {
+  const result = shallowRef(window.activeColorTheme);
+  useDisposable(window.onDidChangeActiveColorTheme((theme) => {
+    result.value = theme;
+  }));
+  return result;
+});

package/dist/composables/useActiveDebugSession.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="vscode" />
+/**
+ * @reactive `debug.activeDebugSession`
+ */
+export declare const useActiveDebugSession: () => import("@vue/reactivity").ComputedRef<import("vscode").DebugSession | undefined>;

package/dist/composables/useActiveDebugSession.mjs

@@ -0,0 +1,11 @@
+import { computed, shallowRef } from "@vue/runtime-core";
+import { debug } from "vscode";
+import { createSingletonComposable } from "../utils/index.mjs";
+import { useDisposable } from "./useDisposable.mjs";
+export const useActiveDebugSession = createSingletonComposable(() => {
+  const session = shallowRef(debug.activeDebugSession);
+  useDisposable(debug.onDidChangeActiveDebugSession((ev) => {
+    session.value = ev;
+  }));
+  return computed(() => session.value);
+});

package/dist/composables/useActiveEditorDecorations.d.ts

@@ -0,0 +1,8 @@
+import type { MaybeRefOrGetter } from '@vue/runtime-core';
+import type { DecorationOptions, DecorationRenderOptions, Range } from 'vscode';
+/**
+ * Reactively set decorations on the active editor. See `vscode::window.activeTextEditor`.
+ *
+ * @category editor
+ */
+export declare function useActiveEditorDecorations(options: DecorationRenderOptions, rangesOrOptions: MaybeRefOrGetter<readonly Range[] | readonly DecorationOptions[]>): void;

package/dist/composables/useActiveEditorDecorations.mjs

@@ -0,0 +1,6 @@
+import { useActiveTextEditor } from "./useActiveTextEditor.mjs";
+import { useEditorDecorations } from "./useEditorDecorations.mjs";
+export function useActiveEditorDecorations(options, rangesOrOptions) {
+  const activeEditor = useActiveTextEditor();
+  useEditorDecorations(options, activeEditor, rangesOrOptions);
+}

package/dist/composables/useActiveNotebookEditor.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="vscode" />
+/**
+ * @reactive `window.activeNotebookEditor`
+ * @category editor
+ */
+export declare const useActiveNotebookEditor: () => import("@vue/reactivity").ShallowRef<import("vscode").NotebookEditor | undefined>;

package/dist/composables/useActiveNotebookEditor.mjs

@@ -0,0 +1,11 @@
+import { shallowRef } from "@vue/runtime-core";
+import { window } from "vscode";
+import { createSingletonComposable } from "../utils/index.mjs";
+import { useDisposable } from "./useDisposable.mjs";
+export const useActiveNotebookEditor = createSingletonComposable(() => {
+  const activeNotebookEditor = shallowRef(window.activeNotebookEditor);
+  useDisposable(window.onDidChangeActiveNotebookEditor((editor) => {
+    activeNotebookEditor.value = editor;
+  }));
+  return activeNotebookEditor;
+});

package/dist/composables/useActiveTerminal.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="vscode" />
+/**
+ * @reactive `window.activeTerminal`
+ * @category terminal
+ */
+export declare const useActiveTerminal: () => import("@vue/reactivity").ShallowRef<import("vscode").Terminal | undefined>;

package/dist/composables/useActiveTerminal.mjs

@@ -0,0 +1,11 @@
+import { shallowRef } from "@vue/runtime-core";
+import { window } from "vscode";
+import { createSingletonComposable } from "../utils/index.mjs";
+import { useDisposable } from "./useDisposable.mjs";
+export const useActiveTerminal = createSingletonComposable(() => {
+  const activeTerminal = shallowRef(window.activeTerminal);
+  useDisposable(window.onDidChangeActiveTerminal((terminal) => {
+    activeTerminal.value = terminal;
+  }));
+  return activeTerminal;
+});

package/dist/composables/useActiveTextEditor.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="vscode" />
+/**
+ * @reactive `window.activeTextEditor`
+ * @category editor
+ */
+export declare const useActiveTextEditor: () => import("@vue/reactivity").ShallowRef<import("vscode").TextEditor | undefined>;

package/dist/composables/useActiveTextEditor.mjs

@@ -0,0 +1,11 @@
+import { shallowRef } from "@vue/runtime-core";
+import { window } from "vscode";
+import { createSingletonComposable } from "../utils/index.mjs";
+import { useDisposable } from "./useDisposable.mjs";
+export const useActiveTextEditor = createSingletonComposable(() => {
+  const activeTextEditor = shallowRef(window.activeTextEditor);
+  useDisposable(window.onDidChangeActiveTextEditor((editor) => {
+    activeTextEditor.value = editor;
+  }));
+  return activeTextEditor;
+});

package/dist/composables/useAllExtensions.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="vscode" />
+/**
+ * @reactive `extensions.all`
+ */
+export declare const useAllExtensions: () => import("@vue/reactivity").ComputedRef<readonly import("vscode").Extension<any>[]>;

package/dist/composables/useAllExtensions.mjs

@@ -0,0 +1,11 @@
+import { computed, shallowRef } from "@vue/runtime-core";
+import { extensions } from "vscode";
+import { createSingletonComposable } from "../utils/index.mjs";
+import { useDisposable } from "./useDisposable.mjs";
+export const useAllExtensions = createSingletonComposable(() => {
+  const allExtensions = shallowRef(extensions.all);
+  useDisposable(extensions.onDidChange(() => {
+    allExtensions.value = extensions.all;
+  }));
+  return computed(() => allExtensions.value);
+});

package/dist/composables/useCommand.d.ts

@@ -0,0 +1,7 @@
+import type { Commands } from '../utils';
+/**
+ * Register a command. See `vscode::commands.registerCommand`.
+ *
+ * @category commands
+ */
+export declare function useCommand<K extends Extract<keyof Commands, string>>(command: K, callback: Commands[K]): void;

package/dist/composables/useCommand.mjs

@@ -0,0 +1,5 @@
+import { commands } from "vscode";
+import { useDisposable } from "./useDisposable.mjs";
+export function useCommand(command, callback) {
+  useDisposable(commands.registerCommand(command, callback));
+}

package/dist/composables/useCommands.d.ts

@@ -0,0 +1,7 @@
+import type { Commands } from '../utils';
+/**
+ * Register multiple commands. See `vscode::commands.registerCommand`.
+ *
+ * @category commands
+ */
+export declare function useCommands(commands: Commands): void;

package/dist/composables/useCommands.mjs

@@ -0,0 +1,5 @@
+import { useCommand } from "./useCommand.mjs";
+export function useCommands(commands) {
+  for (const [command, callback] of Object.entries(commands))
+    useCommand(command, callback);
+}

package/dist/composables/useCommentController.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="vscode" />
+/**
+ * @reactive `comments.createCommentController`
+ */
+export declare function useCommentController(id: string, label: string): import("vscode").CommentController;

package/dist/composables/useCommentController.mjs

@@ -0,0 +1,5 @@
+import { comments } from "vscode";
+import { useDisposable } from "./useDisposable.mjs";
+export function useCommentController(id, label) {
+  return useDisposable(comments.createCommentController(id, label));
+}

package/dist/composables/useDefaultShell.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @reactive `env.shell`
+ */
+export declare const useDefaultShell: () => import("@vue/reactivity").ComputedRef<string>;

package/dist/composables/useDefaultShell.mjs

@@ -0,0 +1,11 @@
+import { computed, shallowRef } from "@vue/runtime-core";
+import { env } from "vscode";
+import { createSingletonComposable } from "../utils/index.mjs";
+import { useDisposable } from "./useDisposable.mjs";
+export const useDefaultShell = createSingletonComposable(() => {
+  const defaultShell = shallowRef(env.shell);
+  useDisposable(env.onDidChangeShell((ev) => {
+    defaultShell.value = ev;
+  }));
+  return computed(() => defaultShell.value);
+});

package/dist/composables/useDisposable.d.ts

@@ -0,0 +1,7 @@
+import type { Disposable } from 'vscode';
+/**
+ * Dispose the disposable when the current scope is disposed. See `vscode::Disposable`.
+ *
+ * @category lifecycle
+ */
+export declare function useDisposable<T extends Disposable>(disposable: T): T;

package/dist/composables/useDisposable.mjs

@@ -0,0 +1,7 @@
+import { getCurrentScope } from "@vue/runtime-core";
+import { extensionScope } from "../utils/index.mjs";
+export function useDisposable(disposable) {
+  const scope = getCurrentScope() ?? extensionScope;
+  scope.cleanups.push(disposable.dispose.bind(disposable));
+  return disposable;
+}

package/dist/composables/useDocumentText.d.ts

@@ -0,0 +1,7 @@
+import type { MaybeRefOrGetter } from '@vue/runtime-core';
+import type { TextDocument } from 'vscode';
+/**
+ * @reactive `TextDocument.getText`
+ * @category document
+ */
+export declare function useDocumentText(doc: MaybeRefOrGetter<TextDocument | undefined>): import("@vue/reactivity").ShallowRef<string | undefined>;

package/dist/composables/useDocumentText.mjs

@@ -0,0 +1,14 @@
+import { shallowRef, toValue, watchEffect } from "@vue/runtime-core";
+import { workspace } from "vscode";
+import { useDisposable } from "./useDisposable.mjs";
+export function useDocumentText(doc) {
+  const text = shallowRef(toValue(doc)?.getText());
+  watchEffect(() => {
+    text.value = toValue(doc)?.getText();
+  });
+  useDisposable(workspace.onDidChangeTextDocument((ev) => {
+    if (ev.document === toValue(doc))
+      text.value = ev.document.getText();
+  }));
+  return text;
+}

package/dist/composables/useEditorDecorations.d.ts

@@ -0,0 +1,9 @@
+import type { MaybeRefOrGetter } from '@vue/runtime-core';
+import type { DecorationOptions, DecorationRenderOptions, Range, TextEditor } from 'vscode';
+import type { Nullable } from '../utils/types';
+/**
+ * Reactively set decorations on the given editor. See `vscode::TextEditor.setDecorations`.
+ *
+ * @category editor
+ */
+export declare function useEditorDecorations(options: DecorationRenderOptions, editor: MaybeRefOrGetter<Nullable<TextEditor>>, rangesOrOptions: MaybeRefOrGetter<readonly Range[] | readonly DecorationOptions[]>): void;

package/dist/composables/useEditorDecorations.mjs

@@ -0,0 +1,8 @@
+import { toValue, watchEffect } from "@vue/runtime-core";
+import { window } from "vscode";
+export function useEditorDecorations(options, editor, rangesOrOptions) {
+  const decorationType = window.createTextEditorDecorationType(options);
+  watchEffect(() => {
+    toValue(editor)?.setDecorations(decorationType, toValue(rangesOrOptions));
+  });
+}

package/dist/composables/useEvent.d.ts

@@ -0,0 +1,6 @@
+import type { Event } from 'vscode';
+/**
+ * @category utilities
+ * @reactive `Event`
+ */
+export declare function useEvent<T>(event: Event<T>, listeners?: ((e: T) => any)[]): Event<T>;

package/dist/composables/useEvent.mjs

@@ -0,0 +1,8 @@
+export function useEvent(event, listeners = []) {
+  const addListener = (listener, thisArgs, disposables) => {
+    return event(listener, thisArgs, disposables);
+  };
+  for (const listener of listeners)
+    addListener(listener);
+  return addListener;
+}

package/dist/composables/useEventEmitter.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="vscode" />
+/**
+ * @category utilities
+ * @reactive `EventEmitter`
+ */
+export declare function useEventEmitter<T>(listeners?: ((e: T) => any)[]): {
+    event: import("vscode").Event<T>;
+    fire: any;
+    addListener: import("vscode").Event<T>;
+};

package/dist/composables/useEventEmitter.mjs

@@ -0,0 +1,14 @@
+import { EventEmitter } from "vscode";
+import { useDisposable } from "./useDisposable.mjs";
+import { useEvent } from "./useEvent.mjs";
+export function useEventEmitter(listeners = []) {
+  const emitter = useDisposable(new EventEmitter());
+  const addListener = useEvent(emitter.event, listeners);
+  for (const listener of listeners)
+    addListener(listener);
+  return {
+    event: emitter.event,
+    fire: emitter.fire.bind(emitter),
+    addListener
+  };
+}

package/dist/composables/useFetchTasks.d.ts

@@ -0,0 +1,6 @@
+import type { MaybeRefOrGetter } from '@vue/runtime-core';
+import type { TaskFilter } from 'vscode';
+/**
+ * @reactive `tasks.fetchTasks`
+ */
+export declare function useFetchTasks(filter?: MaybeRefOrGetter<TaskFilter | undefined>): import("@vue/reactivity").ComputedRef<Thenable<import("vscode").Task[]>>;

package/dist/composables/useFetchTasks.mjs

@@ -0,0 +1,5 @@
+import { computed, toValue } from "@vue/runtime-core";
+import { tasks } from "vscode";
+export function useFetchTasks(filter) {
+  return computed(() => tasks.fetchTasks(toValue(filter)));
+}

package/dist/composables/useFileUri.d.ts

@@ -0,0 +1,23 @@
+import type { MaybeRefOrGetter } from '@vue/runtime-core';
+import { Uri } from 'vscode';
+/**
+ * @reactive `Uri.file`
+ * @category utilities
+ */
+export declare function useFileUri(path: MaybeRefOrGetter<string>): import("@vue/reactivity").ShallowReactive<{
+    readonly scheme: string;
+    readonly authority: string;
+    readonly path: string;
+    readonly query: string;
+    readonly fragment: string;
+    readonly fsPath: string;
+    with(change: {
+        scheme?: string | undefined;
+        authority?: string | undefined;
+        path?: string | undefined;
+        query?: string | undefined;
+        fragment?: string | undefined;
+    }): Uri;
+    toString(): string;
+    toJSON(): any;
+}>;

package/dist/composables/useFileUri.mjs

@@ -0,0 +1,6 @@
+import { toValue } from "@vue/runtime-core";
+import { Uri } from "vscode";
+import { useUri } from "./useUri.mjs";
+export function useFileUri(path) {
+  return useUri(() => Uri.file(toValue(path)));
+}

package/dist/composables/useFoldingRangeProvider.d.ts

@@ -0,0 +1,6 @@
+import type { MaybeRefOrGetter } from '@vue/runtime-core';
+import type { DocumentSelector, FoldingRangeProvider } from 'vscode';
+/**
+ * @reactive `languages.registerFoldingRangeProvider`
+ */
+export declare function useFoldingRangeProvider(selector: DocumentSelector, provideFoldingRanges: MaybeRefOrGetter<FoldingRangeProvider['provideFoldingRanges']>): void;

package/dist/composables/useFoldingRangeProvider.mjs

@@ -0,0 +1,21 @@
+import { shallowRef, toValue, watchEffect } from "@vue/runtime-core";
+import { EventEmitter, languages } from "vscode";
+import { useDisposable } from "./useDisposable.mjs";
+export function useFoldingRangeProvider(selector, provideFoldingRanges) {
+  const changeEventEmitter = new EventEmitter();
+  const provideFn = shallowRef();
+  watchEffect(() => {
+    if (provideFn.value)
+      changeEventEmitter.fire();
+    provideFn.value = toValue(provideFoldingRanges);
+  });
+  useDisposable(languages.registerFoldingRangeProvider(
+    selector,
+    {
+      onDidChangeFoldingRanges: changeEventEmitter.event,
+      provideFoldingRanges(document, context, token) {
+        return provideFn.value?.(document, context, token);
+      }
+    }
+  ));
+}

package/dist/composables/useIsDarkTheme.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Determines if the current color theme is dark. See `vscode::ColorTheme.kind`.
+ *
+ * @category window
+ */
+export declare const useIsDarkTheme: () => import("@vue/reactivity").ComputedRef<boolean>;

package/dist/composables/useIsDarkTheme.mjs

@@ -0,0 +1,8 @@
+import { computed } from "@vue/runtime-core";
+import { ColorThemeKind } from "vscode";
+import { createSingletonComposable } from "../utils/index.mjs";
+import { useActiveColorTheme } from "./useActiveColorTheme.mjs";
+export const useIsDarkTheme = createSingletonComposable(() => {
+  const theme = useActiveColorTheme();
+  return computed(() => theme.value.kind === ColorThemeKind.Dark || theme.value.kind === ColorThemeKind.HighContrast);
+});

package/dist/composables/useIsTelemetryEnabled.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @reactive `env.isTelemetryEnabled`
+ */
+export declare const useIsTelemetryEnabled: () => import("@vue/reactivity").ComputedRef<boolean>;

package/dist/composables/useIsTelemetryEnabled.mjs

@@ -0,0 +1,11 @@
+import { computed, shallowRef } from "@vue/runtime-core";
+import { env } from "vscode";
+import { createSingletonComposable } from "../utils/index.mjs";
+import { useDisposable } from "./useDisposable.mjs";
+export const useIsTelemetryEnabled = createSingletonComposable(() => {
+  const isTelemetryEnabled = shallowRef(env.isTelemetryEnabled);
+  useDisposable(env.onDidChangeTelemetryEnabled((ev) => {
+    isTelemetryEnabled.value = ev;
+  }));
+  return computed(() => isTelemetryEnabled.value);
+});

package/dist/composables/useL10nText.d.ts

@@ -0,0 +1,6 @@
+import type { ComputedRef, MaybeRefOrGetter } from '@vue/runtime-core';
+/**
+ * @reactive `l10n.t`
+ */
+export declare function useL10nText(message: MaybeRefOrGetter<string>, ...args: Array<MaybeRefOrGetter<string | number | boolean>>): ComputedRef<string>;
+export declare function useL10nText(message: MaybeRefOrGetter<string>, args: Record<string, any>): ComputedRef<string>;

package/dist/composables/useL10nText.mjs

@@ -0,0 +1,7 @@
+import { computed, toRaw, toValue } from "@vue/runtime-core";
+import { l10n } from "vscode";
+export function useL10nText(message, ...args) {
+  return computed(() => {
+    return typeof args[0] === "object" ? l10n.t(toValue(message), toRaw(args[0])) : l10n.t(toValue(message), ...args.map(toValue));
+  });
+}

package/dist/composables/useLogLevel.d.ts

@@ -0,0 +1,5 @@
+/// <reference types="vscode" />
+/**
+ * @reactive `env.logLevel`
+ */
+export declare const useLogLevel: () => import("@vue/reactivity").ComputedRef<import("vscode").LogLevel>;

package/dist/composables/useLogLevel.mjs

@@ -0,0 +1,11 @@
+import { computed, shallowRef } from "@vue/runtime-core";
+import { env } from "vscode";
+import { createSingletonComposable } from "../utils/index.mjs";
+import { useDisposable } from "./useDisposable.mjs";
+export const useLogLevel = createSingletonComposable(() => {
+  const logLevel = shallowRef(env.logLevel);
+  useDisposable(env.onDidChangeLogLevel((ev) => {
+    logLevel.value = ev;
+  }));
+  return computed(() => logLevel.value);
+});

package/dist/composables/useLogger.d.ts

@@ -0,0 +1,21 @@
+/// <reference types="vscode" />
+declare function defaultGetPrefix(type: string): string;
+/**
+ * Creates a logger that writes to the output channel.
+ *
+ * @category view
+ */
+export declare function useLogger(name: string, getPrefix?: typeof defaultGetPrefix): {
+    outputChannel: import("vscode").OutputChannel;
+    createLoggerFunc: (type: string) => (...message: any[]) => void;
+    info: (...message: any[]) => void;
+    warn: (...message: any[]) => void;
+    error: (...message: any[]) => void;
+    append: any;
+    appendLine: any;
+    replace: any;
+    clear: any;
+    show: any;
+    hide: any;
+};
+export {};