@omujs/chat 0.9.47 → 0.9.49

package/src/chat.ts

@@ -1,131 +0,0 @@
-import type { Omu } from '@omujs/omu';
-import { Serializer } from '@omujs/omu';
-import { EndpointType } from '@omujs/omu/api/endpoint';
-import type { Signal } from '@omujs/omu/api/signal';
-import { SignalType } from '@omujs/omu/api/signal';
-import type { Table } from '@omujs/omu/api/table';
-import { TableType } from '@omujs/omu/api/table';
-
-import { PLUGIN_ID } from './const';
-import type { EventHandler, EventSource } from './event';
-import { EventRegistry } from './event';
-import { Author, Channel, Message, Provider, Reaction, Room, Vote } from './models';
-import {
-    CHAT_CHANNEL_TREE_PERMISSION_ID,
-    CHAT_PERMISSION_ID,
-    CHAT_READ_PERMISSION_ID,
-    CHAT_WRITE_PERMISSION_ID,
-} from './permissions';
-
-const MESSAGE_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
-    name: 'messages',
-    serializer: Message,
-    key: (item) => item.key(),
-    permissions: {
-        all: CHAT_PERMISSION_ID,
-        read: CHAT_READ_PERMISSION_ID,
-        write: CHAT_WRITE_PERMISSION_ID,
-    },
-});
-const AUTHOR_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
-    name: 'authors',
-    serializer: Author,
-    key: (item) => item.key(),
-    permissions: {
-        all: CHAT_PERMISSION_ID,
-        read: CHAT_READ_PERMISSION_ID,
-        write: CHAT_WRITE_PERMISSION_ID,
-    },
-});
-const CHANNEL_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
-    name: 'channels',
-    serializer: Channel,
-    key: (item) => item.key(),
-    permissions: {
-        all: CHAT_PERMISSION_ID,
-        read: CHAT_READ_PERMISSION_ID,
-        write: CHAT_WRITE_PERMISSION_ID,
-    },
-});
-const PROVIDER_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
-    name: 'providers',
-    serializer: Provider,
-    key: (item) => item.key(),
-    permissions: {
-        all: CHAT_PERMISSION_ID,
-        read: CHAT_READ_PERMISSION_ID,
-        write: CHAT_WRITE_PERMISSION_ID,
-    },
-});
-const ROOM_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
-    name: 'rooms',
-    serializer: Room,
-    key: (item) => item.key(),
-    permissions: {
-        all: CHAT_PERMISSION_ID,
-        read: CHAT_READ_PERMISSION_ID,
-        write: CHAT_WRITE_PERMISSION_ID,
-    },
-});
-const VOTE_TABLE_TYPE = TableType.createJson(PLUGIN_ID, {
-    name: 'votes',
-    serializer: Vote,
-    key: (item) => item.key(),
-    permissions: {
-        all: CHAT_PERMISSION_ID,
-        read: CHAT_READ_PERMISSION_ID,
-        write: CHAT_WRITE_PERMISSION_ID,
-    },
-});
-const CREATE_CHANNEL_TREE_ENDPOINT = EndpointType.createJson(PLUGIN_ID, {
-    name: 'create_channel_tree',
-    requestSerializer: Serializer.noop<string>(),
-    responseSerializer: Serializer.of(Channel).toArray(),
-    permissionId: CHAT_CHANNEL_TREE_PERMISSION_ID,
-});
-const REACTION_SIGNAL = SignalType.createJson(PLUGIN_ID, {
-    name: 'reaction',
-    serializer: Reaction,
-    permissions: { all: CHAT_PERMISSION_ID },
-});
-
-export class Chat {
-    public readonly messages: Table<Message>;
-    public readonly authors: Table<Author>;
-    public readonly channels: Table<Channel>;
-    public readonly providers: Table<Provider>;
-    public readonly rooms: Table<Room>;
-    public readonly votes: Table<Vote>;
-    public readonly reactionSignal: Signal<Reaction>;
-    private readonly eventRegistry: EventRegistry;
-
-    private constructor(private readonly omu: Omu) {
-        omu.sessions.require(PLUGIN_ID);
-        omu.permissions.require(CHAT_PERMISSION_ID);
-        this.eventRegistry = new EventRegistry(this);
-        this.messages = omu.tables.get(MESSAGE_TABLE_TYPE);
-        this.authors = omu.tables.get(AUTHOR_TABLE_TYPE);
-        this.channels = omu.tables.get(CHANNEL_TABLE_TYPE);
-        this.providers = omu.tables.get(PROVIDER_TABLE_TYPE);
-        this.rooms = omu.tables.get(ROOM_TABLE_TYPE);
-        this.votes = omu.tables.get(VOTE_TABLE_TYPE);
-        this.reactionSignal = omu.signals.get(REACTION_SIGNAL);
-        this.messages.setCacheSize(1000);
-        this.authors.setCacheSize(500);
-    }
-
-    public static create(omu: Omu): Chat {
-        if (omu.ready) {
-            throw new Error('OMU instance is already started');
-        }
-        return new Chat(omu);
-    }
-
-    public async createChannelTree(url: string): Promise<Channel[]> {
-        return await this.omu.endpoints.call(CREATE_CHANNEL_TREE_ENDPOINT, url);
-    }
-
-    public on<P extends Array<any>>(event: EventSource<P>, handler: EventHandler<P>): void {
-        this.eventRegistry.register(event, handler);
-    }
-}

package/src/const.ts

@@ -1,3 +0,0 @@
-import { Identifier } from '@omujs/omu';
-
-export const PLUGIN_ID: Identifier = new Identifier('com.omuapps', 'chat');

package/src/event/event-types.ts

@@ -1,16 +0,0 @@
-import { Author } from '../models/author.js';
-import { Channel } from '../models/channel.js';
-import { Message } from '../models/message.js';
-import { Provider } from '../models/provider.js';
-import { Room } from '../models/room.js';
-import { Vote } from '../models/vote.js';
-import { TableEvent } from './event.js';
-
-export const events: { Message: TableEvent<Message>; Author: TableEvent<Author>; Channel: TableEvent<Channel>; Provider: TableEvent<Provider>; Room: TableEvent<Room>; Vote: TableEvent<Vote> } = {
-    Message: new TableEvent((chat) => chat.messages),
-    Author: new TableEvent((chat) => chat.authors),
-    Channel: new TableEvent((chat) => chat.channels),
-    Provider: new TableEvent((chat) => chat.providers),
-    Room: new TableEvent((chat) => chat.rooms),
-    Vote: new TableEvent((chat) => chat.votes),
-};

package/src/event/event.ts

@@ -1,102 +0,0 @@
-import type { Table } from '@omujs/omu/api/table';
-import type { Unlisten } from '@omujs/omu/event';
-import { EventEmitter } from '@omujs/omu/event';
-
-import type { Chat } from '../chat.js';
-
-export type EventHandler<P extends Array<any>> = (...args: P) => Promise<void> | void;
-
-export interface EventSource<P extends Array<any>> {
-    subscribe(handler: EventHandler<P>, chat: Chat): Unlisten;
-}
-
-export class ListenerEvent<P extends Array<any>> implements EventSource<P> {
-    constructor(private readonly getListener: (chat: Chat) => EventEmitter<P>) {}
-
-    public subscribe(handler: EventHandler<P>, chat: Chat): Unlisten {
-        const listener = this.getListener(chat);
-        return listener.listen(handler);
-    }
-}
-
-export class TableEvent<T> extends ListenerEvent<[Map<string, T>]> {
-    public readonly AddBatch: ListenerEvent<[Map<string, T>]>;
-    public readonly UpdateBatch: ListenerEvent<[Map<string, T>]>;
-    public readonly RemoveBatch: ListenerEvent<[Map<string, T>]>;
-    public readonly Add: EventSource<[T]>;
-    public readonly Update: EventSource<[T]>;
-    public readonly Remove: EventSource<[T]>;
-    public readonly Clear: EventSource<[]>;
-    public readonly wrappers: Record<string, Unlisten>;
-
-    constructor(private readonly getTable: (chat: Chat) => Table<T>) {
-        super((chat) => getTable(chat).event.cacheUpdate);
-        this.AddBatch = new ListenerEvent((chat) => getTable(chat).event.add);
-        this.UpdateBatch = new ListenerEvent((chat) => getTable(chat).event.update);
-        this.RemoveBatch = new ListenerEvent((chat) => getTable(chat).event.remove);
-        this.Add = this.createBatchSubscriber((table) => table.event.add);
-        this.Update = this.createBatchSubscriber((table) => table.event.update);
-        this.Remove = this.createBatchSubscriber((table) => table.event.remove);
-        this.Clear = new ListenerEvent((client) => getTable(client).event.clear);
-        this.wrappers = {};
-    }
-
-    private static createBatchWrapper<T>(emit: EventHandler<[T]>): EventHandler<[Map<string, T>]> {
-        return async (items) => {
-            for (const item of items.values()) {
-                await emit(item);
-            }
-        };
-    }
-
-    private createBatchSubscriber(
-        getListener: (table: Table<T>) => EventEmitter<[Map<string, T>]>,
-    ): EventSource<[T]> {
-        let batchWrapper: EventHandler<[Map<string, T>]> | null = null;
-
-        const subscribe = (emit: EventHandler<[T]>, chat: Chat): Unlisten => {
-            const table = this.getTable(chat);
-            const listener = getListener(table);
-            batchWrapper = TableEvent.createBatchWrapper((item) => emit(item));
-            const stopListen = table.listen();
-            const clearEvent = listener.listen(batchWrapper);
-            return () => {
-                stopListen();
-                clearEvent();
-            };
-        };
-
-        return {
-            subscribe,
-        };
-    }
-}
-
-type Entry<P extends Array<any>> = {
-    source: EventSource<P>;
-    listeners: EventEmitter<P>;
-};
-
-export class EventRegistry {
-    private readonly chat: Chat;
-    private readonly events: Map<EventSource<any>, Entry<any>>;
-
-    constructor(chat: Chat) {
-        this.chat = chat;
-        this.events = new Map();
-    }
-
-    public register<P extends Array<any>>(event: EventSource<P>, handler: EventHandler<P>): void {
-        let entry = this.events.get(event) as Entry<P> | null;
-        if (!entry) {
-            const newEntry: Entry<P> = {
-                source: event,
-                listeners: new EventEmitter(),
-            };
-            entry = newEntry;
-            this.events.set(event, newEntry);
-            event.subscribe((...args) => newEntry.listeners.emit(...args), this.chat);
-        }
-        entry.listeners.listen((...args) => handler(...args));
-    }
-}

package/src/models/author.ts

@@ -1,72 +0,0 @@
-import { Identifier } from '@omujs/omu';
-
-import type { RoleJson } from './role.js';
-import { Role } from './role.js';
-
-export type AuthorMetadata = {
-    url?: string;
-    screen_id?: string;
-    avatar_url?: string;
-    description?: string;
-    links?: string[];
-};
-
-export type AuthorJson = {
-    provider_id: string;
-    id: string;
-    metadata: AuthorMetadata;
-    name?: string;
-    avatar_url?: string;
-    roles?: RoleJson[];
-};
-
-export class Author {
-    public providerId: Identifier;
-    public id: Identifier;
-    public metadata: AuthorMetadata;
-    public name?: string;
-    public avatarUrl?: string;
-    public roles?: Role[];
-
-    constructor(options: {
-        providerId: Identifier;
-        id: Identifier;
-        metadata?: AuthorMetadata;
-        name?: string;
-        avatarUrl?: string;
-        roles?: Role[];
-    }) {
-        this.providerId = options.providerId;
-        this.id = options.id;
-        this.metadata = options.metadata || {};
-        this.name = options.name;
-        this.avatarUrl = options.avatarUrl;
-        this.roles = options.roles;
-    }
-
-    public static deserialize(info: AuthorJson): Author {
-        return new Author({
-            providerId: Identifier.fromKey(info.provider_id),
-            id: Identifier.fromKey(info.id),
-            name: info.name,
-            avatarUrl: info.avatar_url,
-            roles: info.roles?.map((role) => Role.fromJson(role)),
-            metadata: info.metadata,
-        });
-    }
-
-    key(): string {
-        return this.id.key();
-    }
-
-    public static serialize(item: Author): AuthorJson {
-        return {
-            provider_id: item.providerId.key(),
-            id: item.id.key(),
-            name: item.name,
-            avatar_url: item.avatarUrl,
-            roles: item.roles?.map((role) => role.toJson()),
-            metadata: item.metadata,
-        };
-    }
-}

package/src/models/channel.ts

@@ -1,67 +0,0 @@
-import { Identifier } from '@omujs/omu';
-
-export type ChannelJson = {
-    provider_id: string;
-    id: string;
-    url: string;
-    name: string;
-    description: string;
-    active: boolean;
-    icon_url: string;
-};
-
-export class Channel {
-    providerId: Identifier;
-    id: Identifier;
-    url: string;
-    name: string;
-    description: string;
-    active: boolean;
-    iconUrl: string;
-
-    constructor(option: {
-        providerId: Identifier;
-        id: Identifier;
-        url: string;
-        name: string;
-        description: string;
-        active: boolean;
-        iconUrl: string;
-    }) {
-        this.providerId = option.providerId;
-        this.id = option.id;
-        this.url = option.url;
-        this.name = option.name;
-        this.description = option.description;
-        this.active = option.active;
-        this.iconUrl = option.iconUrl;
-    }
-
-    public static deserialize(json: ChannelJson): Channel {
-        return new Channel({
-            providerId: Identifier.fromKey(json.provider_id),
-            id: Identifier.fromKey(json.id),
-            url: json.url,
-            name: json.name,
-            description: json.description,
-            active: json.active,
-            iconUrl: json.icon_url,
-        });
-    }
-
-    key(): string {
-        return this.id.key();
-    }
-
-    public static serialize(item: Channel): ChannelJson {
-        return {
-            provider_id: item.providerId.key(),
-            id: item.id.key(),
-            url: item.url,
-            name: item.name,
-            description: item.description,
-            active: item.active,
-            icon_url: item.iconUrl,
-        };
-    }
-}

package/src/models/content.ts

@@ -1,62 +0,0 @@
-import { JsonType } from '@omujs/omu/serialize';
-
-export type ComponentType<T extends string, D extends JsonType = JsonType> = {
-    type: T;
-    data: D;
-};
-
-export type Root = ComponentType<'root', Component[]>;
-
-export type Text = ComponentType<'text', string>;
-
-export type Image = ComponentType<'image', {
-    url: string;
-    id: string;
-    name?: string;
-}>;
-
-export type Asset = ComponentType<'asset', {
-    id: string;
-}>;
-
-export type Link = ComponentType<'link', {
-    url: string;
-    children: Component[];
-}>;
-
-export type System = ComponentType<'system', Component[]>;
-
-export type Component =
-                    | Root
-                    | Text
-                    | Image
-                    | Asset
-                    | Link
-                    | System;
-
-export function children(component: Component): Component[] {
-    switch (component.type) {
-        case 'root': return component.data;
-        case 'system': return component.data;
-        case 'link': return component.data.children;
-        case 'text': return [];
-        case 'image': return [];
-        case 'asset': return [];
-    }
-}
-
-export function *walk(component: Component): Iterable<Component> {
-    const queue = [component];
-    while (queue.length > 0) {
-        const component = queue.pop();
-        if (!component) return;
-        yield component;
-        queue.push(...children(component).slice().reverse());
-    }
-}
-
-export function format(component: Component): string {
-    return [...walk(component)]
-        .filter(it => it.type === 'text')
-        .map(it => it.data).join('');
-}

package/src/models/gift.ts

@@ -1,49 +0,0 @@
-export type GiftJson = {
-    id: string;
-    name?: string;
-    amount?: number;
-    is_paid?: boolean;
-    image_url?: string;
-};
-
-export class Gift {
-    id: string;
-    name?: string;
-    amount?: number;
-    isPaid?: boolean;
-    imageUrl?: string;
-
-    constructor(options: {
-        id: string;
-        name?: string;
-        amount?: number;
-        isPaid?: boolean;
-        imageUrl?: string;
-    }) {
-        this.id = options.id;
-        this.name = options.name;
-        this.amount = options.amount;
-        this.isPaid = options.isPaid;
-        this.imageUrl = options.imageUrl;
-    }
-
-    static fromJson(options: GiftJson): Gift {
-        return new Gift({
-            id: options.id,
-            name: options.name,
-            amount: options.amount,
-            isPaid: options.is_paid,
-            imageUrl: options.image_url,
-        });
-    }
-
-    toJson(): GiftJson {
-        return {
-            id: this.id,
-            name: this.name,
-            amount: this.amount,
-            is_paid: this.isPaid,
-            image_url: this.imageUrl,
-        };
-    }
-}

package/src/models/message.ts

@@ -1,88 +0,0 @@
-import { Identifier } from '@omujs/omu';
-import * as content from './content.js';
-import type { GiftJson } from './gift.js';
-import { Gift } from './gift.js';
-import type { PaidJson } from './paid.js';
-import { Paid } from './paid.js';
-
-export type MessageJson = {
-    room_id: string;
-    id: string;
-    created_at: string; // ISO 8601 date string
-    author_id?: string;
-    content?: content.Component;
-    paid?: PaidJson;
-    gifts?: GiftJson[];
-    deleted?: boolean;
-};
-
-export class Message {
-    public roomId: Identifier;
-    public id: Identifier;
-    public authorId?: Identifier;
-    public content?: content.Component;
-    public paid?: Paid;
-    public gifts?: Gift[];
-    public createdAt: Date;
-    public deleted?: boolean;
-
-    constructor(options: {
-        roomId: Identifier;
-        id: Identifier;
-        authorId?: Identifier;
-        createdAt: Date;
-        content?: content.Component;
-        paid?: Paid;
-        gifts?: Gift[];
-        deleted?: boolean;
-    }) {
-        if (!(options.createdAt instanceof Date)) {
-            throw new Error('created_at must be a Date');
-        }
-        this.roomId = options.roomId;
-        this.id = options.id;
-        this.authorId = options.authorId;
-        this.content = options.content;
-        this.paid = options.paid;
-        this.gifts = options.gifts;
-        this.createdAt = options.createdAt;
-        this.deleted = options.deleted;
-    }
-
-    public static serialize(data: Message): MessageJson {
-        return {
-            room_id: data.roomId.key(),
-            id: data.id.key(),
-            author_id: data.authorId?.key(),
-            created_at: data.createdAt.toISOString(),
-            content: data.content,
-            paid: data.paid?.toJson(),
-            gifts: data.gifts?.map((gift) => gift.toJson()),
-            deleted: data.deleted,
-        };
-    }
-
-    public static deserialize(info: MessageJson): Message {
-        return new Message({
-            roomId: Identifier.fromKey(info.room_id),
-            id: Identifier.fromKey(info.id),
-            authorId: info.author_id ? Identifier.fromKey(info.author_id) : undefined,
-            content: info.content,
-            paid: info.paid && Paid.fromJson(info.paid),
-            gifts: info.gifts?.map((gift) => Gift.fromJson(gift)),
-            createdAt: new Date(info.created_at),
-            deleted: info.deleted,
-        });
-    }
-
-    get text(): string {
-        if (!this.content) {
-            return '';
-        }
-        return content.format(this.content);
-    }
-
-    key(): string {
-        return this.id.key();
-    }
-}

package/src/models/paid.ts

@@ -1,22 +0,0 @@
-export type PaidJson = {
-    amount: number;
-    currency: string;
-};
-
-export class Paid {
-    constructor(
-        public amount: number,
-        public currency: string,
-    ) { }
-
-    static fromJson(options: PaidJson): Paid {
-        return new Paid(options.amount, options.currency);
-    }
-
-    toJson(): PaidJson {
-        return {
-            amount: this.amount,
-            currency: this.currency,
-        };
-    }
-}

package/src/models/provider.ts

@@ -1,73 +0,0 @@
-import { Identifier } from '@omujs/omu';
-
-export type ProviderJson = {
-    id: string;
-    url: string;
-    name: string;
-    version: string;
-    repository_url: string;
-    image_url?: string;
-    description: string;
-    regex: string;
-};
-
-export class Provider {
-    public id: Identifier;
-    public url: string;
-    public name: string;
-    public version: string;
-    public repositoryUrl: string;
-    public imageUrl?: string;
-    public description: string;
-    public regex: string;
-
-    constructor(options: {
-        id: Identifier;
-        url: string;
-        name: string;
-        version: string;
-        repository_url: string;
-        image_url?: string;
-        description: string;
-        regex: string;
-    }) {
-        this.id = options.id;
-        this.url = options.url;
-        this.name = options.name;
-        this.version = options.version;
-        this.repositoryUrl = options.repository_url;
-        this.imageUrl = options.image_url;
-        this.description = options.description;
-        this.regex = options.regex;
-    }
-
-    public static serialize(item: Provider): ProviderJson {
-        return {
-            id: item.id.key(),
-            url: item.url,
-            name: item.name,
-            version: item.version,
-            repository_url: item.repositoryUrl,
-            image_url: item.imageUrl,
-            description: item.description,
-            regex: item.regex,
-        };
-    }
-
-    public static deserialize(data: ProviderJson): Provider {
-        return new Provider({
-            id: Identifier.fromKey(data.id),
-            url: data.url,
-            name: data.name,
-            version: data.version,
-            repository_url: data.repository_url,
-            image_url: data.image_url,
-            description: data.description,
-            regex: data.regex,
-        });
-    }
-
-    key(): string {
-        return this.id.key();
-    }
-}