@vscode/web-editors 0.0.2-104 → 0.0.2-106

package/dist/index.d.ts

@@ -2143,12 +2143,14 @@ declare const ZodReadonly: $constructor<ZodReadonly>;
 declare const zEditorCapabilities: ZodObject<{
   supportsContentEdits: ZodOptional<ZodBoolean>;
   supportsOptions: ZodOptional<ZodBoolean>;
+  supportsPresentation: ZodOptional<ZodBoolean>;
 }, $strip>;
 declare const zHostCapabilities: ZodObject<{
   supportsContentEdits: ZodOptional<ZodBoolean>;
   supportsOptions: ZodOptional<ZodBoolean>;
   supportsForceUpdate: ZodOptional<ZodBoolean>;
   supportsHostTransport: ZodOptional<ZodBoolean>;
+  supportsPresentation: ZodOptional<ZodBoolean>;
 }, $strip>;
 declare const zTextEdit: ZodObject<{
   offset: ZodNumber;
@@ -2176,16 +2178,39 @@ declare const zWebEditorUpdate: ZodObject<{
   acknowledgedClientRevision: ZodOptional<ZodNumber>;
   force: ZodOptional<ZodBoolean>;
 }, $strip>;
+/** How an embedding host currently presents the editor. */
+declare const zPresentationMode: ZodEnum<{
+  inline: "inline";
+  "full-width": "full-width";
+  "full-view": "full-view";
+}>;
+/**
+ * Presentation controls the editor asks its embedding host for. The host's own
+ * configuration takes precedence over these preferences.
+ */
+declare const zPresentationPreferences: ZodObject<{
+  resizable: ZodOptional<ZodBoolean>;
+  fullWidth: ZodOptional<ZodBoolean>;
+  fullView: ZodOptional<ZodBoolean>;
+  minHeight: ZodOptional<ZodNumber>;
+  maxAutomaticHeight: ZodOptional<ZodNumber>;
+}, $strip>;
 type ContentEdit = output<typeof zContentEdit>;
 type TextEdit = output<typeof zTextEdit>;
 type EditorCapabilities = output<typeof zEditorCapabilities>;
 type HostCapabilities = output<typeof zHostCapabilities>;
 type WebEditorUpdate = output<typeof zWebEditorUpdate>;
+type PresentationMode = output<typeof zPresentationMode>;
+type PresentationPreferences = output<typeof zPresentationPreferences>;
 type ContentType = "text" | "json";
 declare const webEditorHostInterface: any;
 declare const webEditorInterface: any;
 declare const webEditorHostTransportInterface: any;
 declare const webEditorClientTransportInterface: any;
+/** Methods the editor exposes to a presenting host. */
+declare const webEditorPresentationInterface: any;
+/** Methods a presenting host exposes to the editor. */
+declare const webEditorPresentationHostInterface: any;
 declare const zEmbeddedAppDescriptor: ZodObject<{
   handleId: ZodString;
   appId: ZodString;
@@ -2210,6 +2235,8 @@ type WebEditorHostProxy = InterfaceClient<typeof webEditorHostInterface>;
 type WebEditorProxy = InterfaceClient<typeof webEditorInterface>;
 type WebEditorHostTransportProxy = InterfaceClient<typeof webEditorHostTransportInterface>;
 type WebEditorClientTransportProxy = InterfaceClient<typeof webEditorClientTransportInterface>;
+type WebEditorPresentationProxy = InterfaceClient<typeof webEditorPresentationInterface>;
+type WebEditorPresentationHostProxy = InterfaceClient<typeof webEditorPresentationHostInterface>;
 /** Typed proxy used by an app to invoke `vscode-app-host` methods. */
 type VsCodeAppHostProxy = InterfaceClient<typeof vscodeAppHostInterface>;
 type VsCodeAppEmbeddingEventsProxy = InterfaceClient<typeof vscodeAppEmbeddingEventsInterface>;
@@ -2319,6 +2346,12 @@ interface WebEditorHostOptions {
   capabilities?: HostCapabilities;
   /** Optional message transport to expose to the editor. */
   hostTransport?: HostTransport;
+  /**
+   * The host presents the editor inline (for example as a block in a document)
+   * and exchanges presentation state with editors that support it: see
+   * {@link WebEditorHost.setPresentationMode} and the presentation events.
+   */
+  supportsPresentation?: boolean;
   /** Called when the editor sends malformed input. Defaults to `console.error`. */
   onError?: (message: string, detail?: unknown) => void;
 }
@@ -2333,6 +2366,7 @@ declare class WebEditorHost implements IDisposable {
   private readonly _connection;
   private readonly _editor;
   private readonly _clientTransport;
+  private readonly _presentation;
   private readonly _contentType;
   private readonly _jsonFormat;
   private readonly _onError;
@@ -2340,6 +2374,7 @@ declare class WebEditorHost implements IDisposable {
   private readonly _hostTransportSubscription;
   private _text;
   private _readOnly;
+  private _presentationMode;
   private _serverRevision;
   private _acknowledgedClientRevision;
   private _editorInitialized;
@@ -2357,6 +2392,12 @@ declare class WebEditorHost implements IDisposable {
   readonly onDidReportSize: Event<{
     height: number;
   }>;
+  private readonly _onDidSetPresentationPreferences;
+  /** The editor replaced its presentation preferences. Only fires with `supportsPresentation`. */
+  readonly onDidSetPresentationPreferences: Event<PresentationPreferences>;
+  private readonly _onDidRequestExitFullView;
+  /** The editor asked to leave full view. Only fires with `supportsPresentation`. */
+  readonly onDidRequestExitFullView: Event<void>;
   constructor(options: WebEditorHostOptions);
   /** The text the host believes the document currently holds. */
   getText(): string;
@@ -2374,6 +2415,11 @@ declare class WebEditorHost implements IDisposable {
    */
   reuse(text: string, readOnly: boolean): void;
   getReadOnly(): boolean;
+  /**
+   * Tell the editor how the host presents it. Sent to editors that support
+   * presentation once they initialized, and again after they reconnect.
+   */
+  setPresentationMode(mode: PresentationMode): void;
   setReadOnly(readOnly: boolean): void;
   /**
    * Push fine-grained edits to the editor.
@@ -2383,6 +2429,7 @@ declare class WebEditorHost implements IDisposable {
   dispose(): void;
   private _pushFullUpdate;
   private _pushAcknowledgement;
+  private _pushPresentationMode;
   private _acknowledgeAndRestore;
 }
 //#endregion
@@ -2484,12 +2531,16 @@ declare class WebEditorClient implements IDisposable {
   private readonly _connection;
   private readonly _host;
   private readonly _hostTransportProxy;
+  private readonly _presentationHost;
   private readonly _onError;
   private _hostTransport;
   private _content;
   private _readOnly;
   private _options;
   private _hostCapabilities;
+  private _connected;
+  private _presentationMode;
+  private _presentationPreferences;
   private readonly _pendingHostTransportMessages;
   private _hostTransportActivated;
   private _clientRevision;
@@ -2514,6 +2565,11 @@ declare class WebEditorClient implements IDisposable {
   readonly onDidChangeOptions: Event<{
     options: JsonValue;
   }>;
+  private readonly _onDidChangePresentationMode;
+  /** The embedding host changed how it presents this editor. See {@link getPresentationMode}. */
+  readonly onDidChangePresentationMode: Event<{
+    mode: PresentationMode;
+  }>;
   private readonly _onDidReceiveHostMessage;
   /** Resolves once the host has acknowledged `initialized`. */
   readonly onDidConnect: Promise<{
@@ -2539,10 +2595,24 @@ declare class WebEditorClient implements IDisposable {
    */
   applyEdits(edits: readonly ContentEdit[]): void;
   /**
-   * Report the editor's current laid-out content height (px) to the host.
-   * A host embedding this editor in an iframe uses it to size the frame.
+   * Report the editor's preferred content height (px): the height it needs to
+   * show its content without scrolling, independent of the frame's current
+   * height. A host embedding this editor in an iframe sizes the frame to it.
    */
   reportSize(height: number): void;
+  /**
+   * How an embedding host currently presents this editor, or `undefined` when
+   * the host does not present it inline (for example a standalone editor).
+   */
+  getPresentationMode(): PresentationMode | undefined;
+  /**
+   * Ask a presenting host for presentation controls (resize grips, full view).
+   * Replaces earlier preferences; sent once connected, and ignored by hosts
+   * that do not present the editor inline.
+   */
+  setPresentationPreferences(preferences: PresentationPreferences): void;
+  /** Ask a presenting host to leave full view. */
+  exitFullView(): void;
   dispose(): void;
   private _handleUpdate;
   private _handleApplyContentEdits;
@@ -2681,7 +2751,20 @@ declare class VsCodeAppHostClient {
   configureEditorAssociation(extension: string, options?: {
     dismissable?: boolean;
   }): Promise<EditorAssociationResult>;
+  /**
+   * This editor tab's view state, or `undefined` when none is set. VS Code
+   * restores it with the tab (for example after a window reload); a newly
+   * opened tab starts without one. Validate it like any other persisted
+   * input, since it may come from an older version of the app.
+   */
+  getViewState(): Promise<unknown>;
+  /**
+   * Replace this editor tab's view state with a JSON value, for example
+   * scroll positions or selections. Use per-app storage for state shared by
+   * every tab. Rejects for values too large to persist and in embedded apps.
+   */
+  setViewState(value: unknown): Promise<void>;
 }
 //#endregion
-export { AppContext, type ConnectionInput, ContentEdit, ContentType, EditorAssociationResult, EditorCapabilities, EditorRegistrationStatus, EditorScope, EmbeddedAppAccessOptions, EmbeddedAppDescriptor, EmbeddedAppHandle, EmbeddingContext, type Event, HostCapabilities, HostTransport, type IDisposable, JsonFormatOptions, JsonValue, type MessageEndpoint, type MessageLikeEvent, ScopeRegistration, TextEdit, VsCodeAppEmbeddingEventsProxy, VsCodeAppHostClient, VsCodeAppHostClientOptions, VsCodeAppHostProxy, WebEditorClient, WebEditorClientOptions, WebEditorClientState, WebEditorClientTransportProxy, WebEditorHost, WebEditorHostOptions, WebEditorHostProxy, WebEditorHostTransportProxy, WebEditorProxy, WebEditorUpdate, WindowMessageTransport, applyContentEdits, applyTextEdits, createWindowParentConnection, decodeFromEditor, encodeForEditor, vscodeAppEmbeddingEventsInterface, vscodeAppHostInterface, webEditorClientTransportInterface, webEditorHostInterface, webEditorHostTransportInterface, webEditorInterface };
+export { AppContext, type ConnectionInput, ContentEdit, ContentType, EditorAssociationResult, EditorCapabilities, EditorRegistrationStatus, EditorScope, EmbeddedAppAccessOptions, EmbeddedAppDescriptor, EmbeddedAppHandle, EmbeddingContext, type Event, HostCapabilities, HostTransport, type IDisposable, JsonFormatOptions, JsonValue, type MessageEndpoint, type MessageLikeEvent, PresentationMode, PresentationPreferences, ScopeRegistration, TextEdit, VsCodeAppEmbeddingEventsProxy, VsCodeAppHostClient, VsCodeAppHostClientOptions, VsCodeAppHostProxy, WebEditorClient, WebEditorClientOptions, WebEditorClientState, WebEditorClientTransportProxy, WebEditorHost, WebEditorHostOptions, WebEditorHostProxy, WebEditorHostTransportProxy, WebEditorPresentationHostProxy, WebEditorPresentationProxy, WebEditorProxy, WebEditorUpdate, WindowMessageTransport, applyContentEdits, applyTextEdits, createWindowParentConnection, decodeFromEditor, encodeForEditor, vscodeAppEmbeddingEventsInterface, vscodeAppHostInterface, webEditorClientTransportInterface, webEditorHostInterface, webEditorHostTransportInterface, webEditorInterface, webEditorPresentationHostInterface, webEditorPresentationInterface };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -4120,13 +4120,17 @@ function superRefine(fn, params) {
 const zJsonValue = unknown();
 const zEditorCapabilities = object({
 	supportsContentEdits: boolean().optional(),
-	supportsOptions: boolean().optional()
+	supportsOptions: boolean().optional(),
+	/** The editor implements `web-editor-presentation` (see {@link webEditorPresentationInterface}). */
+	supportsPresentation: boolean().optional()
 });
 const zHostCapabilities = object({
 	supportsContentEdits: boolean().optional(),
 	supportsOptions: boolean().optional(),
 	supportsForceUpdate: boolean().optional(),
-	supportsHostTransport: boolean().optional()
+	supportsHostTransport: boolean().optional(),
+	/** The host presents the editor inline and implements `web-editor-presentation-host`. */
+	supportsPresentation: boolean().optional()
 });
 const zTextEdit = object({
 	offset: number().int().nonnegative(),
@@ -4150,6 +4154,28 @@ const zWebEditorUpdate = object({
 	acknowledgedClientRevision: number().int().nonnegative().optional(),
 	force: boolean().optional()
 });
+/** How an embedding host currently presents the editor. */
+const zPresentationMode = _enum([
+	"inline",
+	"full-width",
+	"full-view"
+]);
+const zEditorHeight = number().positive().max(1e4);
+/**
+* Presentation controls the editor asks its embedding host for. The host's own
+* configuration takes precedence over these preferences.
+*/
+const zPresentationPreferences = object({
+	/** A height grip; dragging near the automatic (content) height snaps back to it. */
+	resizable: boolean().optional(),
+	/** A width grip that widens the editor up to the host's viewport. */
+	fullWidth: boolean().optional(),
+	/** A toolbar action that fills the host's viewport. */
+	fullView: boolean().optional(),
+	minHeight: zEditorHeight.optional(),
+	/** Upper bound for the automatic height; users can still resize beyond it. */
+	maxAutomaticHeight: zEditorHeight.optional()
+});
 const webEditorHostInterface = defineInterface({
 	id: "web-editor-host",
 	description: "Methods the host exposes to the editor (web-editor/0.12)."
@@ -4197,6 +4223,23 @@ const webEditorClientTransportInterface = defineInterface({
 	id: "web-editor-client-transport",
 	description: "Optional messages the web editor host sends to the editor."
 }, { message: notificationType(object({ message: zJsonValue })) });
+/** Methods the editor exposes to a presenting host. */
+const webEditorPresentationInterface = defineInterface({
+	id: "web-editor-presentation",
+	description: "How the embedding host currently presents the editor."
+}, { 
+/** Sent once the editor initialized, and whenever the mode changes. */
+changed: notificationType(object({ mode: zPresentationMode })) });
+/** Methods a presenting host exposes to the editor. */
+const webEditorPresentationHostInterface = defineInterface({
+	id: "web-editor-presentation-host",
+	description: "Presentation preferences and actions of an embedded editor."
+}, {
+	/** Replaces the editor's previous preferences. */
+	setPreferences: notificationType(zPresentationPreferences),
+	/** Asks the host to leave full view, for example when the user presses Escape. */
+	exitFullView: notificationType(object({}))
+});
 /** Per-scope registration: `registered` (toolbar button) and `isDefault` (auto-open). */
 const zScopeRegistration = object({
 	registered: boolean(),
@@ -4272,7 +4315,21 @@ const vscodeAppHostInterface = defineInterface({
 		workspace: zScopeRegistration,
 		hasWorkspace: boolean(),
 		changed: boolean()
-	}))
+	})),
+	/**
+	* The view state of this editor tab, such as scroll positions or
+	* selections, as last set by {@link setViewState}. `value` is omitted
+	* when none is set. VS Code restores it when it restores the tab (for
+	* example after a window reload), but a newly opened tab starts
+	* without one. Only the top-level app of a tab has view state.
+	*/
+	getViewState: requestType(object({}), object({ value: zJsonValue.optional() })),
+	/**
+	* Replace this editor tab's view state with a JSON value. The host
+	* rejects values too large to persist with the tab, and calls from
+	* embedded apps.
+	*/
+	setViewState: requestType(object({ value: zJsonValue }), object({}))
 });
 /** Host-to-parent notifications for loaded child runtime changes. */
 const vscodeAppEmbeddingEventsInterface = defineInterface({
@@ -4395,6 +4452,7 @@ var WebEditorHost = class {
 	_connection;
 	_editor;
 	_clientTransport;
+	_presentation;
 	_contentType;
 	_jsonFormat;
 	_onError;
@@ -4402,6 +4460,7 @@ var WebEditorHost = class {
 	_hostTransportSubscription;
 	_text;
 	_readOnly;
+	_presentationMode;
 	_serverRevision = 0;
 	_acknowledgedClientRevision = 0;
 	_editorInitialized = false;
@@ -4413,6 +4472,12 @@ var WebEditorHost = class {
 	onDidInitialize = this._onDidInitialize.event;
 	_onDidReportSize = new Emitter();
 	onDidReportSize = this._onDidReportSize.event;
+	_onDidSetPresentationPreferences = new Emitter();
+	/** The editor replaced its presentation preferences. Only fires with `supportsPresentation`. */
+	onDidSetPresentationPreferences = this._onDidSetPresentationPreferences.event;
+	_onDidRequestExitFullView = new Emitter();
+	/** The editor asked to leave full view. Only fires with `supportsPresentation`. */
+	onDidRequestExitFullView = this._onDidRequestExitFullView.event;
 	constructor(options) {
 		this._connection = options.connection;
 		this._contentType = options.contentType ?? "text";
@@ -4422,10 +4487,12 @@ var WebEditorHost = class {
 		this._onError = options.onError ?? ((m, d) => console.error("WebEditorHost:", m, d));
 		this._capabilities = {
 			...options.capabilities ?? { supportsForceUpdate: true },
-			supportsHostTransport: options.hostTransport ? true : void 0
+			supportsHostTransport: options.hostTransport ? true : void 0,
+			supportsPresentation: options.supportsPresentation ? true : void 0
 		};
 		this._editor = this._connection.get(webEditorInterface);
 		this._clientTransport = this._connection.get(webEditorClientTransportInterface);
+		this._presentation = this._connection.get(webEditorPresentationInterface);
 		this._connection.register(webEditorHostInterface, {
 			initialized: (params) => {
 				if (params.contentType !== this._contentType) this._onError(`Editor contentType "${params.contentType}" does not match host "${this._contentType}"`);
@@ -4435,6 +4502,7 @@ var WebEditorHost = class {
 				this._acknowledgedClientRevision = 0;
 				this._pushFullUpdate();
 				for (const message of this._pendingHostTransportMessages.splice(0)) this._clientTransport.message({ message });
+				this._pushPresentationMode();
 				this._onDidInitialize.fire({ capabilities: params.capabilities });
 				return {
 					protocolVersion: "web-editor-host/0.12",
@@ -4479,6 +4547,10 @@ var WebEditorHost = class {
 				this._onDidReportSize.fire({ height: params.height });
 			}
 		});
+		if (options.supportsPresentation) this._connection.register(webEditorPresentationHostInterface, {
+			setPreferences: (preferences) => this._onDidSetPresentationPreferences.fire(preferences),
+			exitFullView: () => this._onDidRequestExitFullView.fire()
+		});
 		if (options.hostTransport) {
 			this._connection.register(webEditorHostTransportInterface, { message: ({ message }) => options.hostTransport.sendMessage(message) });
 			this._hostTransportSubscription = options.hostTransport.onMessage((message) => {
@@ -4513,6 +4585,15 @@ var WebEditorHost = class {
 	getReadOnly() {
 		return this._readOnly;
 	}
+	/**
+	* Tell the editor how the host presents it. Sent to editors that support
+	* presentation once they initialized, and again after they reconnect.
+	*/
+	setPresentationMode(mode) {
+		if (this._presentationMode === mode) return;
+		this._presentationMode = mode;
+		this._pushPresentationMode();
+	}
 	setReadOnly(readOnly) {
 		if (this._readOnly === readOnly) return;
 		this._readOnly = readOnly;
@@ -4547,6 +4628,8 @@ var WebEditorHost = class {
 		this._onDidChangeText.dispose();
 		this._onDidInitialize.dispose();
 		this._onDidReportSize.dispose();
+		this._onDidSetPresentationPreferences.dispose();
+		this._onDidRequestExitFullView.dispose();
 		this._pendingHostTransportMessages.length = 0;
 		this._connection.close();
 	}
@@ -4575,6 +4658,10 @@ var WebEditorHost = class {
 			acknowledgedClientRevision: this._acknowledgedClientRevision
 		});
 	}
+	_pushPresentationMode() {
+		if (!this._editorInitialized || !this._capabilities.supportsPresentation || !this._editorCapabilities?.supportsPresentation || this._presentationMode === void 0) return;
+		this._presentation.changed({ mode: this._presentationMode });
+	}
 	_acknowledgeAndRestore(clientRevision) {
 		this._acknowledgedClientRevision = Math.max(this._acknowledgedClientRevision, clientRevision);
 		this._pushFullUpdate(true);
@@ -4727,12 +4814,16 @@ var WebEditorClient = class WebEditorClient {
 	_connection;
 	_host;
 	_hostTransportProxy;
+	_presentationHost;
 	_onError;
 	_hostTransport;
 	_content = void 0;
 	_readOnly = false;
 	_options = void 0;
 	_hostCapabilities;
+	_connected = false;
+	_presentationMode;
+	_presentationPreferences;
 	_pendingHostTransportMessages = [];
 	_hostTransportActivated = false;
 	_clientRevision = 0;
@@ -4747,6 +4838,9 @@ var WebEditorClient = class WebEditorClient {
 	onDidChangeReadOnly = this._onDidChangeReadOnly.event;
 	_onDidChangeOptions = new Emitter();
 	onDidChangeOptions = this._onDidChangeOptions.event;
+	_onDidChangePresentationMode = new Emitter();
+	/** The embedding host changed how it presents this editor. See {@link getPresentationMode}. */
+	onDidChangePresentationMode = this._onDidChangePresentationMode.event;
 	_onDidReceiveHostMessage = new Emitter();
 	/** Resolves once the host has acknowledged `initialized`. */
 	onDidConnect;
@@ -4760,6 +4854,7 @@ var WebEditorClient = class WebEditorClient {
 		this._onError = options.onError ?? ((m, d) => console.error("WebEditorClient:", m, d));
 		this._host = this._connection.get(webEditorHostInterface);
 		this._hostTransportProxy = this._connection.get(webEditorHostTransportInterface);
+		this._presentationHost = this._connection.get(webEditorPresentationHostInterface);
 		this._connection.register(webEditorInterface, {
 			update: (params) => this._handleUpdate(params),
 			applyContentEdits: (params) => this._handleApplyContentEdits(params),
@@ -4767,6 +4862,11 @@ var WebEditorClient = class WebEditorClient {
 				return { schema: options.getContentSchema ? await options.getContentSchema() : null };
 			}
 		});
+		this._connection.register(webEditorPresentationInterface, { changed: ({ mode }) => {
+			if (mode === this._presentationMode) return;
+			this._presentationMode = mode;
+			this._onDidChangePresentationMode.fire({ mode });
+		} });
 		this._connection.register(webEditorClientTransportInterface, { message: ({ message }) => {
 			if (this._hostTransportActivated) this._onDidReceiveHostMessage.fire(message);
 			else this._pendingHostTransportMessages.push(message);
@@ -4774,9 +4874,14 @@ var WebEditorClient = class WebEditorClient {
 		this.onDidConnect = this._host.initialized({
 			protocolVersion: "web-editor/0.12",
 			contentType: options.contentType ?? "text",
-			capabilities: options.capabilities
+			capabilities: {
+				...options.capabilities,
+				supportsPresentation: true
+			}
 		}).then((r) => {
 			this._hostCapabilities = r.capabilities;
+			this._connected = true;
+			if (this._presentationPreferences) this.setPresentationPreferences(this._presentationPreferences);
 			if (r.capabilities?.supportsHostTransport) this._hostTransport = {
 				onMessage: (listener) => {
 					const disposable = this._onDidReceiveHostMessage.event(listener);
@@ -4841,17 +4946,39 @@ var WebEditorClient = class WebEditorClient {
 		});
 	}
 	/**
-	* Report the editor's current laid-out content height (px) to the host.
-	* A host embedding this editor in an iframe uses it to size the frame.
+	* Report the editor's preferred content height (px): the height it needs to
+	* show its content without scrolling, independent of the frame's current
+	* height. A host embedding this editor in an iframe sizes the frame to it.
 	*/
 	reportSize(height) {
 		this._host.reportSize({ height });
 	}
+	/**
+	* How an embedding host currently presents this editor, or `undefined` when
+	* the host does not present it inline (for example a standalone editor).
+	*/
+	getPresentationMode() {
+		return this._presentationMode;
+	}
+	/**
+	* Ask a presenting host for presentation controls (resize grips, full view).
+	* Replaces earlier preferences; sent once connected, and ignored by hosts
+	* that do not present the editor inline.
+	*/
+	setPresentationPreferences(preferences) {
+		this._presentationPreferences = preferences;
+		if (this._connected && this._hostCapabilities?.supportsPresentation) this._presentationHost.setPreferences(preferences);
+	}
+	/** Ask a presenting host to leave full view. */
+	exitFullView() {
+		if (this._connected && this._hostCapabilities?.supportsPresentation) this._presentationHost.exitFullView({});
+	}
 	dispose() {
 		this._onDidChangeContent.dispose();
 		this._onDidApplyHostEdits.dispose();
 		this._onDidChangeReadOnly.dispose();
 		this._onDidChangeOptions.dispose();
+		this._onDidChangePresentationMode.dispose();
 		this._onDidReceiveHostMessage.dispose();
 		this._pendingHostTransportMessages.length = 0;
 		this._connection.close();
@@ -5102,8 +5229,25 @@ var VsCodeAppHostClient = class {
 			dismissable: options?.dismissable
 		});
 	}
+	/**
+	* This editor tab's view state, or `undefined` when none is set. VS Code
+	* restores it with the tab (for example after a window reload); a newly
+	* opened tab starts without one. Validate it like any other persisted
+	* input, since it may come from an older version of the app.
+	*/
+	async getViewState() {
+		return (await this._host.getViewState({})).value;
+	}
+	/**
+	* Replace this editor tab's view state with a JSON value, for example
+	* scroll positions or selections. Use per-app storage for state shared by
+	* every tab. Rejects for values too large to persist and in embedded apps.
+	*/
+	async setViewState(value) {
+		await this._host.setViewState({ value });
+	}
 };
 //#endregion
-export { EmbeddedAppHandle, VsCodeAppHostClient, WebEditorClient, WebEditorHost, WindowMessageTransport, applyContentEdits, applyTextEdits, createWindowParentConnection, decodeFromEditor, encodeForEditor, vscodeAppEmbeddingEventsInterface, vscodeAppHostInterface, webEditorClientTransportInterface, webEditorHostInterface, webEditorHostTransportInterface, webEditorInterface };
+export { EmbeddedAppHandle, VsCodeAppHostClient, WebEditorClient, WebEditorHost, WindowMessageTransport, applyContentEdits, applyTextEdits, createWindowParentConnection, decodeFromEditor, encodeForEditor, vscodeAppEmbeddingEventsInterface, vscodeAppHostInterface, webEditorClientTransportInterface, webEditorHostInterface, webEditorHostTransportInterface, webEditorInterface, webEditorPresentationHostInterface, webEditorPresentationInterface };
 
 //# sourceMappingURL=index.js.map