@omujs/omu 0.1.22

package/src/localization/localization.ts

@@ -0,0 +1,9 @@
+import type { Locale } from './locale.js';
+
+export type LocalizedText = {
+    [key in Locale]?: string;
+} | string;
+
+export interface Translations {
+    [key: string]: Translations | LocalizedText;
+}

package/src/model.ts

@@ -0,0 +1,4 @@
+export interface Model<T> {
+    toJson(): T;
+    toString(): string;
+}

package/src/network/connection.ts

@@ -0,0 +1,43 @@
+import { Identifier, IdentifierMap } from '../identifier.js';
+import type { Serializable } from '../serializer.js';
+
+import type { PacketData, PacketType } from './packet/index.js';
+import type { Packet } from './packet/packet.js';
+
+export class PacketMapper implements Serializable<Packet, PacketData> {
+    private readonly packetMap = new IdentifierMap<PacketType<unknown>>();
+
+    public register(...packetTypes: PacketType<unknown>[]): void {
+        for (const type of packetTypes) {
+            if (this.packetMap.has(type.id)) {
+                throw new Error(`Packet id ${type.id.key()} already registered`);
+            }
+            this.packetMap.set(type.id, type);
+        }
+    }
+
+    serialize(packet: Packet): PacketData {
+        return {
+            type: packet.type.id.key(),
+            data: packet.type.serializer.serialize(packet.data),
+        };
+    }
+
+    deserialize(data: PacketData): Packet {
+        const identifier = Identifier.fromKey(data.type);
+        const type = this.packetMap.get(identifier);
+        if (!type) throw new Error(`Packet type ${data.type} not registered`);
+        return {
+            type,
+            data: type.serializer.deserialize(data.data),
+        };
+    }
+}
+
+export interface Connection {
+    connect(): Promise<void>;
+    send(packet: Packet, serializer: Serializable<Packet, PacketData>): void;
+    receive(serializer: Serializable<Packet, PacketData>): Promise<Packet | null>;
+    close(): void;
+    closed: boolean;
+}

package/src/network/index.ts

@@ -0,0 +1,3 @@
+export type { Address } from '../address.js';
+export type { Connection } from './connection.js';
+export { Network, NetworkStatus } from './network.js';

package/src/network/network.ts

@@ -0,0 +1,225 @@
+import type { Address } from '../address.js';
+import type { Client } from '../client.js';
+import type { OmuError } from '../errors.js';
+import {
+    AnotherConnection,
+    InvalidOrigin,
+    InvalidPacket,
+    InvalidToken,
+    InvalidVersion,
+    PermissionDenied,
+} from '../errors.js';
+import { EventEmitter } from '../event-emitter.js';
+import { IdentifierMap } from '../identifier.js';
+import type { TokenProvider } from '../token.js';
+
+import type { Connection } from './connection.js';
+import { PacketMapper } from './connection.js';
+import { ConnectPacket, DisconnectType, PACKET_TYPES } from './packet/packet-types.js';
+import type { Packet, PacketType } from './packet/packet.js';
+
+type PacketHandler<T> = {
+    readonly type: PacketType<T>;
+    event: EventEmitter<(packet: T) => void>;
+};
+
+export enum NetworkStatus {
+    DISCONNECTED = 'disconnected',
+    CONNECTING = 'connecting',
+    CONNECTED = 'connected',
+    READY = 'ready',
+    ERROR = 'error',
+    CLOSED = 'closed',
+}
+
+export class Network {
+    public status: NetworkStatus = NetworkStatus.DISCONNECTED;
+    public readonly event = {
+        connected: new EventEmitter<() => void>(),
+        disconnected: new EventEmitter<() => void>(),
+        packet: new EventEmitter<(packet: Packet) => void>(),
+        status: new EventEmitter<(status: NetworkStatus) => void>(),
+    };
+    private readonly tasks: Array<() => Promise<void> | void> = [];
+    private readonly packetMapper = new PacketMapper();
+    private readonly packetHandlers = new IdentifierMap<PacketHandler<unknown>>();
+
+    constructor(
+        private readonly client: Client,
+        public readonly address: Address,
+        private readonly tokenProvider: TokenProvider,
+        private connection: Connection,
+    ) {
+        this.registerPacket(
+            PACKET_TYPES.CONNECT,
+            PACKET_TYPES.DISCONNECT,
+            PACKET_TYPES.TOKEN,
+            PACKET_TYPES.READY,
+        );
+        this.addPacketHandler(PACKET_TYPES.TOKEN, async (token: string) => {
+            await this.tokenProvider.set(this.address, this.client.app, token);
+        });
+        this.addPacketHandler(PACKET_TYPES.DISCONNECT, (reason) => {
+            if (reason.type === DisconnectType.SHUTDOWN || reason.type === DisconnectType.CLOSE) {
+                return;
+            }
+            this.setStatus(NetworkStatus.ERROR);
+            const ERROR_MAP: Record<DisconnectType, typeof OmuError | undefined> = {
+                [DisconnectType.ANOTHER_CONNECTION]: AnotherConnection,
+                [DisconnectType.PERMISSION_DENIED]: PermissionDenied,
+                [DisconnectType.INVALID_TOKEN]: InvalidToken,
+                [DisconnectType.INVALID_ORIGIN]: InvalidOrigin,
+                [DisconnectType.INVALID_VERSION]: InvalidVersion,
+                [DisconnectType.INVALID_PACKET]: InvalidPacket,
+                [DisconnectType.INVALID_PACKET_TYPE]: InvalidPacket,
+                [DisconnectType.INVALID_PACKET_DATA]: InvalidPacket,
+                [DisconnectType.CLOSE]: undefined,
+                [DisconnectType.SHUTDOWN]: undefined,
+            };
+            const error = ERROR_MAP[reason.type];
+            if (error) {
+                throw new error(reason.message);
+            }
+        });
+        this.addPacketHandler(PACKET_TYPES.READY, () => {
+            if (this.status === NetworkStatus.READY) {
+                throw new Error('Received READY packet when already ready');
+            }
+            this.setStatus(NetworkStatus.READY);
+            this.event.status.emit(NetworkStatus.READY);
+            this.client.event.ready.emit();
+        });
+    }
+
+    public setConnection(connection: Connection): void {
+        if (this.status !== NetworkStatus.DISCONNECTED) {
+            throw new Error('Cannot change connection while connected');
+        }
+        this.connection = connection;
+    }
+
+    public registerPacket(...packetTypes: PacketType<unknown>[]): void {
+        this.packetMapper.register(...packetTypes);
+        for (const type of packetTypes) {
+            this.packetHandlers.set(type.id, {
+                type,
+                event: new EventEmitter(),
+            });
+        }
+    }
+
+    public addPacketHandler<T>(type: PacketType<T>, handler: (packet: T) => void): void {
+        const listeners = this.packetHandlers.get(type.id) as PacketHandler<unknown> | undefined;
+        if (!listeners) {
+            throw new Error(`Packet type ${type.id.key()} not registered`);
+        }
+        listeners.event.listen(handler as (packet: unknown) => void);
+    }
+
+    public async connect(recconect = true): Promise<void> {
+        if (this.status !== NetworkStatus.DISCONNECTED) {
+            throw new Error(`Cannot connect while ${this.status}`);
+        }
+
+        try {
+            await this.connection.connect();
+        } catch (error) {
+            if (recconect) {
+                await this.tryReconnect();
+            } else {
+                throw error;
+            }
+        }
+        this.setStatus(NetworkStatus.CONNECTING);
+        const token = await this.tokenProvider.get(this.address, this.client.app);
+        this.send({
+            type: PACKET_TYPES.CONNECT,
+            data: new ConnectPacket({
+                app: this.client.app,
+                token,
+            }),
+        });
+        const listenPromise = this.listen();
+        await this.event.status.emit(NetworkStatus.CONNECTED);
+        await this.event.connected.emit();
+        await this.dispatchTasks();
+        this.send({
+            type: PACKET_TYPES.READY,
+            data: null,
+        });
+        await listenPromise;
+
+        if (recconect) {
+            await this.tryReconnect();
+        }
+    }
+
+    private async tryReconnect(): Promise<void> {
+        if (this.status === NetworkStatus.CLOSED) {
+            return;
+        }
+        await new Promise((resolve) => setTimeout(resolve, 1000));
+        await this.connect();
+    }
+
+    public disconnect(): void {
+        if (this.status === NetworkStatus.CLOSED) {
+            return;
+        }
+        this.setStatus(NetworkStatus.DISCONNECTED);
+        this.event.status.emit(NetworkStatus.DISCONNECTED);
+        this.connection.close();
+        this.event.disconnected.emit();
+    }
+
+    public send(packet: Packet): void {
+        if (this.connection.closed) {
+            throw new Error('Cannot send packet while connection is closed');
+        }
+        this.connection.send(packet, this.packetMapper);
+    }
+
+    private async listen(): Promise<void> {
+        while (!this.connection.closed) {
+            const packet = await this.connection.receive(this.packetMapper);
+            if (!packet) {
+                return;
+            }
+            this.dispatchPacket(packet);
+        }
+    }
+
+    private async dispatchPacket(packet: Packet): Promise<void> {
+        await this.event.packet.emit(packet);
+        const packetHandler = this.packetHandlers.get(packet.type.id);
+        if (!packetHandler) {
+            return;
+        }
+        await packetHandler.event.emit(packet.data);
+    }
+
+    public addTask(task: () => Promise<void> | void): void {
+        if (this.client.running) {
+            throw new Error('Cannot add task after client is ready');
+        }
+        this.tasks.push(task);
+    }
+
+    public removeTask(task: () => Promise<void> | void): void {
+        this.tasks.splice(this.tasks.indexOf(task), 1);
+    }
+
+    private async dispatchTasks(): Promise<void> {
+        for (const task of this.tasks) {
+            await task();
+        }
+    }
+
+    private setStatus(status: NetworkStatus): void {
+        if (this.status === status) {
+            throw new Error(`Cannot set status to ${status} when already ${status}`);
+        }
+        this.status = status;
+        this.event.status.emit(status);
+    }
+}

package/src/network/packet/index.ts

@@ -0,0 +1,2 @@
+export { PacketType } from './packet.js';
+export type { PacketData } from './packet.js';

package/src/network/packet/packet-types.ts

@@ -0,0 +1,101 @@
+import type { AppJson } from '../../app.js';
+import { App } from '../../app.js';
+import { Identifier } from '../../identifier.js';
+import type { Model } from '../../model.js';
+import { Serializer } from '../../serializer.js';
+
+import { PacketType } from './packet.js';
+
+const IDENTIFIER = new Identifier('core', 'packet');
+
+type ConnectPacketJson = {
+    app: AppJson,
+    token?: string,
+};
+export class ConnectPacket implements Model<ConnectPacketJson> {
+    public readonly app: App;
+    public readonly token?: string;
+    constructor(options: {
+        app: App,
+        token?: string,
+    }) {
+        this.app = options.app;
+        this.token = options.token;
+    }
+
+    static fromJson(data: ConnectPacketJson): ConnectPacket {
+        return new ConnectPacket({
+            app: App.fromJson(data.app),
+            token: data.token,
+        });
+    }
+
+    toJson(): ConnectPacketJson {
+        return {
+            app: this.app.toJson(),
+            token: this.token,
+        };
+    }
+}
+
+export enum DisconnectType {
+    INVALID_TOKEN = 'invalid_token',
+    INVALID_ORIGIN = 'invalid_origin',
+    INVALID_VERSION = 'invalid_version',
+    INVALID_PACKET_TYPE = 'invalid_packet_type',
+    INVALID_PACKET_DATA = 'invalid_packet_data',
+    INVALID_PACKET = 'invalid_packet',
+    ANOTHER_CONNECTION = 'another_connection',
+    PERMISSION_DENIED = 'permission_denied',
+    SHUTDOWN = 'shutdown',
+    CLOSE = 'close',
+}
+
+type DisconnectPacketJson = {
+    type: DisconnectType,
+    message: string | null,
+};
+
+export class DisconnectPacket implements Model<DisconnectPacketJson> {
+    public readonly type: DisconnectType;
+    public readonly message: string | null;
+
+    constructor(options: {
+        type: DisconnectType,
+        message?: string | null,
+    }) {
+        this.type = options.type;
+        this.message = options.message ?? null;
+    }
+
+    static fromJson(data: DisconnectPacketJson): DisconnectPacket {
+        return new DisconnectPacket({
+            type: data.type,
+            message: data.message,
+        });
+    }
+
+    toJson(): DisconnectPacketJson {
+        return {
+            type: this.type,
+            message: this.message,
+        };
+    }
+}
+
+export const PACKET_TYPES = {
+    CONNECT: PacketType.createJson<ConnectPacket>(IDENTIFIER, {
+        name: 'connect',
+        serializer: Serializer.model(ConnectPacket),
+    }),
+    DISCONNECT: PacketType.createJson<DisconnectPacket>(IDENTIFIER, {
+        name: 'disconnect',
+        serializer: Serializer.model(DisconnectPacket),
+    }),
+    TOKEN: PacketType.createJson<string>(IDENTIFIER, {
+        name: 'token',
+    }),
+    READY: PacketType.createJson<undefined>(IDENTIFIER, {
+        name: 'ready',
+    }),
+};

package/src/network/packet/packet.ts

@@ -0,0 +1,46 @@
+import type { Identifier } from '../../identifier.js';
+import { Serializer, type Serializable } from '../../serializer.js';
+
+export interface PacketData {
+    readonly type: string;
+    readonly data: Uint8Array;
+}
+
+export interface Packet<T = unknown> {
+    readonly type: PacketType<T>;
+    readonly data: T;
+}
+
+export class PacketType<T> {
+    constructor(
+        public readonly id: Identifier,
+        public readonly serializer: Serializable<T, Uint8Array>,
+    ) { }
+
+    static createJson<T>(identifier: Identifier, {
+        name,
+        serializer,
+    }: {
+        name: string;
+        serializer?: Serializable<T, any>;
+    }): PacketType<T> {
+        return new PacketType(
+            identifier.join(name),
+            Serializer.of<T, any>(serializer ?? Serializer.noop())
+                .pipe(Serializer.json()),
+        );
+    }
+
+    static createSerialized<T>(identifier: Identifier, {
+        name,
+        serializer,
+    }: {
+        name: string;
+        serializer: Serializable<T, Uint8Array>;
+    }): PacketType<T> {
+        return new PacketType(
+            identifier.join(name),
+            serializer,
+        );
+    }
+}

package/src/network/websocket-connection.ts

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

package/src/omu.ts

@@ -0,0 +1,123 @@
+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 { Connection, Address } from './network/index.js';
+import { Network } from './network/index.js';
+import type { PacketType } from './network/packet/packet.js';
+import { WebsocketConnection } from './network/websocket-connection.js';
+import { BrowserTokenProvider, type TokenProvider } from './token.js';
+
+export class Omu implements Client {
+    public ready: boolean;
+    public running: boolean;
+    readonly event: ClientEvents = {
+        started: new EventEmitter(),
+        stopped: new EventEmitter(),
+        ready: new EventEmitter(),
+    };
+    readonly token: TokenProvider;
+    readonly address: Address;
+    readonly network: Network;
+    readonly endpoints: EndpointExtension;
+    readonly permissions: PermissionExtension;
+    readonly plugins: PluginExtension;
+    readonly dashboard: DashboardExtension;
+    readonly extensions: ExtensionRegistry;
+    readonly tables: TableExtension;
+    readonly registry: RegistryExtension;
+    readonly signal: SignalExtension;
+    readonly assets: AssetExtension;
+    readonly i18n: I18nExtension;
+    readonly server: ServerExtension;
+    readonly logger: LoggerExtension;
+
+    constructor(
+        public readonly app: App,
+        options?: {
+            address?: Address;
+            token?: TokenProvider;
+            connection?: Connection;
+        },
+    ) {
+        this.ready = false;
+        this.running = false;
+        this.token = options?.token ?? new BrowserTokenProvider('omu-token');
+        this.address = options?.address ?? {
+            host: '127.0.0.1',
+            port: 26423,
+            secure: false,
+        };
+        this.network = new Network(
+            this,
+            this.address,
+            this.token,
+            options?.connection ?? new WebsocketConnection(this.address),
+        );
+        this.extensions = new ExtensionRegistry(this);
+
+        this.endpoints = this.extensions.register(ENDPOINT_EXTENSION_TYPE);
+        this.permissions = this.extensions.register(PERMISSION_EXTENSION_TYPE);
+        this.plugins = this.extensions.register(PLUGIN_EXTENSION_TYPE);
+        this.tables = this.extensions.register(TABLE_EXTENSION_TYPE);
+        this.dashboard = this.extensions.register(DASHBOARD_EXTENSION_TYPE);
+        this.registry = this.extensions.register(REGISTRY_EXTENSION_TYPE);
+        this.signal = 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.event.ready.listen(() => {
+            this.ready = true;
+        });
+        this.network.event.disconnected.listen(() => {
+            this.ready = false;
+        });
+    }
+
+    public send<T>(packetType: PacketType<T>, data: T): void {
+        this.network.send({
+            type: packetType,
+            data,
+        });
+    }
+
+    public start(): void {
+        if (this.running) {
+            throw new Error('Client already running');
+        }
+        this.running = true;
+        this.network.connect();
+        this.event.started.emit();
+    }
+
+    public stop(): void {
+        this.running = false;
+        this.event.stopped.emit();
+    }
+
+    public whenReady(callback: () => void): Unlisten {
+        if (this.ready) {
+            callback();
+        }
+        return this.event.ready.listen(callback);
+    }
+}