@tutorialkit-rb/runtime 1.5.2-rb.0.1.0

package/dist/webcontainer/terminal-config.js

@@ -0,0 +1,230 @@
+export class TerminalConfig {
+    _config;
+    constructor(config) {
+        const normalized = normalizeTerminalConfig(config);
+        this._config = normalized;
+    }
+    get panels() {
+        return this._config.panels;
+    }
+    get activePanel() {
+        return this._config.activePanel;
+    }
+    get defaultOpen() {
+        return this._config.defaultOpen;
+    }
+}
+const TERMINAL_PANEL_TITLES = {
+    output: 'Output',
+    terminal: 'Terminal',
+};
+let globalId = 0;
+/**
+ * This class contains the state for a terminal panel. This is a panel which is attached to a process and renders
+ * the process output to a screen.
+ */
+export class TerminalPanel {
+    type;
+    _options;
+    static panelCount = {
+        output: 0,
+        terminal: 0,
+    };
+    static resetCount() {
+        this.panelCount = {
+            output: 0,
+            terminal: 0,
+        };
+    }
+    id;
+    title;
+    _terminal;
+    _process;
+    _data = [];
+    _onData;
+    constructor(type, _options) {
+        this.type = type;
+        this._options = _options;
+        let title = _options?.title;
+        // automatically infer a title if no title is provided
+        if (!title) {
+            title = TERMINAL_PANEL_TITLES[type];
+            // we keep track of all untitled panel and add an index to the title
+            const count = TerminalPanel.panelCount[type];
+            if (count > 0) {
+                title += ` ${count}`;
+            }
+            TerminalPanel.panelCount[type]++;
+        }
+        this.title = title;
+        this.id = _options?.id ?? (type === 'output' ? 'output' : `${type}-${globalId++}`);
+    }
+    get terminal() {
+        return this._terminal;
+    }
+    get process() {
+        return this._process;
+    }
+    get processOptions() {
+        if (this.type === 'output') {
+            return undefined;
+        }
+        return {
+            allowRedirects: this._options?.allowRedirects ?? false,
+            allowCommands: this._options?.allowCommands,
+        };
+    }
+    // #region ITerminal methods
+    get cols() {
+        // we fallback to a default
+        return this._terminal?.cols;
+    }
+    get rows() {
+        return this._terminal?.rows;
+    }
+    reset() {
+        if (this._terminal) {
+            this._terminal.reset();
+        }
+        else {
+            this._data = [];
+        }
+    }
+    /** @internal*/
+    write(data) {
+        if (this._terminal) {
+            this._terminal.write(data);
+        }
+        else {
+            this._data.push({ data, type: 'echo' });
+        }
+    }
+    input(data) {
+        if (this.type !== 'terminal') {
+            throw new Error('Cannot write data to output-only terminal');
+        }
+        if (this._terminal) {
+            this._terminal.input(data);
+        }
+        else {
+            this._data.push({ data, type: 'input' });
+        }
+    }
+    onData(callback) {
+        if (this._terminal) {
+            this._terminal.onData(callback);
+        }
+        else {
+            this._onData = callback;
+        }
+    }
+    // #endregion
+    /**
+     * Attach a WebContainer process to this panel.
+     *
+     * @param process The WebContainer process
+     */
+    attachProcess(process) {
+        this._process = process;
+        if (this.cols != null && this.rows != null) {
+            this._process.resize({ cols: this.cols, rows: this.rows });
+        }
+    }
+    /**
+     * Attach a terminal to this panel.
+     *
+     * @param terminal The terminal.
+     */
+    attachTerminal(terminal) {
+        for (const { type, data } of this._data) {
+            if (type === 'echo') {
+                terminal.write(data);
+            }
+            else {
+                terminal.input(data);
+            }
+        }
+        this._data = [];
+        this._terminal = terminal;
+        if (this._onData) {
+            terminal.onData(this._onData);
+        }
+        if (this.cols != null && this.rows != null) {
+            this._process?.resize({ cols: this.cols, rows: this.rows });
+        }
+    }
+}
+/**
+ * Normalize the provided configuration to a configuration which is easier to parse.
+ *
+ * @param config The terminal configuration.
+ * @returns A normalized terminal configuration.
+ */
+function normalizeTerminalConfig(config) {
+    let activePanel = 0;
+    if (config === false) {
+        // if the value is `false`, we don't render anything
+        return {
+            panels: [],
+            activePanel,
+            defaultOpen: false,
+        };
+    }
+    // reset the count so that the auto-infered titles are indexed properly
+    TerminalPanel.resetCount();
+    // if no config is set, or the value is `true`, we just render the output panel
+    if (config === undefined || config === true) {
+        return {
+            panels: [new TerminalPanel('output')],
+            activePanel,
+            defaultOpen: false,
+        };
+    }
+    const panels = [];
+    const options = {
+        allowRedirects: config.allowRedirects,
+        allowCommands: config.allowCommands,
+    };
+    if (config.panels) {
+        if (config.panels === 'output') {
+            panels.push(new TerminalPanel('output'));
+        }
+        else if (config.panels === 'terminal') {
+            panels.push(new TerminalPanel('terminal', options));
+        }
+        else if (Array.isArray(config.panels)) {
+            for (const panel of config.panels) {
+                let terminalPanel;
+                if (typeof panel === 'string') {
+                    terminalPanel = new TerminalPanel(panel, options);
+                }
+                else if (Array.isArray(panel)) {
+                    terminalPanel = new TerminalPanel(panel[0], {
+                        title: panel[1],
+                        ...options,
+                    });
+                }
+                else {
+                    terminalPanel = new TerminalPanel(panel.type, {
+                        id: panel.id,
+                        title: panel.title,
+                        allowRedirects: panel.allowRedirects ?? config.allowRedirects,
+                        allowCommands: panel.allowCommands ?? config.allowCommands,
+                    });
+                }
+                panels.push(terminalPanel);
+            }
+        }
+    }
+    if (typeof config.activePanel === 'number') {
+        activePanel = config.activePanel;
+        if (activePanel >= panels.length) {
+            activePanel = 0;
+        }
+    }
+    return {
+        activePanel,
+        panels,
+        defaultOpen: config.open || false,
+    };
+}

package/dist/webcontainer/utils/files.d.ts

@@ -0,0 +1,10 @@
+import type { Files } from '@tutorialkit-rb/types';
+import type { FileSystemTree } from '@webcontainer/api';
+export declare function areFilesEqual(a: Files, b: Files): boolean;
+interface FilesDiff {
+    addedOrModified: Files;
+    removed: string[];
+}
+export declare function diffFiles(before: Files, after: Files): FilesDiff;
+export declare function toFileTree(files: Files): FileSystemTree;
+export {};

package/dist/webcontainer/utils/files.js

@@ -0,0 +1,76 @@
+export function areFilesEqual(a, b) {
+    const aFilePaths = Object.keys(a);
+    const bFilePaths = Object.keys(b);
+    if (aFilePaths.length !== bFilePaths.length) {
+        return false;
+    }
+    aFilePaths.sort();
+    bFilePaths.sort();
+    for (let i = 0; i < aFilePaths.length; ++i) {
+        const filePath = aFilePaths[i];
+        if (bFilePaths[i] !== filePath) {
+            return false;
+        }
+        if (a[filePath] !== b[filePath]) {
+            return false;
+        }
+    }
+    return true;
+}
+export function diffFiles(before, after) {
+    const addedOrModified = {};
+    const removed = [];
+    for (const filePath in before) {
+        const beforeFile = before[filePath];
+        const afterFile = after[filePath];
+        if (typeof afterFile == 'undefined') {
+            removed.push(filePath);
+        }
+        else if (beforeFile !== afterFile) {
+            addedOrModified[filePath] = afterFile;
+        }
+    }
+    for (const filePath in after) {
+        if (!(filePath in before)) {
+            addedOrModified[filePath] = after[filePath];
+        }
+    }
+    return {
+        addedOrModified,
+        removed,
+    };
+}
+export function toFileTree(files) {
+    const root = {};
+    for (const filePath in files) {
+        const segments = filePath.split('/').filter((segment) => segment);
+        let currentTree = root;
+        for (let i = 0; i < segments.length; ++i) {
+            const name = segments[i];
+            if (i === segments.length - 1) {
+                currentTree[name] = {
+                    file: {
+                        contents: files[filePath],
+                    },
+                };
+            }
+            else {
+                let folder = currentTree[name];
+                assertDirectoryNode(folder);
+                if (!folder) {
+                    folder = {
+                        directory: {},
+                    };
+                    currentTree[name] = folder;
+                }
+                currentTree = folder.directory;
+            }
+        }
+    }
+    return root;
+}
+function assertDirectoryNode(node) {
+    if (node && !('directory' in node)) {
+        throw new Error('Expected directory node');
+    }
+}

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@tutorialkit-rb/runtime",
+  "version": "1.5.2-rb.0.1.0",
+  "description": "TutorialKit runtime",
+  "author": "StackBlitz Inc.",
+  "type": "module",
+  "bugs": "https://github.com/stackblitz/tutorialkit/issues",
+  "homepage": "https://github.com/stackblitz/tutorialkit",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Bakaface/tutorialkit.rb",
+    "directory": "packages/runtime"
+  },
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./tasks": "./dist/tasks.js"
+  },
+  "files": [
+    "dist"
+  ],
+  "typesVersions": {
+    "*": {
+      "tasks": [
+        "dist/tasks.d.ts"
+      ]
+    }
+  },
+  "scripts": {
+    "build": "tsc -b tsconfig.build.json",
+    "dev": "pnpm run build --watch --preserveWatchOutput",
+    "test": "vitest"
+  },
+  "dependencies": {
+    "@tutorialkit-rb/types": "1.5.2",
+    "@webcontainer/api": "1.5.1",
+    "nanostores": "^0.10.3",
+    "picomatch": "^4.0.2"
+  },
+  "devDependencies": {
+    "@types/picomatch": "^3.0.1",
+    "typescript": "^5.4.5",
+    "vite": "^5.3.1",
+    "vite-tsconfig-paths": "^4.3.2",
+    "vitest": "^3.0.5"
+  },
+  "keywords": [
+    "ruby",
+    "rails",
+    "wasm"
+  ]
+}