@omujs/omu 0.9.48 → 0.9.50

package/src/lock.ts

@@ -1,43 +0,0 @@
-
-type Task = () => Promise<void>;
-
-export class Lock {
-    private tasks: (Task)[] = [];
-    private waiter: Promise<void> | null = null;
-
-    private wait(): Promise<void> {
-        if (this.waiter) {
-            return this.waiter;
-        }
-        this.waiter = new Promise<void>((resolve) => {
-            const runTasks = async () => {
-                while (this.tasks.length > 0) {
-                    const task = this.tasks.shift();
-                    if (task) {
-                        await task();
-                    }
-                }
-                this.waiter = null;
-                resolve();
-            };
-            runTasks();
-        });
-        return this.waiter;
-    }
-
-    public async use<T>(callback: () => Promise<T>): Promise<T> {
-        const promise = new Promise<T>((resolve, reject) => {
-            const task = async () => {
-                const promise = callback();
-                try {
-                    resolve(await promise);
-                } catch (reason) {
-                    reject(reason);
-                }
-            };
-            this.tasks.push(task);
-        });
-        await this.wait();
-        return promise;
-    }
-}

package/src/network/connection.ts

@@ -1,45 +0,0 @@
-import { Identifier, IdentifierMap } from '../identifier';
-import type { Serializable } from '../serialize';
-
-import type { Packet, PacketData, PacketType } from './packet';
-
-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 Transport {
-    connect(): Promise<Connection>;
-}
-
-export interface Connection {
-    send(packet: Packet, serializer: Serializable<Packet, PacketData>): void;
-    receive(serializer: Serializable<Packet, PacketData>): Promise<Packet | null>;
-    close(): void;
-    closed: boolean;
-}

package/src/network/encryption.ts

@@ -1,221 +0,0 @@
-import { textDecoder, textEncoder } from '../const';
-import { ByteReader, ByteWriter } from '../serialize';
-import { Packet, PacketData } from './packet';
-import { PACKET_TYPES } from './packet/packet-types';
-
-function base64UrlEncode(buffer: Uint8Array): string {
-    return buffer
-        .toBase64()
-        .replace(/\+/g, '-')
-        .replace(/\//g, '_')
-        .replace(/=/g, '');
-}
-
-function base64UrlDecode(data: string): Uint8Array {
-    data = data.replace(/-/g, '+').replace(/_/g, '/');
-    while (data.length % 4) {
-        data += '=';
-    }
-    return Uint8Array.fromBase64(data);
-}
-
-function convertUint8ArrayToArrayBuffer(u8: Uint8Array): ArrayBuffer {
-    const buf = new ArrayBuffer(u8.length);
-    const view = new Uint8Array(buf);
-    view.set(u8);
-    return buf;
-}
-
-type RSANumbers = {
-    e: string;
-    n: string;
-};
-
-export type EncryptionResponse = {
-    kind: 'v1';
-    rsa: RSANumbers;
-    aes: string;
-};
-
-export const ENCRYPTION_AVAILABLE: boolean = typeof crypto !== 'undefined' && !!crypto.subtle;
-
-export class Decryptor {
-    private constructor(
-        private readonly privateKey: CryptoKey,
-        private readonly publicKey: CryptoKey,
-    ) {}
-
-    public static async new(): Promise<Decryptor> {
-        const { privateKey, publicKey } = await crypto.subtle.generateKey(
-            {
-                name: 'RSA-OAEP',
-                modulusLength: 4096,
-                publicExponent: new Uint8Array([1, 0, 1]),
-                hash: 'SHA-256',
-            },
-            true,
-            ['encrypt', 'decrypt'],
-        );
-
-        return new Decryptor(privateKey, publicKey);
-    }
-
-    public async toRequest(): Promise<RSANumbers> {
-        const key = await crypto.subtle.exportKey('jwk', this.publicKey);
-        if (!key.e) throw new Error('Key export failed: missing exponent');
-        if (!key.n) throw new Error('Key export failed: missing modulus');
-        return {
-            e: key.e,
-            n: key.n,
-        };
-    }
-
-    public async decrypt(data: ArrayBuffer): Promise<ArrayBuffer> {
-        const decrypted = await crypto.subtle.decrypt(
-            { name: 'RSA-OAEP' },
-            this.privateKey,
-            data,
-        );
-        return decrypted;
-    }
-
-    public async decryptString(data: string): Promise<string> {
-        const decrypted = await crypto.subtle.decrypt(
-            { name: 'RSA-OAEP' },
-            this.privateKey,
-            convertUint8ArrayToArrayBuffer(base64UrlDecode(data)),
-        );
-        return textDecoder.decode(decrypted);
-    }
-}
-
-export class Encryptor {
-    private constructor(
-        private readonly publicKey: CryptoKey,
-    ) {}
-
-    public static async new(request: RSANumbers): Promise<Encryptor> {
-        const publicKey = await crypto.subtle.importKey(
-            'jwk',
-            {
-                alg: 'RSA-OAEP-256',
-                ext: true,
-                key_ops: ['encrypt'],
-                kty: 'RSA',
-                e: request.e.replace(/=+$/, ''),
-                n: request.n.replace(/=+$/, ''),
-            },
-            {
-                name: 'RSA-OAEP',
-                hash: 'SHA-256',
-            },
-            true,
-            ['encrypt'],
-        );
-        return new Encryptor(publicKey);
-    }
-
-    public async encrypt(data: ArrayBuffer): Promise<ArrayBuffer> {
-        return await crypto.subtle.encrypt(
-            {
-                name: 'RSA-OAEP',
-            },
-            this.publicKey,
-            data,
-        );
-    }
-
-    public async encryptString(data: string): Promise<string> {
-        const encrypted = await crypto.subtle.encrypt(
-            {
-                name: 'RSA-OAEP',
-            },
-            this.publicKey,
-            textEncoder.encode(data),
-        );
-        return base64UrlEncode(new Uint8Array(encrypted));
-    }
-}
-
-export class AES {
-    private constructor(
-        private readonly key: CryptoKey,
-        private readonly iv: ArrayBuffer,
-    ) {}
-
-    public static async new(): Promise<AES> {
-        const key = await crypto.subtle.generateKey(
-            {
-                name: 'AES-CBC',
-                length: 128,
-            },
-            true,
-            ['encrypt', 'decrypt'],
-        );
-        const iv = crypto.getRandomValues(new Uint8Array(16));
-        return new AES(key, iv.buffer);
-    }
-
-    public static async deserialize(aes: string, decryptor: Decryptor): Promise<AES> {
-        const decrypted = await decryptor.decrypt(convertUint8ArrayToArrayBuffer(base64UrlDecode(aes)));
-        const reader = ByteReader.fromArrayBuffer(decrypted);
-        const key = reader.readUint8Array();
-        const iv = reader.readUint8Array();
-
-        const key_encoded = await crypto.subtle.importKey(
-            'raw',
-            convertUint8ArrayToArrayBuffer(key),
-            'AES-CBC',
-            false,
-            ['encrypt', 'decrypt'],
-        );
-        return new AES(
-            key_encoded,
-            convertUint8ArrayToArrayBuffer(iv),
-        );
-    }
-
-    public async serialize(encryptor: Encryptor): Promise<string> {
-        const writer = new ByteWriter();
-        const rawKey = await crypto.subtle.exportKey('raw', this.key);
-        writer.writeUint8Array(new Uint8Array(rawKey));
-        writer.writeUint8Array(new Uint8Array(this.iv));
-        const encrypted = await encryptor.encrypt(convertUint8ArrayToArrayBuffer(writer.finish()));
-        return base64UrlEncode(new Uint8Array(encrypted));
-    }
-
-    public async encrypt(data: PacketData): Promise<Packet> {
-        const writer = new ByteWriter();
-        writer.writeString(data.type);
-        writer.writeUint8Array(data.data);
-        const encrypted = await crypto.subtle.encrypt(
-            {
-                name: 'AES-CBC',
-                iv: this.iv,
-                length: 16,
-            },
-            this.key,
-            convertUint8ArrayToArrayBuffer(writer.finish()),
-        );
-        return PACKET_TYPES.ENCRYPTED_PACKET.new(new Uint8Array(encrypted));
-    }
-
-    public async decrypt(packet: Packet<Uint8Array>): Promise<PacketData> {
-        const decrypted = await crypto.subtle.decrypt(
-            {
-                name: 'AES-CBC',
-                iv: this.iv,
-                length: 16,
-            },
-            this.key,
-            convertUint8ArrayToArrayBuffer(packet.data),
-        );
-        const reader = ByteReader.fromArrayBuffer(decrypted);
-        const type = reader.readString();
-        const data = reader.readUint8Array();
-        return {
-            type,
-            data,
-        };
-    }
-}

package/src/network/frame-transport.ts

@@ -1,186 +0,0 @@
-
-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';
-
-const FRAME_TYPE_KEY = 'omuapps-frame';
-
-type Command = ({
-    type: 'syn';
-    payload: {
-        origin: string;
-    };
-} | {
-    type: 'connect';
-    payload: object;
-} | {
-    type: 'disconnect';
-    payload: object;
-} | {
-    type: 'send';
-    payload: Uint8Array;
-} | {
-    type: 'receive';
-    payload: Uint8Array;
-} | {
-    type: 'error';
-    payload: string;
-}) & {
-    type_key?: string;
-};
-
-export class FrameTransport implements Transport {
-    public connect(): Promise<FrameConnection> {
-        return FrameConnection.create();
-    }
-}
-
-export class FrameConnection implements Connection {
-    public connected: boolean;
-    private origin: string | null = null;
-    private readonly packetQueue: Array<PacketData> = [];
-    private readonly sendQueue: Array<Command> = [];
-    private receiveWaiter: (() => void) | null = null;
-
-    constructor(
-        private connectedWaiter: (() => void) | null,
-    ) {
-        this.connected = false;
-        window.addEventListener('message', (event) => {
-            if (event.data === null || typeof event.data !== 'object') {
-                return;
-            }
-            if (!('type_key' in event.data) || event.data.type_key !== FRAME_TYPE_KEY) {
-                return;
-            }
-            const command = event.data as Command;
-            if (command.type === 'syn') {
-                this.origin = event.origin;
-            }
-            if (event.origin !== this.origin) {
-                return;
-            }
-            this.handleCommand(command);
-        });
-    }
-
-    public static create(): Promise<FrameConnection> {
-        return new Promise<FrameConnection>((resolve) => {
-            const connection = new FrameConnection((): void => resolve(connection));
-            connection.postCommand({
-                type: 'connect',
-                payload: {},
-            });
-        });
-    }
-
-    private handleCommand(command: Command): void {
-        const { type, payload } = command;
-        switch (type) {
-            case 'syn':
-                this.origin = payload.origin;
-                this.postCommand({
-                    type: 'syn',
-                    payload: {
-                        origin: window.origin,
-                    },
-                });
-                break;
-            case 'connect':
-                this.connected = true;
-                if (this.connectedWaiter) {
-                    this.connectedWaiter();
-                    this.connectedWaiter = null;
-                }
-                break;
-            case 'disconnect':
-                this.connected = false;
-                break;
-            case 'receive': {
-                const reader = ByteReader.fromUint8Array(payload);
-                this.packetQueue.push({
-                    type: reader.readString(),
-                    data: reader.readUint8Array(),
-                });
-                reader.finish();
-                if (this.receiveWaiter) {
-                    this.receiveWaiter();
-                }
-                break;
-            }
-            case 'error':
-                throw new Error(payload);
-            case 'send':
-                break;
-            default:
-                throw new Error(`Unknown command type: ${type}`);
-        }
-    }
-
-    private postCommand(command: Command): void {
-        command.type_key = FRAME_TYPE_KEY;
-        if (!this.origin) {
-            this.sendQueue.push(command);
-            return;
-        }
-        for (const queuedCommand of this.sendQueue) {
-            window.parent.postMessage(queuedCommand, this.origin);
-        }
-        this.sendQueue.length = 0;
-        window.parent.postMessage(command, this.origin);
-    }
-
-    public async receive(serializer: Serializable<Packet<unknown>, PacketData>): Promise<Packet | null> {
-        if (this.receiveWaiter) {
-            throw new Error('Already receiving');
-        }
-        if (!this.connected) {
-            return null;
-        }
-        while (this.packetQueue.length === 0 && this.connected) {
-            await new Promise<void>((resolve) => {
-                this.receiveWaiter = (): void => resolve();
-            });
-        }
-        if (!this.connected) {
-            return null;
-        }
-        const packet = serializer.deserialize(this.packetQueue.shift()!);
-        this.receiveWaiter = null;
-        return packet;
-    }
-
-    get closed(): boolean {
-        return !this.connected;
-    }
-
-    close(): void {
-        if (this.connected) {
-            this.postCommand({
-                type: 'disconnect',
-                payload: {},
-            });
-        }
-        this.connected = false;
-        if (this.receiveWaiter) {
-            this.receiveWaiter();
-            this.receiveWaiter = null;
-        }
-    }
-
-    send(packet: Packet, serializer: Serializable<Packet<unknown>, PacketData>): void {
-        if (!this.connected) {
-            throw new Error('Not connected');
-        }
-        const packetData = serializer.serialize(packet);
-        const writer = new ByteWriter();
-        writer.writeString(packetData.type);
-        writer.writeUint8Array(packetData.data);
-        this.postCommand({
-            type: 'send',
-            payload: writer.finish(),
-        });
-    }
-}