@codingame/monaco-vscode-katex-common 29.1.1 → 30.0.0

package/vscode/src/vs/workbench/contrib/notebook/common/model/notebookMetadataTextModel.js

@@ -0,0 +1,90 @@
+
+import { toFormattedString } from '@codingame/monaco-vscode-api/vscode/vs/base/common/jsonFormatter';
+import { NotebookMetadataUri, NotebookCellsChangeType } from '@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon';
+import { StringSHA1 } from '@codingame/monaco-vscode-api/vscode/vs/base/common/hash';
+import { Disposable } from '@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle';
+import { DefaultEndOfLine, EndOfLinePreference } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model';
+import { Emitter } from '@codingame/monaco-vscode-api/vscode/vs/base/common/event';
+import { Range } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/core/range';
+import { createTextBuffer } from '@codingame/monaco-vscode-api/vscode/vs/editor/common/model/textModel';
+
+function getFormattedNotebookMetadataJSON(transientMetadata, metadata) {
+    let filteredMetadata = {};
+    if (transientMetadata) {
+        const keys = ( new Set([...( Object.keys(metadata))]));
+        for (const key of keys) {
+            if (!(transientMetadata[key])) {
+                filteredMetadata[key] = metadata[key];
+            }
+        }
+    } else {
+        filteredMetadata = metadata;
+    }
+    const metadataSource = toFormattedString(filteredMetadata, {});
+    return metadataSource;
+}
+class NotebookDocumentMetadataTextModel extends Disposable {
+    get metadata() {
+        return this.notebookModel.metadata;
+    }
+    get textBuffer() {
+        if (this._textBuffer) {
+            return this._textBuffer;
+        }
+        const source = getFormattedNotebookMetadataJSON(
+            this.notebookModel.transientOptions.transientDocumentMetadata,
+            this.metadata
+        );
+        this._textBuffer = this._register(createTextBuffer(source, DefaultEndOfLine.LF).textBuffer);
+        this._register(this._textBuffer.onDidChangeContent(() => {
+            this._onDidChange.fire();
+        }));
+        return this._textBuffer;
+    }
+    constructor(notebookModel) {
+        super();
+        this.notebookModel = notebookModel;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._textBufferHash = null;
+        this.uri = NotebookMetadataUri.generate(this.notebookModel.uri);
+        this._register(this.notebookModel.onDidChangeContent(e => {
+            if (( e.rawEvents.some(
+                event => event.kind === NotebookCellsChangeType.ChangeDocumentMetadata || event.kind === NotebookCellsChangeType.ModelChange
+            ))) {
+                this._textBuffer?.dispose();
+                this._textBuffer = undefined;
+                this._textBufferHash = null;
+                this._onDidChange.fire();
+            }
+        }));
+    }
+    getHash() {
+        if (this._textBufferHash !== null) {
+            return this._textBufferHash;
+        }
+        const shaComputer = ( new StringSHA1());
+        const snapshot = this.textBuffer.createSnapshot(false);
+        let text;
+        while ((text = snapshot.read())) {
+            shaComputer.update(text);
+        }
+        this._textBufferHash = shaComputer.digest();
+        return this._textBufferHash;
+    }
+    getValue() {
+        const fullRange = this.getFullModelRange();
+        const eol = this.textBuffer.getEOL();
+        if (eol === "\n") {
+            return this.textBuffer.getValueInRange(fullRange, EndOfLinePreference.LF);
+        } else {
+            return this.textBuffer.getValueInRange(fullRange, EndOfLinePreference.CRLF);
+        }
+    }
+    getFullModelRange() {
+        const lineCount = this.textBuffer.getLineCount();
+        return ( new Range(1, 1, lineCount, this.textBuffer.getLineLength(lineCount) + 1));
+    }
+}
+
+export { NotebookDocumentMetadataTextModel, getFormattedNotebookMetadataJSON };

package/vscode/src/vs/workbench/contrib/notebook/common/notebookDiff.d.ts

@@ -0,0 +1,26 @@
+import { CellKind, INotebookDiffResult } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/notebook/common/notebookCommon";
+export type CellDiffInfo = {
+    originalCellIndex: number;
+    modifiedCellIndex: number;
+    type: "unchanged" | "modified";
+} | {
+    originalCellIndex: number;
+    type: "delete";
+} | {
+    modifiedCellIndex: number;
+    type: "insert";
+};
+interface ICell {
+    cellKind: CellKind;
+    getHashValue(): number;
+    equal(cell: ICell): boolean;
+}
+export declare function computeDiff(originalModel: {
+    readonly cells: readonly ICell[];
+}, modifiedModel: {
+    readonly cells: readonly ICell[];
+}, diffResult: INotebookDiffResult): {
+    cellDiffInfo: CellDiffInfo[];
+    firstChangeIndex: number;
+};
+export {};

package/vscode/src/vs/workbench/contrib/notebook/common/notebookDiff.js

@@ -0,0 +1,92 @@
+
+
+function computeDiff(originalModel, modifiedModel, diffResult) {
+    const cellChanges = diffResult.cellsDiff.changes;
+    const cellDiffInfo = [];
+    let originalCellIndex = 0;
+    let modifiedCellIndex = 0;
+    let firstChangeIndex = -1;
+    for (let i = 0; i < cellChanges.length; i++) {
+        const change = cellChanges[i];
+        for (let j = 0; j < change.originalStart - originalCellIndex; j++) {
+            const originalCell = originalModel.cells[originalCellIndex + j];
+            const modifiedCell = modifiedModel.cells[modifiedCellIndex + j];
+            if (originalCell.getHashValue() === modifiedCell.getHashValue()) {
+                cellDiffInfo.push({
+                    originalCellIndex: originalCellIndex + j,
+                    modifiedCellIndex: modifiedCellIndex + j,
+                    type: 'unchanged'
+                });
+            }
+            else {
+                if (firstChangeIndex === -1) {
+                    firstChangeIndex = cellDiffInfo.length;
+                }
+                cellDiffInfo.push({
+                    originalCellIndex: originalCellIndex + j,
+                    modifiedCellIndex: modifiedCellIndex + j,
+                    type: 'modified'
+                });
+            }
+        }
+        const modifiedLCS = computeModifiedLCS(change, originalModel, modifiedModel);
+        if (modifiedLCS.length && firstChangeIndex === -1) {
+            firstChangeIndex = cellDiffInfo.length;
+        }
+        cellDiffInfo.push(...modifiedLCS);
+        originalCellIndex = change.originalStart + change.originalLength;
+        modifiedCellIndex = change.modifiedStart + change.modifiedLength;
+    }
+    for (let i = originalCellIndex; i < originalModel.cells.length; i++) {
+        cellDiffInfo.push({
+            originalCellIndex: i,
+            modifiedCellIndex: i - originalCellIndex + modifiedCellIndex,
+            type: 'unchanged'
+        });
+    }
+    return {
+        cellDiffInfo,
+        firstChangeIndex
+    };
+}
+function computeModifiedLCS(change, originalModel, modifiedModel) {
+    const result = [];
+    const modifiedLen = Math.min(change.originalLength, change.modifiedLength);
+    for (let j = 0; j < modifiedLen; j++) {
+        const originalCell = originalModel.cells[change.originalStart + j];
+        const modifiedCell = modifiedModel.cells[change.modifiedStart + j];
+        if (originalCell.cellKind !== modifiedCell.cellKind) {
+            result.push({
+                originalCellIndex: change.originalStart + j,
+                type: 'delete'
+            });
+            result.push({
+                modifiedCellIndex: change.modifiedStart + j,
+                type: 'insert'
+            });
+        }
+        else {
+            const isTheSame = originalCell.equal(modifiedCell);
+            result.push({
+                originalCellIndex: change.originalStart + j,
+                modifiedCellIndex: change.modifiedStart + j,
+                type: isTheSame ? 'unchanged' : 'modified'
+            });
+        }
+    }
+    for (let j = modifiedLen; j < change.originalLength; j++) {
+        result.push({
+            originalCellIndex: change.originalStart + j,
+            type: 'delete'
+        });
+    }
+    for (let j = modifiedLen; j < change.modifiedLength; j++) {
+        result.push({
+            modifiedCellIndex: change.modifiedStart + j,
+            type: 'insert'
+        });
+    }
+    return result;
+}
+
+export { computeDiff };

package/vscode/src/vs/workbench/contrib/replNotebook/browser/replEditor.js

@@ -243,7 +243,7 @@ let ReplEditor = class ReplEditor extends EditorPane {
             ...editorOptions,
             ...editorOptionsOverride,
             ...{
-                ariaLabel: ( localize(12127, "REPL Input")),
+                ariaLabel: ( localize(12192, "REPL Input")),
                 glyphMargin: true,
                 padding: {
                     top: INPUT_EDITOR_PADDING,

package/vscode/src/vs/workbench/contrib/replNotebook/browser/replEditorInput.js

@@ -23,7 +23,7 @@ import { IWorkbenchEnvironmentService } from '@codingame/monaco-vscode-api/vscod
 import { IPathService } from '@codingame/monaco-vscode-api/vscode/vs/workbench/services/path/common/pathService.service';
 
 var ReplEditorInput_1;
-const replTabIcon = registerIcon("repl-editor-label-icon", Codicon.debugLineByLine, ( localize(12141, "Icon of the REPL editor label.")));
+const replTabIcon = registerIcon("repl-editor-label-icon", Codicon.debugLineByLine, ( localize(12206, "Icon of the REPL editor label.")));
 let ReplEditorInput = class ReplEditorInput extends NotebookEditorInput {
     static {
         ReplEditorInput_1 = this;

package/vscode/src/vs/workbench/contrib/chat/browser/chatSessions/chatSessions.contribution.d.ts

@@ -1,152 +0,0 @@
-import { CancellationToken } from "@codingame/monaco-vscode-api/vscode/vs/base/common/cancellation";
-import { Event } from "@codingame/monaco-vscode-api/vscode/vs/base/common/event";
-import { Disposable, IDisposable } from "@codingame/monaco-vscode-api/vscode/vs/base/common/lifecycle";
-import { URI } from "@codingame/monaco-vscode-api/vscode/vs/base/common/uri";
-import { IMenuService } from "@codingame/monaco-vscode-api/vscode/vs/platform/actions/common/actions.service";
-import { IContextKeyService } from "@codingame/monaco-vscode-api/vscode/vs/platform/contextkey/common/contextkey.service";
-import { ILabelService } from "@codingame/monaco-vscode-api/vscode/vs/platform/label/common/label.service";
-import { ILogService } from "@codingame/monaco-vscode-api/vscode/vs/platform/log/common/log.service";
-import { IThemeService } from "@codingame/monaco-vscode-api/vscode/vs/platform/theme/common/themeService.service";
-import { IExtensionService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/services/extensions/common/extensions.service";
-import { IChatAgentAttachmentCapabilities } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents";
-import { IChatAgentService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/participants/chatAgents.service";
-import { IChatNewSessionRequest, IChatSession, IChatSessionContentProvider, IChatSessionItem, IChatSessionItemController, IChatSessionItemsDelta, IChatSessionOptionsChangeEvent, IChatSessionProviderOptionGroup, IChatSessionProviderOptionItem, IChatSessionRequestHistoryItem, IChatSessionsExtensionPoint, ReadonlyChatSessionOptionsMap, ResolvedChatSessionsExtensionPoint } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService";
-import { IChatSessionsService } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/chatSessionsService.service";
-import { IChatModel } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/model/chatModel";
-import { Target } from "@codingame/monaco-vscode-api/vscode/vs/workbench/contrib/chat/common/promptSyntax/promptTypes";
-export declare class ChatSessionsService extends Disposable implements IChatSessionsService {
-    private readonly _logService;
-    private readonly _chatAgentService;
-    private readonly _extensionService;
-    private readonly _contextKeyService;
-    private readonly _menuService;
-    private readonly _themeService;
-    private readonly _labelService;
-    readonly _serviceBrand: undefined;
-    private readonly _itemControllers;
-    private readonly _contributions;
-    private readonly _contributionDisposables;
-    private readonly _contentProviders;
-    private readonly _alternativeIdMap;
-    private readonly _contextKeys;
-    private readonly _onDidChangeItemsProviders;
-    readonly onDidChangeItemsProviders: Event<{
-        readonly chatSessionType: string;
-    }>;
-    private readonly _onDidChangeSessionItems;
-    readonly onDidChangeSessionItems: Event<IChatSessionItemsDelta>;
-    private readonly _onDidChangeAvailability;
-    readonly onDidChangeAvailability: Event<void>;
-    private readonly _onDidChangeInProgress;
-    get onDidChangeInProgress(): Event<void>;
-    private readonly _onDidChangeContentProviderSchemes;
-    get onDidChangeContentProviderSchemes(): Event<{
-        readonly added: string[];
-        readonly removed: string[];
-    }>;
-    private readonly _onDidChangeSessionOptions;
-    get onDidChangeSessionOptions(): Event<IChatSessionOptionsChangeEvent>;
-    private readonly _onDidChangeOptionGroups;
-    get onDidChangeOptionGroups(): Event<string>;
-    private readonly inProgressMap;
-    private readonly _sessionTypeOptions;
-    private readonly _sessionTypeNewSessionOptions;
-    private readonly _sessions;
-    private readonly _resourceAliases;
-    private readonly _hasCanDelegateProvidersKey;
-    constructor(_logService: ILogService, _chatAgentService: IChatAgentService, _extensionService: IExtensionService, _contextKeyService: IContextKeyService, _menuService: IMenuService, _themeService: IThemeService, _labelService: ILabelService);
-    private reportInProgress;
-    getInProgress(): {
-        chatSessionType: string;
-        count: number;
-    }[];
-    private updateInProgressStatus;
-    private registerContribution;
-    private _isContributionAvailable;
-    /**
-     * Resolves a session type to its primary type, checking for alternative IDs.
-     * @param sessionType The session type or alternative ID to resolve
-     * @returns The primary session type, or undefined if not found or not available
-     */
-    private _resolveToPrimaryType;
-    private _registerMenuItems;
-    private _registerCommands;
-    private _evaluateAvailability;
-    private _enableContribution;
-    /**
-     * Disposes of all sessions that belong to a contribution
-     *
-     * @returns List of session resources that were disposed.
-     */
-    private _disposeSessionsForContribution;
-    private _registerAgent;
-    getAllChatSessionContributions(): ResolvedChatSessionsExtensionPoint[];
-    private _updateHasCanDelegateProvidersContextKey;
-    getChatSessionContribution(chatSessionType: string): ResolvedChatSessionsExtensionPoint | undefined;
-    private resolveChatSessionContribution;
-    private getContributionIcon;
-    private resolveIconForCurrentColorTheme;
-    registerChatSessionContribution(contribution: IChatSessionsExtensionPoint): IDisposable;
-    activateChatSessionItemProvider(chatViewType: string): Promise<void>;
-    private doActivateChatSessionItemController;
-    canResolveChatSession(sessionType: string): Promise<boolean>;
-    private tryActivateControllers;
-    getChatSessionItems(providersToResolve: readonly string[] | undefined, token: CancellationToken): AsyncIterable<{
-        readonly chatSessionType: string;
-        readonly items: readonly IChatSessionItem[];
-    }>;
-    refreshChatSessionItems(providersToResolve: readonly string[] | undefined, token: CancellationToken): Promise<void>;
-    getRegisteredChatSessionItemProviders(): readonly string[];
-    registerChatSessionItemController(chatSessionType: string, controller: IChatSessionItemController): IDisposable;
-    registerChatSessionContentProvider(chatSessionType: string, provider: IChatSessionContentProvider): IDisposable;
-    getInProgressSessionDescription(chatModel: IChatModel): string | undefined;
-    createNewChatSessionItem(chatSessionType: string, request: IChatNewSessionRequest, token: CancellationToken): Promise<IChatSessionItem | undefined>;
-    getOrCreateChatSession(sessionResource: URI, token: CancellationToken): Promise<IChatSession>;
-    hasAnySessionOptions(sessionResource: URI): boolean;
-    getSessionOptions(sessionResource: URI): Map<string, string> | undefined;
-    getSessionOption(sessionResource: URI, optionId: string): string | IChatSessionProviderOptionItem | undefined;
-    setSessionOption(sessionResource: URI, optionId: string, value: string | IChatSessionProviderOptionItem): boolean;
-    updateSessionOptions(sessionResource: URI, updates: ReadonlyChatSessionOptionsMap): boolean;
-    /**
-     * Resolve a resource through the alias map. If the resource is a real
-     * resource that has been aliased to an untitled resource, return the
-     * untitled resource (the canonical key in {@link _sessions}).
-     */
-    private _resolveResource;
-    registerSessionResourceAlias(untitledResource: URI, realResource: URI): void;
-    /**
-     * Store option groups for a session type
-     */
-    setOptionGroupsForSessionType(chatSessionType: string, handle: number, optionGroups?: IChatSessionProviderOptionGroup[]): void;
-    /**
-     * Get available option groups for a session type
-     */
-    getOptionGroupsForSessionType(chatSessionType: string): IChatSessionProviderOptionGroup[] | undefined;
-    getNewSessionOptionsForSessionType(chatSessionType: string): ReadonlyChatSessionOptionsMap | undefined;
-    setNewSessionOptionsForSessionType(chatSessionType: string, options: ReadonlyChatSessionOptionsMap): void;
-    /**
-     * Get the capabilities for a specific session type
-     */
-    getCapabilitiesForSessionType(chatSessionType: string): IChatAgentAttachmentCapabilities | undefined;
-    /**
-     * Get the customAgentTarget for a specific session type.
-     * When set, the mode picker should show filtered custom agents matching this target.
-     */
-    getCustomAgentTargetForSessionType(chatSessionType: string): Target;
-    requiresCustomModelsForSessionType(chatSessionType: string): boolean;
-    supportsDelegationForSessionType(chatSessionType: string): boolean;
-    sessionSupportsFork(sessionResource: URI): boolean;
-    forkChatSession(sessionResource: URI, request: IChatSessionRequestHistoryItem | undefined, token: CancellationToken): Promise<IChatSessionItem>;
-    getContentProviderSchemes(): string[];
-}
-export declare enum ChatSessionPosition {
-    Editor = "editor",
-    Sidebar = "sidebar"
-}
-export type NewChatSessionOpenOptions = {
-    readonly type: string;
-    readonly position: ChatSessionPosition;
-    readonly displayName: string;
-    readonly replaceEditor?: boolean;
-};
-export declare function getResourceForNewChatSession(options: NewChatSessionOpenOptions): URI;