sonic-ws 1.0.0-alpha.0

package/.gitattributes

@@ -0,0 +1,2 @@
+# Auto detect text files and perform LF normalization
+* text=auto

package/README.md

@@ -0,0 +1,2 @@
+# sonic-ws
+Bandwidth efficient (but stupid) websocket library

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { SonicWS } from './ws/client/SonicWS';
+export { SonicWSConnection } from './ws/server/SonicWSConnection';
+export { SonicWSServer } from './ws/server/SonicWSServer';

package/dist/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonicWSServer = exports.SonicWSConnection = exports.SonicWS = void 0;
+var SonicWS_1 = require("./ws/client/SonicWS");
+Object.defineProperty(exports, "SonicWS", { enumerable: true, get: function () { return SonicWS_1.SonicWS; } });
+var SonicWSConnection_1 = require("./ws/server/SonicWSConnection");
+Object.defineProperty(exports, "SonicWSConnection", { enumerable: true, get: function () { return SonicWSConnection_1.SonicWSConnection; } });
+var SonicWSServer_1 = require("./ws/server/SonicWSServer");
+Object.defineProperty(exports, "SonicWSServer", { enumerable: true, get: function () { return SonicWSServer_1.SonicWSServer; } });

package/dist/ws/KeyHolder.d.ts

@@ -0,0 +1,9 @@
+export declare class KeyHolder {
+    private key;
+    keys: Record<string, number>;
+    constructor();
+    createKey(tag: string): void;
+    createKeys(tags: string[]): void;
+    get(key: string): number;
+    getChar(key: string): string;
+}

package/dist/ws/KeyHolder.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KeyHolder = void 0;
+var KeyHolder = /** @class */ (function () {
+    function KeyHolder() {
+        this.key = 1;
+        this.keys = {};
+    }
+    KeyHolder.prototype.createKey = function (tag) {
+        this.key++;
+        this.keys[tag] = this.key;
+    };
+    KeyHolder.prototype.createKeys = function (tags) {
+        for (var _i = 0, tags_1 = tags; _i < tags_1.length; _i++) {
+            var tag = tags_1[_i];
+            this.createKey(tag);
+        }
+    };
+    KeyHolder.prototype.get = function (key) {
+        return this.keys[key];
+    };
+    KeyHolder.prototype.getChar = function (key) {
+        return String.fromCodePoint(this.get(key));
+    };
+    return KeyHolder;
+}());
+exports.KeyHolder = KeyHolder;

package/dist/ws/SonicWS.d.ts

@@ -0,0 +1,16 @@
+import * as WS from 'ws';
+import { KeyHolder } from './KeyHolder';
+export declare class SonicWS {
+    private ws;
+    private listeners;
+    clientKeys: KeyHolder;
+    serverKeys: KeyHolder;
+    constructor(url: string, options?: WS.ClientOptions);
+    raw_onmessage(listener: (data: string) => void): void;
+    raw_onclose(listener: (event: CloseEvent) => void): void;
+    send(key: string, value: string): void;
+    on_ready(listener: () => void): void;
+    on(key: string, listener: (value: string) => void): void;
+    createClientKeys(...keys: string[]): void;
+    createServerKeys(...keys: string[]): void;
+}

package/dist/ws/SonicWS.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonicWS = void 0;
+var WS = __importStar(require("ws"));
+var KeyHolder_1 = require("./KeyHolder");
+var SonicWS = /** @class */ (function () {
+    function SonicWS(url, options) {
+        var _this = this;
+        this.ws = new WS.WebSocket(url, options);
+        this.listeners = {
+            message: [],
+            close: [],
+            event: {},
+        };
+        this.clientKeys = new KeyHolder_1.KeyHolder();
+        this.serverKeys = new KeyHolder_1.KeyHolder();
+        this.ws.on('message', function (data) {
+            var _a;
+            data = data.toString();
+            _this.listeners.message.forEach(function (listener) { return listener(data); });
+            if (data.length < 1)
+                return;
+            var key = data.substring(0, 1);
+            var value = data.substring(1);
+            (_a = _this.listeners.event[key.codePointAt(0)]) === null || _a === void 0 ? void 0 : _a.forEach(function (l) { return l(value); });
+        });
+        this.ws.on('close', function (event) {
+            _this.listeners.close.forEach(function (listener) { return listener(event); });
+        });
+    }
+    SonicWS.prototype.raw_onmessage = function (listener) {
+        this.listeners.message.push(listener);
+    };
+    SonicWS.prototype.raw_onclose = function (listener) {
+        this.listeners.close.push(listener);
+    };
+    SonicWS.prototype.send = function (key, value) {
+        var code = this.clientKeys.getChar(key);
+        if (code == null)
+            throw new Error("Key \"".concat(key, "\" has not been created!"));
+        this.ws.send(code + value);
+    };
+    SonicWS.prototype.on_ready = function (listener) {
+        this.ws.on('open', listener);
+    };
+    SonicWS.prototype.on = function (key, listener) {
+        this.listeners.event[this.serverKeys.get(key)].push(listener);
+    };
+    SonicWS.prototype.createClientKeys = function () {
+        var keys = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            keys[_i] = arguments[_i];
+        }
+        this.clientKeys.createKeys(keys);
+    };
+    SonicWS.prototype.createServerKeys = function () {
+        var keys = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            keys[_i] = arguments[_i];
+        }
+        this.serverKeys.createKeys(keys);
+        for (var _a = 0, keys_1 = keys; _a < keys_1.length; _a++) {
+            var key = keys_1[_a];
+            this.listeners.event[this.serverKeys.get(key)] = [];
+        }
+    };
+    return SonicWS;
+}());
+exports.SonicWS = SonicWS;

package/dist/ws/SonicWSClient.d.ts

@@ -0,0 +1,12 @@
+import * as WS from 'ws';
+import { SonicWSServer } from './SonicWSServer';
+export declare class SonicWSClient {
+    private socket;
+    private host;
+    private listeners;
+    constructor(socket: WS.WebSocket, host: SonicWSServer);
+    raw_send(data: string): void;
+    /** Listens for when the client sends a message. This will use the server's key system */
+    on(key: string, listener: (value: string) => void): void;
+    send(key: string, value: string): void;
+}

package/dist/ws/SonicWSClient.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonicWSClient = void 0;
+var SonicWSClient = /** @class */ (function () {
+    function SonicWSClient(socket, host) {
+        var _this = this;
+        this.socket = socket;
+        this.host = host;
+        this.listeners = {};
+        for (var _i = 0, _a = Object.values(host.clientKeys.keys); _i < _a.length; _i++) {
+            var key = _a[_i];
+            this.listeners[String.fromCodePoint(key)] = [];
+        }
+        this.socket.on('message', function (data) {
+            var message = data.toString();
+            if (message.length < 1) {
+                _this.socket.close();
+                return;
+            }
+            var key = message.substring(0, 1);
+            var value = message.substring(1);
+            if (!_this.listeners[key]) {
+                _this.socket.close();
+                return;
+            }
+            _this.listeners[key].forEach(function (listener) { return listener(value); });
+        });
+    }
+    SonicWSClient.prototype.raw_send = function (data) {
+        this.socket.send(data);
+    };
+    /** Listens for when the client sends a message. This will use the server's key system */
+    SonicWSClient.prototype.on = function (key, listener) {
+        var code = this.host.clientKeys.getChar(key);
+        if (code == null)
+            throw new Error("Key \"".concat(key, "\" has not been created!"));
+        if (!this.listeners[code])
+            this.listeners[code] = [];
+        this.listeners[code].push(listener);
+    };
+    SonicWSClient.prototype.send = function (key, value) {
+        var code = this.host.serverKeys.getChar(key);
+        if (code == null)
+            throw new Error("Key \"".concat(key, "\" has not been created!"));
+        this.socket.send(code + value);
+    };
+    return SonicWSClient;
+}());
+exports.SonicWSClient = SonicWSClient;

package/dist/ws/SonicWSServer.d.ts

@@ -0,0 +1,13 @@
+import * as WS from 'ws';
+import { SonicWSClient } from './SonicWSClient';
+import { KeyHolder } from './KeyHolder';
+export declare class SonicWSServer {
+    private ws;
+    clientKeys: KeyHolder;
+    serverKeys: KeyHolder;
+    constructor(options: WS.ServerOptions);
+    createClientKeys(...keys: string[]): void;
+    createServerKeys(...keys: string[]): void;
+    on_connect(runner: (client: SonicWSClient) => void): void;
+    on_ready(runner: () => void): void;
+}

package/dist/ws/SonicWSServer.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonicWSServer = void 0;
+var WS = __importStar(require("ws"));
+var SonicWSClient_1 = require("./SonicWSClient");
+var KeyHolder_1 = require("./KeyHolder");
+var SonicWSServer = /** @class */ (function () {
+    function SonicWSServer(options) {
+        this.ws = new WS.WebSocketServer(options);
+        this.clientKeys = new KeyHolder_1.KeyHolder();
+        this.serverKeys = new KeyHolder_1.KeyHolder();
+    }
+    SonicWSServer.prototype.createClientKeys = function () {
+        var keys = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            keys[_i] = arguments[_i];
+        }
+        this.clientKeys.createKeys(keys);
+    };
+    SonicWSServer.prototype.createServerKeys = function () {
+        var keys = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            keys[_i] = arguments[_i];
+        }
+        this.serverKeys.createKeys(keys);
+    };
+    SonicWSServer.prototype.on_connect = function (runner) {
+        var _this = this;
+        this.ws.on('connection', function (socket) { return runner(new SonicWSClient_1.SonicWSClient(socket, _this)); });
+    };
+    SonicWSServer.prototype.on_ready = function (runner) {
+        this.ws.on('listening', runner);
+    };
+    return SonicWSServer;
+}());
+exports.SonicWSServer = SonicWSServer;

package/dist/ws/client/SonicWS.d.ts

@@ -0,0 +1,16 @@
+import * as WS from 'ws';
+import { KeyHolder } from '../KeyHolder';
+export declare class SonicWS {
+    private ws;
+    private listeners;
+    clientKeys: KeyHolder;
+    serverKeys: KeyHolder;
+    constructor(url: string, options?: WS.ClientOptions);
+    raw_onmessage(listener: (data: string) => void): void;
+    raw_onclose(listener: (event: CloseEvent) => void): void;
+    send(key: string, value: string): void;
+    on_ready(listener: () => void): void;
+    on(key: string, listener: (value: string) => void): void;
+    createClientKeys(...keys: string[]): void;
+    createServerKeys(...keys: string[]): void;
+}

package/dist/ws/client/SonicWS.js

@@ -0,0 +1,92 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonicWS = void 0;
+var WS = __importStar(require("ws"));
+var KeyHolder_1 = require("../KeyHolder");
+var SonicWS = /** @class */ (function () {
+    function SonicWS(url, options) {
+        var _this = this;
+        this.ws = new WS.WebSocket(url, options);
+        this.listeners = {
+            message: [],
+            close: [],
+            event: {},
+        };
+        this.clientKeys = new KeyHolder_1.KeyHolder();
+        this.serverKeys = new KeyHolder_1.KeyHolder();
+        this.ws.on('message', function (data) {
+            var _a;
+            data = data.toString();
+            _this.listeners.message.forEach(function (listener) { return listener(data); });
+            if (data.length < 1)
+                return;
+            var key = data.substring(0, 1);
+            var value = data.substring(1);
+            (_a = _this.listeners.event[key.codePointAt(0)]) === null || _a === void 0 ? void 0 : _a.forEach(function (l) { return l(value); });
+        });
+        this.ws.on('close', function (event) {
+            _this.listeners.close.forEach(function (listener) { return listener(event); });
+        });
+    }
+    SonicWS.prototype.raw_onmessage = function (listener) {
+        this.listeners.message.push(listener);
+    };
+    SonicWS.prototype.raw_onclose = function (listener) {
+        this.listeners.close.push(listener);
+    };
+    SonicWS.prototype.send = function (key, value) {
+        var code = this.clientKeys.getChar(key);
+        if (code == null)
+            throw new Error("Key \"".concat(key, "\" has not been created!"));
+        this.ws.send(code + value);
+    };
+    SonicWS.prototype.on_ready = function (listener) {
+        this.ws.on('open', listener);
+    };
+    SonicWS.prototype.on = function (key, listener) {
+        this.listeners.event[this.serverKeys.get(key)].push(listener);
+    };
+    SonicWS.prototype.createClientKeys = function () {
+        var keys = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            keys[_i] = arguments[_i];
+        }
+        this.clientKeys.createKeys(keys);
+    };
+    SonicWS.prototype.createServerKeys = function () {
+        var keys = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            keys[_i] = arguments[_i];
+        }
+        this.serverKeys.createKeys(keys);
+        for (var _a = 0, keys_1 = keys; _a < keys_1.length; _a++) {
+            var key = keys_1[_a];
+            this.listeners.event[this.serverKeys.get(key)] = [];
+        }
+    };
+    return SonicWS;
+}());
+exports.SonicWS = SonicWS;

package/dist/ws/server/SonicWSConnection.d.ts

@@ -0,0 +1,12 @@
+import * as WS from 'ws';
+import { SonicWSServer } from './SonicWSServer';
+export declare class SonicWSConnection {
+    private socket;
+    private host;
+    private listeners;
+    constructor(socket: WS.WebSocket, host: SonicWSServer);
+    raw_send(data: string): void;
+    /** Listens for when the client sends a message. This will use the server's key system */
+    on(key: string, listener: (value: string) => void): void;
+    send(key: string, value: string): void;
+}

package/dist/ws/server/SonicWSConnection.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonicWSConnection = void 0;
+var SonicWSConnection = /** @class */ (function () {
+    function SonicWSConnection(socket, host) {
+        var _this = this;
+        this.socket = socket;
+        this.host = host;
+        this.listeners = {};
+        for (var _i = 0, _a = Object.values(host.clientKeys.keys); _i < _a.length; _i++) {
+            var key = _a[_i];
+            this.listeners[String.fromCodePoint(key)] = [];
+        }
+        this.socket.on('message', function (data) {
+            var message = data.toString();
+            if (message.length < 1) {
+                _this.socket.close();
+                return;
+            }
+            var key = message.substring(0, 1);
+            var value = message.substring(1);
+            if (!_this.listeners[key]) {
+                _this.socket.close();
+                return;
+            }
+            _this.listeners[key].forEach(function (listener) { return listener(value); });
+        });
+    }
+    SonicWSConnection.prototype.raw_send = function (data) {
+        this.socket.send(data);
+    };
+    /** Listens for when the client sends a message. This will use the server's key system */
+    SonicWSConnection.prototype.on = function (key, listener) {
+        var code = this.host.clientKeys.getChar(key);
+        if (code == null)
+            throw new Error("Key \"".concat(key, "\" has not been created!"));
+        if (!this.listeners[code])
+            this.listeners[code] = [];
+        this.listeners[code].push(listener);
+    };
+    SonicWSConnection.prototype.send = function (key, value) {
+        var code = this.host.serverKeys.getChar(key);
+        if (code == null)
+            throw new Error("Key \"".concat(key, "\" has not been created!"));
+        this.socket.send(code + value);
+    };
+    return SonicWSConnection;
+}());
+exports.SonicWSConnection = SonicWSConnection;

package/dist/ws/server/SonicWSServer.d.ts

@@ -0,0 +1,13 @@
+import * as WS from 'ws';
+import { SonicWSConnection } from './SonicWSConnection';
+import { KeyHolder } from '../KeyHolder';
+export declare class SonicWSServer {
+    private ws;
+    clientKeys: KeyHolder;
+    serverKeys: KeyHolder;
+    constructor(options: WS.ServerOptions);
+    createClientKeys(...keys: string[]): void;
+    createServerKeys(...keys: string[]): void;
+    on_connect(runner: (client: SonicWSConnection) => void): void;
+    on_ready(runner: () => void): void;
+}

package/dist/ws/server/SonicWSServer.js

@@ -0,0 +1,59 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SonicWSServer = void 0;
+var WS = __importStar(require("ws"));
+var SonicWSConnection_1 = require("./SonicWSConnection");
+var KeyHolder_1 = require("../KeyHolder");
+var SonicWSServer = /** @class */ (function () {
+    function SonicWSServer(options) {
+        this.ws = new WS.WebSocketServer(options);
+        this.clientKeys = new KeyHolder_1.KeyHolder();
+        this.serverKeys = new KeyHolder_1.KeyHolder();
+    }
+    SonicWSServer.prototype.createClientKeys = function () {
+        var keys = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            keys[_i] = arguments[_i];
+        }
+        this.clientKeys.createKeys(keys);
+    };
+    SonicWSServer.prototype.createServerKeys = function () {
+        var keys = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            keys[_i] = arguments[_i];
+        }
+        this.serverKeys.createKeys(keys);
+    };
+    SonicWSServer.prototype.on_connect = function (runner) {
+        var _this = this;
+        this.ws.on('connection', function (socket) { return runner(new SonicWSConnection_1.SonicWSConnection(socket, _this)); });
+    };
+    SonicWSServer.prototype.on_ready = function (runner) {
+        this.ws.on('listening', runner);
+    };
+    return SonicWSServer;
+}());
+exports.SonicWSServer = SonicWSServer;

package/package.json

@@ -0,0 +1,27 @@
+{
+  "name": "sonic-ws",
+  "version": "1.0.0-alpha.0",
+  "description": "A bandwidth efficient websocket library",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc -d",
+    "test": "npm run build && node test"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cutelittlelily/sonic-ws.git"
+  },
+  "bugs": {
+    "url": "https://github.com/cutelittlelily/sonic-ws/issues"
+  },
+  "homepage": "https://github.com/cutelittlelily/sonic-ws#readme",
+  "author": "lily",
+  "license": "ISC",
+  "dependencies": {
+    "ws": "^8.18.2"
+  },
+  "devDependencies": {
+    "@types/ws": "^8.18.1"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { SonicWS } from './ws/client/SonicWS';
+export { SonicWSConnection } from './ws/server/SonicWSConnection';
+export { SonicWSServer } from './ws/server/SonicWSServer';

package/src/ws/KeyHolder.ts

@@ -0,0 +1,26 @@
+export class KeyHolder {
+
+    private key: number;
+    public keys: Record<string, number>;
+
+    constructor() {
+        this.key = 1;
+        this.keys = {};
+    }
+
+    public createKey(tag: string): void {
+        this.key++;
+        this.keys[tag] = this.key;
+    }
+    public createKeys(tags: string[]): void {
+        for (const tag of tags) this.createKey(tag);
+    }
+
+    public get(key: string): number {
+        return this.keys[key];
+    }
+    public getChar(key: string): string {
+        return String.fromCodePoint(this.get(key));
+    }
+
+}

package/src/ws/client/SonicWS.ts

@@ -0,0 +1,80 @@
+import * as WS from 'ws';
+import { KeyHolder } from '../KeyHolder';
+
+export class SonicWS {
+    private ws: WS.WebSocket;
+
+    private listeners: {
+        message: Array<(data: string) => void>,
+        close: Array<(event: CloseEvent) => void>
+        event: {[key: string]: Array<(key: string) => void>}
+    };
+
+    public clientKeys: KeyHolder;
+    public serverKeys: KeyHolder;
+
+    constructor(url: string, options?: WS.ClientOptions) {
+        this.ws = new WS.WebSocket(url, options);
+
+        this.listeners = {
+            message: [],
+            close: [],
+            event: {},
+        };
+
+        this.clientKeys = new KeyHolder();
+        this.serverKeys = new KeyHolder();
+
+        this.ws.on('message', (data: string) => {
+            data = data.toString();
+            
+            this.listeners.message.forEach(listener => listener(data));
+
+            if(data.length < 1) return;
+
+            const key = data.substring(0, 1);
+            const value = data.substring(1);
+
+            this.listeners.event[key.codePointAt(0)!]?.forEach(l => l(value));
+
+        });
+
+        this.ws.on('close', (event: CloseEvent) => {
+            this.listeners.close.forEach(listener => listener(event));
+        });
+    }
+
+    public raw_onmessage(listener: (data: string) => void): void {
+        this.listeners.message.push(listener);
+    }
+
+    public raw_onclose(listener: (event: CloseEvent) => void): void {
+        this.listeners.close.push(listener);
+    }
+
+    public send(key: string, value: string): void {
+        const code = this.clientKeys.getChar(key);
+        if (code == null) throw new Error(`Key "${key}" has not been created!`);
+
+        this.ws.send(code + value);
+    }
+
+    public on_ready(listener: () => void): void {
+        this.ws.on('open', listener);
+    }
+
+    public on(key: string, listener: (value: string) => void) {
+        this.listeners.event[this.serverKeys.get(key)].push(listener);
+    }
+
+    public createClientKeys(...keys: string[]) {
+        this.clientKeys.createKeys(keys);
+    }
+    public createServerKeys(...keys: string[]) {
+        this.serverKeys.createKeys(keys);
+        for(const key of keys) {
+            this.listeners.event[this.serverKeys.get(key)] = [];
+        }
+    }
+
+}

package/src/ws/server/SonicWSConnection.ts

@@ -0,0 +1,59 @@
+import * as WS from 'ws';
+import { SonicWSServer } from './SonicWSServer';
+
+export class SonicWSConnection {
+    private socket: WS.WebSocket;
+    private host: SonicWSServer;
+    private listeners: Record<string, Array<(value: string) => void>>;
+
+    constructor(socket: WS.WebSocket, host: SonicWSServer) {
+        this.socket = socket;
+        this.host = host;
+
+        this.listeners = {};
+        for (const key of Object.values(host.clientKeys.keys)) {
+            this.listeners[String.fromCodePoint(key)] = [];
+        }
+
+        this.socket.on('message', (data: WS.RawData) => {
+            const message = data.toString();
+
+            if (message.length < 1) {
+                this.socket.close();
+                return;
+            }
+
+            const key = message.substring(0, 1);
+            const value = message.substring(1);
+
+            if(!this.listeners[key]) {
+                this.socket.close();
+                return;
+            }
+
+            this.listeners[key].forEach(listener => listener(value));
+        });
+    }
+
+    public raw_send(data: string): void {
+        this.socket.send(data);
+    }
+
+    /** Listens for when the client sends a message. This will use the server's key system */
+    public on(key: string, listener: (value: string) => void): void {
+        const code = this.host.clientKeys.getChar(key);
+        if (code == null) throw new Error(`Key "${key}" has not been created!`);
+
+        if (!this.listeners[code]) this.listeners[code] = [];
+
+        this.listeners[code].push(listener);
+    }
+
+    public send(key: string, value: string) {
+        const code = this.host.serverKeys.getChar(key);
+        if(code == null) throw new Error(`Key "${key}" has not been created!`);
+
+        this.socket.send(code + value);
+    }
+
+}

package/src/ws/server/SonicWSServer.ts

@@ -0,0 +1,33 @@
+import * as WS from 'ws';
+import { SonicWSConnection } from './SonicWSConnection';
+import { KeyHolder } from '../KeyHolder';
+
+export class SonicWSServer {
+    private ws: WS.WebSocketServer;
+
+    public clientKeys: KeyHolder;
+    public serverKeys: KeyHolder;
+
+    constructor(options: WS.ServerOptions) {
+        this.ws = new WS.WebSocketServer(options);
+
+        this.clientKeys = new KeyHolder();
+        this.serverKeys = new KeyHolder();
+    }
+
+    public createClientKeys(...keys: string[]) {
+        this.clientKeys.createKeys(keys);
+    }
+    public createServerKeys(...keys: string[]) {
+        this.serverKeys.createKeys(keys);
+    }
+
+    public on_connect(runner: (client: SonicWSConnection) => void): void {
+        this.ws.on('connection', (socket) => runner(new SonicWSConnection(socket, this)));
+    }
+
+    public on_ready(runner: () => void): void {
+        this.ws.on('listening', runner);
+    }
+
+}

package/tsconfig.json

@@ -0,0 +1,16 @@
+{
+    "compilerOptions": {
+      "target": "es5",                          
+      "module": "commonjs",                     
+      "strict": true,                           
+      "esModuleInterop": true,                  
+      "skipLibCheck": true,                     
+      "forceConsistentCasingInFileNames": true,
+      "outDir": "./dist/",                       
+      "declaration": true,
+      "rootDir": "./src/",
+      "lib":["es2015","dom"],                
+    },
+    "include": ["./src/**/*"],
+    "exclude": ["node_modules"]
+}