@codingame/monaco-vscode-api 1.79.0 → 1.79.1

package/dist/vscode/vs/workbench/contrib/interactiveSession/common/interactiveSessionContextKeys.js

@@ -45,4 +45,12 @@ const CONTEXT_IN_INTERACTIVE_SESSION = ( new RawContextKey(
   "True when focus is in the interactive session widget, false otherwise."
  )) }
 ));
-export { CONTEXT_INTERACTIVE_INPUT_HAS_TEXT, CONTEXT_INTERACTIVE_REQUEST_IN_PROGRESS, CONTEXT_IN_INTERACTIVE_INPUT, CONTEXT_IN_INTERACTIVE_SESSION, CONTEXT_RESPONSE_HAS_PROVIDER_ID, CONTEXT_RESPONSE_VOTE };
+const CONTEXT_PROVIDER_EXISTS = ( new RawContextKey(
+ 'hasInteractiveSessionProvider',
+ false,
+ { type: 'boolean', description: ( localize(
+  'hasInteractiveSessionProvider',
+  "True when some interactive session provider has been registered."
+ )) }
+));
+export { CONTEXT_INTERACTIVE_INPUT_HAS_TEXT, CONTEXT_INTERACTIVE_REQUEST_IN_PROGRESS, CONTEXT_IN_INTERACTIVE_INPUT, CONTEXT_IN_INTERACTIVE_SESSION, CONTEXT_PROVIDER_EXISTS, CONTEXT_RESPONSE_HAS_PROVIDER_ID, CONTEXT_RESPONSE_VOTE };

package/dist/vscode/vs/workbench/contrib/interactiveSession/common/interactiveSessionModel.js

@@ -0,0 +1,305 @@
+import { __decorate, __param } from '../../../../../../node_modules/tslib/tslib.es6.js';
+import { DeferredPromise } from 'monaco-editor/esm/vs/base/common/async.js';
+import { Emitter } from 'monaco-editor/esm/vs/base/common/event.js';
+import { MarkdownString } from 'monaco-editor/esm/vs/base/common/htmlContent.js';
+import { Disposable } from 'monaco-editor/esm/vs/base/common/lifecycle.js';
+import { URI } from 'monaco-editor/esm/vs/base/common/uri.js';
+import { generateUuid } from 'monaco-editor/esm/vs/base/common/uuid.js';
+import { ILogService } from 'monaco-editor/esm/vs/platform/log/common/log.js';
+class InteractiveRequestModel {
+    get id() {
+        return this._id;
+    }
+    get username() {
+        return this._session.requesterUsername;
+    }
+    get avatarIconUri() {
+        return this._session.requesterAvatarIconUri;
+    }
+    constructor(_session, message) {
+        this._session = _session;
+        this.message = message;
+        this._id = 'request_' + InteractiveRequestModel.nextId++;
+    }
+}
+InteractiveRequestModel.nextId = 0;
+class InteractiveResponseModel extends Disposable {
+    get id() {
+        return this._id;
+    }
+    get providerResponseId() {
+        return this._providerResponseId;
+    }
+    get isComplete() {
+        return this._isComplete;
+    }
+    get isCanceled() {
+        return this._isCanceled;
+    }
+    get vote() {
+        return this._vote;
+    }
+    get followups() {
+        return this._followups;
+    }
+    get response() {
+        return this._response;
+    }
+    get errorDetails() {
+        return this._errorDetails;
+    }
+    get providerId() {
+        return this._session.providerId;
+    }
+    get username() {
+        return this._session.responderUsername;
+    }
+    get avatarIconUri() {
+        return this._session.responderAvatarIconUri;
+    }
+    constructor(_response, _session, _isComplete = false, _isCanceled = false, _vote, _providerResponseId, _errorDetails, _followups) {
+        super();
+        this._response = _response;
+        this._session = _session;
+        this._isComplete = _isComplete;
+        this._isCanceled = _isCanceled;
+        this._vote = _vote;
+        this._providerResponseId = _providerResponseId;
+        this._errorDetails = _errorDetails;
+        this._followups = _followups;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._id = 'response_' + InteractiveResponseModel.nextId++;
+    }
+    updateContent(responsePart) {
+        this._response = ( new MarkdownString(this.response.value + responsePart));
+        this._onDidChange.fire();
+    }
+    setProviderResponseId(providerResponseId) {
+        this._providerResponseId = providerResponseId;
+    }
+    complete(errorDetails) {
+        this._isComplete = true;
+        this._errorDetails = errorDetails;
+        this._onDidChange.fire();
+    }
+    cancel() {
+        this._isComplete = true;
+        this._isCanceled = true;
+        this._onDidChange.fire();
+    }
+    setFollowups(followups) {
+        this._followups = followups;
+        this._onDidChange.fire();
+    }
+    setVote(vote) {
+        this._vote = vote;
+        this._onDidChange.fire();
+    }
+}
+InteractiveResponseModel.nextId = 0;
+let InteractiveSessionModel = class InteractiveSessionModel extends Disposable {
+    get session() {
+        return this._session;
+    }
+    get welcomeMessage() {
+        return this._welcomeMessage;
+    }
+    get providerState() {
+        return this._providerState;
+    }
+    get sessionId() {
+        return this._sessionId;
+    }
+    get inputPlaceholder() {
+        return this._session?.inputPlaceholder;
+    }
+    get requestInProgress() {
+        const lastRequest = this._requests[this._requests.length - 1];
+        return !!lastRequest && !!lastRequest.response && !lastRequest.response.isComplete;
+    }
+    get creationDate() {
+        return this._creationDate;
+    }
+    get requesterUsername() {
+        return this._session?.requesterUsername ?? this.initialData?.requesterUsername ?? '';
+    }
+    get responderUsername() {
+        return this._session?.responderUsername ?? this.initialData?.responderUsername ?? '';
+    }
+    get requesterAvatarIconUri() {
+        return this._session?.requesterAvatarIconUri ?? this._initialRequesterAvatarIconUri;
+    }
+    get responderAvatarIconUri() {
+        return this._session?.responderAvatarIconUri ?? this._initialResponderAvatarIconUri;
+    }
+    constructor(providerId, initialData, logService) {
+        super();
+        this.providerId = providerId;
+        this.initialData = initialData;
+        this.logService = logService;
+        this._onDidDispose = this._register(( new Emitter()));
+        this.onDidDispose = this._onDidDispose.event;
+        this._onDidChange = this._register(( new Emitter()));
+        this.onDidChange = this._onDidChange.event;
+        this._isInitializedDeferred = ( new DeferredPromise());
+        this._sessionId = initialData ? initialData.sessionId : generateUuid();
+        this._requests = initialData ? this._deserialize(initialData) : [];
+        this._providerState = initialData ? initialData.providerState : undefined;
+        this._creationDate = initialData?.creationDate ?? Date.now();
+        this._initialRequesterAvatarIconUri = initialData?.requesterAvatarIconUri && URI.revive(initialData.requesterAvatarIconUri);
+        this._initialResponderAvatarIconUri = initialData?.responderAvatarIconUri && URI.revive(initialData.responderAvatarIconUri);
+    }
+    _deserialize(obj) {
+        const requests = obj.requests;
+        if (!Array.isArray(requests)) {
+            this.logService.error(`Ignoring malformed session data: ${obj}`);
+            return [];
+        }
+        if (obj.welcomeMessage) {
+            const content = ( obj.welcomeMessage.map(item => typeof item === 'string' ? ( new MarkdownString(item)) : item));
+            this._welcomeMessage = ( new InteractiveSessionWelcomeMessageModel(
+                content,
+                obj.responderUsername,
+                obj.responderAvatarIconUri && URI.revive(obj.responderAvatarIconUri)
+            ));
+        }
+        return ( requests.map((raw) => {
+            const request = ( new InteractiveRequestModel(this, raw.message));
+            if (raw.response || raw.responseErrorDetails) {
+                request.response = ( new InteractiveResponseModel(( new MarkdownString(raw.response)), this, true, raw.isCanceled, raw.vote, raw.providerResponseId, raw.responseErrorDetails, raw.followups));
+            }
+            return request;
+        }));
+    }
+    initialize(session, welcomeMessage) {
+        if (this._session) {
+            throw new Error('InteractiveSessionModel is already initialized');
+        }
+        this._session = session;
+        if (!this._welcomeMessage) {
+            this._welcomeMessage = welcomeMessage;
+        }
+        this._isInitializedDeferred.complete();
+        if (session.onDidChangeState) {
+            this._register(session.onDidChangeState(state => {
+                this._providerState = state;
+                this.logService.trace('InteractiveSessionModel#acceptNewSessionState');
+            }));
+        }
+        this._onDidChange.fire({ kind: 'initialize' });
+    }
+    waitForInitialization() {
+        return this._isInitializedDeferred.p;
+    }
+    getRequests() {
+        return this._requests;
+    }
+    addRequest(message) {
+        if (!this._session) {
+            throw new Error('addRequest: No session');
+        }
+        const request = ( new InteractiveRequestModel(this, message));
+        request.response = ( new InteractiveResponseModel(( new MarkdownString('')), this));
+        this._requests.push(request);
+        this._onDidChange.fire({ kind: 'addRequest', request });
+        return request;
+    }
+    acceptResponseProgress(request, progress) {
+        if (!this._session) {
+            throw new Error('acceptResponseProgress: No session');
+        }
+        if (!request.response) {
+            request.response = ( new InteractiveResponseModel(( new MarkdownString('')), this));
+        }
+        if (request.response.isComplete) {
+            throw new Error('acceptResponseProgress: Adding progress to a completed response');
+        }
+        if ('content' in progress) {
+            request.response.updateContent(progress.content);
+        }
+        else {
+            request.response.setProviderResponseId(progress.responseId);
+        }
+    }
+    cancelRequest(request) {
+        if (request.response) {
+            request.response.cancel();
+        }
+    }
+    completeResponse(request, rawResponse) {
+        if (!this._session) {
+            throw new Error('completeResponse: No session');
+        }
+        if (!request.response) {
+            request.response = ( new InteractiveResponseModel(( new MarkdownString('')), this));
+        }
+        request.response.complete(rawResponse.errorDetails);
+    }
+    setFollowups(request, followups) {
+        if (!request.response) {
+            return;
+        }
+        request.response.setFollowups(followups);
+    }
+    setResponse(request, response) {
+        request.response = response;
+        this._onDidChange.fire({ kind: 'addResponse', response });
+    }
+    toJSON() {
+        return {
+            sessionId: this.sessionId,
+            creationDate: this._creationDate,
+            requesterUsername: this._session.requesterUsername,
+            requesterAvatarIconUri: this._session.requesterAvatarIconUri,
+            responderUsername: this._session.responderUsername,
+            responderAvatarIconUri: this._session.responderAvatarIconUri,
+            welcomeMessage: this._welcomeMessage?.content.map(c => {
+                if (Array.isArray(c)) {
+                    return c;
+                }
+                else {
+                    return c.value;
+                }
+            }),
+            requests: ( this._requests.map((r) => {
+                return {
+                    providerResponseId: r.response?.providerResponseId,
+                    message: typeof r.message === 'string' ? r.message : r.message.message,
+                    response: r.response ? r.response.response.value : undefined,
+                    responseErrorDetails: r.response?.errorDetails,
+                    followups: r.response?.followups,
+                    isCanceled: r.response?.isCanceled,
+                    vote: r.response?.vote
+                };
+            })),
+            providerId: this.providerId,
+            providerState: this._providerState
+        };
+    }
+    dispose() {
+        this._session?.dispose?.();
+        this._requests.forEach(r => r.response?.dispose());
+        this._onDidDispose.fire();
+        if (!this._isInitializedDeferred.isSettled) {
+            this._isInitializedDeferred.error(( new Error('model disposed before initialization')));
+        }
+        super.dispose();
+    }
+};
+InteractiveSessionModel = ( __decorate([
+    ( __param(2, ILogService))
+], InteractiveSessionModel));
+class InteractiveSessionWelcomeMessageModel {
+    get id() {
+        return this._id;
+    }
+    constructor(content, username, avatarIconUri) {
+        this.content = content;
+        this.username = username;
+        this.avatarIconUri = avatarIconUri;
+        this._id = 'welcome_' + InteractiveSessionWelcomeMessageModel.nextId++;
+    }
+}
+InteractiveSessionWelcomeMessageModel.nextId = 0;
+export { InteractiveRequestModel, InteractiveResponseModel, InteractiveSessionModel, InteractiveSessionWelcomeMessageModel };

package/dist/vscode/vs/workbench/contrib/interactiveSession/common/interactiveSessionService.js

@@ -4,5 +4,10 @@ var InteractiveSessionVoteDirection;
     InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Up"] = 1] = "Up";
     InteractiveSessionVoteDirection[InteractiveSessionVoteDirection["Down"] = 2] = "Down";
 })(InteractiveSessionVoteDirection || (InteractiveSessionVoteDirection = {})));
+var InteractiveSessionCopyKind;
+( (function(InteractiveSessionCopyKind) {
+    InteractiveSessionCopyKind[InteractiveSessionCopyKind["Action"] = 1] = "Action";
+    InteractiveSessionCopyKind[InteractiveSessionCopyKind["Toolbar"] = 2] = "Toolbar";
+})(InteractiveSessionCopyKind || (InteractiveSessionCopyKind = {})));
 const IInteractiveSessionService = ( createDecorator('IInteractiveSessionService'));
-export { IInteractiveSessionService, InteractiveSessionVoteDirection };
+export { IInteractiveSessionService, InteractiveSessionCopyKind, InteractiveSessionVoteDirection };