@omujs/omu 0.9.48 → 0.9.50

package/src/api/plugin/extension.ts

@@ -1,100 +0,0 @@
-import { Identifier } from '../../identifier';
-import { PacketType } from '../../network/packet/packet.js';
-import { Omu } from '../../omu';
-import { EndpointType } from '../endpoint/endpoint.js';
-import { ExtensionType } from '../extension.js';
-import { Table, TableType } from '../table/table.js';
-
-export const PLUGIN_EXTENSION_TYPE: ExtensionType<PluginExtension> = new ExtensionType(
-    'plugin',
-    (omu: Omu) => new PluginExtension(omu),
-);
-
-export class PluginExtension {
-    public readonly type: ExtensionType<PluginExtension> = PLUGIN_EXTENSION_TYPE;
-    private readonly requiredPlugins: Map<string, string | null> = new Map();
-
-    constructor(private readonly omu: Omu) {
-        omu.network.registerPacket(PLUGIN_REQUIRE_PACKET);
-        omu.network.addTask(() => this.onTask());
-    }
-
-    public getAllowedPackages(): Table<PluginPackageInfo> {
-        return this.omu.tables.get(PLUGIN_ALLOWED_PACKAGE_TABLE);
-    }
-
-    public reload(options: ReloadOptions): void {
-        this.omu.endpoints.call(PLUGIN_RELOAD_ENDPOINT_TYPE, options);
-    }
-
-    private async onTask(): Promise<void> {
-        this.omu.send(PLUGIN_REQUIRE_PACKET, Object.fromEntries(this.requiredPlugins));
-    }
-
-    public require(plugins: Record<string, string | null>): void {
-        if (this.omu.running) {
-            throw new Error('Plugins must be required before the client starts');
-        }
-        for (const [key, value] of Object.entries(plugins)) {
-            this.requiredPlugins.set(key, value);
-        }
-    }
-}
-
-const PLUGIN_REQUIRE_PACKET = PacketType.createJson<Record<string, string | null>>(
-    PLUGIN_EXTENSION_TYPE,
-    {
-        name: 'require',
-    },
-);
-export class PluginPackageInfo {
-    public package: string;
-    public version: string;
-
-    constructor(_package: string, version: string) {
-        this.package = _package;
-        this.version = version;
-    }
-
-    public static serialize(data: PluginPackageInfo): { package: string; version: string } {
-        return data.toJson();
-    }
-
-    public static deserialize(data: { package: string; version: string }): PluginPackageInfo {
-        return PluginPackageInfo.fromJson(data);
-    }
-
-    public static fromJson(json: { package: string; version: string }): PluginPackageInfo {
-        return new PluginPackageInfo(json.package, json.version);
-    }
-
-    public toJson(): { package: string; version: string } {
-        return { package: this.package, version: this.version };
-    }
-
-    public key(): string {
-        return this.package;
-    }
-}
-
-export const PLUGIN_READ_PACKAGE_PERMISSION_ID: Identifier = PLUGIN_EXTENSION_TYPE.join('package', 'read');
-export const PLUGIN_MANAGE_PACKAGE_PERMISSION_ID: Identifier = PLUGIN_EXTENSION_TYPE.join('package', 'manage');
-
-const PLUGIN_ALLOWED_PACKAGE_TABLE = TableType.createJson(PLUGIN_EXTENSION_TYPE, {
-    name: 'allowed_package',
-    serializer: PluginPackageInfo,
-    key: (item) => item.key(),
-});
-
-type ReloadOptions = {
-    packages: string[] | null;
-};
-
-type ReloadResult = {
-    packages: Record<string, string>;
-};
-
-const PLUGIN_RELOAD_ENDPOINT_TYPE = EndpointType.createJson<ReloadOptions, ReloadResult>(PLUGIN_EXTENSION_TYPE, {
-    name: 'reload',
-    permissionId: PLUGIN_MANAGE_PACKAGE_PERMISSION_ID,
-});

package/src/api/registry/extension.ts

@@ -1,326 +0,0 @@
-import type { Unlisten } from '../../event';
-import { EventEmitter } from '../../event';
-import { Identifier, IdentifierMap } from '../../identifier';
-import { Lock } from '../../lock.js';
-import { PacketType } from '../../network/packet';
-import { Omu } from '../../omu';
-import { JsonType, Serializer } from '../../serialize';
-import { EndpointType } from '../endpoint/endpoint.js';
-import { type Extension, ExtensionType } from '../extension.js';
-
-import { RegisterPacket, RegistryPacket } from './packets.js';
-import { type Registry, RegistryType, Writable } from './registry.js';
-
-export class RegistryExtension implements Extension {
-    public readonly type: ExtensionType<RegistryExtension> = REGISTRY_EXTENSION_TYPE;
-    private readonly registries = new IdentifierMap<Registry<unknown>>();
-
-    constructor(private readonly omu: Omu) {
-        omu.network.registerPacket(
-            REGISTRY_REGISTER_PACKET,
-            REGISTRY_UPDATE_PACKET,
-            REGISTRY_LISTEN_PACKET,
-        );
-    }
-
-    private createRegistry<T>(registryType: RegistryType<T>): Registry<T> {
-        if (this.registries.has(registryType.id)) {
-            throw new Error(`Registry with identifier '${registryType.id}' already exists`);
-        }
-        return new RegistryImpl(this.omu, registryType);
-    }
-
-    public get<T>(registryType: RegistryType<T>): Registry<T> {
-        const identifier = registryType.id;
-        let registry = this.registries.get(identifier);
-        if (registry === undefined) {
-            registry = this.createRegistry(registryType);
-            this.registries.set(identifier, registry);
-        }
-        return registry as Registry<T>;
-    }
-
-    public json<T, D extends JsonType = JsonType>(name: string, options: { default: T; serializer?: Serializer<T, D> }): Registry<T> {
-        const identifier = this.omu.app.id.base.join(name);
-        if (this.registries.has(identifier)) {
-            throw new Error(`Registry with name '${name}' already exists`);
-        }
-        const tableType = RegistryType.createJson<T>(identifier, {
-            name,
-            defaultValue: options.default,
-            serializer: options.serializer,
-        });
-        return this.createRegistry(tableType);
-    }
-
-    public serialized<T>(name: string, options: { default: T; serializer: Serializer<T, Uint8Array> }): Registry<T> {
-        const identifier = this.omu.app.id.base.join(name);
-        if (this.registries.has(identifier)) {
-            throw new Error(`Registry with name '${name}' already exists`);
-        }
-        const tableType = RegistryType.createSerialized<T>(identifier, {
-            name,
-            defaultValue: options.default,
-            serializer: options.serializer,
-        });
-        return this.createRegistry(tableType);
-    }
-}
-
-class RegistryImpl<T> implements Registry<T> {
-    private readonly eventEmitter: EventEmitter<[T]> = new EventEmitter();
-    private readonly lock: Lock = new Lock();
-    private listening = false;
-    public value: T;
-
-    constructor(
-        private readonly omu: Omu,
-        public readonly type: RegistryType<T>,
-    ) {
-        this.value = type.defaultValue;
-        omu.network.addPacketHandler(REGISTRY_UPDATE_PACKET, (packet) =>
-            this.handleUpdate(packet),
-        );
-        omu.network.addTask(() => this.onTask());
-    }
-
-    async #get(): Promise<T> {
-        const result = await this.omu.endpoints.call(REGISTRY_GET_ENDPOINT, this.type.id);
-        if (result.value === null) {
-            return this.type.defaultValue;
-        }
-        return this.type.serializer.deserialize(result.value);
-    }
-
-    async #set(value: T): Promise<void> {
-        this.omu.send(REGISTRY_UPDATE_PACKET, {
-            id: this.type.id,
-            value: this.type.serializer.serialize(value),
-        });
-    }
-
-    public async get(): Promise<T> {
-        const value = await this.lock.use(async () => this.#get());
-        this.eventEmitter.emit(value);
-        return value;
-    }
-
-    public async set(value: T): Promise<void> {
-        await this.lock.use(async () => this.#set(value));
-        this.eventEmitter.emit(value);
-    }
-
-    public async update(fn: (value: T) => PromiseLike<T> | T): Promise<T> {
-        const value = await this.lock.use(async () => {
-            const value = await this.#get();
-            const newValue = await fn(value);
-            await this.#set(newValue);
-            return newValue;
-        });
-        this.eventEmitter.emit(value);
-        return value;
-    }
-
-    public async modify(fn: (value: T) => PromiseLike<void> | void): Promise<T> {
-        const value = await this.lock.use(async () => {
-            const value = await this.#get();
-            await fn(value);
-            await this.#set(value);
-            return value;
-        });
-        this.eventEmitter.emit(value);
-        return value;
-    }
-
-    public listen(handler: (value: T) => Promise<void> | void): Unlisten {
-        if (!this.listening && this.omu.ready) {
-            this.omu.send(REGISTRY_LISTEN_PACKET, this.type.id);
-        }
-        this.listening = true;
-        return this.eventEmitter.listen(handler);
-    }
-
-    private handleUpdate(data: RegistryPacket): void {
-        if (!data.id.isEqual(this.type.id)) {
-            return;
-        }
-        if (data.value !== null) {
-            this.value = this.type.serializer.deserialize(data.value);
-        }
-        this.eventEmitter.emit(this.value);
-    }
-
-    private onTask(): void {
-        if (this.listening) {
-            this.omu.send(REGISTRY_LISTEN_PACKET, this.type.id);
-        }
-        if (!this.type.id.isSubpathOf(this.omu.app.id)) {
-            return;
-        }
-        this.omu.send(REGISTRY_REGISTER_PACKET, {
-            id: this.type.id,
-            permissions: this.type.permissions,
-        });
-    }
-
-    public compatSvelte(): Writable<T> {
-        let isReady = false;
-        const context = {
-            changed: false,
-            markChanged: () => {
-                context.changed = true;
-                this.#set(this.value);
-                handle(this.value);
-            },
-        };
-        const listeners = new Set<(value: T) => void>();
-
-        const handle = (newValue: T) => {
-            isReady = true;
-            emit(newValue);
-        };
-
-        const unsubscribe = this.listen(handle);
-
-        const emit = (value: T) => {
-            this.value = value;
-            const proxied = proxy(value, context);
-            listeners.forEach(listener => listener(proxied));
-        };
-
-        return {
-            set: (value: T) => {
-                if (!isReady) {
-                    throw new Error(`Registry ${this.type.id.key()} is not ready`);
-                }
-                const proxied = value?.[PROXIED_SYMBOL];
-                if (proxied && !context.changed) return;
-                this.#set(value);
-                emit(value);
-                context.changed = false;
-            },
-            subscribe: (run: (value: T) => void) => {
-                listeners.add(run);
-                run(proxy(this.value, context));
-
-                return () => {
-                    listeners.delete(run);
-                    if (listeners.size === 0) {
-                        unsubscribe?.();
-                    }
-                };
-            },
-            update: (fn: (value: T) => T) => {
-                if (!isReady) {
-                    throw new Error(`Registry ${this.type.id.key()} is not ready`);
-                }
-                this.update(fn);
-            },
-            wait: (): Promise<T> => {
-                return isReady
-                    ? Promise.resolve(this.value)
-                    : new Promise(resolve => {
-                        const unsubscribe = this.listen((value: T) => {
-                            unsubscribe?.();
-                            resolve(value);
-                        });
-                    });
-            },
-        };
-    }
-}
-
-const PROXIED_SYMBOL = Symbol('ProxiedRegistry');
-
-function deepEqual(objA, objB) {
-    if (objA === objB) return true; // Check for referential equality and primitive values
-
-    if (
-        typeof objA !== 'object' ||
-        typeof objB !== 'object' ||
-        objA === null ||
-        objB === null
-    ) {
-        return false;
-    }
-
-    const keysA = Object.keys(objA);
-    const keysB = Object.keys(objB);
-
-    if (keysA.length !== keysB.length) return false; // Different number of properties
-
-    for (const key of keysA) {
-        if (!keysB.includes(key) || !deepEqual(objA[key], objB[key])) {
-            return false; // Property missing or values are not deeply equal
-        }
-    }
-
-    return true; // All properties and their values are deeply equal
-}
-
-type ProxyContext = {
-    changed: boolean;
-    markChanged: () => void;
-};
-
-function proxy<T>(
-    value: T,
-    context: ProxyContext,
-) {
-    if (typeof value !== 'object' || value === null) {
-        return value;
-    }
-    if (PROXIED_SYMBOL in value) {
-        return value;
-    }
-    let changed = false;
-    return new Proxy(value, {
-        set(target, prop, value) {
-            changed = !deepEqual(target[prop], value);
-            if (!changed) return true;
-            target[prop] = value;
-            context.markChanged();
-            return true;
-        },
-        get(target, prop) {
-            if (prop === PROXIED_SYMBOL) {
-                return value;
-            }
-            return proxy(target[prop], context);
-        },
-        has(target, p) {
-            if (p === PROXIED_SYMBOL) return true;
-            return p in target;
-        },
-    });
-}
-
-export const REGISTRY_EXTENSION_TYPE: ExtensionType<RegistryExtension> = new ExtensionType(
-    'registry',
-    (omu: Omu) => new RegistryExtension(omu),
-);
-export const REGISTRY_PERMISSION_ID: Identifier = REGISTRY_EXTENSION_TYPE.join('permission');
-const REGISTRY_REGISTER_PACKET = PacketType.createJson<RegisterPacket>(REGISTRY_EXTENSION_TYPE, {
-    name: 'register',
-    serializer: RegisterPacket,
-});
-const REGISTRY_UPDATE_PACKET = PacketType.createSerialized<RegistryPacket>(
-    REGISTRY_EXTENSION_TYPE,
-    {
-        name: 'update',
-        serializer: RegistryPacket,
-    },
-);
-const REGISTRY_LISTEN_PACKET = PacketType.createJson<Identifier>(REGISTRY_EXTENSION_TYPE, {
-    name: 'listen',
-    serializer: Identifier,
-});
-const REGISTRY_GET_ENDPOINT = EndpointType.createSerialized<Identifier, RegistryPacket>(
-    REGISTRY_EXTENSION_TYPE,
-    {
-        name: 'get',
-        requestSerializer: Serializer.of(Identifier).toJson(),
-        responseSerializer: RegistryPacket,
-        permissionId: REGISTRY_PERMISSION_ID,
-    },
-);

package/src/api/registry/packets.ts

@@ -1,64 +0,0 @@
-import { Identifier } from '../../identifier';
-import { ByteReader, ByteWriter } from '../../serialize';
-import { RegistryPermissions, RegistryPermissionsJSON } from './registry';
-
-export class RegistryPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly value: Uint8Array | null,
-    ) { }
-
-    public static serialize(packet: RegistryPacket): Uint8Array {
-        const writer = new ByteWriter();
-        writer.writeString(packet.id.key());
-        writer.writeBoolean(packet.value !== null);
-        if (packet.value !== null) {
-            writer.writeUint8Array(packet.value);
-        }
-        return writer.finish();
-    }
-
-    public static deserialize(data: Uint8Array): RegistryPacket {
-        const reader = ByteReader.fromUint8Array(data);
-        const id = Identifier.fromKey(reader.readString());
-        const existing = reader.readBoolean();
-        const value = existing ? reader.readUint8Array() : null;
-        return new RegistryPacket(id, value);
-    }
-}
-
-export interface RegisterPacketJSON {
-    id: string;
-    permissions: RegistryPermissionsJSON;
-}
-
-export class RegisterPacket {
-    constructor(
-        public readonly id: Identifier,
-        public readonly permissions: RegistryPermissions,
-    ) {}
-
-    public static serialize(packet: RegisterPacket): RegisterPacketJSON {
-        const { permissions: perms } = packet;
-        return {
-            id: packet.id.key(),
-            permissions: {
-                all: perms.all ? Identifier.from(perms.all).key() : undefined,
-                read: perms.read ? Identifier.from(perms.read).key() : undefined,
-                write: perms.write ? Identifier.from(perms.write).key() : undefined,
-            },
-        };
-    }
-
-    public static deserialize(data: RegisterPacketJSON): RegisterPacket {
-        const { permissions: perms } = data;
-        return new RegisterPacket(
-            Identifier.from(data.id),
-            {
-                all: perms.all ? Identifier.from(perms.all) : undefined,
-                read: perms.read ? Identifier.from(perms.read) : undefined,
-                write: perms.write ? Identifier.from(perms.write) : undefined,
-            },
-        );
-    }
-}

package/src/api/server/extension.ts

@@ -1,155 +0,0 @@
-import { App, AppJson } from '../../app.js';
-import { Identifier, IdentifierMap, IntoId } from '../../identifier';
-import { LocalizedText } from '../../localization/localization.js';
-import { Omu } from '../../omu.js';
-import { EndpointType } from '../endpoint/endpoint.js';
-import { ExtensionType, type Extension } from '../extension.js';
-import { Registry, RegistryType } from '../registry';
-import { TableType, type Table } from '../table';
-
-export const SERVER_EXTENSION_TYPE: ExtensionType<ServerExtension> = new ExtensionType(
-    'server',
-    (omu: Omu) => new ServerExtension(omu),
-);
-
-export interface AppIndexEntry {
-    url: string;
-    meta?: AppIndexRegistryMeta;
-    added_at: string;
-};
-
-export interface AppIndex {
-    indexes: Record<string, AppIndexEntry>;
-};
-
-export const SERVER_APPS_READ_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('apps', 'read');
-export const SERVER_APPS_WRITE_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('apps', 'write');
-export const SERVER_INDEX_READ_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('index', 'read');
-export const SERVER_INDEX_REGISTRY_TYPE: RegistryType<AppIndex> = RegistryType.createJson<AppIndex>(SERVER_EXTENSION_TYPE, {
-    name: 'index',
-    defaultValue: { 'indexes': {} },
-    permissions: {
-        write: SERVER_APPS_WRITE_PERMISSION_ID,
-        read: SERVER_INDEX_READ_PERMISSION_ID,
-    },
-});
-const APP_TABLE_TYPE = TableType.createJson(SERVER_EXTENSION_TYPE, {
-    name: 'apps',
-    serializer: App,
-    key: (app) => app.id.key(),
-    permissions: {
-        all: SERVER_APPS_WRITE_PERMISSION_ID,
-        read: SERVER_APPS_READ_PERMISSION_ID,
-    },
-});
-
-export const SERVER_SHUTDOWN_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('shutdown');
-const SHUTDOWN_ENDPOINT_TYPE = EndpointType.createJson<boolean, boolean>(SERVER_EXTENSION_TYPE, {
-    name: 'shutdown',
-    permissionId: SERVER_SHUTDOWN_PERMISSION_ID,
-});
-export const TRUSTED_ORIGINS_GET_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('trusted_origins', 'get');
-export const TRUSTED_ORIGINS_SET_PERMISSION_ID: Identifier = SERVER_EXTENSION_TYPE.join('trusted_origins', 'set');
-const TRUSTED_HOSTS_REGISTRY_TYPE = RegistryType.createJson<Record<string, string>>(SERVER_EXTENSION_TYPE, {
-    name: 'trusted_hosts',
-    defaultValue: {},
-    permissions: {
-        read: TRUSTED_ORIGINS_GET_PERMISSION_ID,
-        write: TRUSTED_ORIGINS_SET_PERMISSION_ID,
-    },
-});
-
-export class ServerExtension implements Extension {
-    public readonly type: ExtensionType<ServerExtension> = SERVER_EXTENSION_TYPE;
-    public readonly apps: Table<App>;
-    public readonly index: Registry<AppIndex>;
-    public readonly trustedHosts: Registry<Record<string, string>>;
-
-    constructor(private readonly omu: Omu) {
-        this.apps = omu.tables.get(APP_TABLE_TYPE);
-        this.index = omu.registries.get(SERVER_INDEX_REGISTRY_TYPE);
-        this.trustedHosts = omu.registries.get(TRUSTED_HOSTS_REGISTRY_TYPE);
-    }
-
-    public async shutdown(restart?: boolean): Promise<boolean> {
-        this.omu.endpoints.call(SHUTDOWN_ENDPOINT_TYPE, restart ?? false);
-        await new Promise<void>((resolve) => {
-            const unlisten = this.omu.network.event.disconnected.listen(() => {
-                resolve();
-                unlisten();
-            });
-        });
-        return true;
-    }
-}
-
-export class SessionObserver {
-    constructor(
-        public readonly onConnectCallbacks: Array<(app: App) => Promise<void> | void>,
-        public readonly onDisconnectCallbacks: Array<(app: App) => Promise<void> | void>,
-    ) { }
-
-    public onConnect(callback: (app: App) => Promise<void> | void): void {
-        this.onConnectCallbacks.push(callback);
-    }
-
-    public onDisconnect(callback: (app: App) => Promise<void> | void): void {
-        this.onDisconnectCallbacks.push(callback);
-    }
-}
-
-export type AppIndexRegistryMeta = {
-    name: LocalizedText;
-    note: LocalizedText;
-};
-
-export interface AppIndexRegistryJSON {
-    id: string;
-    meta?: AppIndexRegistryMeta;
-    apps: Record<string, AppJson>;
-}
-
-export class AppIndexRegistry {
-    constructor(
-        public id: Identifier,
-        public apps: IdentifierMap<App>,
-        public meta: AppIndexRegistryMeta | undefined,
-    ) { }
-
-    public static build(options: { id: IntoId; meta: AppIndexRegistryMeta; apps: App[] }): AppIndexRegistry {
-        return new AppIndexRegistry(
-            Identifier.from(options.id),
-            new IdentifierMap(options.apps.map((app) => [app.id, app])),
-            options.meta,
-        );
-    }
-
-    public static fromJSON(json: AppIndexRegistryJSON): AppIndexRegistry {
-        const id = Identifier.fromKey(json['id']);
-        const apps = new IdentifierMap<App>();
-        for (const [idStr, appJSON] of Object.entries(json['apps'])) {
-            const id = Identifier.fromKey(idStr);
-            const app = App.deserialize(appJSON);
-            if (!id.isNamespaceEqual(app.id)) {
-                throw new Error(`App ID does not match the ID in the index. ${app.id} != ${id}`);
-            }
-            apps.set(id, app);
-        }
-        return new AppIndexRegistry(
-            id,
-            apps,
-            json.meta,
-        );
-    }
-
-    public toJSON(): AppIndexRegistryJSON {
-        return {
-            id: this.id.key(),
-            meta: this.meta,
-            apps: Object.fromEntries([...this.apps.entries()].map(([id, app]) => [
-                id.key(),
-                App.serialize(app),
-            ])),
-        };
-    }
-}

package/src/api/server/index.ts

@@ -1,11 +0,0 @@
-export {
-    AppIndexRegistry,
-    SERVER_APPS_READ_PERMISSION_ID,
-    SERVER_SHUTDOWN_PERMISSION_ID,
-    TRUSTED_ORIGINS_GET_PERMISSION_ID,
-    TRUSTED_ORIGINS_SET_PERMISSION_ID,
-    type AppIndex,
-    type AppIndexEntry,
-    type AppIndexRegistryJSON,
-} from './extension.js';
-