@omujs/omu 0.9.48 → 0.9.49

package/{src/localization/localization.ts → dist/dts/localization/localization.d.ts}

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

package/dist/dts/lock.d.ts

@@ -0,0 +1,6 @@
+export declare class Lock {
+    private tasks;
+    private waiter;
+    private wait;
+    use<T>(callback: () => Promise<T>): Promise<T>;
+}

package/dist/dts/network/connection.d.ts

@@ -0,0 +1,17 @@
+import type { Serializable } from '../serialize';
+import type { Packet, PacketData, PacketType } from './packet';
+export declare class PacketMapper implements Serializable<Packet, PacketData> {
+    private readonly packetMap;
+    register(...packetTypes: PacketType<unknown>[]): void;
+    serialize(packet: Packet): PacketData;
+    deserialize(data: PacketData): Packet;
+}
+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/dist/dts/network/encryption.d.ts

@@ -0,0 +1,38 @@
+import { Packet, PacketData } from './packet';
+type RSANumbers = {
+    e: string;
+    n: string;
+};
+export type EncryptionResponse = {
+    kind: 'v1';
+    rsa: RSANumbers;
+    aes: string;
+};
+export declare const ENCRYPTION_AVAILABLE: boolean;
+export declare class Decryptor {
+    private readonly privateKey;
+    private readonly publicKey;
+    private constructor();
+    static new(): Promise<Decryptor>;
+    toRequest(): Promise<RSANumbers>;
+    decrypt(data: ArrayBuffer): Promise<ArrayBuffer>;
+    decryptString(data: string): Promise<string>;
+}
+export declare class Encryptor {
+    private readonly publicKey;
+    private constructor();
+    static new(request: RSANumbers): Promise<Encryptor>;
+    encrypt(data: ArrayBuffer): Promise<ArrayBuffer>;
+    encryptString(data: string): Promise<string>;
+}
+export declare class AES {
+    private readonly key;
+    private readonly iv;
+    private constructor();
+    static new(): Promise<AES>;
+    static deserialize(aes: string, decryptor: Decryptor): Promise<AES>;
+    serialize(encryptor: Encryptor): Promise<string>;
+    encrypt(data: PacketData): Promise<Packet>;
+    decrypt(packet: Packet<Uint8Array>): Promise<PacketData>;
+}
+export {};

package/dist/dts/network/frame-transport.d.ts

@@ -0,0 +1,22 @@
+import type { Serializable } from '../serialize';
+import type { Connection, Transport } from './connection.js';
+import type { Packet, PacketData } from './packet/packet.js';
+export declare class FrameTransport implements Transport {
+    connect(): Promise<FrameConnection>;
+}
+export declare class FrameConnection implements Connection {
+    private connectedWaiter;
+    connected: boolean;
+    private origin;
+    private readonly packetQueue;
+    private readonly sendQueue;
+    private receiveWaiter;
+    constructor(connectedWaiter: (() => void) | null);
+    static create(): Promise<FrameConnection>;
+    private handleCommand;
+    private postCommand;
+    receive(serializer: Serializable<Packet<unknown>, PacketData>): Promise<Packet | null>;
+    get closed(): boolean;
+    close(): void;
+    send(packet: Packet, serializer: Serializable<Packet<unknown>, PacketData>): void;
+}

package/{src/network/index.ts → dist/dts/network/index.d.ts}

@@ -3,4 +3,3 @@ export type { Connection } from './connection.js';
 export { FrameTransport } from './frame-transport.js';
 export { Network, type NetworkStatus } from './network.js';
 export { WebsocketTransport } from './websocket-transport.js';
-

package/dist/dts/network/network.d.ts

@@ -0,0 +1,59 @@
+import type { Address } from '../address.js';
+import { DisconnectReason } from '../errors.js';
+import { EventEmitter } from '../event';
+import { Omu } from '../omu.js';
+import type { SessioTokenProvider } from '../token.js';
+import type { Connection, Transport } from './connection.js';
+import { AES } from './encryption.js';
+import type { Packet, PacketType } from './packet/packet.js';
+type StatusType<T> = {
+    type: T;
+};
+export type NetworkStatus = StatusType<'connecting'> | StatusType<'connected'> | StatusType<'ready'> | {
+    type: 'disconnected';
+    attempt?: number;
+    reason?: DisconnectReason;
+} | {
+    type: 'reconnecting';
+    attempt: number;
+    timeout: number;
+    date: Date;
+    cancel: () => void;
+};
+export declare class Network {
+    private readonly omu;
+    address: Address;
+    private readonly tokenProvider;
+    private transport;
+    private connection?;
+    private aes?;
+    status: NetworkStatus;
+    readonly event: {
+        connected: EventEmitter<[]>;
+        disconnected: EventEmitter<[DisconnectReason | undefined]>;
+        packet: EventEmitter<[Packet<unknown>]>;
+        status: EventEmitter<[NetworkStatus]>;
+    };
+    private readonly tasks;
+    private readonly packetMapper;
+    private readonly packetHandlers;
+    private listenTask;
+    reason: DisconnectReason | undefined;
+    private attempt;
+    constructor(omu: Omu, address: Address, tokenProvider: SessioTokenProvider, transport: Transport, connection?: Connection | undefined, aes?: AES | undefined);
+    setConnection(connection: Connection): void;
+    registerPacket(...packetTypes: PacketType<unknown>[]): void;
+    addPacketHandler<T>(type: PacketType<T>, handler: (packet: T) => void): void;
+    private scheduleReconnect;
+    connect(reconnect?: boolean): Promise<void>;
+    private isState;
+    send(packet: Packet): Promise<void>;
+    private listen;
+    private dispatchPacket;
+    addTask(task: () => Promise<void> | void): void;
+    removeTask(task: () => Promise<void> | void): void;
+    private dispatchTasks;
+    private setStatus;
+    close(): void;
+}
+export {};

package/{src/network/packet/index.ts → dist/dts/network/packet/index.d.ts}

@@ -1,3 +1,2 @@
 export { DisconnectPacket, DisconnectType } from './packet-types.js';
 export { PacketType, type Packet, type PacketData } from './packet.js';
-

package/dist/dts/network/packet/packet-types.d.ts

@@ -0,0 +1,84 @@
+import type { AppJson } from '../../app.js';
+import { App } from '../../app.js';
+import { PacketType } from './packet.js';
+type ProtocolInfo = {
+    version: string;
+};
+type RSANumbers = {
+    e: string;
+    n: string;
+};
+type EncryptionRequest = {
+    kind: 'v1';
+    rsa: RSANumbers;
+};
+type EncryptionResponse = {
+    kind: 'v1';
+    rsa: RSANumbers;
+    aes: string;
+};
+export type ServerMeta = {
+    protocol: ProtocolInfo;
+    encryption: EncryptionRequest | null;
+    hash: string | undefined;
+};
+type ConnectPacketJson = {
+    protocol: ProtocolInfo;
+    app: AppJson;
+    token: string;
+    encryption: EncryptionResponse | null;
+};
+export declare class ConnectPacket {
+    readonly protocol: ProtocolInfo;
+    readonly app: App;
+    readonly token: string;
+    readonly encryption: EncryptionResponse | null;
+    constructor(options: {
+        protocol: ProtocolInfo;
+        app: App;
+        token: string;
+        encryption?: EncryptionResponse | null;
+    });
+    static deserialize(data: ConnectPacketJson): ConnectPacket;
+    static serialize(data: ConnectPacket): ConnectPacketJson;
+}
+export declare 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",
+    INTERNAL_ERROR = "internal_error",
+    ANOTHER_CONNECTION = "another_connection",
+    PERMISSION_DENIED = "permission_denied",
+    APP_REMOVED = "app_removed",
+    SERVER_RESTART = "server_restart",
+    SHUTDOWN = "shutdown",
+    CLOSE = "close"
+}
+type DisconnectPacketJson = {
+    type: DisconnectType;
+    message: string | null;
+};
+export declare class DisconnectPacket {
+    readonly type: DisconnectType;
+    readonly message: string | null;
+    constructor(options: {
+        type: DisconnectType;
+        message?: string | null;
+    });
+    static serialize(data: DisconnectPacket): DisconnectPacketJson;
+    static deserialize(data: DisconnectPacketJson): DisconnectPacket;
+    static fromJson(data: DisconnectPacketJson): DisconnectPacket;
+    toJson(): DisconnectPacketJson;
+}
+export declare const PACKET_TYPES: {
+    SERVER_META: PacketType<ServerMeta>;
+    CONNECT: PacketType<ConnectPacket>;
+    DISCONNECT: PacketType<DisconnectPacket>;
+    TOKEN: PacketType<string>;
+    READY: PacketType<undefined>;
+    ENCRYPTED_PACKET: PacketType<Uint8Array>;
+};
+export {};

package/dist/dts/network/packet/packet.d.ts

@@ -0,0 +1,25 @@
+import type { Identifier } from '../../identifier';
+import { JsonType, type Serializable } from '../../serialize';
+export type PacketData = {
+    readonly type: string;
+    readonly data: Uint8Array;
+};
+export type Packet<T = unknown> = {
+    readonly type: PacketType<T>;
+    readonly data: T;
+};
+export declare class PacketType<T> {
+    readonly id: Identifier;
+    readonly serializer: Serializable<T, Uint8Array>;
+    constructor(id: Identifier, serializer: Serializable<T, Uint8Array>);
+    new(data: T): Packet<T>;
+    match(packet: Packet): packet is Packet<T>;
+    static createJson<T, D extends JsonType = JsonType>(identifier: Identifier, { name, serializer, }: {
+        name: string;
+        serializer?: Serializable<T, D>;
+    }): PacketType<T>;
+    static createSerialized<T>(identifier: Identifier, { name, serializer, }: {
+        name: string;
+        serializer: Serializable<T, Uint8Array>;
+    }): PacketType<T>;
+}

package/dist/dts/network/websocket-transport.d.ts

@@ -0,0 +1,24 @@
+import type { Address } from '../address.js';
+import type { Serializable } from '../serialize';
+import type { Connection, Transport } from './connection.js';
+import type { Packet, PacketData } from './packet/packet.js';
+export declare class WebsocketTransport implements Transport {
+    private readonly address;
+    constructor(address: Address);
+    private get wsEndpoint();
+    connect(): Promise<Connection>;
+}
+export declare class WebsocketConnection implements Connection {
+    private socket;
+    private readonly packetQueue;
+    private receiveWaiter;
+    private readingPromise;
+    private beingClosed;
+    constructor(socket: WebSocket);
+    static fromSocket(socket: WebSocket): Promise<WebsocketConnection>;
+    private onMessage;
+    receive(serializer: Serializable<Packet<unknown>, PacketData>): Promise<Packet | null>;
+    get closed(): boolean;
+    close(): void;
+    send(packet: Packet, serializer: Serializable<Packet<unknown>, PacketData>): void;
+}

package/dist/dts/omu.d.ts

@@ -0,0 +1,61 @@
+import { ExtensionRegistry } from './api';
+import { type AssetExtension } from './api/asset/extension';
+import { type DashboardExtension } from './api/dashboard/extension';
+import { type EndpointExtension } from './api/endpoint/extension';
+import { HttpExtension } from './api/http/extension';
+import { type I18nExtension } from './api/i18n/extension';
+import { type LoggerExtension } from './api/logger/extension.js';
+import { type PermissionExtension } from './api/permission/extension';
+import { type PluginExtension } from './api/plugin/extension';
+import { type RegistryExtension } from './api/registry/extension';
+import { type ServerExtension } from './api/server/extension';
+import { SessionExtension } from './api/session';
+import { type SignalExtension } from './api/signal/extension';
+import { type TableExtension } from './api/table/extension';
+import type { App } from './app.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 type { PacketType } from './network/packet/packet.js';
+import { type SessioTokenProvider } from './token.js';
+export type ClientEvents = {
+    started: EventEmitter<[]>;
+    stopped: EventEmitter<[]>;
+    ready: EventEmitter<[]>;
+};
+export declare class Omu {
+    readonly app: App;
+    ready: boolean;
+    running: boolean;
+    readonly event: ClientEvents;
+    readonly token: SessioTokenProvider;
+    readonly address: Address;
+    readonly sessions: SessionExtension;
+    readonly network: Network;
+    readonly endpoints: EndpointExtension;
+    readonly permissions: PermissionExtension;
+    readonly plugins: PluginExtension;
+    readonly dashboard: DashboardExtension;
+    readonly extensions: ExtensionRegistry;
+    readonly tables: TableExtension;
+    readonly registries: RegistryExtension;
+    readonly signals: SignalExtension;
+    readonly assets: AssetExtension;
+    readonly i18n: I18nExtension;
+    readonly server: ServerExtension;
+    readonly logger: LoggerExtension;
+    readonly http: HttpExtension;
+    constructor(app: App, options?: {
+        address?: Address;
+        token?: SessioTokenProvider | string;
+        transport?: Transport;
+        connection?: Connection;
+    });
+    send<T>(packetType: PacketType<T>, data: T): void;
+    start(): Promise<void>;
+    stop(): void;
+    onReady(callback: () => void): Unlisten;
+    waitForReady(): Promise<void>;
+}

package/dist/dts/result.d.ts

@@ -0,0 +1,26 @@
+export type Success<T> = {
+    data: T;
+    error: null;
+};
+export type Failure<E> = {
+    data: null;
+    error: E;
+};
+export type Result<T, E = Error> = Success<T> | Failure<E>;
+export declare function tryCatch<T, E = Error>(promise: Promise<T>): Promise<Result<T, E>>;
+export declare function success<T>(data: T): Result<T>;
+export declare function failure<E>(error: E): Result<null, E>;
+export declare class PromiseResult<T, E = Error> implements Promise<T> {
+    private readonly promise;
+    private constructor();
+    static create<T, E = Error>(): {
+        promise: PromiseResult<T, E>;
+        resolve: (value: T) => void;
+        reject: (error: E) => void;
+    };
+    then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | null | undefined, onrejected?: ((reason: E) => TResult2 | PromiseLike<TResult2>) | null | undefined): Promise<TResult1 | TResult2>;
+    catch<TResult = never>(onrejected?: ((reason: E) => TResult | PromiseLike<TResult>) | null | undefined): Promise<T | TResult>;
+    finally(onfinally?: (() => void) | null | undefined): Promise<T>;
+    [Symbol.toStringTag]: string;
+    toResult(): Promise<Result<T, E>>;
+}

package/dist/dts/serialize/bytebuffer.d.ts

@@ -0,0 +1,73 @@
+import { JsonType } from './serializer.js';
+export declare class Flags {
+    private value;
+    private length;
+    constructor(options: {
+        value?: number;
+        length?: number;
+    });
+    has(position: number): boolean;
+    get(position: number): boolean;
+    ifSet<T>(position: number, callback: () => T): T | undefined;
+    set(position: number, value: boolean): void;
+    write(writer: ByteWriter): void;
+    static read(reader: ByteReader, length: number): Flags;
+}
+export declare class ByteWriter {
+    private dataView;
+    private buffer;
+    private offset;
+    private finished;
+    constructor(init?: ArrayBuffer, offset?: number);
+    static fromUint8Array(buffer: Uint8Array): ByteWriter;
+    private allocate;
+    write(data: Uint8Array): ByteWriter;
+    writeBoolean(value: boolean): ByteWriter;
+    writeInt8(value: number): ByteWriter;
+    writeUint8(value: number): ByteWriter;
+    writeInt16(value: number): ByteWriter;
+    writeUint16(value: number): ByteWriter;
+    writeInt32(value: number): ByteWriter;
+    writeUint32(value: number): ByteWriter;
+    writeInt64(value: bigint): ByteWriter;
+    writeUint64(value: bigint): ByteWriter;
+    writeULEB128(value: number): ByteWriter;
+    writeFloat16(value: number): ByteWriter;
+    writeFloat32(value: number): ByteWriter;
+    writeFloat64(value: number): ByteWriter;
+    writeUint8Array(value: Uint8Array): ByteWriter;
+    writeString(value: string): ByteWriter;
+    writeJSON(value: JsonType): ByteWriter;
+    writeFlags(flags: Flags): ByteWriter;
+    finish(): Uint8Array;
+    toUint8Array(): Uint8Array;
+    toArrayBuffer(): ArrayBuffer;
+}
+export declare class ByteReader {
+    private dataView;
+    private offset;
+    private finished;
+    private constructor();
+    static fromUint8Array(buffer: Uint8Array): ByteReader;
+    static fromArrayBuffer(buffer: ArrayBuffer): ByteReader;
+    static fromBlob(blob: Blob): Promise<ByteReader>;
+    read(size: number): Uint8Array;
+    readBoolean(): boolean;
+    readInt8(): number;
+    readUint8(): number;
+    readInt16(): number;
+    readUint16(): number;
+    readInt32(): number;
+    readUint32(): number;
+    readInt64(): bigint;
+    readUint64(): bigint;
+    readULEB128(): number;
+    readFloat16(): number;
+    readFloat32(): number;
+    readFloat64(): number;
+    readUint8Array(): Uint8Array;
+    readString(): string;
+    readJSON<T extends JsonType>(): T;
+    readFlags(length: number): Flags;
+    finish(): void;
+}

package/dist/dts/serialize/serializer.d.ts

@@ -0,0 +1,26 @@
+export type JsonType = string | number | boolean | null | undefined | {
+    [key in never]?: JsonType;
+} | JsonType[];
+export interface Serializable<T, D> {
+    serialize(data: T): D;
+    deserialize(data: D): T;
+}
+export declare class Serializer<T, D> {
+    serialize: (data: T) => D;
+    deserialize: (data: D) => T;
+    constructor(serialize: (data: T) => D, deserialize: (data: D) => T);
+    static of<T, D>(serializer: Serializable<T, D>): Serializer<T, D>;
+    static pipe<T, R, D>(ser1: Serializable<T, R>, ser2: Serializable<R, D>): Serializable<T, D>;
+    static transform<T>(func: (value: T) => T): Serializer<T, T>;
+    static noop<T>(): Serializer<T, T>;
+    field<K extends keyof D, R>(key: K, serializer: Serializable<D[K], R>): Serializer<T, {
+        [P in keyof D]: P extends K ? R : D[P];
+    }>;
+    static json<T extends JsonType>(): Serializer<T, Uint8Array>;
+    toJson(): Serializer<T, Uint8Array>;
+    toArray(): Serializer<T[], D[]>;
+    toMap(): Serializer<Map<string, T>, Map<string, D>>;
+    fallback(fallback: T): Serializer<T, D>;
+    fallbackMap(fallback: (data: D, error: unknown) => T): Serializer<T, D>;
+    pipe<E>(serializer: Serializable<D, E>): Serializer<T, E>;
+}

package/dist/dts/token.d.ts

@@ -0,0 +1,14 @@
+import type { Address } from './address.js';
+import type { App } from './app.js';
+export interface SessioTokenProvider {
+    get(serverAddress: Address, app: App): Promise<string | undefined>;
+}
+export type SessionParam = {
+    address: Address;
+    token: string;
+};
+export declare class BrowserSession implements SessioTokenProvider {
+    static readonly PARAM_NAME = "_omu_session";
+    get(address: Address): Promise<string | undefined>;
+    private parseParamSession;
+}

package/dist/dts/version.d.ts

@@ -0,0 +1,2 @@
+export declare const VERSION = "0.9.49";
+export declare const VERSION_MINOR = "0.9.0";

package/dist/esm/address.js

@@ -0,0 +1,4 @@
+// @bun
+
+//# debugId=EED7009B9B6A303464756E2164756E21
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFtdLAogICJzb3VyY2VzQ29udGVudCI6IFsKICBdLAogICJtYXBwaW5ncyI6ICIiLAogICJkZWJ1Z0lkIjogIkVFRDcwMDlCOUI2QTMwMzQ2NDc1NkUyMTY0NzU2RTIxIiwKICAibmFtZXMiOiBbXQp9