@omujs/omu 0.9.48 → 0.9.49

package/src/api/http/websocket.ts

@@ -1,283 +0,0 @@
-import { textDecoder } from '../../const';
-import { DataChunk, RequestHandle } from './http';
-
-export type WSData = string | ArrayBufferLike | Blob | ArrayBufferView;
-
-export const WSMsgType = {
-    CONTINUATION: 0x0,
-    TEXT: 0x1,
-    BINARY: 0x2,
-    PING: 0x9,
-    PONG: 0xA,
-    CLOSE: 0x8,
-} as const;
-
-export const WSCloseCode = {
-    OK: 1000,
-    GOING_AWAY: 1001,
-    PROTOCOL_ERROR: 1002,
-    UNSUPPORTED_DATA: 1003,
-    ABNORMAL_CLOSURE: 1006,
-    INVALID_TEXT: 1007,
-    POLICY_VIOLATION: 1008,
-    MESSAGE_TOO_BIG: 1009,
-    MANDATORY_EXTENSION: 1010,
-    INTERNAL_ERROR: 1011,
-    SERVICE_RESTART: 1012,
-    TRY_AGAIN_LATER: 1013,
-    BAD_GATEWAY: 1014,
-} as const;
-
-export type WebSocketOpen = RequestHandle & {
-    url: string;
-    protocol?: string | null;
-};
-export type WebSocketClose = RequestHandle & {
-    code?: number;
-    reason?: string | null;
-};
-export type WebSocketError = RequestHandle & {
-    type: 'ConnectionRefused';
-    reason?: string | null;
-};
-
-export type EventListenerMap<T> = {
-    [K in keyof T]: ((event: T[K]) => unknown)[]
-};
-
-export type WSMsg = {
-    type: 'open';
-    data: WebSocketOpen;
-} | {
-    type: 'error';
-    data: WebSocketError;
-} | {
-    type: 'text';
-    data: string;
-} | {
-    type: 'binary';
-    data: Uint8Array;
-} | {
-    type: 'close';
-    data: WebSocketClose;
-};
-
-export type WebSocketHandle = {
-    ws: OmuWS;
-    open: (response: WebSocketOpen) => void;
-    dispatch: (data: DataChunk<WSDataMeta>) => void;
-    close: (response: WebSocketClose) => void;
-    error: (response: WebSocketError) => void;
-};
-
-export type WSDataMeta = {
-    id: string;
-    type:
-        | typeof WSMsgType.TEXT
-        | typeof WSMsgType.BINARY
-        | typeof WSMsgType.PING
-        | typeof WSMsgType.PONG;
-};
-
-export type WSHandleState = {
-    type: 'created' | 'receiving';
-    handle: WebSocketHandle;
-};
-
-type WSOptions = {
-    addQueue: (data: WSData) => void;
-    dispose(options: {
-        code?: number;
-        reason?: string;
-    }): void;
-};
-
-export class OmuWS {
-    constructor(
-        protected readonly addQueue: (data: WSData) => void,
-        protected readonly dispose: (options: { code?: number; reason?: string }) => void,
-        protected readonly receiveQueue: WSMsg[] = [],
-        private receiveResolve: (() => void) | undefined = undefined,
-        private status: 'connecting' | 'open' | 'closed' = 'connecting',
-    ) { }
-
-    public toWebSocket(): OmuWebSocket {
-        return new OmuWebSocket(this);
-    }
-
-    public static create(options: WSOptions): WebSocketHandle {
-        const ws = new OmuWS(options.addQueue, options.dispose);
-        return {
-            ws,
-            open: (response) => {
-                ws.receiveQueue.push({
-                    type: 'open',
-                    data: response,
-                });
-                ws.receiveResolve?.();
-            },
-            dispatch: (data: DataChunk<WSDataMeta>): void => {
-                if (data.meta.type === WSMsgType.BINARY) {
-                    ws.receiveQueue.push({
-                        type: 'binary',
-                        data: data.body,
-                    });
-                } else {
-                    ws.receiveQueue.push({
-                        type: 'text',
-                        data: textDecoder.decode(data.body),
-                    });
-                }
-                ws.receiveResolve?.();
-            },
-            close: (response) => {
-                ws.receiveQueue.push({
-                    type: 'close',
-                    data: response,
-                });
-                ws.receiveResolve?.();
-            },
-            error: (response) => {
-                ws.receiveQueue.push({
-                    type: 'error',
-                    data: response,
-                });
-                ws.receiveResolve?.();
-            },
-        };
-    }
-
-    public send(data: WSData): void {
-        this.addQueue(data);
-    }
-
-    public close(code?: number, reason?: string): void {
-        this.dispose({ code, reason });
-    }
-
-    public async receive(): Promise<WSMsg> {
-        if (this.receiveResolve) {
-            throw new Error('Already receiving from another async call');
-        }
-        while (this.status !== 'closed') {
-            const data = this.receiveQueue.shift();
-            if (!data) {
-                await new Promise<void>((resolve) => this.receiveResolve = resolve);
-                continue;
-            }
-            if (data.type === 'close') {
-                this.status = 'closed';
-            }
-            if (data.type === 'open') {
-                this.status = 'open';
-            }
-            this.receiveResolve = undefined;
-            return data;
-        }
-        throw new Error('Receiving on already closed socket');
-    }
-
-    protocol: string = '';
-    url: string = '';
-}
-
-export class OmuWebSocket implements WebSocket {
-    public CONNECTING = 0 as const;
-    public OPEN = 1 as const;
-    public CLOSING = 2 as const;
-    public CLOSED = 3 as const;
-
-    binaryType: BinaryType = 'blob';
-    bufferedAmount: number = 0;
-    extensions: string = '';
-    onclose: ((this: WebSocket, ev: CloseEvent) => unknown) | null = null;
-    onerror: ((this: WebSocket, ev: Event) => unknown) | null = null;
-    onmessage: ((this: WebSocket, ev: MessageEvent) => unknown) | null = null;
-    onopen: ((this: WebSocket, ev: Event) => unknown) | null = null;
-    protocol: string = '';
-    readyState: 0 | 2 | 1 | 3 = 0;
-    url: string = '';
-
-    constructor(
-        protected readonly ws: OmuWS,
-        private readonly eventListeners: EventListenerMap<WebSocketEventMap> = {
-            close: [],
-            error: [],
-            message: [],
-            open: [],
-        },
-    ) {
-        this.receiveLoop();
-    }
-
-    private async receiveLoop() {
-        while (this.readyState === WebSocket.CLOSED) {
-            const { data, type } = await this.ws.receive();
-            switch (type) {
-                case 'close':
-                    this.dispatchEvent(new CloseEvent('close', {
-                        code: data.code,
-                        reason: data.reason ?? undefined,
-                    }));
-                    break;
-                case 'open':
-                    this.url = data.url;
-                    this.protocol = data.protocol ?? '';
-                    this.dispatchEvent(new Event('open', {}));
-                    break;
-                case 'error':
-                    this.dispatchEvent(new ErrorEvent('error', {
-                        error: data.type,
-                        message: data.reason ?? undefined,
-                    }));
-                    break;
-                case 'text':
-                case 'binary':
-                    this.dispatchEvent(new MessageEvent('message', {
-                        data,
-                    }));
-                    break;
-            }
-        }
-    }
-
-    dispatchEvent(event: Event): boolean {
-        const listeners = this.eventListeners[event.type];
-        for (const listener of listeners) {
-            listener(event);
-        }
-        if (event.type === 'open') {
-            this.onopen?.(event as MessageEvent);
-        }
-        if (event.type === 'error') {
-            this.onerror?.(event);
-        }
-        if (event.type === 'message') {
-            this.onmessage?.(event as MessageEvent);
-        }
-        if (event.type === 'close') {
-            this.onclose?.(event as CloseEvent);
-        }
-        return true;
-    }
-
-    send(data: string | ArrayBufferLike | Blob | ArrayBufferView): void {
-        this.ws.send(data);
-    }
-
-    close(code?: number, reason?: string): void {
-        this.ws.close(code, reason);
-    }
-
-    addEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => unknown): void {
-        this.eventListeners[type].push(listener);
-    }
-
-    removeEventListener<K extends keyof WebSocketEventMap>(type: K, listener: (this: WebSocket, ev: WebSocketEventMap[K]) => unknown): void {
-        const listeners = this.eventListeners[type];
-        const index = listeners.indexOf(listener);
-        if (index !== -1) {
-            listeners.splice(index, 1);
-        }
-    }
-}

package/src/api/i18n/extension.ts

@@ -1,65 +0,0 @@
-import { Identifier } from '../../identifier';
-import type { Locale } from '../../localization/locale.js';
-import type { LocalizedText } from '../../localization/localization.js';
-import { Omu } from '../../omu';
-import type { Extension } from '../extension.js';
-import { ExtensionType } from '../extension.js';
-import { RegistryType, type Registry } from '../registry';
-
-export const I18N_EXTENSION_TYPE: ExtensionType<I18nExtension> = new ExtensionType('i18n', (client) => new I18nExtension(client));
-
-export const I18N_SET_LOCALES_PERMISSION_ID: Identifier = I18N_EXTENSION_TYPE.join('locales', 'set');
-export const I18N_GET_LOCALES_PERMISSION_ID: Identifier = I18N_EXTENSION_TYPE.join('locales', 'get');
-const I18N_LOCALES_REGISTRY_TYPE = RegistryType.createJson<Locale[]>(I18N_EXTENSION_TYPE, {
-    name: 'locales',
-    defaultValue: typeof window === 'undefined' ? [] : window.navigator.languages as Locale[],
-});
-
-export class I18nExtension implements Extension {
-    public readonly type: ExtensionType<I18nExtension> = I18N_EXTENSION_TYPE;
-    public readonly localesRegistry: Registry<Locale[]>;
-
-    constructor(private readonly omu: Omu) {
-        this.localesRegistry = omu.registries.get(I18N_LOCALES_REGISTRY_TYPE);
-    }
-
-    public translate(localizedText: LocalizedText): string {
-        const locales = this.localesRegistry.value;
-        if (typeof localizedText === 'string') {
-            return localizedText;
-        }
-        const translation = this.selectBestTranslation(locales, localizedText);
-        if (!translation) {
-            return Object.values(localizedText)[0];
-        }
-        return translation;
-    }
-
-    public selectBestTranslation(
-        locales: readonly Locale[],
-        localizedText: LocalizedText,
-    ): string | undefined {
-        if (typeof localizedText === 'string') {
-            return localizedText;
-        }
-        const translations = localizedText;
-        const transformedLocales = locales.reduce((acc, l) => {
-            const parts = l.split('-');
-            for (let i = parts.length; i > 0; i--) {
-                acc.push(parts.slice(0, i).join('-'));
-            }
-            return acc;
-        }, [] as string[]);
-        for (const l of transformedLocales) {
-            const translation = translations[l];
-            if (translation) {
-                return translation;
-            }
-        }
-        return undefined;
-    }
-
-    public setLocale(locale: Locale[]): Promise<void> {
-        return this.localesRegistry.set(locale);
-    }
-}

package/src/api/logger/extension.ts

@@ -1,75 +0,0 @@
-import type { Unlisten } from '../../event';
-import { Identifier, IdentifierMap } from '../../identifier';
-import { PacketType } from '../../network/packet/packet.js';
-import { Omu } from '../../omu';
-import { ExtensionType } from '../extension.js';
-
-import type { LogMessage } from './packets.js';
-import { LogPacket, LogType } from './packets.js';
-
-export const LOGGER_EXTENSION_TYPE: ExtensionType<LoggerExtension> = new ExtensionType(
-    'logger',
-    (client) => new LoggerExtension(client),
-);
-
-export const LOGGER_LOG_PERMISSION_ID: Identifier = LOGGER_EXTENSION_TYPE.join('log');
-
-export const LOGGER_LOG_PACKET: PacketType<LogPacket> = PacketType.createSerialized<LogPacket>(LOGGER_EXTENSION_TYPE, {
-    name: 'log',
-    serializer: LogPacket,
-});
-export const LOGGER_LISTEN_PACKET: PacketType<Identifier> = PacketType.createJson<Identifier>(LOGGER_EXTENSION_TYPE, {
-    name: 'listen',
-    serializer: Identifier,
-});
-
-type LogListener = (message: LogMessage) => void;
-export class LoggerExtension {
-    public readonly type: ExtensionType<LoggerExtension> = LOGGER_EXTENSION_TYPE;
-    private readonly listeners: IdentifierMap<LogListener[]> = new IdentifierMap();
-
-    constructor(private readonly omu: Omu) {
-        omu.network.registerPacket(LOGGER_LOG_PACKET, LOGGER_LISTEN_PACKET);
-        omu.network.addPacketHandler(LOGGER_LOG_PACKET, (packet) => {
-            const listener = this.listeners.get(packet.id);
-            if (listener) {
-                listener.forEach((it) => it(packet.message));
-            }
-        });
-    }
-
-    public log(message: LogMessage): void {
-        const packet = new LogPacket(this.omu.app.id, message);
-        this.omu.send(LOGGER_LOG_PACKET, packet);
-    }
-
-    public error(text: string): void {
-        this.log({ type: LogType.ERROR, text });
-    }
-
-    public warning(text: string): void {
-        this.log({ type: LogType.WARNING, text });
-    }
-
-    public info(text: string): void {
-        this.log({ type: LogType.INFO, text });
-    }
-
-    public debug(text: string): void {
-        this.log({ type: LogType.DEBUG, text });
-    }
-
-    public listen(id: Identifier, listener: LogListener): Unlisten {
-        if (!this.listeners.has(id)) {
-            this.omu.onReady(() => {
-                this.omu.send(LOGGER_LISTEN_PACKET, id);
-            });
-        }
-        const list = this.listeners.get(id) ?? [];
-        list.push(listener);
-        this.listeners.set(id, list);
-        return () => {
-            list.splice(list.indexOf(listener), 1);
-        };
-    }
-}

package/src/api/logger/index.ts

@@ -1,4 +0,0 @@
-export {
-    LOGGER_LOG_PERMISSION_ID,
-} from './extension.js';
-

package/src/api/logger/packets.ts

@@ -1,38 +0,0 @@
-import { Identifier } from '../../identifier';
-import { ByteReader, ByteWriter } from '../../serialize';
-
-export enum LogType {
-    ERROR = 'error',
-    WARNING = 'warning',
-    INFO = 'info',
-    DEBUG = 'debug',
-}
-
-export type LogMessage = {
-    type: LogType;
-    text: string;
-};
-
-export class LogPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly message: LogMessage,
-    ) {}
-
-    public static serialize(item: LogPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(item.id.key());
-        writer.writeString(item.message.type);
-        writer.writeString(item.message.text);
-        return writer.finish();
-    }
-
-    public static deserialize(item: Uint8Array): LogPacket {
-        const reader = ByteReader.fromUint8Array(item);
-        const id = reader.readString();
-        const type = reader.readString() as LogType;
-        const text = reader.readString();
-        const message = { type, text };
-        return new LogPacket(Identifier.fromKey(id), message);
-    }
-}

package/src/api/permission/extension.ts

@@ -1,107 +0,0 @@
-import { Identifier, IdentifierMap, IdentifierSet, IntoId } from '../../identifier';
-import { PacketType } from '../../network/packet/packet.js';
-import { Omu } from '../../omu';
-import { Serializer } from '../../serialize';
-import { EndpointType } from '../endpoint/endpoint.js';
-import { ExtensionType } from '../extension.js';
-
-import { PermissionType } from './permission.js';
-
-export const PERMISSION_EXTENSION_TYPE: ExtensionType<PermissionExtension> = new ExtensionType(
-    'permission',
-    (client) => new PermissionExtension(client),
-);
-const PERMISSION_REGISTER_PACKET = PacketType.createJson<PermissionType[]>(
-    PERMISSION_EXTENSION_TYPE,
-    {
-        name: 'register',
-        serializer: Serializer.of(PermissionType).toArray(),
-    },
-);
-const PERMISSION_REQUIRE_PACKET = PacketType.createJson<Identifier[]>(PERMISSION_EXTENSION_TYPE, {
-    name: 'require',
-    serializer: Serializer.of(Identifier).toArray(),
-});
-const PERMISSION_REQUEST_ENDPOINT = EndpointType.createJson<Identifier[], void>(
-    PERMISSION_EXTENSION_TYPE,
-    {
-        name: 'request',
-        requestSerializer: Serializer.of(Identifier).toArray(),
-    },
-);
-const PERMISSION_GRANT_PACKET = PacketType.createJson<PermissionType[]>(PERMISSION_EXTENSION_TYPE, {
-    name: 'grant',
-    serializer: Serializer.of(PermissionType).toArray(),
-});
-
-export class PermissionExtension {
-    public readonly type: ExtensionType<PermissionExtension> = PERMISSION_EXTENSION_TYPE;
-    private permissions = new IdentifierMap<PermissionType>();
-    private readonly registeredPermissions = new IdentifierMap<PermissionType>();
-    private readonly requiredPermissions = new IdentifierSet();
-
-    constructor(private readonly omu: Omu) {
-        omu.network.registerPacket(
-            PERMISSION_REGISTER_PACKET,
-            PERMISSION_REQUIRE_PACKET,
-            PERMISSION_GRANT_PACKET,
-        );
-        omu.network.addPacketHandler(PERMISSION_GRANT_PACKET, (permissions) => {
-            for (const permission of permissions) {
-                this.permissions.set(permission.id, permission);
-            }
-        });
-        omu.network.addTask(() => this.onTask());
-    }
-
-    private onTask(): void {
-        if (this.omu.app.type === 'remote') {
-            return;
-        }
-        if (this.registeredPermissions.size > 0) {
-            this.omu.send(
-                PERMISSION_REGISTER_PACKET,
-                Array.from(this.registeredPermissions.values()),
-            );
-        }
-        if (this.requiredPermissions.size > 0) {
-            this.omu.send(
-                PERMISSION_REQUIRE_PACKET,
-                Array.from(this.requiredPermissions.values()),
-            );
-        }
-    }
-
-    public register(permission: PermissionType): void {
-        if (this.omu.running) {
-            this.omu.send(PERMISSION_REGISTER_PACKET, [permission]);
-        }
-        this.registeredPermissions.set(permission.id, permission);
-    }
-
-    public require(...permissionIds: IntoId[]): void {
-        const ids = permissionIds.map(Identifier.from);
-        const missing = ids.filter((id) => !this.permissions.has(id));
-        if (this.omu.running) {
-            if (missing.length > 0) {
-                throw new Error('Permissions must be registered before the client starts');
-            }
-            return;
-        }
-        for (const id of ids) {
-            this.requiredPermissions.add(id);
-        }
-    }
-
-    public async request(...permissionIds: Identifier[]): Promise<void> {
-        await this.omu.endpoints.call(PERMISSION_REQUEST_ENDPOINT, permissionIds);
-    }
-
-    public has(permissionIdentifier: Identifier): boolean {
-        return this.permissions.has(permissionIdentifier);
-    }
-
-    public required(permissionIdentifier: Identifier): boolean {
-        return this.requiredPermissions.has(permissionIdentifier);
-    }
-}

package/src/api/permission/permission.ts

@@ -1,53 +0,0 @@
-import { Identifier, IntoId } from '../../identifier';
-import type { LocalizedText } from '../../localization/localization.js';
-
-export type PermissionLevel = 'low' | 'medium' | 'high';
-
-export type PermissionMetadata = {
-    name: LocalizedText;
-    note?: LocalizedText;
-    level: PermissionLevel;
-};
-
-export type PermissionTypeJson = {
-    id: string;
-    metadata: PermissionMetadata;
-};
-
-export class PermissionType {
-    public readonly id: Identifier;
-    public readonly metadata: PermissionMetadata;
-
-    constructor(options: { id: Identifier; metadata: PermissionMetadata }) {
-        this.id = options.id;
-        this.metadata = options.metadata;
-    }
-
-    public static create(
-        identifier: IntoId,
-        {
-            metadata,
-        }: {
-            metadata: PermissionMetadata;
-        },
-    ): PermissionType {
-        return new PermissionType({
-            id: Identifier.from(identifier),
-            metadata: metadata,
-        });
-    }
-
-    public static serialize(data: PermissionType): PermissionTypeJson {
-        return {
-            id: data.id.key(),
-            metadata: data.metadata,
-        };
-    }
-
-    public static deserialize(json: PermissionTypeJson): PermissionType {
-        return new PermissionType({
-            id: Identifier.fromKey(json.id),
-            metadata: json.metadata,
-        });
-    }
-}