npm - @vscode/markdown-editor - Versions diffs - 0.0.2-51 → 0.0.2-53 - Mend

@vscode/markdown-editor 0.0.2-51 → 0.0.2-53

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/dist/web-editors.d.ts CHANGED Viewed

@@ -1,3 +1,25 @@
+import { ContentType } from '@vscode/web-editors';
+import { IDisposable } from './_observables/index';
+export declare interface CodeBlockEditorProviderDefinition {
+    readonly id: string;
+    readonly selector: CodeBlockEditorSelector;
+}
+export declare type CodeBlockEditorProviderSelection<T> = {
+    readonly kind: 'match';
+    readonly provider: T;
+} | {
+    readonly kind: 'ambiguous';
+    readonly providers: readonly T[];
+};
+export declare type CodeBlockEditorSelector = {
+    readonly language: string;
+} | {
+    readonly languagePrefix: string;
+};
 /**
  * Build an {@link IEmbeddedCodeEditorFactory} that renders matching code blocks
  * with the sample web editor embedded in an iframe.
@@ -28,6 +50,8 @@ declare interface IEmbeddedCodeEditor {
      * is how edits the editor itself originated are prevented from echoing back.
      */
     setContent(content: string): void;
+    /** Update whether the embedded editor may change its content. */
+    setReadOnly?(readOnly: boolean): void;
     /**
      * Optional synchronous height (px) to reserve for `content` *before* the
      * editor has laid out. Return `undefined` to let the editor size itself
@@ -53,13 +77,15 @@ declare interface IEmbeddedCodeEditorFactory {
     create(language: string, initialContent: string): IEmbeddedCodeEditor | undefined;
 }
-export declare interface IframeEmbeddedEditorOptions {
-    /** The guest bundle source (an IIFE/ESM string), inlined into the iframe. */
-    readonly bundleJs: string;
+declare interface IframeEmbeddedEditorBaseOptions {
     /** Decide whether this factory handles `language`. */
     readonly handlesLanguage: (language: string) => boolean;
+    /** Content representation used by the guest. Default `text`. */
+    readonly contentType?: ContentType;
+    /** Nonce applied to author and host-injected scripts for an inherited parent CSP. */
+    readonly scriptNonce?: string;
     /** Theme CSS injected into the iframe `<head>` (e.g. `--vscode-*` variables). */
-    readonly themeCss?: string;
+    readonly themeCss?: string | (() => string);
     /**
      * Optional synchronous height (px) reserved from content before the guest
      * measures itself. Return `undefined` to let the guest size the frame.
@@ -67,6 +93,29 @@ export declare interface IframeEmbeddedEditorOptions {
     readonly estimateHeight?: (content: string) => number | undefined;
 }
+export declare type IframeEmbeddedEditorOptions = IframeEmbeddedEditorBaseOptions & ({
+    /** Self-contained HTML document loaded into the sandboxed iframe. */
+    readonly html: string;
+    readonly bundleJs?: never;
+} | {
+    /** @deprecated Use `html`. Retained for the sample fixture. */
+    readonly bundleJs: string;
+    readonly html?: never;
+});
+export declare interface IframeEmbeddedEditorProvider extends CodeBlockEditorProviderDefinition {
+    readonly resolve: (language: string) => Promise<ResolvedIframeEmbeddedEditor | undefined>;
+}
+export declare type IframeEmbeddedEditorProviderSelector = CodeBlockEditorSelector;
+declare interface IframeSandboxOptions {
+    readonly forms?: boolean;
+    readonly downloads?: boolean;
+    readonly pointerLock?: boolean;
+    readonly clipboardWrite?: boolean;
+}
 declare class OffsetRange {
     readonly start: number;
     readonly endExclusive: number;
@@ -94,6 +143,59 @@ declare class OffsetRange {
     toString(): string;
 }
+declare class PhysicalIframe implements IDisposable {
+    private readonly _descriptor;
+    private readonly _frameRoot;
+    private readonly _scriptNonce;
+    private readonly _themeCss;
+    readonly iframe: HTMLIFrameElement;
+    editor: VirtualizedIframeEmbeddedEditor | undefined;
+    readonly pool: PhysicalIframePool;
+    private _host;
+    private _transport;
+    private _pendingEditor;
+    private _disposed;
+    private readonly _onWindowMessage;
+    constructor(pool: PhysicalIframePool, _descriptor: ResolvedIframeEmbeddedEditor, frameLayer: HTMLElement, _frameRoot: HTMLElement, _scriptNonce: string | undefined, _themeCss: string | (() => string) | undefined);
+    bind(editor: VirtualizedIframeEmbeddedEditor): void;
+    unbind(): void;
+    layout(editor: VirtualizedIframeEmbeddedEditor): void;
+    dispose(): void;
+    private _setup;
+    private _getThemeCss;
+    private _postTheme;
+}
+declare class PhysicalIframePool implements IDisposable {
+    private readonly _frameLayer;
+    private readonly _frameRoot;
+    private readonly _scriptNonce;
+    private readonly _themeCss;
+    readonly descriptor: ResolvedIframeEmbeddedEditor;
+    private readonly _frames;
+    constructor(descriptor: ResolvedIframeEmbeddedEditor, _frameLayer: HTMLElement, _frameRoot: HTMLElement, _scriptNonce: string | undefined, _themeCss: string | (() => string) | undefined);
+    get leasedFrames(): number;
+    get idleFrames(): number;
+    acquire(editor: VirtualizedIframeEmbeddedEditor): void;
+    release(editor: VirtualizedIframeEmbeddedEditor): void;
+    park(iframe: HTMLIFrameElement): void;
+    dispose(): void;
+    layout(): void;
+    private _createFrame;
+}
+export declare interface ResolvedIframeEmbeddedEditor {
+    readonly cacheKey?: string;
+    readonly html: string;
+    readonly contentType?: ContentType;
+    readonly initialHeight?: number;
+    readonly sandbox?: IframeSandboxOptions;
+}
+export declare type ResolvedIframeEmbeddedEditorSandbox = IframeSandboxOptions;
+export declare function selectCodeBlockEditorProvider<T extends CodeBlockEditorProviderDefinition>(providers: readonly T[], language: string): CodeBlockEditorProviderSelection<T> | undefined;
 declare class StringEdit {
     static readonly empty: StringEdit;
     static single(replacement: StringReplacement): StringEdit;
@@ -127,4 +229,87 @@ declare class StringReplacement {
     toString(): string;
 }
+declare class VirtualizedIframeEmbeddedEditor implements IEmbeddedCodeEditor {
+    private readonly _factory;
+    readonly provider: IframeEmbeddedEditorProvider;
+    readonly element: HTMLElement;
+    onEdit?: (edit: StringEdit) => void;
+    readonly estimateHeight: () => number;
+    frame: PhysicalIframe | undefined;
+    disposed: boolean;
+    visible: boolean;
+    readonly language: string;
+    private readonly _frameHost;
+    private _content;
+    private _readOnly;
+    private _pool;
+    private _resolved;
+    constructor(_factory: VirtualizedIframeEmbeddedEditorFactory, provider: IframeEmbeddedEditorProvider, language: string, initialContent: string, initialHeight: number, generation: number);
+    setContent(content: string): void;
+    setReadOnly(readOnly: boolean): void;
+    setVisible(visible: boolean): void;
+    resolve(pool: PhysicalIframePool | undefined): void;
+    invalidate(): void;
+    bindFrame(frame: PhysicalIframe): void;
+    unbindFrame(height: number): void;
+    applyGuestText(text: string): void;
+    applyHeight(height: number): void;
+    observeLayout(observer: ResizeObserver): void;
+    hasFocus(): boolean;
+    get content(): string;
+    get readOnly(): boolean;
+    get frameHost(): HTMLElement;
+    dispose(): void;
+    private _renderFallback;
+}
+export declare interface VirtualizedIframeEmbeddedEditorDiagnostics {
+    readonly logicalEditors: number;
+    readonly leasedFrames: number;
+    readonly idleFrames: number;
+    readonly descriptorCacheEntries: number;
+    readonly descriptorCacheHits: number;
+}
+export declare class VirtualizedIframeEmbeddedEditorFactory implements IEmbeddedCodeEditorFactory, IDisposable {
+    private readonly _options;
+    private readonly _frameLayer;
+    private _frameRoot;
+    private _restoreFrameRootPosition;
+    private _layoutObserver;
+    private _layoutFrame;
+    private readonly _observer;
+    private readonly _logicalEditors;
+    private readonly _pools;
+    private readonly _descriptorCache;
+    private readonly _rejectedProviders;
+    private _providers;
+    private _generation;
+    private _descriptorCacheHits;
+    private _disposed;
+    constructor(_options: VirtualizedIframeEmbeddedEditorOptions);
+    updateProviders(providers: readonly IframeEmbeddedEditorProvider[]): void;
+    get diagnostics(): VirtualizedIframeEmbeddedEditorDiagnostics;
+    create(language: string, initialContent: string): IEmbeddedCodeEditor | undefined;
+    dispose(): void;
+    remove(editor: VirtualizedIframeEmbeddedEditor): void;
+    resolve(editor: VirtualizedIframeEmbeddedEditor, generation: number): Promise<void>;
+    private _rejectEditor;
+    private _ensureFrameRoot;
+    private _setFrameRoot;
+    private readonly _scheduleLayout;
+    private _disposePools;
+}
+export declare interface VirtualizedIframeEmbeddedEditorOptions {
+    readonly providers: readonly IframeEmbeddedEditorProvider[];
+    readonly root?: Element | Document | null;
+    readonly frameRoot?: HTMLElement;
+    readonly scriptNonce?: string;
+    readonly themeCss?: string | (() => string);
+    readonly defaultHeight?: number;
+    readonly onAmbiguous?: (language: string, providers: readonly CodeBlockEditorProviderDefinition[]) => void;
+    readonly onDidChange?: () => void;
+}
 export { }