@omujs/omu 0.1.22

package/src/extension/extension.ts

@@ -0,0 +1,18 @@
+import { type Client } from '../client.js';
+import { Identifier } from '../identifier.js';
+
+export interface Extension {}
+
+export class ExtensionType<T extends Extension = Extension> extends Identifier {
+    constructor(
+        public readonly name: string,
+        public readonly create: (client: Client) => T,
+        public readonly dependencies?: () => ExtensionType[],
+    ) {
+        super('ext', name);
+    }
+
+    public key(): string {
+        return this.name;
+    }
+}

package/src/extension/i18n/i18n-extension.ts

@@ -0,0 +1,73 @@
+import type { Client } from '../../client.js';
+import type { Locale } from '../../localization/locale.js';
+import type { LocalizedText } from '../../localization/localization.js';
+import type { Extension } from '../extension.js';
+import { ExtensionType } from '../extension.js';
+import type { Registry } from '../registry/index.js';
+import { RegistryType } from '../registry/index.js';
+
+export const I18N_EXTENSION_TYPE = new ExtensionType('i18n', (client) => new I18nExtension(client));
+
+export const I18N_SET_LOCALES_PERMISSION_ID = I18N_EXTENSION_TYPE.join('locales', 'set');
+export const I18N_GET_LOCALES_PERMISSION_ID = I18N_EXTENSION_TYPE.join('locales', 'get');
+const I18N_LOCALES_REGISTRY_TYPE = RegistryType.createJson<Locale[]>(I18N_EXTENSION_TYPE, {
+    name: 'locales',
+    defaultValue: [],
+});
+
+export class I18nExtension implements Extension {
+    public readonly localesRegistry: Registry<Locale[]>;
+    public locales?: Locale[];
+
+    constructor(private readonly client: Client) {
+        client.permissions.require(I18N_GET_LOCALES_PERMISSION_ID);
+        this.localesRegistry = client.registry.get(I18N_LOCALES_REGISTRY_TYPE);
+        this.localesRegistry.listen((locale) => {
+            this.locales = locale;
+        });
+    }
+
+    public translate(localizedText: LocalizedText): string {
+        if (!this.locales) {
+            throw new Error('Locale not set');
+        }
+        if (typeof localizedText === 'string') {
+            return localizedText;
+        }
+        const translation = this.selectBestTranslation(this.locales, localizedText);
+        if (!translation) {
+            throw new Error(
+                `Missing translation for ${this.locales} in ${JSON.stringify(localizedText)}`,
+            );
+        }
+        return translation;
+    }
+
+    public selectBestTranslation(
+        locales: Locale[],
+        localizedText: LocalizedText,
+    ): string | undefined {
+        if (typeof localizedText === 'string') {
+            return localizedText;
+        }
+        const translations = localizedText;
+        const transformedLocales = locales.reduce((acc, l) => {
+            const parts = l.split('-');
+            for (let i = parts.length; i > 0; i--) {
+                acc.push(parts.slice(0, i).join('-'));
+            }
+            return acc;
+        }, [] as string[]);
+        for (const l of transformedLocales) {
+            const translation = translations[l];
+            if (translation) {
+                return translation;
+            }
+        }
+        return undefined;
+    }
+
+    public setLocale(locale: Locale[]): Promise<void> {
+        return this.localesRegistry.set(locale);
+    }
+}

package/src/extension/i18n/index.ts

@@ -0,0 +1,2 @@
+export { I18N_EXTENSION_TYPE, I18N_GET_LOCALES_PERMISSION_ID, I18N_SET_LOCALES_PERMISSION_ID, I18nExtension } from './i18n-extension.js';
+

package/src/extension/index.ts

@@ -0,0 +1,3 @@
+export { ExtensionRegistry } from './extension-registry.js';
+export { Extension, ExtensionType } from './extension.js';
+

package/src/extension/logger/index.ts

@@ -0,0 +1,5 @@
+export {
+    LOGGER_EXTENSION_TYPE,
+    LOGGER_LOG_PERMISSION_ID,
+    LoggerExtension,
+} from './logger-extension.js';

package/src/extension/logger/logger-extension.ts

@@ -0,0 +1,75 @@
+import type { Client } from '../../client.js';
+import type { Unlisten } from '../../event-emitter.js';
+import { Identifier, IdentifierMap } from '../../identifier.js';
+import { PacketType } from '../../network/packet/packet.js';
+import { Serializer } from '../../serializer.js';
+import { ExtensionType } from '../extension.js';
+
+import type { LogMessage } from './packets.js';
+import { LogPacket, LogType } from './packets.js';
+
+export const LOGGER_EXTENSION_TYPE = new ExtensionType(
+    'logger',
+    (client) => new LoggerExtension(client),
+);
+
+export const LOGGER_LOG_PERMISSION_ID = LOGGER_EXTENSION_TYPE.join('log');
+
+export const LOGGER_LOG_PACKET = PacketType.createSerialized<LogPacket>(LOGGER_EXTENSION_TYPE, {
+    name: 'log',
+    serializer: LogPacket,
+});
+export const LOGGER_LISTEN_PACKET = PacketType.createJson<Identifier>(LOGGER_EXTENSION_TYPE, {
+    name: 'listen',
+    serializer: Serializer.model(Identifier),
+});
+
+type LogListener = (message: LogMessage) => void;
+export class LoggerExtension {
+    private readonly listeners: IdentifierMap<LogListener[]> = new IdentifierMap();
+
+    constructor(private readonly client: Client) {
+        client.network.registerPacket(LOGGER_LOG_PACKET, LOGGER_LISTEN_PACKET);
+        client.network.addPacketHandler(LOGGER_LOG_PACKET, (packet) => {
+            const listener = this.listeners.get(packet.id);
+            if (listener) {
+                listener.forEach((it) => it(packet.message));
+            }
+        });
+    }
+
+    public log(message: LogMessage): void {
+        const packet = new LogPacket(this.client.app.id, message);
+        this.client.send(LOGGER_LOG_PACKET, packet);
+    }
+
+    public error(text: string): void {
+        this.log({ type: LogType.ERROR, text });
+    }
+
+    public warning(text: string): void {
+        this.log({ type: LogType.WARNING, text });
+    }
+
+    public info(text: string): void {
+        this.log({ type: LogType.INFO, text });
+    }
+
+    public debug(text: string): void {
+        this.log({ type: LogType.DEBUG, text });
+    }
+
+    public listen(id: Identifier, listener: LogListener): Unlisten {
+        if (!this.listeners.has(id)) {
+            this.client.whenReady(() => {
+                this.client.send(LOGGER_LISTEN_PACKET, id);
+            });
+        }
+        const list = this.listeners.get(id) ?? [];
+        list.push(listener);
+        this.listeners.set(id, list);
+        return () => {
+            list.splice(list.indexOf(listener), 1);
+        };
+    }
+}

package/src/extension/logger/packets.ts

@@ -0,0 +1,38 @@
+import { ByteReader, ByteWriter } from '../../bytebuffer.js';
+import { Identifier } from '../../identifier.js';
+
+export enum LogType {
+    ERROR = 'error',
+    WARNING = 'warning',
+    INFO = 'info',
+    DEBUG = 'debug',
+}
+
+export type LogMessage = {
+    type: LogType;
+    text: string;
+};
+
+export class LogPacket {
+    constructor(
+        public readonly id: Identifier,
+        public readonly message: LogMessage,
+    ) {}
+
+    public static serialize(item: LogPacket): Uint8Array {
+        const writer = new ByteWriter();
+        writer.writeString(item.id.key());
+        writer.writeString(item.message.type);
+        writer.writeString(item.message.text);
+        return writer.finish();
+    }
+
+    public static deserialize(item: Uint8Array): LogPacket {
+        const reader = new ByteReader(item);
+        const id = reader.readString();
+        const type = reader.readString() as LogType;
+        const text = reader.readString();
+        const message = { type, text };
+        return new LogPacket(Identifier.fromKey(id), message);
+    }
+}

package/src/extension/permission/index.ts

@@ -0,0 +1,3 @@
+export { PERMISSION_EXTENSION_TYPE, PermissionExtension } from './permission-extension.js';
+export { PermissionType } from './permission.js';
+

package/src/extension/permission/permission-extension.ts

@@ -0,0 +1,98 @@
+import type { Client } from '../../client.js';
+import { Identifier, IdentifierMap, IdentifierSet } from '../../identifier.js';
+import { PacketType } from '../../network/packet/packet.js';
+import { Serializer } from '../../serializer.js';
+import { EndpointType } from '../endpoint/endpoint.js';
+import { ExtensionType } from '../extension.js';
+
+import { PermissionType } from './permission.js';
+
+export const PERMISSION_EXTENSION_TYPE = new ExtensionType(
+    'permission',
+    (client) => new PermissionExtension(client),
+);
+const PERMISSION_REGISTER_PACKET = PacketType.createJson<PermissionType[]>(
+    PERMISSION_EXTENSION_TYPE,
+    {
+        name: 'register',
+        serializer: Serializer.model(PermissionType).toArray(),
+    },
+);
+const PERMISSION_REQUIRE_PACKET = PacketType.createJson<Identifier[]>(PERMISSION_EXTENSION_TYPE, {
+    name: 'require',
+    serializer: Serializer.model(Identifier).toArray(),
+});
+const PERMISSION_REQUEST_ENDPOINT = EndpointType.createJson<Identifier[], void>(
+    PERMISSION_EXTENSION_TYPE,
+    {
+        name: 'request',
+        requestSerializer: Serializer.model(Identifier).toArray(),
+    },
+);
+const PERMISSION_GRANT_PACKET = PacketType.createJson<PermissionType[]>(PERMISSION_EXTENSION_TYPE, {
+    name: 'grant',
+    serializer: Serializer.model(PermissionType).toArray(),
+});
+
+export class PermissionExtension {
+    private permissions = new IdentifierMap<PermissionType>();
+    private readonly registeredPermissions = new IdentifierMap<PermissionType>();
+    private readonly requiredPermissions = new IdentifierSet();
+
+    constructor(private readonly client: Client) {
+        client.network.registerPacket(
+            PERMISSION_REGISTER_PACKET,
+            PERMISSION_REQUIRE_PACKET,
+            PERMISSION_GRANT_PACKET,
+        );
+        client.network.addPacketHandler(PERMISSION_GRANT_PACKET, (permissions) => {
+            for (const permission of permissions) {
+                this.permissions.set(permission.id, permission);
+            }
+        });
+        client.network.addTask(() => this.onTask());
+    }
+
+    private onTask(): void {
+        if (this.registeredPermissions.size > 0) {
+            this.client.send(
+                PERMISSION_REGISTER_PACKET,
+                Array.from(this.registeredPermissions.values()),
+            );
+        }
+        if (this.requiredPermissions.size > 0) {
+            this.client.send(
+                PERMISSION_REQUIRE_PACKET,
+                Array.from(this.requiredPermissions.values()),
+            );
+        }
+    }
+
+    public register(permission: PermissionType): void {
+        if (this.client.running) {
+            this.client.send(PERMISSION_REGISTER_PACKET, [permission]);
+        }
+        this.registeredPermissions.set(permission.id, permission);
+    }
+
+    public require(...permissionIds: (Identifier | string)[]): void {
+        if (this.client.running) {
+            throw new Error('Permissions must be required before the client starts');
+        }
+        for (const permissionId of permissionIds) {
+            if (typeof permissionId === 'string') {
+                this.requiredPermissions.add(Identifier.fromKey(permissionId));
+            } else {
+                this.requiredPermissions.add(permissionId);
+            }
+        }
+    }
+
+    public async request(...permissionIds: Identifier[]): Promise<void> {
+        await this.client.endpoints.call(PERMISSION_REQUEST_ENDPOINT, permissionIds);
+    }
+
+    public has(permissionIdentifier: Identifier): boolean {
+        return this.permissions.has(permissionIdentifier);
+    }
+}

package/src/extension/permission/permission.ts

@@ -0,0 +1,56 @@
+import { Identifier } from '../../identifier.js';
+import type { LocalizedText } from '../../localization/localization.js';
+import type { Model } from '../../model.js';
+
+type PermissionLevel = 'low' | 'medium' | 'high';
+
+export type PermissionMetadata = {
+    name: LocalizedText,
+    note: LocalizedText,
+    level: PermissionLevel,
+}
+
+export type PermissionTypeJson = {
+    id: string;
+    metadata: PermissionMetadata;
+}
+
+export class PermissionType implements Model<PermissionTypeJson> {
+    public readonly id: Identifier;
+    public readonly metadata: PermissionMetadata;
+
+    constructor(options: {
+        id: Identifier,
+        metadata: PermissionMetadata,
+    }) {
+        this.id = options.id;
+        this.metadata = options.metadata;
+    }
+
+    public static create(identifier: Identifier, {
+        name,
+        metadata,
+    }: {
+        name: string,
+        metadata: PermissionMetadata,
+    }): PermissionType {
+        return new PermissionType({
+            id: identifier.join(name),
+            metadata: metadata,
+        });
+    }
+
+    public toJson(): PermissionTypeJson {
+        return {
+            id: this.id.key(),
+            metadata: this.metadata,
+        };
+    }
+
+    public static fromJson(json: PermissionTypeJson): PermissionType {
+        return new PermissionType({
+            id: Identifier.fromKey(json.id),
+            metadata: json.metadata,
+        });
+    }
+}

package/src/extension/plugin/index.ts

@@ -0,0 +1,2 @@
+export { PLUGIN_EXTENSION_TYPE, PluginExtension } from './plugin-extension.js';
+

package/src/extension/plugin/package-info.ts

@@ -0,0 +1,91 @@
+// type generated from https://warehouse.pypa.io/api-reference/json.html
+export type Downloads = {
+    last_day: number;
+    last_month: number;
+    last_week: number;
+};
+
+export type ProjectUrls = {
+    'Bug Reports': string;
+    'Funding': string;
+    'Homepage': string;
+    'Say Thanks!': string;
+    'Source': string;
+};
+export type Info = {
+    author: string;
+    author_email: string;
+    bugtrack_url: string | null;
+    classifiers: string[];
+    description: string;
+    description_content_type: 'text/markdown';
+    docs_url: string | null;
+    download_url: string;
+    downloads: Downloads;
+    home_page: string;
+    keywords: string;
+    license: string;
+    maintainer: string;
+    maintainer_email: string;
+    name: string;
+    package_url: string;
+    platform: unknown;
+    project_url: string;
+    project_urls: ProjectUrls;
+    release_url: string;
+    requires_dist: string[];
+    requires_python: string;
+    summary: string;
+    version: string;
+    yanked: boolean;
+    yanked_reason: string | null;
+};
+export type Digests = {
+    blake2b_256: string;
+    md5: string;
+    sha256: string;
+};
+
+export type ReleasesItem = {
+    comment_text: string;
+    digests: Digests;
+    downloads: string;
+    filename: string;
+    has_sig: boolean;
+    md5_digest: string;
+    packagetype: string;
+    python_version: string;
+    requires_python: string | null;
+    size: number;
+    upload_time: string;
+    upload_time_iso_8601: string;
+    url: string;
+    yanked: boolean;
+    yanked_reason: string | null;
+};
+
+export type Releases = {
+    [key: string]: ReleasesItem[];
+};
+export type Urls = ReleasesItem[];
+
+export type VulnerabilitiesItem = {
+    aliases: string[];
+    details: string;
+    summary: string;
+    fixed_in: string[];
+    id: string;
+    link: string;
+    source: string;
+    withdrawn: string | null;
+};
+
+export type Vulnerabilities = VulnerabilitiesItem[];
+
+export type PackageInfo = {
+    info: Info;
+    last_serial: number;
+    releases: Releases;
+    urls: Urls;
+    vulnerabilities: Vulnerabilities;
+};

package/src/extension/plugin/plugin-extension.ts

@@ -0,0 +1,37 @@
+import type { Client } from '../../client.js';
+import { PacketType } from '../../network/packet/packet.js';
+import { ExtensionType } from '../extension.js';
+
+export const PLUGIN_EXTENSION_TYPE = new ExtensionType(
+    'plugin',
+    (client: Client) => new PluginExtension(client),
+);
+
+export class PluginExtension {
+    private readonly requiredPlugins: Map<string, string | null> = new Map();
+
+    constructor(private readonly client: Client) {
+        client.network.registerPacket(PLUGIN_REQUIRE_PACKET);
+        client.network.addTask(() => this.onTask());
+    }
+
+    private async onTask(): Promise<void> {
+        this.client.send(PLUGIN_REQUIRE_PACKET, Object.fromEntries(this.requiredPlugins));
+    }
+
+    public require(plugins: Record<string, string | null>): void {
+        if (this.client.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',
+    },
+);

package/src/extension/registry/index.ts

@@ -0,0 +1,3 @@
+export { REGISTRY_EXTENSION_TYPE, RegistryExtension } from './registry-extension.js';
+export { Registry, RegistryType } from './registry.js';
+

package/src/extension/registry/packets.ts

@@ -0,0 +1,50 @@
+import { ByteReader, ByteWriter } from '../../bytebuffer.js';
+import { Identifier } from '../../identifier.js';
+
+import { RegistryPermissions } from './registry.js';
+
+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.writeByteArray(packet.value);
+        }
+        return writer.finish();
+    }
+
+    public static deserialize(data: Uint8Array): RegistryPacket {
+        const reader = new ByteReader(data);
+        const id = Identifier.fromKey(reader.readString());
+        const existing = reader.readBoolean();
+        const value = existing ? reader.readByteArray() : null;
+        return new RegistryPacket(id, value);
+    }
+}
+
+export class RegistryRegisterPacket {
+    constructor(
+        public readonly id: Identifier,
+        public readonly permissions: RegistryPermissions,
+    ) { }
+
+    public static serialize(packet: RegistryRegisterPacket): Uint8Array {
+        const writer = new ByteWriter();
+        writer.writeString(packet.id.key());
+        packet.permissions.serialize(writer);
+        return writer.finish();
+    }
+
+    public static deserialize(data: Uint8Array): RegistryRegisterPacket {
+        const reader = new ByteReader(data);
+        const id = Identifier.fromKey(reader.readString());
+        const permissions = RegistryPermissions.deserialize(reader);
+        return new RegistryRegisterPacket(id, permissions);
+    }
+}