elphadeal-terminal 1.0.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/README.md +77 -0
- package/dist/cli.js +117 -0
- package/dist/index.js +90 -0
- package/dist/main.wasm +0 -0
- package/dist/wasm_exec.js +575 -0
- package/package.json +24 -0
package/README.md
ADDED
|
@@ -0,0 +1,77 @@
|
|
|
1
|
+
# Elphadeal Terminal
|
|
2
|
+
|
|
3
|
+
A custom terminal design powered by Go WebAssembly, packaged as an npm module.
|
|
4
|
+
|
|
5
|
+
## Installation
|
|
6
|
+
|
|
7
|
+
```bash
|
|
8
|
+
npm install -g elphadeal-terminal
|
|
9
|
+
```
|
|
10
|
+
|
|
11
|
+
## Usage
|
|
12
|
+
|
|
13
|
+
### As a command-line tool
|
|
14
|
+
|
|
15
|
+
Run the interactive terminal:
|
|
16
|
+
|
|
17
|
+
```bash
|
|
18
|
+
elphadeal-terminal
|
|
19
|
+
```
|
|
20
|
+
|
|
21
|
+
Or using npx:
|
|
22
|
+
|
|
23
|
+
```bash
|
|
24
|
+
npx elphadeal-terminal
|
|
25
|
+
```
|
|
26
|
+
|
|
27
|
+
### In browser
|
|
28
|
+
|
|
29
|
+
Include the necessary files in your HTML:
|
|
30
|
+
|
|
31
|
+
```html
|
|
32
|
+
<!DOCTYPE html>
|
|
33
|
+
<html>
|
|
34
|
+
<head>
|
|
35
|
+
<title>Elphadeal Terminal</title>
|
|
36
|
+
<script src="node_modules/elphadeal-terminal/dist/wasm_exec.js"></script>
|
|
37
|
+
<script src="node_modules/elphadeal-terminal/dist/index.js"></script>
|
|
38
|
+
</head>
|
|
39
|
+
<body>
|
|
40
|
+
<div id="terminal-container"></div>
|
|
41
|
+
|
|
42
|
+
<script>
|
|
43
|
+
const terminal = new GoWasmTerminal('terminal-container');
|
|
44
|
+
</script>
|
|
45
|
+
</body>
|
|
46
|
+
</html>
|
|
47
|
+
```
|
|
48
|
+
|
|
49
|
+
## Commands
|
|
50
|
+
|
|
51
|
+
- `hello`: Prints a greeting from Go WASM
|
|
52
|
+
- `clear`: Clears the terminal
|
|
53
|
+
- `exit`: Exits the terminal
|
|
54
|
+
- Any other command: Executes as a shell command
|
|
55
|
+
|
|
56
|
+
## Supported Shells
|
|
57
|
+
|
|
58
|
+
- Bash
|
|
59
|
+
- Zsh
|
|
60
|
+
- Cmd (Windows)
|
|
61
|
+
- PowerShell
|
|
62
|
+
|
|
63
|
+
## Building
|
|
64
|
+
|
|
65
|
+
To build the package:
|
|
66
|
+
|
|
67
|
+
```bash
|
|
68
|
+
npm run build
|
|
69
|
+
```
|
|
70
|
+
|
|
71
|
+
## Publishing
|
|
72
|
+
|
|
73
|
+
To publish to npm:
|
|
74
|
+
|
|
75
|
+
```bash
|
|
76
|
+
npm publish
|
|
77
|
+
```
|
package/dist/cli.js
ADDED
|
@@ -0,0 +1,117 @@
|
|
|
1
|
+
#!/usr/bin/env node
|
|
2
|
+
|
|
3
|
+
const fs = require('fs');
|
|
4
|
+
const path = require('path');
|
|
5
|
+
const readline = require('readline');
|
|
6
|
+
const { exec } = require('child_process');
|
|
7
|
+
|
|
8
|
+
// Load wasm_exec.js
|
|
9
|
+
require('./wasm_exec.js');
|
|
10
|
+
|
|
11
|
+
const rl = readline.createInterface({
|
|
12
|
+
input: process.stdin,
|
|
13
|
+
output: process.stdout,
|
|
14
|
+
prompt: '> '
|
|
15
|
+
});
|
|
16
|
+
|
|
17
|
+
let goInstance;
|
|
18
|
+
|
|
19
|
+
function displayError(command, error, stderr) {
|
|
20
|
+
console.log('\x1b[31m╔══════════════════════════════════════╗\x1b[0m');
|
|
21
|
+
console.log('\x1b[31m║ ❌ ERROR ║\x1b[0m');
|
|
22
|
+
console.log('\x1b[31m╚══════════════════════════════════════╝\x1b[0m');
|
|
23
|
+
console.log(`\x1b[31mCommand: ${command}\x1b[0m`);
|
|
24
|
+
if (error.code) {
|
|
25
|
+
console.log(`\x1b[31mExit Code: ${error.code}\x1b[0m`);
|
|
26
|
+
}
|
|
27
|
+
if (error.signal) {
|
|
28
|
+
console.log(`\x1b[31mSignal: ${error.signal}\x1b[0m`);
|
|
29
|
+
}
|
|
30
|
+
console.log(`\x1b[31mMessage: ${error.message}\x1b[0m`);
|
|
31
|
+
if (stderr) {
|
|
32
|
+
console.log(`\x1b[33mStderr: ${stderr}\x1b[0m`);
|
|
33
|
+
}
|
|
34
|
+
console.log('\x1b[31m════════════════════════════════════════\x1b[0m');
|
|
35
|
+
}
|
|
36
|
+
|
|
37
|
+
function displaySuccess(command, stdout) {
|
|
38
|
+
console.log(`\x1b[32m✅ Command executed successfully: ${command}\x1b[0m`);
|
|
39
|
+
if (stdout) {
|
|
40
|
+
console.log(stdout);
|
|
41
|
+
}
|
|
42
|
+
}
|
|
43
|
+
|
|
44
|
+
function displayWarning(stderr) {
|
|
45
|
+
console.log('\x1b[33m╔══════════════════════════════════════╗\x1b[0m');
|
|
46
|
+
console.log('\x1b[33m║ ⚠️ WARNING ║\x1b[0m');
|
|
47
|
+
console.log('\x1b[33m╚══════════════════════════════════════╝\x1b[0m');
|
|
48
|
+
console.log(`\x1b[33m${stderr}\x1b[0m`);
|
|
49
|
+
console.log('\x1b[33m════════════════════════════════════════\x1b[0m');
|
|
50
|
+
}
|
|
51
|
+
|
|
52
|
+
async function init() {
|
|
53
|
+
const go = new Go();
|
|
54
|
+
const wasmPath = path.join(__dirname, 'main.wasm');
|
|
55
|
+
const wasmBuffer = fs.readFileSync(wasmPath);
|
|
56
|
+
const result = await WebAssembly.instantiate(wasmBuffer, go.importObject);
|
|
57
|
+
go.run(result.instance);
|
|
58
|
+
goInstance = go;
|
|
59
|
+
|
|
60
|
+
// Define functions for WASM
|
|
61
|
+
global.addToTerminal = (text) => {
|
|
62
|
+
process.stdout.write(text);
|
|
63
|
+
};
|
|
64
|
+
|
|
65
|
+
global.clearTerminal = () => {
|
|
66
|
+
console.clear();
|
|
67
|
+
console.log('\x1b[36m╔══════════════════════════════════════╗\x1b[0m');
|
|
68
|
+
console.log('\x1b[36m║ Elphadeal Terminal ║\x1b[0m');
|
|
69
|
+
console.log('\x1b[36m║ Powered by Go WebAssembly ║\x1b[0m');
|
|
70
|
+
console.log('\x1b[36m╚══════════════════════════════════════╝\x1b[0m');
|
|
71
|
+
rl.prompt();
|
|
72
|
+
};
|
|
73
|
+
|
|
74
|
+
console.log('\x1b[36m╔══════════════════════════════════════╗\x1b[0m');
|
|
75
|
+
console.log('\x1b[36m║ Elphadeal Terminal ║\x1b[0m');
|
|
76
|
+
console.log('\x1b[36m║ Powered by Go WebAssembly ║\x1b[0m');
|
|
77
|
+
console.log('\x1b[36m╚══════════════════════════════════════╝\x1b[0m');
|
|
78
|
+
rl.setPrompt('\x1b[32m>\x1b[0m ');
|
|
79
|
+
rl.prompt();
|
|
80
|
+
|
|
81
|
+
// Set up event listener after init
|
|
82
|
+
rl.on('line', (line) => {
|
|
83
|
+
const command = line.trim();
|
|
84
|
+
if (command === 'exit') {
|
|
85
|
+
console.log('\x1b[35m👋 Exiting terminal...\x1b[0m');
|
|
86
|
+
rl.close();
|
|
87
|
+
} else if (command === 'clear') {
|
|
88
|
+
console.log('\x1b[36m🧹 Clearing terminal...\x1b[0m');
|
|
89
|
+
global.clearTerminal();
|
|
90
|
+
} else if (command === 'hello') {
|
|
91
|
+
console.log('\x1b[36m🔹 Executing Go WASM command: hello\x1b[0m');
|
|
92
|
+
globalThis.printToTerminal("Hello from Go WASM!");
|
|
93
|
+
rl.prompt();
|
|
94
|
+
} else {
|
|
95
|
+
// For other commands, try to execute them
|
|
96
|
+
console.log(`\x1b[34mExecuting: ${command}\x1b[0m`);
|
|
97
|
+
exec(command, (error, stdout, stderr) => {
|
|
98
|
+
if (error) {
|
|
99
|
+
displayError(command, error, stderr);
|
|
100
|
+
} else if (stderr) {
|
|
101
|
+
displayWarning(stderr);
|
|
102
|
+
displaySuccess(command, stdout);
|
|
103
|
+
} else {
|
|
104
|
+
displaySuccess(command, stdout);
|
|
105
|
+
}
|
|
106
|
+
rl.prompt();
|
|
107
|
+
});
|
|
108
|
+
return; // Don't prompt again here
|
|
109
|
+
}
|
|
110
|
+
rl.prompt();
|
|
111
|
+
}).on('close', () => {
|
|
112
|
+
console.log('\x1b[31mGoodbye!\x1b[0m');
|
|
113
|
+
process.exit(0);
|
|
114
|
+
});
|
|
115
|
+
}
|
|
116
|
+
|
|
117
|
+
init().catch(console.error);
|
package/dist/index.js
ADDED
|
@@ -0,0 +1,90 @@
|
|
|
1
|
+
class GoWasmTerminal {
|
|
2
|
+
constructor(containerId) {
|
|
3
|
+
this.container = document.getElementById(containerId);
|
|
4
|
+
this.terminal = null;
|
|
5
|
+
this.input = null;
|
|
6
|
+
this.init();
|
|
7
|
+
}
|
|
8
|
+
|
|
9
|
+
async init() {
|
|
10
|
+
// Create terminal UI
|
|
11
|
+
this.createUI();
|
|
12
|
+
|
|
13
|
+
// Load and run WASM
|
|
14
|
+
const go = new Go();
|
|
15
|
+
const result = await WebAssembly.instantiateStreaming(fetch("main.wasm"), go.importObject);
|
|
16
|
+
go.run(result.instance);
|
|
17
|
+
|
|
18
|
+
// Set up event listeners
|
|
19
|
+
this.setupEvents();
|
|
20
|
+
}
|
|
21
|
+
|
|
22
|
+
createUI() {
|
|
23
|
+
this.terminal = document.createElement('div');
|
|
24
|
+
this.terminal.id = 'terminal';
|
|
25
|
+
this.terminal.style.cssText = `
|
|
26
|
+
background-color: #000;
|
|
27
|
+
color: #0f0;
|
|
28
|
+
font-family: 'Courier New', monospace;
|
|
29
|
+
border: 1px solid #0f0;
|
|
30
|
+
padding: 10px;
|
|
31
|
+
height: 400px;
|
|
32
|
+
overflow-y: auto;
|
|
33
|
+
white-space: pre-wrap;
|
|
34
|
+
`;
|
|
35
|
+
this.terminal.textContent = 'Welcome to the custom terminal powered by Go WASM!\n> ';
|
|
36
|
+
|
|
37
|
+
this.input = document.createElement('input');
|
|
38
|
+
this.input.type = 'text';
|
|
39
|
+
this.input.id = 'input';
|
|
40
|
+
this.input.placeholder = 'Type a command...';
|
|
41
|
+
this.input.style.cssText = `
|
|
42
|
+
background-color: #000;
|
|
43
|
+
color: #0f0;
|
|
44
|
+
border: 1px solid #0f0;
|
|
45
|
+
width: 100%;
|
|
46
|
+
font-family: 'Courier New', monospace;
|
|
47
|
+
outline: none;
|
|
48
|
+
`;
|
|
49
|
+
|
|
50
|
+
this.container.appendChild(this.terminal);
|
|
51
|
+
this.container.appendChild(this.input);
|
|
52
|
+
}
|
|
53
|
+
|
|
54
|
+
setupEvents() {
|
|
55
|
+
this.input.addEventListener('keydown', (event) => {
|
|
56
|
+
if (event.key === 'Enter') {
|
|
57
|
+
const command = this.input.value;
|
|
58
|
+
this.addToTerminal(command + '\n');
|
|
59
|
+
if (command === 'clear') {
|
|
60
|
+
this.clearTerminal();
|
|
61
|
+
} else if (command === 'hello') {
|
|
62
|
+
globalThis.printToTerminal("Hello from Go WASM!");
|
|
63
|
+
} else {
|
|
64
|
+
this.addToTerminal('Unknown command: ' + command + '\n');
|
|
65
|
+
}
|
|
66
|
+
this.addToTerminal('> ');
|
|
67
|
+
this.input.value = '';
|
|
68
|
+
}
|
|
69
|
+
});
|
|
70
|
+
}
|
|
71
|
+
|
|
72
|
+
addToTerminal(text) {
|
|
73
|
+
this.terminal.textContent += text;
|
|
74
|
+
this.terminal.scrollTop = this.terminal.scrollHeight;
|
|
75
|
+
}
|
|
76
|
+
|
|
77
|
+
clearTerminal() {
|
|
78
|
+
this.terminal.textContent = '> ';
|
|
79
|
+
}
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
// For browser usage
|
|
83
|
+
if (typeof window !== 'undefined') {
|
|
84
|
+
window.GoWasmTerminal = GoWasmTerminal;
|
|
85
|
+
}
|
|
86
|
+
|
|
87
|
+
// For Node.js/module usage
|
|
88
|
+
if (typeof module !== 'undefined' && module.exports) {
|
|
89
|
+
module.exports = GoWasmTerminal;
|
|
90
|
+
}
|
package/dist/main.wasm
ADDED
|
Binary file
|
|
@@ -0,0 +1,575 @@
|
|
|
1
|
+
// Copyright 2018 The Go Authors. All rights reserved.
|
|
2
|
+
// Use of this source code is governed by a BSD-style
|
|
3
|
+
// license that can be found in the LICENSE file.
|
|
4
|
+
|
|
5
|
+
"use strict";
|
|
6
|
+
|
|
7
|
+
(() => {
|
|
8
|
+
const enosys = () => {
|
|
9
|
+
const err = new Error("not implemented");
|
|
10
|
+
err.code = "ENOSYS";
|
|
11
|
+
return err;
|
|
12
|
+
};
|
|
13
|
+
|
|
14
|
+
if (!globalThis.fs) {
|
|
15
|
+
let outputBuf = "";
|
|
16
|
+
globalThis.fs = {
|
|
17
|
+
constants: { O_WRONLY: -1, O_RDWR: -1, O_CREAT: -1, O_TRUNC: -1, O_APPEND: -1, O_EXCL: -1, O_DIRECTORY: -1 }, // unused
|
|
18
|
+
writeSync(fd, buf) {
|
|
19
|
+
outputBuf += decoder.decode(buf);
|
|
20
|
+
const nl = outputBuf.lastIndexOf("\n");
|
|
21
|
+
if (nl != -1) {
|
|
22
|
+
console.log(outputBuf.substring(0, nl));
|
|
23
|
+
outputBuf = outputBuf.substring(nl + 1);
|
|
24
|
+
}
|
|
25
|
+
return buf.length;
|
|
26
|
+
},
|
|
27
|
+
write(fd, buf, offset, length, position, callback) {
|
|
28
|
+
if (offset !== 0 || length !== buf.length || position !== null) {
|
|
29
|
+
callback(enosys());
|
|
30
|
+
return;
|
|
31
|
+
}
|
|
32
|
+
const n = this.writeSync(fd, buf);
|
|
33
|
+
callback(null, n);
|
|
34
|
+
},
|
|
35
|
+
chmod(path, mode, callback) { callback(enosys()); },
|
|
36
|
+
chown(path, uid, gid, callback) { callback(enosys()); },
|
|
37
|
+
close(fd, callback) { callback(enosys()); },
|
|
38
|
+
fchmod(fd, mode, callback) { callback(enosys()); },
|
|
39
|
+
fchown(fd, uid, gid, callback) { callback(enosys()); },
|
|
40
|
+
fstat(fd, callback) { callback(enosys()); },
|
|
41
|
+
fsync(fd, callback) { callback(null); },
|
|
42
|
+
ftruncate(fd, length, callback) { callback(enosys()); },
|
|
43
|
+
lchown(path, uid, gid, callback) { callback(enosys()); },
|
|
44
|
+
link(path, link, callback) { callback(enosys()); },
|
|
45
|
+
lstat(path, callback) { callback(enosys()); },
|
|
46
|
+
mkdir(path, perm, callback) { callback(enosys()); },
|
|
47
|
+
open(path, flags, mode, callback) { callback(enosys()); },
|
|
48
|
+
read(fd, buffer, offset, length, position, callback) { callback(enosys()); },
|
|
49
|
+
readdir(path, callback) { callback(enosys()); },
|
|
50
|
+
readlink(path, callback) { callback(enosys()); },
|
|
51
|
+
rename(from, to, callback) { callback(enosys()); },
|
|
52
|
+
rmdir(path, callback) { callback(enosys()); },
|
|
53
|
+
stat(path, callback) { callback(enosys()); },
|
|
54
|
+
symlink(path, link, callback) { callback(enosys()); },
|
|
55
|
+
truncate(path, length, callback) { callback(enosys()); },
|
|
56
|
+
unlink(path, callback) { callback(enosys()); },
|
|
57
|
+
utimes(path, atime, mtime, callback) { callback(enosys()); },
|
|
58
|
+
};
|
|
59
|
+
}
|
|
60
|
+
|
|
61
|
+
if (!globalThis.process) {
|
|
62
|
+
globalThis.process = {
|
|
63
|
+
getuid() { return -1; },
|
|
64
|
+
getgid() { return -1; },
|
|
65
|
+
geteuid() { return -1; },
|
|
66
|
+
getegid() { return -1; },
|
|
67
|
+
getgroups() { throw enosys(); },
|
|
68
|
+
pid: -1,
|
|
69
|
+
ppid: -1,
|
|
70
|
+
umask() { throw enosys(); },
|
|
71
|
+
cwd() { throw enosys(); },
|
|
72
|
+
chdir() { throw enosys(); },
|
|
73
|
+
}
|
|
74
|
+
}
|
|
75
|
+
|
|
76
|
+
if (!globalThis.path) {
|
|
77
|
+
globalThis.path = {
|
|
78
|
+
resolve(...pathSegments) {
|
|
79
|
+
return pathSegments.join("/");
|
|
80
|
+
}
|
|
81
|
+
}
|
|
82
|
+
}
|
|
83
|
+
|
|
84
|
+
if (!globalThis.crypto) {
|
|
85
|
+
throw new Error("globalThis.crypto is not available, polyfill required (crypto.getRandomValues only)");
|
|
86
|
+
}
|
|
87
|
+
|
|
88
|
+
if (!globalThis.performance) {
|
|
89
|
+
throw new Error("globalThis.performance is not available, polyfill required (performance.now only)");
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
if (!globalThis.TextEncoder) {
|
|
93
|
+
throw new Error("globalThis.TextEncoder is not available, polyfill required");
|
|
94
|
+
}
|
|
95
|
+
|
|
96
|
+
if (!globalThis.TextDecoder) {
|
|
97
|
+
throw new Error("globalThis.TextDecoder is not available, polyfill required");
|
|
98
|
+
}
|
|
99
|
+
|
|
100
|
+
const encoder = new TextEncoder("utf-8");
|
|
101
|
+
const decoder = new TextDecoder("utf-8");
|
|
102
|
+
|
|
103
|
+
globalThis.Go = class {
|
|
104
|
+
constructor() {
|
|
105
|
+
this.argv = ["js"];
|
|
106
|
+
this.env = {};
|
|
107
|
+
this.exit = (code) => {
|
|
108
|
+
if (code !== 0) {
|
|
109
|
+
console.warn("exit code:", code);
|
|
110
|
+
}
|
|
111
|
+
};
|
|
112
|
+
this._exitPromise = new Promise((resolve) => {
|
|
113
|
+
this._resolveExitPromise = resolve;
|
|
114
|
+
});
|
|
115
|
+
this._pendingEvent = null;
|
|
116
|
+
this._scheduledTimeouts = new Map();
|
|
117
|
+
this._nextCallbackTimeoutID = 1;
|
|
118
|
+
|
|
119
|
+
const setInt64 = (addr, v) => {
|
|
120
|
+
this.mem.setUint32(addr + 0, v, true);
|
|
121
|
+
this.mem.setUint32(addr + 4, Math.floor(v / 4294967296), true);
|
|
122
|
+
}
|
|
123
|
+
|
|
124
|
+
const setInt32 = (addr, v) => {
|
|
125
|
+
this.mem.setUint32(addr + 0, v, true);
|
|
126
|
+
}
|
|
127
|
+
|
|
128
|
+
const getInt64 = (addr) => {
|
|
129
|
+
const low = this.mem.getUint32(addr + 0, true);
|
|
130
|
+
const high = this.mem.getInt32(addr + 4, true);
|
|
131
|
+
return low + high * 4294967296;
|
|
132
|
+
}
|
|
133
|
+
|
|
134
|
+
const loadValue = (addr) => {
|
|
135
|
+
const f = this.mem.getFloat64(addr, true);
|
|
136
|
+
if (f === 0) {
|
|
137
|
+
return undefined;
|
|
138
|
+
}
|
|
139
|
+
if (!isNaN(f)) {
|
|
140
|
+
return f;
|
|
141
|
+
}
|
|
142
|
+
|
|
143
|
+
const id = this.mem.getUint32(addr, true);
|
|
144
|
+
return this._values[id];
|
|
145
|
+
}
|
|
146
|
+
|
|
147
|
+
const storeValue = (addr, v) => {
|
|
148
|
+
const nanHead = 0x7FF80000;
|
|
149
|
+
|
|
150
|
+
if (typeof v === "number" && v !== 0) {
|
|
151
|
+
if (isNaN(v)) {
|
|
152
|
+
this.mem.setUint32(addr + 4, nanHead, true);
|
|
153
|
+
this.mem.setUint32(addr, 0, true);
|
|
154
|
+
return;
|
|
155
|
+
}
|
|
156
|
+
this.mem.setFloat64(addr, v, true);
|
|
157
|
+
return;
|
|
158
|
+
}
|
|
159
|
+
|
|
160
|
+
if (v === undefined) {
|
|
161
|
+
this.mem.setFloat64(addr, 0, true);
|
|
162
|
+
return;
|
|
163
|
+
}
|
|
164
|
+
|
|
165
|
+
let id = this._ids.get(v);
|
|
166
|
+
if (id === undefined) {
|
|
167
|
+
id = this._idPool.pop();
|
|
168
|
+
if (id === undefined) {
|
|
169
|
+
id = this._values.length;
|
|
170
|
+
}
|
|
171
|
+
this._values[id] = v;
|
|
172
|
+
this._goRefCounts[id] = 0;
|
|
173
|
+
this._ids.set(v, id);
|
|
174
|
+
}
|
|
175
|
+
this._goRefCounts[id]++;
|
|
176
|
+
let typeFlag = 0;
|
|
177
|
+
switch (typeof v) {
|
|
178
|
+
case "object":
|
|
179
|
+
if (v !== null) {
|
|
180
|
+
typeFlag = 1;
|
|
181
|
+
}
|
|
182
|
+
break;
|
|
183
|
+
case "string":
|
|
184
|
+
typeFlag = 2;
|
|
185
|
+
break;
|
|
186
|
+
case "symbol":
|
|
187
|
+
typeFlag = 3;
|
|
188
|
+
break;
|
|
189
|
+
case "function":
|
|
190
|
+
typeFlag = 4;
|
|
191
|
+
break;
|
|
192
|
+
}
|
|
193
|
+
this.mem.setUint32(addr + 4, nanHead | typeFlag, true);
|
|
194
|
+
this.mem.setUint32(addr, id, true);
|
|
195
|
+
}
|
|
196
|
+
|
|
197
|
+
const loadSlice = (addr) => {
|
|
198
|
+
const array = getInt64(addr + 0);
|
|
199
|
+
const len = getInt64(addr + 8);
|
|
200
|
+
return new Uint8Array(this._inst.exports.mem.buffer, array, len);
|
|
201
|
+
}
|
|
202
|
+
|
|
203
|
+
const loadSliceOfValues = (addr) => {
|
|
204
|
+
const array = getInt64(addr + 0);
|
|
205
|
+
const len = getInt64(addr + 8);
|
|
206
|
+
const a = new Array(len);
|
|
207
|
+
for (let i = 0; i < len; i++) {
|
|
208
|
+
a[i] = loadValue(array + i * 8);
|
|
209
|
+
}
|
|
210
|
+
return a;
|
|
211
|
+
}
|
|
212
|
+
|
|
213
|
+
const loadString = (addr) => {
|
|
214
|
+
const saddr = getInt64(addr + 0);
|
|
215
|
+
const len = getInt64(addr + 8);
|
|
216
|
+
return decoder.decode(new DataView(this._inst.exports.mem.buffer, saddr, len));
|
|
217
|
+
}
|
|
218
|
+
|
|
219
|
+
const testCallExport = (a, b) => {
|
|
220
|
+
this._inst.exports.testExport0();
|
|
221
|
+
return this._inst.exports.testExport(a, b);
|
|
222
|
+
}
|
|
223
|
+
|
|
224
|
+
const timeOrigin = Date.now() - performance.now();
|
|
225
|
+
this.importObject = {
|
|
226
|
+
_gotest: {
|
|
227
|
+
add: (a, b) => a + b,
|
|
228
|
+
callExport: testCallExport,
|
|
229
|
+
},
|
|
230
|
+
gojs: {
|
|
231
|
+
// Go's SP does not change as long as no Go code is running. Some operations (e.g. calls, getters and setters)
|
|
232
|
+
// may synchronously trigger a Go event handler. This makes Go code get executed in the middle of the imported
|
|
233
|
+
// function. A goroutine can switch to a new stack if the current stack is too small (see morestack function).
|
|
234
|
+
// This changes the SP, thus we have to update the SP used by the imported function.
|
|
235
|
+
|
|
236
|
+
// func wasmExit(code int32)
|
|
237
|
+
"runtime.wasmExit": (sp) => {
|
|
238
|
+
sp >>>= 0;
|
|
239
|
+
const code = this.mem.getInt32(sp + 8, true);
|
|
240
|
+
this.exited = true;
|
|
241
|
+
delete this._inst;
|
|
242
|
+
delete this._values;
|
|
243
|
+
delete this._goRefCounts;
|
|
244
|
+
delete this._ids;
|
|
245
|
+
delete this._idPool;
|
|
246
|
+
this.exit(code);
|
|
247
|
+
},
|
|
248
|
+
|
|
249
|
+
// func wasmWrite(fd uintptr, p unsafe.Pointer, n int32)
|
|
250
|
+
"runtime.wasmWrite": (sp) => {
|
|
251
|
+
sp >>>= 0;
|
|
252
|
+
const fd = getInt64(sp + 8);
|
|
253
|
+
const p = getInt64(sp + 16);
|
|
254
|
+
const n = this.mem.getInt32(sp + 24, true);
|
|
255
|
+
fs.writeSync(fd, new Uint8Array(this._inst.exports.mem.buffer, p, n));
|
|
256
|
+
},
|
|
257
|
+
|
|
258
|
+
// func resetMemoryDataView()
|
|
259
|
+
"runtime.resetMemoryDataView": (sp) => {
|
|
260
|
+
sp >>>= 0;
|
|
261
|
+
this.mem = new DataView(this._inst.exports.mem.buffer);
|
|
262
|
+
},
|
|
263
|
+
|
|
264
|
+
// func nanotime1() int64
|
|
265
|
+
"runtime.nanotime1": (sp) => {
|
|
266
|
+
sp >>>= 0;
|
|
267
|
+
setInt64(sp + 8, (timeOrigin + performance.now()) * 1000000);
|
|
268
|
+
},
|
|
269
|
+
|
|
270
|
+
// func walltime() (sec int64, nsec int32)
|
|
271
|
+
"runtime.walltime": (sp) => {
|
|
272
|
+
sp >>>= 0;
|
|
273
|
+
const msec = (new Date).getTime();
|
|
274
|
+
setInt64(sp + 8, msec / 1000);
|
|
275
|
+
this.mem.setInt32(sp + 16, (msec % 1000) * 1000000, true);
|
|
276
|
+
},
|
|
277
|
+
|
|
278
|
+
// func scheduleTimeoutEvent(delay int64) int32
|
|
279
|
+
"runtime.scheduleTimeoutEvent": (sp) => {
|
|
280
|
+
sp >>>= 0;
|
|
281
|
+
const id = this._nextCallbackTimeoutID;
|
|
282
|
+
this._nextCallbackTimeoutID++;
|
|
283
|
+
this._scheduledTimeouts.set(id, setTimeout(
|
|
284
|
+
() => {
|
|
285
|
+
this._resume();
|
|
286
|
+
while (this._scheduledTimeouts.has(id)) {
|
|
287
|
+
// for some reason Go failed to register the timeout event, log and try again
|
|
288
|
+
// (temporary workaround for https://github.com/golang/go/issues/28975)
|
|
289
|
+
console.warn("scheduleTimeoutEvent: missed timeout event");
|
|
290
|
+
this._resume();
|
|
291
|
+
}
|
|
292
|
+
},
|
|
293
|
+
getInt64(sp + 8),
|
|
294
|
+
));
|
|
295
|
+
this.mem.setInt32(sp + 16, id, true);
|
|
296
|
+
},
|
|
297
|
+
|
|
298
|
+
// func clearTimeoutEvent(id int32)
|
|
299
|
+
"runtime.clearTimeoutEvent": (sp) => {
|
|
300
|
+
sp >>>= 0;
|
|
301
|
+
const id = this.mem.getInt32(sp + 8, true);
|
|
302
|
+
clearTimeout(this._scheduledTimeouts.get(id));
|
|
303
|
+
this._scheduledTimeouts.delete(id);
|
|
304
|
+
},
|
|
305
|
+
|
|
306
|
+
// func getRandomData(r []byte)
|
|
307
|
+
"runtime.getRandomData": (sp) => {
|
|
308
|
+
sp >>>= 0;
|
|
309
|
+
crypto.getRandomValues(loadSlice(sp + 8));
|
|
310
|
+
},
|
|
311
|
+
|
|
312
|
+
// func finalizeRef(v ref)
|
|
313
|
+
"syscall/js.finalizeRef": (sp) => {
|
|
314
|
+
sp >>>= 0;
|
|
315
|
+
const id = this.mem.getUint32(sp + 8, true);
|
|
316
|
+
this._goRefCounts[id]--;
|
|
317
|
+
if (this._goRefCounts[id] === 0) {
|
|
318
|
+
const v = this._values[id];
|
|
319
|
+
this._values[id] = null;
|
|
320
|
+
this._ids.delete(v);
|
|
321
|
+
this._idPool.push(id);
|
|
322
|
+
}
|
|
323
|
+
},
|
|
324
|
+
|
|
325
|
+
// func stringVal(value string) ref
|
|
326
|
+
"syscall/js.stringVal": (sp) => {
|
|
327
|
+
sp >>>= 0;
|
|
328
|
+
storeValue(sp + 24, loadString(sp + 8));
|
|
329
|
+
},
|
|
330
|
+
|
|
331
|
+
// func valueGet(v ref, p string) ref
|
|
332
|
+
"syscall/js.valueGet": (sp) => {
|
|
333
|
+
sp >>>= 0;
|
|
334
|
+
const result = Reflect.get(loadValue(sp + 8), loadString(sp + 16));
|
|
335
|
+
sp = this._inst.exports.getsp() >>> 0; // see comment above
|
|
336
|
+
storeValue(sp + 32, result);
|
|
337
|
+
},
|
|
338
|
+
|
|
339
|
+
// func valueSet(v ref, p string, x ref)
|
|
340
|
+
"syscall/js.valueSet": (sp) => {
|
|
341
|
+
sp >>>= 0;
|
|
342
|
+
Reflect.set(loadValue(sp + 8), loadString(sp + 16), loadValue(sp + 32));
|
|
343
|
+
},
|
|
344
|
+
|
|
345
|
+
// func valueDelete(v ref, p string)
|
|
346
|
+
"syscall/js.valueDelete": (sp) => {
|
|
347
|
+
sp >>>= 0;
|
|
348
|
+
Reflect.deleteProperty(loadValue(sp + 8), loadString(sp + 16));
|
|
349
|
+
},
|
|
350
|
+
|
|
351
|
+
// func valueIndex(v ref, i int) ref
|
|
352
|
+
"syscall/js.valueIndex": (sp) => {
|
|
353
|
+
sp >>>= 0;
|
|
354
|
+
storeValue(sp + 24, Reflect.get(loadValue(sp + 8), getInt64(sp + 16)));
|
|
355
|
+
},
|
|
356
|
+
|
|
357
|
+
// valueSetIndex(v ref, i int, x ref)
|
|
358
|
+
"syscall/js.valueSetIndex": (sp) => {
|
|
359
|
+
sp >>>= 0;
|
|
360
|
+
Reflect.set(loadValue(sp + 8), getInt64(sp + 16), loadValue(sp + 24));
|
|
361
|
+
},
|
|
362
|
+
|
|
363
|
+
// func valueCall(v ref, m string, args []ref) (ref, bool)
|
|
364
|
+
"syscall/js.valueCall": (sp) => {
|
|
365
|
+
sp >>>= 0;
|
|
366
|
+
try {
|
|
367
|
+
const v = loadValue(sp + 8);
|
|
368
|
+
const m = Reflect.get(v, loadString(sp + 16));
|
|
369
|
+
const args = loadSliceOfValues(sp + 32);
|
|
370
|
+
const result = Reflect.apply(m, v, args);
|
|
371
|
+
sp = this._inst.exports.getsp() >>> 0; // see comment above
|
|
372
|
+
storeValue(sp + 56, result);
|
|
373
|
+
this.mem.setUint8(sp + 64, 1);
|
|
374
|
+
} catch (err) {
|
|
375
|
+
sp = this._inst.exports.getsp() >>> 0; // see comment above
|
|
376
|
+
storeValue(sp + 56, err);
|
|
377
|
+
this.mem.setUint8(sp + 64, 0);
|
|
378
|
+
}
|
|
379
|
+
},
|
|
380
|
+
|
|
381
|
+
// func valueInvoke(v ref, args []ref) (ref, bool)
|
|
382
|
+
"syscall/js.valueInvoke": (sp) => {
|
|
383
|
+
sp >>>= 0;
|
|
384
|
+
try {
|
|
385
|
+
const v = loadValue(sp + 8);
|
|
386
|
+
const args = loadSliceOfValues(sp + 16);
|
|
387
|
+
const result = Reflect.apply(v, undefined, args);
|
|
388
|
+
sp = this._inst.exports.getsp() >>> 0; // see comment above
|
|
389
|
+
storeValue(sp + 40, result);
|
|
390
|
+
this.mem.setUint8(sp + 48, 1);
|
|
391
|
+
} catch (err) {
|
|
392
|
+
sp = this._inst.exports.getsp() >>> 0; // see comment above
|
|
393
|
+
storeValue(sp + 40, err);
|
|
394
|
+
this.mem.setUint8(sp + 48, 0);
|
|
395
|
+
}
|
|
396
|
+
},
|
|
397
|
+
|
|
398
|
+
// func valueNew(v ref, args []ref) (ref, bool)
|
|
399
|
+
"syscall/js.valueNew": (sp) => {
|
|
400
|
+
sp >>>= 0;
|
|
401
|
+
try {
|
|
402
|
+
const v = loadValue(sp + 8);
|
|
403
|
+
const args = loadSliceOfValues(sp + 16);
|
|
404
|
+
const result = Reflect.construct(v, args);
|
|
405
|
+
sp = this._inst.exports.getsp() >>> 0; // see comment above
|
|
406
|
+
storeValue(sp + 40, result);
|
|
407
|
+
this.mem.setUint8(sp + 48, 1);
|
|
408
|
+
} catch (err) {
|
|
409
|
+
sp = this._inst.exports.getsp() >>> 0; // see comment above
|
|
410
|
+
storeValue(sp + 40, err);
|
|
411
|
+
this.mem.setUint8(sp + 48, 0);
|
|
412
|
+
}
|
|
413
|
+
},
|
|
414
|
+
|
|
415
|
+
// func valueLength(v ref) int
|
|
416
|
+
"syscall/js.valueLength": (sp) => {
|
|
417
|
+
sp >>>= 0;
|
|
418
|
+
setInt64(sp + 16, parseInt(loadValue(sp + 8).length));
|
|
419
|
+
},
|
|
420
|
+
|
|
421
|
+
// valuePrepareString(v ref) (ref, int)
|
|
422
|
+
"syscall/js.valuePrepareString": (sp) => {
|
|
423
|
+
sp >>>= 0;
|
|
424
|
+
const str = encoder.encode(String(loadValue(sp + 8)));
|
|
425
|
+
storeValue(sp + 16, str);
|
|
426
|
+
setInt64(sp + 24, str.length);
|
|
427
|
+
},
|
|
428
|
+
|
|
429
|
+
// valueLoadString(v ref, b []byte)
|
|
430
|
+
"syscall/js.valueLoadString": (sp) => {
|
|
431
|
+
sp >>>= 0;
|
|
432
|
+
const str = loadValue(sp + 8);
|
|
433
|
+
loadSlice(sp + 16).set(str);
|
|
434
|
+
},
|
|
435
|
+
|
|
436
|
+
// func valueInstanceOf(v ref, t ref) bool
|
|
437
|
+
"syscall/js.valueInstanceOf": (sp) => {
|
|
438
|
+
sp >>>= 0;
|
|
439
|
+
this.mem.setUint8(sp + 24, (loadValue(sp + 8) instanceof loadValue(sp + 16)) ? 1 : 0);
|
|
440
|
+
},
|
|
441
|
+
|
|
442
|
+
// func copyBytesToGo(dst []byte, src ref) (int, bool)
|
|
443
|
+
"syscall/js.copyBytesToGo": (sp) => {
|
|
444
|
+
sp >>>= 0;
|
|
445
|
+
const dst = loadSlice(sp + 8);
|
|
446
|
+
const src = loadValue(sp + 32);
|
|
447
|
+
if (!(src instanceof Uint8Array || src instanceof Uint8ClampedArray)) {
|
|
448
|
+
this.mem.setUint8(sp + 48, 0);
|
|
449
|
+
return;
|
|
450
|
+
}
|
|
451
|
+
const toCopy = src.subarray(0, dst.length);
|
|
452
|
+
dst.set(toCopy);
|
|
453
|
+
setInt64(sp + 40, toCopy.length);
|
|
454
|
+
this.mem.setUint8(sp + 48, 1);
|
|
455
|
+
},
|
|
456
|
+
|
|
457
|
+
// func copyBytesToJS(dst ref, src []byte) (int, bool)
|
|
458
|
+
"syscall/js.copyBytesToJS": (sp) => {
|
|
459
|
+
sp >>>= 0;
|
|
460
|
+
const dst = loadValue(sp + 8);
|
|
461
|
+
const src = loadSlice(sp + 16);
|
|
462
|
+
if (!(dst instanceof Uint8Array || dst instanceof Uint8ClampedArray)) {
|
|
463
|
+
this.mem.setUint8(sp + 48, 0);
|
|
464
|
+
return;
|
|
465
|
+
}
|
|
466
|
+
const toCopy = src.subarray(0, dst.length);
|
|
467
|
+
dst.set(toCopy);
|
|
468
|
+
setInt64(sp + 40, toCopy.length);
|
|
469
|
+
this.mem.setUint8(sp + 48, 1);
|
|
470
|
+
},
|
|
471
|
+
|
|
472
|
+
"debug": (value) => {
|
|
473
|
+
console.log(value);
|
|
474
|
+
},
|
|
475
|
+
}
|
|
476
|
+
};
|
|
477
|
+
}
|
|
478
|
+
|
|
479
|
+
async run(instance) {
|
|
480
|
+
if (!(instance instanceof WebAssembly.Instance)) {
|
|
481
|
+
throw new Error("Go.run: WebAssembly.Instance expected");
|
|
482
|
+
}
|
|
483
|
+
this._inst = instance;
|
|
484
|
+
this.mem = new DataView(this._inst.exports.mem.buffer);
|
|
485
|
+
this._values = [ // JS values that Go currently has references to, indexed by reference id
|
|
486
|
+
NaN,
|
|
487
|
+
0,
|
|
488
|
+
null,
|
|
489
|
+
true,
|
|
490
|
+
false,
|
|
491
|
+
globalThis,
|
|
492
|
+
this,
|
|
493
|
+
];
|
|
494
|
+
this._goRefCounts = new Array(this._values.length).fill(Infinity); // number of references that Go has to a JS value, indexed by reference id
|
|
495
|
+
this._ids = new Map([ // mapping from JS values to reference ids
|
|
496
|
+
[0, 1],
|
|
497
|
+
[null, 2],
|
|
498
|
+
[true, 3],
|
|
499
|
+
[false, 4],
|
|
500
|
+
[globalThis, 5],
|
|
501
|
+
[this, 6],
|
|
502
|
+
]);
|
|
503
|
+
this._idPool = []; // unused ids that have been garbage collected
|
|
504
|
+
this.exited = false; // whether the Go program has exited
|
|
505
|
+
|
|
506
|
+
// Pass command line arguments and environment variables to WebAssembly by writing them to the linear memory.
|
|
507
|
+
let offset = 4096;
|
|
508
|
+
|
|
509
|
+
const strPtr = (str) => {
|
|
510
|
+
const ptr = offset;
|
|
511
|
+
const bytes = encoder.encode(str + "\0");
|
|
512
|
+
new Uint8Array(this.mem.buffer, offset, bytes.length).set(bytes);
|
|
513
|
+
offset += bytes.length;
|
|
514
|
+
if (offset % 8 !== 0) {
|
|
515
|
+
offset += 8 - (offset % 8);
|
|
516
|
+
}
|
|
517
|
+
return ptr;
|
|
518
|
+
};
|
|
519
|
+
|
|
520
|
+
const argc = this.argv.length;
|
|
521
|
+
|
|
522
|
+
const argvPtrs = [];
|
|
523
|
+
this.argv.forEach((arg) => {
|
|
524
|
+
argvPtrs.push(strPtr(arg));
|
|
525
|
+
});
|
|
526
|
+
argvPtrs.push(0);
|
|
527
|
+
|
|
528
|
+
const keys = Object.keys(this.env).sort();
|
|
529
|
+
keys.forEach((key) => {
|
|
530
|
+
argvPtrs.push(strPtr(`${key}=${this.env[key]}`));
|
|
531
|
+
});
|
|
532
|
+
argvPtrs.push(0);
|
|
533
|
+
|
|
534
|
+
const argv = offset;
|
|
535
|
+
argvPtrs.forEach((ptr) => {
|
|
536
|
+
this.mem.setUint32(offset, ptr, true);
|
|
537
|
+
this.mem.setUint32(offset + 4, 0, true);
|
|
538
|
+
offset += 8;
|
|
539
|
+
});
|
|
540
|
+
|
|
541
|
+
// The linker guarantees global data starts from at least wasmMinDataAddr.
|
|
542
|
+
// Keep in sync with cmd/link/internal/ld/data.go:wasmMinDataAddr.
|
|
543
|
+
const wasmMinDataAddr = 4096 + 8192;
|
|
544
|
+
if (offset >= wasmMinDataAddr) {
|
|
545
|
+
throw new Error("total length of command line and environment variables exceeds limit");
|
|
546
|
+
}
|
|
547
|
+
|
|
548
|
+
this._inst.exports.run(argc, argv);
|
|
549
|
+
if (this.exited) {
|
|
550
|
+
this._resolveExitPromise();
|
|
551
|
+
}
|
|
552
|
+
await this._exitPromise;
|
|
553
|
+
}
|
|
554
|
+
|
|
555
|
+
_resume() {
|
|
556
|
+
if (this.exited) {
|
|
557
|
+
throw new Error("Go program has already exited");
|
|
558
|
+
}
|
|
559
|
+
this._inst.exports.resume();
|
|
560
|
+
if (this.exited) {
|
|
561
|
+
this._resolveExitPromise();
|
|
562
|
+
}
|
|
563
|
+
}
|
|
564
|
+
|
|
565
|
+
_makeFuncWrapper(id) {
|
|
566
|
+
const go = this;
|
|
567
|
+
return function () {
|
|
568
|
+
const event = { id: id, this: this, args: arguments };
|
|
569
|
+
go._pendingEvent = event;
|
|
570
|
+
go._resume();
|
|
571
|
+
return event.result;
|
|
572
|
+
};
|
|
573
|
+
}
|
|
574
|
+
}
|
|
575
|
+
})();
|
package/package.json
ADDED
|
@@ -0,0 +1,24 @@
|
|
|
1
|
+
{
|
|
2
|
+
"name": "elphadeal-terminal",
|
|
3
|
+
"version": "1.0.0",
|
|
4
|
+
"description": "A custom terminal design powered by Go WebAssembly",
|
|
5
|
+
"main": "dist/index.js",
|
|
6
|
+
"bin": {
|
|
7
|
+
"elphadeal-terminal": "dist/cli.js"
|
|
8
|
+
},
|
|
9
|
+
"scripts": {
|
|
10
|
+
"build": "GOOS=js GOARCH=wasm go build -o dist/main.wasm main.go && cp $(go env GOROOT)/lib/wasm/wasm_exec.js dist/",
|
|
11
|
+
"prepublishOnly": "npm run build"
|
|
12
|
+
},
|
|
13
|
+
"keywords": [
|
|
14
|
+
"wasm",
|
|
15
|
+
"terminal",
|
|
16
|
+
"go",
|
|
17
|
+
"webassembly"
|
|
18
|
+
],
|
|
19
|
+
"author": "villiogears",
|
|
20
|
+
"license": "MIT",
|
|
21
|
+
"files": [
|
|
22
|
+
"dist/"
|
|
23
|
+
]
|
|
24
|
+
}
|