@omujs/omu 0.9.48 → 0.9.50

package/src/api/table/packets.ts

@@ -1,252 +0,0 @@
-import { Identifier } from '../../identifier';
-import { ByteReader, ByteWriter, Flags } from '../../serialize';
-
-import type { TableConfig } from './table.js';
-
-export class TablePacket {
-    constructor(public readonly id: Identifier) {}
-
-    public static serialize(packet: TablePacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): TablePacket {
-        const reader = ByteReader.fromUint8Array(data);
-        const id = Identifier.fromKey(reader.readString());
-        return new TablePacket(id);
-    }
-}
-
-export class TableItemsPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly items: Record<string, Uint8Array>,
-    ) {}
-
-    public static serialize(packet: TableItemsPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        writer.writeULEB128(Object.keys(packet.items).length);
-        for (const [key, value] of Object.entries(packet.items)) {
-            writer.writeString(key);
-            writer.writeUint8Array(value);
-        }
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): TableItemsPacket {
-        const reader = ByteReader.fromUint8Array(data);
-        const id = Identifier.fromKey(reader.readString());
-        const count = reader.readULEB128();
-        const items: Record<string, Uint8Array> = {};
-        for (let i = 0; i < count; i++) {
-            const key = reader.readString();
-            const value = reader.readUint8Array();
-            items[key] = value;
-        }
-        return new TableItemsPacket(id, items);
-    }
-}
-
-export class TableKeysPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly keys: string[],
-    ) {}
-
-    public static serialize(packet: TableKeysPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        writer.writeULEB128(packet.keys.length);
-        for (const key of packet.keys) {
-            writer.writeString(key);
-        }
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): TableKeysPacket {
-        const reader = ByteReader.fromUint8Array(data);
-        const id = Identifier.fromKey(reader.readString());
-        const count = reader.readULEB128();
-        const keys: string[] = [];
-        for (let i = 0; i < count; i++) {
-            keys.push(reader.readString());
-        }
-        return new TableKeysPacket(id, keys);
-    }
-}
-
-export class TableProxyPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly items: Record<string, Uint8Array>,
-        public readonly key: number,
-    ) {}
-
-    public static serialize(packet: TableProxyPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        writer.writeULEB128(packet.key);
-        writer.writeULEB128(Object.keys(packet.items).length);
-        for (const [key, value] of Object.entries(packet.items)) {
-            writer.writeString(key);
-            writer.writeUint8Array(value);
-        }
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): TableProxyPacket {
-        const reader = ByteReader.fromUint8Array(data);
-        const id = Identifier.fromKey(reader.readString());
-        const key = reader.readULEB128();
-        const count = reader.readULEB128();
-        const items: Record<string, Uint8Array> = {};
-        for (let i = 0; i < count; i++) {
-            const key = reader.readString();
-            const value = reader.readUint8Array();
-            items[key] = value;
-        }
-        return new TableProxyPacket(id, items, key);
-    }
-}
-export class TableFetchPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly limit: number,
-        public readonly backward: boolean = false,
-        public readonly cursor: string | null = null,
-    ) {}
-
-    public static serialize(packet: TableFetchPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        writer.writeULEB128(packet.limit);
-        const flags = new Flags({ length: 2 });
-        flags.set(0, packet.backward);
-        flags.set(1, packet.cursor !== null);
-        writer.writeFlags(flags);
-        if (packet.cursor !== null) {
-            writer.writeString(packet.cursor);
-        }
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): TableFetchPacket {
-        const reader = ByteReader.fromUint8Array(data);
-        const id = Identifier.fromKey(reader.readString());
-        const limit = reader.readULEB128();
-        const flags = reader.readFlags(2);
-        const backward = flags.get(0);
-        const cursor = flags.ifSet(1, () => reader.readString());
-        return new TableFetchPacket(id, limit, backward, cursor);
-    }
-}
-
-export class TableFetchRangePacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly start: string,
-        public readonly end: string,
-    ) {}
-
-    public static serialize(packet: TableFetchRangePacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        writer.writeString(packet.start);
-        writer.writeString(packet.end);
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): TableFetchRangePacket {
-        const reader = ByteReader.fromUint8Array(data);
-        const id = Identifier.fromKey(reader.readString());
-        const start = reader.readString();
-        const end = reader.readString();
-        return new TableFetchRangePacket(id, start, end);
-    }
-}
-
-export class SetConfigPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly config: TableConfig,
-    ) {}
-
-    public static serialize(packet: SetConfigPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        writer.writeString(JSON.stringify(packet.config));
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): SetConfigPacket {
-        const reader = ByteReader.fromUint8Array(data);
-        const id = Identifier.fromKey(reader.readString());
-        const config = JSON.parse(reader.readString());
-        return new SetConfigPacket(id, config);
-    }
-}
-
-export class SetPermissionPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly all: Identifier | null,
-        public readonly read: Identifier | null,
-        public readonly write: Identifier | null,
-        public readonly remove: Identifier | null,
-        public readonly proxy: Identifier | null,
-    ) {}
-
-    public static serialize(packet: SetPermissionPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        let flags = 0;
-        if (packet.all !== null) {
-            flags |= 0b1;
-        }
-        if (packet.read !== null) {
-            flags |= 0b10;
-        }
-        if (packet.write !== null) {
-            flags |= 0b100;
-        }
-        if (packet.remove !== null) {
-            flags |= 0b1000;
-        }
-        if (packet.proxy !== null) {
-            flags |= 0b10000;
-        }
-        writer.writeUint8(flags);
-        if (packet.all) {
-            writer.writeString(packet.all.key());
-        }
-        if (packet.read) {
-            writer.writeString(packet.read.key());
-        }
-        if (packet.write) {
-            writer.writeString(packet.write.key());
-        }
-        if (packet.remove) {
-            writer.writeString(packet.remove.key());
-        }
-        if (packet.proxy) {
-            writer.writeString(packet.proxy.key());
-        }
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): SetPermissionPacket {
-        const reader = ByteReader.fromUint8Array(data);
-        const id = Identifier.fromKey(reader.readString());
-        const flags = reader.readUint8();
-        const all = flags & 0b1 ? Identifier.fromKey(reader.readString()) : null;
-        const read = flags & 0b10 ? Identifier.fromKey(reader.readString()) : null;
-        const write = flags & 0b100 ? Identifier.fromKey(reader.readString()) : null;
-        const remove = flags & 0b1000 ? Identifier.fromKey(reader.readString()) : null;
-        const proxy = flags & 0b10000 ? Identifier.fromKey(reader.readString()) : null;
-        return new SetPermissionPacket(id, all, read, write, remove, proxy);
-    }
-}
-

package/src/api/table/table.ts

@@ -1,113 +0,0 @@
-import type { EventEmitter, Unlisten } from '../../event';
-import { Identifier, IntoId } from '../../identifier';
-import type { JsonType, Serializable } from '../../serialize';
-import { Serializer } from '../../serialize';
-
-export type TableConfig = {
-    cache_size: number;
-};
-
-export interface Table<T> {
-    readonly cache: ReadonlyMap<string, T>;
-    readonly event: TableEvents<T>;
-    get(key: string): Promise<T | undefined>;
-    getMany(...keys: string[]): Promise<Map<string, T>>;
-    add(...item: T[]): Promise<void>;
-    update(...item: T[]): Promise<void>;
-    remove(...items: T[]): Promise<void>;
-    clear(): Promise<void>;
-    has(key: string): Promise<boolean>;
-    hasMany<T extends Record<string, unknown>>(...keys: (keyof T)[]): Promise<{ [key in keyof T]: boolean }>;
-    hasAll(...keys: string[]): Promise<boolean>;
-    hasAny(...keys: string[]): Promise<boolean>;
-
-    fetchItems({
-        limit,
-        backward,
-        cursor,
-    }: {
-        limit: number;
-        backward?: boolean;
-        cursor?: string;
-    }): Promise<Map<string, T>>;
-    fetchRange({ start, end }: { start: string; end: string }): Promise<Map<string, T>>;
-    fetchAll(): Promise<Map<string, T>>;
-    iterate({ backward, cursor }: { backward?: boolean; cursor?: string }): AsyncIterable<T>;
-    size(): Promise<number>;
-
-    proxy(proxy: (item: T) => T | undefined): Unlisten;
-    setCacheSize(size: number): void;
-    setConfig(config: TableConfig): void;
-    setPermissions(permissions: TablePermissions): void;
-
-    listen(listener?: (items: Map<string, T>) => void): Unlisten;
-}
-
-export type TableEvents<T> = {
-    add: EventEmitter<[Map<string, T>]>;
-    update: EventEmitter<[Map<string, T>]>;
-    remove: EventEmitter<[Map<string, T>]>;
-    clear: EventEmitter<[]>;
-    cacheUpdate: EventEmitter<[Map<string, T>]>;
-};
-
-export type TablePermissions = {
-    all?: Identifier;
-    read?: Identifier;
-    write?: Identifier;
-    remove?: Identifier;
-    proxy?: Identifier;
-};
-
-export class TableType<T> {
-    constructor(
-        public id: Identifier,
-        public serializer: Serializable<T, Uint8Array>,
-        public keyFunction: (item: T) => string,
-        public permissions?: TablePermissions | undefined,
-    ) {}
-
-    public static createJson<T, D extends JsonType = JsonType>(
-        identifier: IntoId,
-        {
-            name,
-            key,
-            permissions,
-            serializer,
-        }: {
-            name: string;
-            key: (item: T) => string;
-            permissions?: TablePermissions;
-            serializer?: Serializable<T, D>;
-        },
-    ): TableType<T> {
-        return new TableType<T>(
-            Identifier.from(identifier).join(name),
-            Serializer.pipe<T, D, Uint8Array>(serializer ?? Serializer.noop(), Serializer.json()),
-            key,
-            permissions,
-        );
-    }
-
-    public static createSerialized<T>(
-        identifier: IntoId,
-        {
-            name,
-            key,
-            permissions,
-            serializer,
-        }: {
-            name: string;
-            key: (item: T) => string;
-            permissions?: TablePermissions;
-            serializer: Serializable<T, Uint8Array>;
-        },
-    ): TableType<T> {
-        return new TableType<T>(
-            Identifier.from(identifier).join(name),
-            serializer,
-            key,
-            permissions,
-        );
-    }
-}

package/src/app.ts

@@ -1,95 +0,0 @@
-import { Identifier, IntoId } from './identifier';
-import type { Locale } from './localization/locale.js';
-import type { LocalizedText } from './localization/localization.js';
-
-export type AppMetadata = {
-    locale: Locale;
-    name?: LocalizedText;
-    icon?: LocalizedText;
-    description?: LocalizedText;
-    image?: LocalizedText;
-    site?: LocalizedText;
-    repository?: LocalizedText;
-    authors?: LocalizedText;
-    license?: LocalizedText;
-    tags?: string[];
-};
-
-export type AppType = 'app' | 'service' | 'remote' | 'plugin' | 'dashboard';
-
-export type DependencySpecifier = {
-    version: string;
-    index?: string;
-};
-
-export type AppJson = {
-    id: string;
-    type: AppType;
-    parent_id?: string;
-    version?: string;
-    url?: string;
-    metadata?: AppMetadata;
-    dependencies?: Record<string, DependencySpecifier | string>;
-};
-
-export class App {
-    public readonly id: Identifier;
-    public readonly type: AppType;
-    public readonly parentId?: Identifier;
-    public readonly version?: string;
-    public readonly url?: string;
-    public readonly metadata?: AppMetadata;
-    public readonly dependencies: Record<string, DependencySpecifier | string>;
-
-    constructor(id: IntoId, options: {
-        type?: AppType;
-        parentId?: IntoId;
-        version?: string;
-        url?: string;
-        metadata?: AppMetadata;
-        dependencies?: Record<string, DependencySpecifier | string>;
-    }) {
-        this.id = Identifier.from(id);
-        this.parentId = Identifier.fromOptional(options.parentId);
-        this.version = options.version;
-        this.url = options.url;
-        this.metadata = options.metadata;
-        this.type = options.type ?? 'app';
-        this.dependencies = options.dependencies ?? {};
-    }
-
-    public static deserialize(info: AppJson): App {
-        const id = Identifier.fromKey(info.id);
-        return new App(id, {
-            parentId: Identifier.fromOptional(info.parent_id),
-            version: info.version,
-            url: info.url,
-            type: info.type,
-            metadata: info.metadata,
-            dependencies: info.dependencies ?? {},
-        });
-    }
-
-    public static serialize(data: App): AppJson {
-        return {
-            id: data.id.key(),
-            type: data.type,
-            parent_id: data.parentId?.key(),
-            version: data.version,
-            url: data.url,
-            metadata: data.metadata,
-            dependencies: data.dependencies,
-        };
-    }
-
-    public join(...paths: string[]): App {
-        return new App(this.id.join(...paths), {
-            parentId: this.parentId,
-            version: this.version,
-            url: this.url,
-            type: this.type,
-            metadata: this.metadata,
-            dependencies: this.dependencies,
-        });
-    }
-}

package/src/const.ts

@@ -1,2 +0,0 @@
-export const textEncoder: TextEncoder = new TextEncoder();
-export const textDecoder: TextDecoder = new TextDecoder();

package/src/errors.ts

@@ -1,70 +0,0 @@
-import { DisconnectType } from './network/packet/packet-types.js';
-export class OmuError extends Error {
-    constructor(message: string | null) {
-        super(message ?? undefined);
-        this.name = this.constructor.name;
-    }
-}
-
-export class DisconnectReason extends OmuError {
-    constructor(
-        public type: DisconnectType,
-        public message = '',
-    ) {
-        super(message);
-    }
-}
-
-export class ServerRestart extends DisconnectReason {
-    constructor(message: string) {
-        super(DisconnectType.SERVER_RESTART, message);
-    }
-}
-
-export class AnotherConnection extends DisconnectReason {
-    constructor(message: string) {
-        super(DisconnectType.ANOTHER_CONNECTION, message);
-    }
-}
-
-export class PermissionDenied extends DisconnectReason {
-    constructor(message: string) {
-        super(DisconnectType.PERMISSION_DENIED, message);
-    }
-}
-
-export class AppRemoved extends DisconnectReason {
-    constructor(message: string) {
-        super(DisconnectType.APP_REMOVED, message);
-    }
-}
-
-export class InvalidToken extends DisconnectReason {
-    constructor(message: string) {
-        super(DisconnectType.INVALID_TOKEN, message);
-    }
-}
-
-export class InvalidOrigin extends DisconnectReason {
-    constructor(message: string) {
-        super(DisconnectType.INVALID_ORIGIN, message);
-    }
-}
-
-export class InvalidVersion extends DisconnectReason {
-    constructor(message: string) {
-        super(DisconnectType.INVALID_VERSION, message);
-    }
-}
-
-export class InvalidPacket extends DisconnectReason {
-    constructor(message: string) {
-        super(DisconnectType.INVALID_PACKET, message);
-    }
-}
-
-export class InternalError extends DisconnectReason {
-    constructor(message: string) {
-        super(DisconnectType.INTERNAL_ERROR, message);
-    }
-}

package/src/event/index.ts

@@ -1,18 +0,0 @@
-export type Unlisten = () => void;
-
-export class EventEmitter<P extends Array<any>> {
-    private readonly listeners: Array<(...args: P) => Promise<void> | void> = [];
-
-    public listen(listener: (...args: P) => any): Unlisten {
-        this.listeners.push(listener);
-        return () => {
-            this.listeners.splice(this.listeners.indexOf(listener), 1);
-        };
-    }
-
-    public async emit(...args: P): Promise<void> {
-        for (const listener of [...this.listeners]) {
-            await listener(...args);
-        }
-    }
-}

package/src/helper.ts

@@ -1,16 +0,0 @@
-type Ok<T> = {
-    ok: true;
-    data: T;
-};
-type Err<E> = {
-    ok: false;
-    data: E;
-};
-
-export function tryCatch<T, E = Error>(func: () => T): Ok<T> | Err<E> {
-    try {
-        return { ok: true, data: func() };
-    } catch (e) {
-        return { ok: false, data: e as E };
-    }
-}