@omujs/omu 0.9.10 → 0.9.27

package/src/network/websocket-transport.ts

@@ -0,0 +1,123 @@
+import type { Address } from '../address.js';
+import type { Serializable } from '../serialize';
+import { ByteReader, ByteWriter } from '../serialize';
+
+import type { Connection, Transport } from './connection.js';
+import type { Packet, PacketData } from './packet/packet.js';
+
+export class WebsocketTransport implements Transport {
+    constructor(
+        private readonly address: Address,
+    ) { }
+
+    private get wsEndpoint(): string {
+        const protocol = this.address.secure ? 'wss' : 'ws';
+        const { host, port } = this.address;
+        return `${protocol}://${host}:${port}/ws`;
+    }
+
+    public connect(): Promise<Connection> {
+        const socket = new WebSocket(this.wsEndpoint);
+        return WebsocketConnection.fromSocket(socket);
+    }
+}
+
+export class WebsocketConnection implements Connection {
+    private readonly packetQueue: Array<PacketData> = [];
+    private receiveWaiter: (() => void) | null = null;
+    private readingPromise: Promise<void> | null = null;
+    private beingClosed: boolean = false;
+
+    constructor(
+        private socket: WebSocket,
+    ) { }
+
+    public static fromSocket(socket: WebSocket): Promise<WebsocketConnection> {
+        const connection = new WebsocketConnection(socket);
+        return new Promise((resolve, reject) => {
+            socket.onerror = reject;
+            socket.onclose = () => {
+                connection.beingClosed = true;
+                if (connection.receiveWaiter) {
+                    connection.receiveWaiter();
+                    connection.receiveWaiter = null;
+                }
+            };
+            socket.onmessage = (event): void => {
+                connection.readingPromise = connection.onMessage(event).finally(() => {
+                    connection.readingPromise = null;
+                });
+            };
+            socket.onopen = (): void => {
+                resolve(connection);
+            };
+        });
+    }
+
+    private async onMessage(event: MessageEvent<string | Blob>): Promise<void> {
+        if (typeof event.data === 'string') {
+            throw new Error('Received string data');
+        }
+        const reader = await ByteReader.fromBlob(event.data);
+        const data = {
+            type: reader.readString(),
+            data: reader.readUint8Array(),
+        };
+        this.packetQueue.push(data);
+        reader.finish();
+        if (this.receiveWaiter) {
+            this.receiveWaiter();
+        }
+    }
+
+    public async receive(serializer: Serializable<Packet<unknown>, PacketData>): Promise<Packet | null> {
+        if (this.receiveWaiter) {
+            throw new Error('Already receiving');
+        }
+        while (this.packetQueue.length === 0 && !this.beingClosed) {
+            await new Promise<void>((resolve) => {
+                this.receiveWaiter = resolve;
+            });
+            this.receiveWaiter = null;
+        }
+        if (this.packetQueue.length === 0 && this.beingClosed) {
+            return null;
+        }
+        const packetData = this.packetQueue.shift()!;
+        return serializer.deserialize(packetData);
+    }
+
+    get closed(): boolean {
+        if (this.readingPromise) {
+            return false;
+        }
+        if (this.packetQueue.length > 0) {
+            return false;
+        }
+        if (this.receiveWaiter) {
+            return false;
+        }
+        if (this.socket.readyState !== WebSocket.CLOSED && this.socket.readyState !== WebSocket.CLOSING) {
+            return false;
+        }
+        return true;
+    }
+
+    close(): void {
+        if (this.socket) {
+            this.socket.close();
+        }
+        if (this.receiveWaiter) {
+            this.receiveWaiter();
+            this.receiveWaiter = null;
+        }
+    }
+
+    send(packet: Packet, serializer: Serializable<Packet<unknown>, PacketData>): void {
+        const packetData = serializer.serialize(packet);
+        const writer = new ByteWriter();
+        writer.writeString(packetData.type);
+        writer.writeUint8Array(packetData.data);
+        this.socket.send(writer.finish());
+    }
+}

package/src/omu.ts

@@ -1,33 +1,35 @@
+import { ExtensionRegistry } from './api';
+import { ASSET_EXTENSION_TYPE, type AssetExtension } from './api/asset/extension';
+import { DASHBOARD_EXTENSION_TYPE, type DashboardExtension } from './api/dashboard/extension';
+import { ENDPOINT_EXTENSION_TYPE, type EndpointExtension } from './api/endpoint/extension';
+import { HTTP_EXTENSION_TYPE, HttpExtension } from './api/http/extension';
+import { I18N_EXTENSION_TYPE, type I18nExtension } from './api/i18n/extension';
+import { LOGGER_EXTENSION_TYPE, type LoggerExtension } from './api/logger/extension.js';
+import { PERMISSION_EXTENSION_TYPE, type PermissionExtension } from './api/permission/extension';
+import { PLUGIN_EXTENSION_TYPE, type PluginExtension } from './api/plugin/extension';
+import { REGISTRY_EXTENSION_TYPE, type RegistryExtension } from './api/registry/extension';
+import { SERVER_EXTENSION_TYPE, type ServerExtension } from './api/server/extension';
+import { SESSION_EXTENSION_TYPE, SessionExtension } from './api/session';
+import { SIGNAL_EXTENSION_TYPE, type SignalExtension } from './api/signal/extension';
+import { TABLE_EXTENSION_TYPE, type TableExtension } from './api/table/extension';
 import type { App } from './app.js';
-import type { Client, ClientEvents } from './client.js';
-import type { Unlisten } from './event-emitter.js';
-import { EventEmitter } from './event-emitter.js';
-import { ASSET_EXTENSION_TYPE, type AssetExtension } from './extension/asset/index.js';
-import { DASHBOARD_EXTENSION_TYPE, type DashboardExtension } from './extension/dashboard/index.js';
-import { ENDPOINT_EXTENSION_TYPE, type EndpointExtension } from './extension/endpoint/index.js';
-import { I18N_EXTENSION_TYPE, type I18nExtension } from './extension/i18n/index.js';
-import { ExtensionRegistry } from './extension/index.js';
-import {
-    LOGGER_EXTENSION_TYPE,
-    type LoggerExtension,
-} from './extension/logger/logger-extension.js';
-import {
-    PERMISSION_EXTENSION_TYPE,
-    type PermissionExtension,
-} from './extension/permission/index.js';
-import { PLUGIN_EXTENSION_TYPE, type PluginExtension } from './extension/plugin/index.js';
-import { REGISTRY_EXTENSION_TYPE, type RegistryExtension } from './extension/registry/index.js';
-import { SERVER_EXTENSION_TYPE, type ServerExtension } from './extension/server/index.js';
-import { SIGNAL_EXTENSION_TYPE, type SignalExtension } from './extension/signal/index.js';
-import { TABLE_EXTENSION_TYPE, type TableExtension } from './extension/table/index.js';
-import type { Address, Connection } from './network/index.js';
-import { Network } from './network/index.js';
+import type { Unlisten } from './event';
+import { EventEmitter } from './event';
+import type { Address, Connection } from './network';
+import { Network } from './network';
+import { Transport } from './network/connection.js';
 import { PACKET_TYPES } from './network/packet/packet-types.js';
 import type { PacketType } from './network/packet/packet.js';
-import { WebsocketConnection } from './network/websocket-connection.js';
+import { WebsocketTransport } from './network/websocket-transport';
 import { BrowserTokenProvider, type TokenProvider } from './token.js';
 
-export class Omu implements Client {
+export type ClientEvents = {
+    started: EventEmitter<[]>;
+    stopped: EventEmitter<[]>;
+    ready: EventEmitter<[]>;
+};
+
+export class Omu {
     public ready: boolean;
     public running: boolean;
     readonly event: ClientEvents = {
@@ -37,6 +39,7 @@ export class Omu implements Client {
     };
     readonly token: TokenProvider;
     readonly address: Address;
+    readonly sessions: SessionExtension;
     readonly network: Network;
     readonly endpoints: EndpointExtension;
     readonly permissions: PermissionExtension;
@@ -50,18 +53,27 @@ export class Omu implements Client {
     readonly i18n: I18nExtension;
     readonly server: ServerExtension;
     readonly logger: LoggerExtension;
+    readonly http: HttpExtension;
 
     constructor(
         public readonly app: App,
         options?: {
             address?: Address;
-            token?: TokenProvider;
+            token?: TokenProvider | string;
+            transport?: Transport;
             connection?: Connection;
         },
     ) {
         this.ready = false;
         this.running = false;
-        this.token = options?.token ?? new BrowserTokenProvider('omu-token');
+        if (typeof options?.token === 'string') {
+            const token = options?.token;
+            this.token = {
+                get: () => Promise.resolve(token),
+            };
+        } else {
+            this.token = options?.token ?? new BrowserTokenProvider();
+        }
         this.address = options?.address ?? {
             host: '127.0.0.1',
             port: 26423,
@@ -71,7 +83,8 @@ export class Omu implements Client {
             this,
             this.address,
             this.token,
-            options?.connection ?? new WebsocketConnection(this.address),
+            options?.transport ?? new WebsocketTransport(this.address),
+            options?.connection,
         );
         this.network.event.disconnected.listen(() => {
             this.ready = false;
@@ -84,18 +97,19 @@ export class Omu implements Client {
             this.event.ready.emit();
         });
         this.extensions = new ExtensionRegistry(this);
-
         this.endpoints = this.extensions.register(ENDPOINT_EXTENSION_TYPE);
         this.plugins = this.extensions.register(PLUGIN_EXTENSION_TYPE);
         this.permissions = this.extensions.register(PERMISSION_EXTENSION_TYPE);
         this.tables = this.extensions.register(TABLE_EXTENSION_TYPE);
-        this.dashboard = this.extensions.register(DASHBOARD_EXTENSION_TYPE);
+        this.sessions = this.extensions.register(SESSION_EXTENSION_TYPE);
         this.registries = this.extensions.register(REGISTRY_EXTENSION_TYPE);
+        this.dashboard = this.extensions.register(DASHBOARD_EXTENSION_TYPE);
         this.signals = this.extensions.register(SIGNAL_EXTENSION_TYPE);
         this.assets = this.extensions.register(ASSET_EXTENSION_TYPE);
         this.i18n = this.extensions.register(I18N_EXTENSION_TYPE);
         this.server = this.extensions.register(SERVER_EXTENSION_TYPE);
         this.logger = this.extensions.register(LOGGER_EXTENSION_TYPE);
+        this.http = this.extensions.register(HTTP_EXTENSION_TYPE);
     }
 
     public send<T>(packetType: PacketType<T>, data: T): void {
@@ -117,6 +131,7 @@ export class Omu implements Client {
 
     public stop(): void {
         this.running = false;
+        this.ready = false;
         this.event.stopped.emit();
     }
 
@@ -126,4 +141,15 @@ export class Omu implements Client {
         }
         return this.event.ready.listen(callback);
     }
+
+    public async waitForReady(): Promise<void> {
+        if (this.ready) return;
+        return new Promise<void>((resolve) => {
+            let unlisten = () => {};
+            unlisten = this.event.ready.listen(() => {
+                unlisten();
+                resolve();
+            });
+        });
+    }
 }

package/src/serialize/bytebuffer.ts

@@ -0,0 +1,424 @@
+import { textDecoder, textEncoder } from '../const.js';
+import { JsonType } from './serializer.js';
+
+export class Flags {
+    private value: number;
+    private length: number;
+
+    constructor(options: { value?: number; length?: number }) {
+        this.value = options.value ?? 0;
+        this.length = options.length ?? 32;
+    }
+
+    public has(position: number): boolean {
+        return (this.value & (1 << position)) !== 0;
+    }
+
+    public get(position: number): boolean {
+        return (this.value & (1 << position)) !== 0;
+    }
+
+    public ifSet<T>(position: number, callback: () => T): T | undefined {
+        if (this.has(position)) {
+            return callback();
+        }
+        return undefined;
+    }
+
+    public set(position: number, value: boolean): void {
+        if (value) {
+            this.value |= 1 << position;
+        } else {
+            this.value &= ~(1 << position);
+        }
+    }
+
+    public write(writer: ByteWriter): void {
+        const bits = new Uint8Array((this.length + 7) / 8);
+        for (let i = 0; i < bits.length; i++) {
+            bits[i] = (this.value >> (i * 8)) & 0xff;
+        }
+        writer.write(bits);
+    }
+
+    public static read(reader: ByteReader, length: number): Flags {
+        let value = 0;
+        for (let i = 0; i < (length + 7) / 8; i++) {
+            value |= reader.readUint8() << (i * 8);
+        }
+        return new Flags({ value, length });
+    }
+}
+
+function readFloat16(dataView: DataView, offset: number): number {
+    const sign = (dataView.getUint16(offset) & 0x8000) ? -1 : 1;
+    const exponent = (dataView.getUint16(offset) & 0x7c00) >> 10;
+    const mantissa = (dataView.getUint16(offset) & 0x03ff);
+    if (exponent === 0 && mantissa === 0) {
+        return 0;
+    } else if (exponent === 0x1f) {
+        return mantissa === 0 ? Infinity * sign : NaN;
+    } else {
+        const normalizedExponent = exponent - 15;
+        const normalizedMantissa = mantissa / 1024;
+        return sign * Math.pow(2, normalizedExponent) * (1 + normalizedMantissa);
+    }
+}
+
+function writeFloat16(dataView: DataView, offset: number, value: number): void {
+    if (value === 0) {
+        dataView.setUint16(offset, 0);
+        return;
+    }
+    const sign = value < 0 ? 1 : 0;
+    value = Math.abs(value);
+    if (!isFinite(value)) {
+        dataView.setUint16(offset, 0x7c00 | (sign << 15));
+        return;
+    }
+    const exponent = Math.floor(Math.log2(value));
+    const mantissa = value / Math.pow(2, exponent) - 1;
+    const normalizedExponent = exponent + 15;
+    const normalizedMantissa = Math.round(mantissa * 1024);
+    if (normalizedExponent <= 0) {
+        dataView.setUint16(offset, sign << 15);
+    } else if (normalizedExponent >= 0x1f) {
+        dataView.setUint16(offset, 0x7c00 | (sign << 15));
+    } else {
+        dataView.setUint16(offset, (sign << 15) | (normalizedExponent << 10) | normalizedMantissa);
+    }
+}
+
+export class ByteWriter {
+    private dataView: DataView;
+    private buffer: ArrayBuffer;
+    private offset = 0;
+    private finished = false;
+
+    constructor(init?: ArrayBuffer, offset?: number) {
+        this.offset = offset ?? 0;
+        this.buffer = init ?? new ArrayBuffer(1024);
+        this.dataView = new DataView(this.buffer);
+    }
+
+    public static fromUint8Array(buffer: Uint8Array): ByteWriter {
+        const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+        const uint8Array = new Uint8Array(arrayBuffer);
+        uint8Array.set(new Uint8Array(buffer));
+        return new ByteWriter(arrayBuffer, buffer.byteLength);
+    }
+
+    private allocate(length: number): void {
+        if (this.offset + length > this.buffer.byteLength) {
+            const newByteLength = Math.max(this.buffer.byteLength * 2, this.offset + length);
+            const newBuffer = new ArrayBuffer(newByteLength);
+            new Uint8Array(newBuffer).set(new Uint8Array(this.buffer));
+            this.buffer = newBuffer;
+            this.dataView = new DataView(this.buffer);
+        }
+    }
+
+    public write(data: Uint8Array): ByteWriter {
+        if (this.finished) {
+            throw new Error('Buffer already finished');
+        }
+        this.allocate(data.length);
+        new Uint8Array(this.buffer).set(data, this.offset);
+        this.offset += data.length;
+        return this;
+    }
+
+    public writeBoolean(value: boolean): ByteWriter {
+        this.allocate(1);
+        this.dataView.setInt8(this.offset, value ? 1 : 0);
+        this.offset += 1;
+        return this;
+    }
+
+    public writeInt8(value: number): ByteWriter {
+        this.allocate(1);
+        this.dataView.setInt8(this.offset, value);
+        this.offset += 1;
+        return this;
+    }
+
+    public writeUint8(value: number): ByteWriter {
+        this.allocate(1);
+        this.dataView.setUint8(this.offset, value);
+        this.offset += 1;
+        return this;
+    }
+
+    public writeInt16(value: number): ByteWriter {
+        this.allocate(2);
+        this.dataView.setInt16(this.offset, value);
+        this.offset += 2;
+        return this;
+    }
+
+    public writeUint16(value: number): ByteWriter {
+        this.allocate(2);
+        this.dataView.setUint16(this.offset, value);
+        this.offset += 2;
+        return this;
+    }
+
+    public writeInt32(value: number): ByteWriter {
+        this.allocate(4);
+        this.dataView.setInt32(this.offset, value);
+        this.offset += 4;
+        return this;
+    }
+
+    public writeUint32(value: number): ByteWriter {
+        this.allocate(4);
+        this.dataView.setUint32(this.offset, value);
+        this.offset += 4;
+        return this;
+    }
+
+    public writeInt64(value: bigint): ByteWriter {
+        this.allocate(8);
+        this.dataView.setBigInt64(this.offset, value);
+        this.offset += 8;
+        return this;
+    }
+
+    public writeUint64(value: bigint): ByteWriter {
+        this.allocate(8);
+        this.dataView.setBigUint64(this.offset, value);
+        this.offset += 8;
+        return this;
+    }
+
+    public writeULEB128(value: number): ByteWriter {
+        // Unsigned LEB128
+        if (value < 0) {
+            throw new Error('Value must be non-negative');
+        }
+        while (value > 0x7f) {
+            this.allocate(1);
+            this.dataView.setUint8(this.offset, (value & 0x7f) | 0x80);
+            this.offset += 1;
+            value >>= 7;
+        }
+        this.allocate(1);
+        this.dataView.setUint8(this.offset, value & 0x7f);
+        this.offset += 1;
+        return this;
+    }
+
+    public writeFloat16(value: number): ByteWriter {
+        this.allocate(2);
+        writeFloat16(this.dataView, this.offset, value);
+        this.offset += 2;
+        return this;
+    }
+
+    public writeFloat32(value: number): ByteWriter {
+        this.allocate(4);
+        this.dataView.setFloat32(this.offset, value);
+        this.offset += 4;
+        return this;
+    }
+
+    public writeFloat64(value: number): ByteWriter {
+        this.allocate(4);
+        this.dataView.setFloat64(this.offset, value);
+        this.offset += 4;
+        return this;
+    }
+
+    public writeUint8Array(value: Uint8Array): ByteWriter {
+        this.writeULEB128(value.byteLength);
+        this.write(value);
+        return this;
+    }
+
+    public writeString(value: string): ByteWriter {
+        this.writeUint8Array(textEncoder.encode(value));
+        return this;
+    }
+
+    public writeJSON(value: JsonType): ByteWriter {
+        this.writeString(JSON.stringify(value));
+        return this;
+    }
+
+    public writeFlags(flags: Flags): ByteWriter {
+        flags.write(this);
+        return this;
+    }
+
+    public finish(): Uint8Array {
+        if (this.finished) {
+            throw new Error('Buffer already finished');
+        }
+        this.finished = true;
+        return new Uint8Array(this.buffer, 0, this.offset);
+    }
+}
+
+export class ByteReader {
+    private dataView: DataView;
+    private offset: number;
+    private finished: boolean;
+
+    private constructor(data: DataView) {
+        this.dataView = data;
+        this.offset = 0;
+        this.finished = false;
+    }
+
+    public static fromUint8Array(buffer: Uint8Array): ByteReader {
+        const arrayBuffer = new ArrayBuffer(buffer.byteLength);
+        const uint8Array = new Uint8Array(arrayBuffer);
+        uint8Array.set(new Uint8Array(buffer));
+        const dataView = new DataView(arrayBuffer);
+        return new ByteReader(dataView);
+    }
+
+    public static fromArrayBuffer(buffer: ArrayBuffer): ByteReader {
+        const dataView = new DataView(buffer);
+        return new ByteReader(dataView);
+    }
+
+    public static async fromBlob(blob: Blob): Promise<ByteReader> {
+        const arrayBuffer = await blob.arrayBuffer();
+        const dataView = new DataView(arrayBuffer);
+        return new ByteReader(dataView);
+    }
+
+    public read(size: number): Uint8Array {
+        if (this.finished) {
+            throw new Error('Buffer already finished');
+        }
+        if (size < 0) {
+            throw new Error('Size must be positive');
+        }
+        if (this.offset + size > this.dataView.byteLength) {
+            throw new Error('Buffer not fully read');
+        }
+        const value = new Uint8Array(this.dataView.buffer, this.offset, size);
+        this.offset += size;
+        return value;
+    }
+
+    public readBoolean(): boolean {
+        const value = this.dataView.getInt8(this.offset);
+        this.offset += 1;
+        return value !== 0;
+    }
+
+    public readInt8(): number {
+        const value = this.dataView.getInt8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+
+    public readUint8(): number {
+        const value = this.dataView.getUint8(this.offset);
+        this.offset += 1;
+        return value;
+    }
+
+    public readInt16(): number {
+        const value = this.dataView.getInt16(this.offset);
+        this.offset += 2;
+        return value;
+    }
+
+    public readUint16(): number {
+        const value = this.dataView.getUint16(this.offset);
+        this.offset += 2;
+        return value;
+    }
+
+    public readInt32(): number {
+        const value = this.dataView.getInt32(this.offset);
+        this.offset += 4;
+        return value;
+    }
+
+    public readUint32(): number {
+        const value = this.dataView.getUint32(this.offset);
+        this.offset += 4;
+        return value;
+    }
+
+    public readInt64(): bigint {
+        const value = this.dataView.getBigInt64(this.offset);
+        this.offset += 8;
+        return value;
+    }
+
+    public readUint64(): bigint {
+        const value = this.dataView.getBigUint64(this.offset);
+        this.offset += 8;
+        return value;
+    }
+
+    public readULEB128(): number {
+        // Unsigned LEB128
+        let value = 0;
+        let shift = 0;
+        let byte: number;
+        do {
+            if (this.offset >= this.dataView.byteLength) {
+                throw new Error('Buffer not fully read');
+            }
+            byte = this.dataView.getUint8(this.offset);
+            this.offset += 1;
+            value |= (byte & 0b01111111) << shift;
+            shift += 7;
+        }
+        while ((byte & 0b10000000) !== 0);
+        return value;
+    }
+
+    public readFloat16(): number {
+        const value = readFloat16(this.dataView, this.offset);
+        this.offset += 2;
+        return value;
+    }
+
+    public readFloat32(): number {
+        const value = this.dataView.getFloat32(this.offset);
+        this.offset += 4;
+        return value;
+    }
+
+    public readFloat64(): number {
+        const value = this.dataView.getFloat64(this.offset);
+        this.offset += 8;
+        return value;
+    }
+
+    public readUint8Array(): Uint8Array {
+        const length = this.readULEB128();
+        return this.read(length);
+    }
+
+    public readString(): string {
+        const byteArray = this.readUint8Array();
+        return textDecoder.decode(byteArray);
+    }
+
+    public readJSON<T extends JsonType>(): T {
+        return JSON.parse(this.readString());
+    }
+
+    public readFlags(length: number): Flags {
+        return Flags.read(this, length);
+    }
+
+    public finish(): void {
+        if (this.finished) {
+            throw new Error('Buffer already finished');
+        }
+        this.finished = true;
+        if (this.offset !== this.dataView.byteLength) {
+            throw new Error('Buffer not fully read');
+        }
+    }
+}

package/src/serialize/index.ts

@@ -0,0 +1,2 @@
+export { ByteReader, ByteWriter, Flags } from './bytebuffer';
+export { JsonType, Serializer, type Serializable } from './serializer';