@omujs/omu 0.9.47 → 0.9.49

package/src/api/dashboard/packets.ts

@@ -1,126 +0,0 @@
-import { App, AppJson } from '../../app.js';
-import { ByteReader, ByteWriter } from '../../serialize';
-
-export type AppInstallResponse = {
-    accepted: boolean;
-};
-
-export type DragDropFile = {
-    type: 'file' | 'directory';
-    size: number;
-    name: string;
-};
-
-export type DragDropPosition = {
-    x: number;
-    y: number;
-};
-
-export type DragEnter = {
-    type: 'enter';
-    drag_id: string;
-    files: DragDropFile[];
-    position: DragDropPosition;
-};
-
-export type DragOver = {
-    type: 'over';
-    drag_id: string;
-    position: DragDropPosition;
-};
-
-export type DragDrop = {
-    type: 'drop';
-    drag_id: string;
-    position: DragDropPosition;
-    files: DragDropFile[];
-};
-
-export type DragLeave = {
-    type: 'leave';
-    drag_id: string;
-};
-
-export type DragState = DragEnter | DragOver | DragDrop | DragLeave;
-
-export type FileDragPacket = {
-    drag_id: string;
-    app: App;
-    state: DragState;
-};
-
-export type DragDropReadRequest = {
-    drag_id: string;
-};
-
-export type DragDropReadRequestDashboard = {
-    request_id: string;
-    drag_id: string;
-};
-
-export type DragDropReadMeta = {
-    request_id: string;
-    drag_id: string;
-    files: readonly DragDropFile[];
-};
-
-export type FileData = {
-    file: DragDropFile;
-    buffer: Uint8Array;
-};
-
-export class DragDropReadResponse {
-    constructor(
-        public readonly meta: DragDropReadMeta,
-        public readonly files: Record<string, FileData>,
-        public readonly version: number = 1,
-    ) {}
-
-    public static serialize(data: DragDropReadResponse): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeULEB128(data.version);
-        writer.writeString(JSON.stringify(data.meta));
-        writer.writeULEB128(Object.keys(data.files).length);
-
-        for (const [key, { file, buffer }] of Object.entries(data.files)) {
-            writer.writeString(key);
-            writer.writeString(JSON.stringify(file));
-            writer.writeUint8Array(buffer);
-        }
-
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): DragDropReadResponse {
-        const reader = ByteReader.fromUint8Array(data);
-        const version = reader.readULEB128();
-        const meta: DragDropReadMeta = JSON.parse(reader.readString());
-        const length = reader.readULEB128();
-
-        const files: Record<string, FileData> = {};
-        for (let i = 0; i < length; i++) {
-            const key = reader.readString();
-            const file: DragDropFile = JSON.parse(reader.readString());
-            const buffer = reader.readUint8Array();
-            files[key] = { file, buffer };
-        }
-
-        return new DragDropReadResponse(
-            meta,
-            files,
-            version,
-        );
-    }
-}
-
-export type DragDropRequest = object;
-
-export type DragDropRequestDashboard = {
-    request_id: string;
-    app: AppJson;
-};
-
-export type DragDropRequestResponse = {
-    request_id: string;
-    ok: boolean;
-};

package/src/api/endpoint/endpoint.ts

@@ -1,56 +0,0 @@
-import { Identifier, IntoId } from '../../identifier';
-import { JsonType, type Serializable, Serializer } from '../../serialize';
-
-export class EndpointType<Req = unknown, Res = unknown> {
-    constructor(
-        public readonly id: Identifier,
-        public readonly requestSerializer: Serializable<Req, Uint8Array>,
-        public readonly responseSerializer: Serializable<Res, Uint8Array>,
-        public readonly permissionId?: Identifier | undefined,
-    ) { }
-
-    static createJson<Req, Res, ReqData extends JsonType = JsonType, ResData extends JsonType = JsonType>(
-        identifier: IntoId,
-        {
-            name,
-            requestSerializer,
-            responseSerializer,
-            permissionId,
-        }: {
-            name: string;
-            requestSerializer?: Serializable<Req, ReqData>;
-            responseSerializer?: Serializable<Res, ResData>;
-            permissionId?: IntoId;
-        },
-    ): EndpointType<Req, Res> {
-        return new EndpointType<Req, Res>(
-            Identifier.from(identifier).join(name),
-            Serializer.pipe<Req, JsonType, Uint8Array>(requestSerializer ?? Serializer.noop(), Serializer.json()),
-            Serializer.pipe<Res, JsonType, Uint8Array>(responseSerializer ?? Serializer.noop(), Serializer.json()),
-            permissionId ? Identifier.from(permissionId) : undefined,
-        );
-    }
-
-    static createSerialized<Req, Res>(
-        identifier: IntoId,
-        {
-            name,
-            requestSerializer,
-            responseSerializer,
-            permissionId,
-        }: {
-            name: string;
-            requestSerializer: Serializable<Req, Uint8Array>;
-            responseSerializer: Serializable<Res, Uint8Array>;
-            permissionId?: IntoId;
-        },
-    ): EndpointType<Req, Res> {
-        return new EndpointType<Req, Res>(
-            Identifier.from(identifier).join(name),
-            requestSerializer,
-            responseSerializer,
-            permissionId ? Identifier.from(permissionId) : undefined,
-        );
-    }
-}
-

package/src/api/endpoint/extension.ts

@@ -1,133 +0,0 @@
-import type { Identifier } from '../../identifier';
-import { IdentifierMap } from '../../identifier';
-import { PacketType } from '../../network/packet';
-import { Omu } from '../../omu';
-import { ExtensionType } from '../extension.js';
-
-import { EndpointType } from './endpoint.js';
-import { EndpointInvokedPacket, EndpointInvokePacket, EndpointRegisterPacket, EndpointResponsePacket, InvokedParams, InvokeParams, ResponseParams } from './packets.js';
-
-export const ENDPOINT_EXTENSION_TYPE: ExtensionType<EndpointExtension> = new ExtensionType(
-    'endpoint',
-    (omu: Omu) => new EndpointExtension(omu),
-);
-
-type CallPromise = {
-    resolve: (data: Uint8Array) => void;
-    reject: (error: Error) => void;
-};
-
-type EndpointHandler = {
-    type: EndpointType;
-    handler: (packet: EndpointInvokedPacket) => Promise<Uint8Array>;
-};
-
-export class EndpointExtension {
-    public readonly type: ExtensionType<EndpointExtension> = ENDPOINT_EXTENSION_TYPE;
-    private readonly boundEndpoints = new IdentifierMap<EndpointHandler>();
-    private readonly responsePromises: Map<number, CallPromise> = new Map();
-    private callId: number;
-
-    constructor(private readonly omu: Omu) {
-        this.callId = Math.floor((performance.timeOrigin + performance.now()) * 1000);
-        omu.network.registerPacket(
-            ENDPOINT_REGISTER_PACKET,
-            ENDPOINT_INVOKE_PACKET,
-            ENDPOINT_INVOKED_PACKET,
-            ENDPOINT_RESPONSE_PACKET,
-        );
-        omu.network.addPacketHandler(ENDPOINT_INVOKED_PACKET, (packet) => {
-            this.handleInvoked(packet);
-        });
-        omu.network.addPacketHandler(ENDPOINT_RESPONSE_PACKET, (packet) => {
-            const promise = this.responsePromises.get(packet.params.key);
-            if (!promise) {
-                throw new Error(
-                    `Received response for unknown key ${packet.params.key} (${packet.params.id.key()})`,
-                );
-            }
-            this.responsePromises.delete(packet.params.key);
-            if (packet.params.error) {
-                promise.reject(new Error(packet.params.error));
-                return;
-            }
-            promise.resolve(packet.buffer);
-        });
-        omu.network.addTask(() => this.onTask());
-    }
-
-    private async handleInvoked(packet: EndpointInvokedPacket) {
-        const endpoint = this.boundEndpoints.get(packet.params.id);
-        if (!endpoint) {
-            throw new Error(`Received invocation for unknown endpoint ${packet.params.id.key()} (${packet.params.key})`);
-        }
-        try {
-            const result = await endpoint.handler(packet);
-            this.omu.send(ENDPOINT_RESPONSE_PACKET, new EndpointResponsePacket(
-                new ResponseParams(packet.params.id, packet.params.key, null),
-                result,
-            ));
-        } catch (error) {
-            this.omu.send(ENDPOINT_RESPONSE_PACKET, new EndpointResponsePacket(
-                new ResponseParams(packet.params.id, packet.params.key, JSON.stringify(error)),
-                new Uint8Array(),
-            ));
-        }
-    }
-
-    private onTask(): void {
-        const endpoints = new IdentifierMap<Identifier | undefined>();
-        for (const [key, endpoint] of this.boundEndpoints) {
-            endpoints.set(key, endpoint.type.permissionId);
-        }
-        const packet = new EndpointRegisterPacket(endpoints);
-        this.omu.send(ENDPOINT_REGISTER_PACKET, packet);
-    }
-
-    public bind<Req, Res>(
-        type: EndpointType<Req, Res>,
-        handler: (data: Req, params: InvokedParams) => Promise<Res>,
-    ): void {
-        if (this.omu.running) {
-            throw new Error('Cannot register endpoints after the client has started');
-        }
-        if (this.boundEndpoints.has(type.id)) {
-            throw new Error(`Endpoint with id ${type.id.key()} is already registered`);
-        }
-        this.boundEndpoints.set(type.id, { type, handler: async ({ buffer, params }) => {
-            const req = type.requestSerializer.deserialize(buffer);
-            const result = await handler(req, params);
-            return type.responseSerializer.serialize(result);
-        } });
-    }
-
-    public async call<Req, Res>(endpoint: EndpointType<Req, Res>, data: Req): Promise<Res> {
-        const key = this.callId++;
-        const promise = new Promise<Uint8Array>((resolve, reject) => {
-            this.responsePromises.set(key, { resolve, reject });
-        });
-        this.omu.send(ENDPOINT_INVOKE_PACKET, new EndpointInvokePacket(
-            new InvokeParams(endpoint.id, key),
-            endpoint.requestSerializer.serialize(data),
-        ));
-        const response = await promise;
-        return endpoint.responseSerializer.deserialize(response);
-    }
-}
-
-const ENDPOINT_REGISTER_PACKET = PacketType.createSerialized<EndpointRegisterPacket>(ENDPOINT_EXTENSION_TYPE, {
-    name: 'register',
-    serializer: EndpointRegisterPacket,
-});
-const ENDPOINT_INVOKE_PACKET = PacketType.createSerialized<EndpointInvokePacket>(ENDPOINT_EXTENSION_TYPE, {
-    name: 'invoke',
-    serializer: EndpointInvokePacket,
-});
-const ENDPOINT_INVOKED_PACKET = PacketType.createSerialized<EndpointInvokedPacket>(ENDPOINT_EXTENSION_TYPE, {
-    name: 'invoked',
-    serializer: EndpointInvokedPacket,
-});
-const ENDPOINT_RESPONSE_PACKET = PacketType.createSerialized<EndpointResponsePacket>(ENDPOINT_EXTENSION_TYPE, {
-    name: 'response',
-    serializer: EndpointResponsePacket,
-});

package/src/api/endpoint/packets.ts

@@ -1,176 +0,0 @@
-import { Identifier, IdentifierMap } from '../../identifier';
-import { ByteReader, ByteWriter } from '../../serialize';
-
-export class EndpointRegisterPacket {
-    constructor(
-        public endpoints: IdentifierMap<Identifier | undefined>,
-    ) { }
-
-    public static serialize(item: EndpointRegisterPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeULEB128(item.endpoints.size);
-        for (const [key, value] of item.endpoints) {
-            writer.writeString(key.key());
-            writer.writeString(value?.key() ?? '');
-        }
-        return writer.finish();
-    }
-
-    public static deserialize(item: Uint8Array): EndpointRegisterPacket {
-        const reader = ByteReader.fromUint8Array(item);
-        const count = reader.readULEB128();
-        const endpoints = new IdentifierMap<Identifier | undefined>();
-        for (let i = 0; i < count; i++) {
-            const key = Identifier.fromKey(reader.readString());
-            const value = Identifier.fromKey(reader.readString());
-            endpoints.set(key, value);
-        }
-        return new EndpointRegisterPacket(endpoints);
-    }
-}
-
-export class InvokedParams {
-    constructor(
-        public readonly id: Identifier,
-        public readonly caller: Identifier,
-        public readonly key: number,
-    ) { }
-
-    public static serialize(item: InvokedParams): string {
-        return JSON.stringify({
-            id: item.id.key(),
-            caller: item.caller.key(),
-            key: item.key,
-        });
-    }
-
-    public static deserialize(item: string): InvokedParams {
-        const data: {
-            id: string;
-            caller: string;
-            key: number;
-        } = JSON.parse(item);
-        return new InvokedParams(
-            Identifier.fromKey(data.id),
-            Identifier.fromKey(data.caller),
-            data.key,
-        );
-    }
-};
-
-export class EndpointInvokedPacket {
-    constructor(
-        public params: InvokedParams,
-        public buffer: Uint8Array,
-    ) { }
-
-    public static serialize(item: EndpointInvokedPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(InvokedParams.serialize(item.params));
-        writer.writeUint8Array(item.buffer);
-        return writer.finish();
-    }
-
-    public static deserialize(item: Uint8Array): EndpointInvokedPacket {
-        const reader = ByteReader.fromUint8Array(item);
-        const params = InvokedParams.deserialize(reader.readString());
-        const buffer = reader.readUint8Array();
-        return new EndpointInvokedPacket(params, buffer);
-    }
-}
-
-export class InvokeParams {
-    constructor(
-        public readonly id: Identifier,
-        public readonly key: number,
-    ) { }
-
-    public static serialize(item: InvokeParams): string {
-        return JSON.stringify({
-            id: item.id.key(),
-            key: item.key,
-        });
-    }
-
-    public static deserialize(item: string): InvokeParams {
-        const data: {
-            id: string;
-            key: number;
-        } = JSON.parse(item);
-        return new InvokeParams(
-            Identifier.fromKey(data.id),
-            data.key,
-        );
-    }
-};
-
-export class EndpointInvokePacket {
-    constructor(
-        public params: InvokeParams,
-        public buffer: Uint8Array,
-    ) { }
-
-    public static serialize(item: EndpointInvokePacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(InvokeParams.serialize(item.params));
-        writer.writeUint8Array(item.buffer);
-        return writer.finish();
-    }
-
-    public static deserialize(item: Uint8Array): EndpointInvokePacket {
-        const reader = ByteReader.fromUint8Array(item);
-        const params = InvokeParams.deserialize(reader.readString());
-        const buffer = reader.readUint8Array();
-        return new EndpointInvokePacket(params, buffer);
-    }
-}
-
-export class ResponseParams {
-    constructor(
-        public readonly id: Identifier,
-        public readonly key: number,
-        public readonly error: string | null,
-    ) { }
-
-    public static serialize(item: ResponseParams): string {
-        return JSON.stringify({
-            id: item.id.key(),
-            key: item.key,
-            error: item.error,
-        });
-    }
-
-    public static deserialize(item: string): ResponseParams {
-        const data: {
-            id: string;
-            key: number;
-            error: string | null;
-        } = JSON.parse(item);
-        return new ResponseParams(
-            Identifier.fromKey(data.id),
-            data.key,
-            data.error,
-        );
-    }
-};
-
-export class EndpointResponsePacket {
-    constructor(
-        public params: ResponseParams,
-        public buffer: Uint8Array,
-    ) { }
-
-    public static serialize(item: EndpointResponsePacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(ResponseParams.serialize(item.params));
-        writer.writeUint8Array(item.buffer);
-        return writer.finish();
-    }
-
-    public static deserialize(item: Uint8Array): EndpointResponsePacket {
-        const reader = ByteReader.fromUint8Array(item);
-        const params = ResponseParams.deserialize(reader.readString());
-        const buffer = reader.readUint8Array();
-        return new EndpointResponsePacket(params, buffer);
-    }
-}

package/src/api/extension-registry.ts

@@ -1,17 +0,0 @@
-import { Omu } from '../omu.js';
-import type { Extension, ExtensionType } from './extension.js';
-
-export class ExtensionRegistry {
-    private readonly extensionMap: Map<string, Extension> = new Map();
-
-    constructor(private readonly omu: Omu) {}
-
-    register<T extends Extension>(type: ExtensionType<T>): T {
-        if (this.extensionMap.has(type.name)) {
-            throw new Error(`Extension type ${type.name} already registered`);
-        }
-        const extension = type.create(this.omu);
-        this.extensionMap.set(type.name, extension);
-        return extension;
-    }
-}

package/src/api/extension.ts

@@ -1,19 +0,0 @@
-import { Identifier } from '../identifier';
-import { Omu } from '../omu';
-
-export interface Extension {
-    readonly type: ExtensionType;
-}
-
-export class ExtensionType<T extends Extension = Extension> extends Identifier {
-    constructor(
-        public readonly name: string,
-        public readonly create: (omu: Omu) => T,
-    ) {
-        super('ext', name);
-    }
-
-    public key(): string {
-        return new Identifier('ext', this.name).key();
-    }
-}