open-collaboration-monaco/lib/monaco-api.js

Connect a single Monaco Editor to an Open Collaboration Tools session

// ******************************************************************************
// Copyright 2024 TypeFox GmbH
// This program and the accompanying materials are made available under the
// terms of the MIT License, which is available in the project root.
// ******************************************************************************
import { ConnectionProvider, SocketIoTransportProvider } from 'open-collaboration-protocol';
import * as types from 'open-collaboration-protocol';
import { createRoom, joinRoom, login } from './collaboration-connection.js';
let connectionProvider;
let instance;
types.initializeProtocol({
    cryptoModule: globalThis.crypto
});
export function monacoCollab(options) {
    connectionProvider = new ConnectionProvider({
        url: options.serverUrl,
        authenticationHandler: options.loginPageOpener ?? (async (_token, metaData) => {
            // If this returns null, it means the window could not be opened and the authentication failed
            return window.open(metaData.loginPageUrl, '_blank') !== null;
        }),
        transports: [SocketIoTransportProvider],
        userToken: options.userToken,
        useCookieAuth: options.useCookieAuth,
        fetch: async (url, options) => {
            const response = await fetch(url, options);
            return {
                ok: response.ok,
                status: response.status,
                json: async () => response.json(),
                text: async () => response.text()
            };
        }
    });
    const doCreateRoom = async () => {
        console.log('Creating room');
        if (!connectionProvider) {
            console.log('No OCT Server configured.');
            throw new Error('No OCT Server configured.');
        }
        instance = await createRoom(connectionProvider, options.callbacks);
        if (instance) {
            return instance.roomId;
        }
        throw new Error('Failed to create room');
    };
    const doJoinRoom = async (roomToken) => {
        console.log('Joining room', roomToken);
        if (!connectionProvider) {
            console.log('No OCT Server configured.');
            throw new Error('No OCT Server configured.');
        }
        const res = await joinRoom(connectionProvider, options.callbacks, roomToken);
        if (res && 'message' in res) {
            console.log('Failed to join room:', res.message);
            throw new Error('Failed to join room:' + res.message);
        }
        else {
            instance = res;
            return instance.roomId;
        }
    };
    const doLogin = async () => {
        if (!connectionProvider) {
            console.log('No OCT Server configured.');
            throw new Error('No OCT Server configured.');
        }
        await login(connectionProvider);
        return connectionProvider.authToken;
    };
    const doSetEditor = (editor) => {
        if (instance) {
            instance.setEditor(editor);
        }
    };
    const doGetUserData = async () => {
        let data;
        if (instance) {
            const me = await instance.ownUserData;
            const others = instance.connectedUsers.map(user => ({
                peer: user.peer,
                color: user.color ?? 'rgba(0, 0, 0, 0.5)'
            }));
            data = { me, others };
        }
        return data;
    };
    const registerUserChangeHandler = (evt) => {
        if (instance) {
            instance.onUsersChanged(evt);
        }
    };
    const doFollowUser = (id) => {
        if (instance) {
            instance.followUser(id);
        }
    };
    const doGetFollowedUser = () => {
        if (instance) {
            return instance.following;
        }
        return undefined;
    };
    const doSetFileName = (fileName) => {
        if (instance) {
            instance.setFileName(fileName);
        }
    };
    const doGetWorkspaceName = () => {
        if (instance) {
            return instance.workspaceName;
        }
        return undefined;
    };
    const doGetFileName = () => {
        if (instance) {
            return instance.fileName;
        }
        return undefined;
    };
    const registerFileNameChangeHandler = (callback) => {
        if (instance) {
            instance.onFileNameChange(callback);
        }
    };
    const doSetWorkspaceName = (workspaceName) => {
        if (instance) {
            instance.workspaceName = workspaceName;
        }
    };
    const isLoggedIn = async () => {
        if (!connectionProvider) {
            return false;
        }
        if (options.useCookieAuth) {
            const valid = await fetch(options.serverUrl + '/api/login/validate', {
                credentials: 'include',
                method: 'POST',
            });
            return valid.ok && (await valid.json())?.valid;
        }
        else {
            return !!connectionProvider.authToken;
        }
    };
    return {
        createRoom: doCreateRoom,
        joinRoom: doJoinRoom,
        leaveRoom: () => instance?.leaveRoom(),
        login: doLogin,
        logout: async () => connectionProvider?.logout(),
        isLoggedIn: isLoggedIn,
        setEditor: doSetEditor,
        getUserData: doGetUserData,
        onUsersChanged: registerUserChangeHandler,
        onFileNameChange: registerFileNameChangeHandler,
        followUser: doFollowUser,
        getFollowedUser: doGetFollowedUser,
        getCurrentConnection: () => instance?.getCurrentConnection(),
        setFileName: doSetFileName,
        getFileName: doGetFileName,
        getWorkspaceName: doGetWorkspaceName,
        setWorkspaceName: doSetWorkspaceName
    };
}
export function deactivate() {
    instance?.dispose();
}
//# sourceMappingURL=monaco-api.js.map