Support wasm target

[oovm]

References

• https://jupyterlite.readthedocs.io/en/latest/howto/extensions/kernel.html
• List of available JupyterLite kernels? jupyterlite/jupyterlite#968

Examples

• https://github.com/jupyterlite/demo
• https://github.com/jupyterlite/echo-kernel

[oovm]

Need build following class from wasm

import {JupyterLiteServer, JupyterLiteServerPlugin} from '@jupyterlite/server';
import {IKernel, BaseKernel, IKernelSpecs} from '@jupyterlite/kernel';
import {KernelMessage} from '@jupyterlab/services';

export class EchoKernel extends BaseKernel {
    async kernelInfoRequest(): Promise<KernelMessage.IInfoReplyMsg['content']> {
        const content: KernelMessage.IInfoReply = {
            implementation: 'Text',
            implementation_version: '0.1.0',
            language_info: {
                codemirror_mode: {
                    name: 'text/plain'
                },
                file_extension: '.txt',
                mimetype: 'text/plain',
                name: 'echo',
                nbconvert_exporter: 'text',
                pygments_lexer: 'text',
                version: 'es2017'
            },
            protocol_version: '5.3',
            status: 'ok',
            banner: 'My kernel running in the browser',
            help_links: [
                {
                    text: 'My Kernel',
                    url: 'https://github.com/jupyterlite/my-kernel'
                }
            ]
        };
        return content;
    }

    /**
     * Handle an `execute_request` message
     *
     * @param msg The parent message.
     */
    async executeRequest(
        content: KernelMessage.IExecuteRequestMsg['content']
    ): Promise<KernelMessage.IExecuteReplyMsg['content']> {
        const {code} = content;

        this.publishExecuteResult({
            execution_count: this.executionCount,
            data: {
                'text/plain': code
            },
            metadata: {}
        });

        return {
            status: 'ok',
            execution_count: this.executionCount,
            user_expressions: {}
        };
    }

    /**
     * Handle an complete_request message
     *
     * @param msg The parent message.
     */
    async completeRequest(
        content: KernelMessage.ICompleteRequestMsg['content']
    ): Promise<KernelMessage.ICompleteReplyMsg['content']> {
        throw new Error('Not implemented');
    }

    /**
     * Handle an `inspect_request` message.
     *
     * @param content - The content of the request.
     *
     * @returns A promise that resolves with the response message.
     */
    async inspectRequest(
        content: KernelMessage.IInspectRequestMsg['content']
    ): Promise<KernelMessage.IInspectReplyMsg['content']> {
        throw new Error('Not implemented');
    }

    /**
     * Handle an `is_complete_request` message.
     *
     * @param content - The content of the request.
     *
     * @returns A promise that resolves with the response message.
     */
    async isCompleteRequest(
        content: KernelMessage.IIsCompleteRequestMsg['content']
    ): Promise<KernelMessage.IIsCompleteReplyMsg['content']> {
        throw new Error('Not implemented');
    }

    /**
     * Handle a `comm_info_request` message.
     *
     * @param content - The content of the request.
     *
     * @returns A promise that resolves with the response message.
     */
    async commInfoRequest(
        content: KernelMessage.ICommInfoRequestMsg['content']
    ): Promise<KernelMessage.ICommInfoReplyMsg['content']> {
        throw new Error('Not implemented');
    }

    /**
     * Send an `input_reply` message.
     *
     * @param content - The content of the reply.
     */
    inputReply(content: KernelMessage.IInputReplyMsg['content']): void {
        throw new Error('Not implemented');
    }

    /**
     * Send an `comm_open` message.
     *
     * @param msg - The comm_open message.
     */
    async commOpen(msg: KernelMessage.ICommOpenMsg): Promise<void> {
        throw new Error('Not implemented');
    }

    /**
     * Send an `comm_msg` message.
     *
     * @param msg - The comm_msg message.
     */
    async commMsg(msg: KernelMessage.ICommMsgMsg): Promise<void> {
        throw new Error('Not implemented');
    }

    /**
     * Send an `comm_close` message.
     *
     * @param close - The comm_close message.
     */
    async commClose(msg: KernelMessage.ICommCloseMsg): Promise<void> {
        throw new Error('Not implemented');
    }
}

export const kernel: JupyterLiteServerPlugin<void> = {
    id: '@jupyterlite/my-kernel:kernel',
    autoStart: true,
    requires: [IKernelSpecs],
    activate: (app: JupyterLiteServer, kernelspecs: IKernelSpecs) => {
        kernelspecs.register({
            spec: {
                name: 'echo',
                display_name: 'Echo',
                language: 'text',
                argv: [],
                resources: {
                    'logo-32x32': '',
                    'logo-64x64': ''
                }
            },
            create: async (options: IKernel.IOptions): Promise<IKernel> => {
                return new EchoKernel(options);
            }
        });
    }
};


const plugins: JupyterLiteServerPlugin<any>[] = [kernel];

export default plugins;

[oovm]

Rust seems unable to export a subtype.

rustwasm/wasm-bindgen#1721