@omujs/chat 0.1.22

package/src/models/author.ts

@@ -0,0 +1,74 @@
+import { Identifier } from '@omujs/omu/identifier.js';
+import type { Keyable } from '@omujs/omu/interface.js';
+import type { Model } from '@omujs/omu/model.js';
+
+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;
+    name?: string;
+    avatar_url?: string;
+    roles?: RoleJson[];
+    metadata?: AuthorMetadata;
+};
+
+export class Author implements Keyable, Model<AuthorJson> {
+    public providerId: Identifier;
+    public id: Identifier;
+    public name?: string;
+    public avatarUrl?: string;
+    public roles?: Role[];
+    public metadata?: AuthorMetadata;
+
+    constructor(options: {
+        providerId: Identifier;
+        id: Identifier;
+        name?: string;
+        avatarUrl?: string;
+        roles?: Role[];
+        metadata?: AuthorMetadata;
+    }) {
+        this.providerId = options.providerId;
+        this.id = options.id;
+        this.name = options.name;
+        this.avatarUrl = options.avatarUrl;
+        this.roles = options.roles;
+        this.metadata = options.metadata;
+    }
+
+    static fromJson(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.providerId}:${this.id}`;
+    }
+
+    toJson(): AuthorJson {
+        return {
+            provider_id: this.providerId.key(),
+            id: this.id.key(),
+            name: this.name,
+            avatar_url: this.avatarUrl,
+            roles: this.roles?.map((role) => role.toJson()),
+            metadata: this.metadata,
+        };
+    }
+}

package/src/models/channel.ts

@@ -0,0 +1,69 @@
+import { Identifier } from '@omujs/omu/identifier.js';
+import type { Keyable } from '@omujs/omu/interface.js';
+import type { Model } from '@omujs/omu/model.js';
+
+export type ChannelJson = {
+    provider_id: string;
+    id: string;
+    url: string;
+    name: string;
+    description: string;
+    active: boolean;
+    icon_url: string;
+};
+
+export class Channel implements Model<ChannelJson>, Keyable {
+    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;
+    }
+
+    static fromJson(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();
+    }
+
+    toJson(): ChannelJson {
+        return {
+            provider_id: this.providerId.key(),
+            id: this.id.key(),
+            url: this.url,
+            name: this.name,
+            description: this.description,
+            active: this.active,
+            icon_url: this.iconUrl,
+        };
+    }
+}

package/src/models/content.ts

@@ -0,0 +1,207 @@
+type Primitive =
+    | {
+        [key: string]: Primitive | string | number | boolean | null;
+    }
+    | any[]
+    | string
+    | number
+    | boolean
+    | null;
+
+export type ComponentJson = {
+    type: string;
+    data: Primitive;
+};
+
+export interface Parent {
+    children: Component[];
+}
+
+export abstract class Component<T extends string = string, D extends Primitive = Primitive> {
+    constructor(public type: T) { }
+
+    abstract toJson(): D;
+
+    isParent(): this is Parent {
+        return 'children' in this;
+    }
+
+    walk(cb: (component: Component) => void): void {
+        const stack: Component[] = [this];
+        while (stack.length) {
+            const component = stack.pop();
+            if (!component) {
+                continue;
+            }
+            cb(component);
+            if (component.isParent()) {
+                stack.push(...component.children);
+            }
+        }
+    }
+
+    *iter(): Iterable<Component> {
+        const stack: Component[] = [this];
+        while (stack.length) {
+            const component = stack.pop();
+            if (!component) {
+                continue;
+            }
+            yield component;
+            if (component.isParent()) {
+                stack.push(...component.children);
+            }
+        }
+    }
+
+    toString(): string {
+        const parts = [] as string[];
+        for (const component of this.iter()) {
+            if (component instanceof Text) {
+                parts.push(component.text);
+            }
+        }
+        return parts.join('');
+    }
+}
+
+export type ComponentType<D, C extends Component> = {
+    type: string;
+    fromJson(json: D): C;
+};
+
+const componentTypes: Record<string, ComponentType<unknown, Component> | undefined> = {};
+
+export function deserialize(json: ComponentJson): Component {
+    const type = componentTypes[json.type];
+    if (!type) {
+        throw new Error(`Unknown component type: ${json.type}`);
+    }
+    return type.fromJson(json.data);
+}
+
+export function serialize(component: Component): ComponentJson {
+    return {
+        type: component.type,
+        data: component.toJson(),
+    };
+}
+
+export function register<D, C extends Component>(type: string, deserialize: (json: D) => C): void {
+    if (componentTypes[type]) {
+        throw new Error(`Component type already registered: ${type}`);
+    }
+    componentTypes[type] = {
+        type,
+        fromJson: deserialize,
+    };
+}
+
+export type RootData = ComponentJson[];
+
+export class Root extends Component<'root', RootData> implements Parent {
+    constructor(public children: Component[]) {
+        super('root');
+    }
+
+    toJson(): RootData {
+        return this.children.map(serialize);
+    }
+
+    add(component: Component): void {
+        this.children.push(component);
+    }
+
+    text(): string {
+        const parts = [] as string[];
+        for (const component of this.iter()) {
+            if (component instanceof Text) {
+                parts.push(component.text);
+            }
+        }
+        return parts.join('');
+    }
+}
+
+export type TextData = string;
+
+export class Text extends Component<'text', TextData> {
+    constructor(public text: string) {
+        super('text');
+    }
+
+    toJson(): TextData {
+        return this.text;
+    }
+
+    static of(text: string): Text {
+        return new Text(text);
+    }
+}
+
+export type ImageData = {
+    url: string;
+    id: string;
+    name?: string;
+};
+
+export class Image extends Component<'image', ImageData> {
+    constructor(
+        public url: string,
+        public id: string,
+        public name: string | undefined = undefined,
+    ) {
+        super('image');
+    }
+
+    toJson(): ImageData {
+        return {
+            url: this.url,
+            id: this.id,
+            name: this.name,
+        };
+    }
+
+    static of({ url, id, name }: { url: string; id: string; name?: string }): Image {
+        return new Image(url, id, name);
+    }
+}
+
+export type LinkData = {
+    url: string;
+    children: ComponentJson[];
+};
+
+export class Link extends Component<'link', LinkData> implements Parent {
+    constructor(
+        public url: string,
+        public children: Component[],
+    ) {
+        super('link');
+    }
+
+    toJson(): LinkData {
+        return {
+            url: this.url,
+            children: this.children.map(serialize),
+        };
+    }
+}
+
+export type SystemData = ComponentJson[];
+
+export class System extends Component<'system', SystemData> implements Parent {
+    constructor(public children: Component[]) {
+        super('system');
+    }
+
+    toJson(): SystemData {
+        return this.children.map(serialize);
+    }
+}
+
+register('root', (json: RootData) => new Root(json.map(deserialize)));
+register('text', (json: TextData) => new Text(json));
+register('image', (json: ImageData) => new Image(json.url, json.id, json.name));
+register('link', (json: LinkData) => new Link(json.url, json.children.map(deserialize)));
+register('system', (json: SystemData) => new System(json.map(deserialize)));

package/src/models/gift.ts

@@ -0,0 +1,51 @@
+import type { Model } from '@omujs/omu/model.js';
+
+export type GiftJson = {
+    id: string;
+    name?: string;
+    amount?: number;
+    is_paid?: boolean;
+    image_url?: string;
+};
+
+export class Gift implements Model<GiftJson> {
+    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/index.ts

@@ -0,0 +1,10 @@
+export { Author } from './author.js';
+export { Channel } from './channel.js';
+export * as content from './content.js';
+export { Gift } from './gift.js';
+export { Message } from './message.js';
+export { Paid } from './paid.js';
+export { Provider } from './provider.js';
+export { Role } from './role.js';
+export { Room } from './room.js';
+

package/src/models/message.ts

@@ -0,0 +1,85 @@
+import { Identifier } from '@omujs/omu/identifier.js';
+import type { Keyable, Timestamped } from '@omujs/omu/interface.js';
+import type { Model } from '@omujs/omu/model.js';
+
+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.ComponentJson;
+    paid?: PaidJson;
+    gifts?: GiftJson[];
+};
+
+export class Message implements Model<MessageJson>, Keyable, Timestamped {
+    public roomId: Identifier;
+    public id: Identifier;
+    public authorId?: Identifier;
+    public content?: content.Component;
+    public paid?: Paid;
+    public gifts?: Gift[];
+    public createdAt: Date;
+
+    constructor(options: {
+        roomId: Identifier;
+        id: Identifier;
+        authorId?: Identifier;
+        createdAt: Date;
+        content?: content.Component;
+        paid?: Paid;
+        gifts?: Gift[];
+    }) {
+        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;
+    }
+
+    static fromJson(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 && content.deserialize(info.content),
+            paid: info.paid && Paid.fromJson(info.paid),
+            gifts: info.gifts?.map((gift) => Gift.fromJson(gift)),
+            createdAt: new Date(info.created_at),
+        });
+    }
+
+    get text(): string {
+        if (!this.content) {
+            return '';
+        }
+        return this.content.toString();
+    }
+
+    key(): string {
+        return this.id.key();
+    }
+
+    toJson(): MessageJson {
+        return {
+            room_id: this.roomId.key(),
+            id: this.id.key(),
+            author_id: this.authorId?.key(),
+            created_at: this.createdAt.toISOString(),
+            content: this.content && content.serialize(this.content),
+            paid: this.paid?.toJson(),
+            gifts: this.gifts?.map((gift) => gift.toJson()),
+        };
+    }
+}

package/src/models/paid.ts

@@ -0,0 +1,24 @@
+import type { Model } from '@omujs/omu/model.js';
+
+export type PaidJson = {
+    amount: number;
+    currency: string;
+};
+
+export class Paid implements Model<PaidJson> {
+    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

@@ -0,0 +1,75 @@
+import { Identifier } from '@omujs/omu/identifier.js';
+import type { Keyable } from '@omujs/omu/interface.js';
+import type { Model } from '@omujs/omu/model.js';
+
+export type ProviderJson = {
+    id: string;
+    url: string;
+    name: string;
+    version: string;
+    repository_url: string;
+    image_url?: string;
+    description: string;
+    regex: string;
+};
+
+export class Provider implements Keyable, Model<ProviderJson> {
+    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;
+    }
+
+    static fromJson(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,
+        });
+    }
+
+    toJson(): ProviderJson {
+        return {
+            id: this.id.key(),
+            url: this.url,
+            name: this.name,
+            version: this.version,
+            repository_url: this.repositoryUrl,
+            image_url: this.imageUrl,
+            description: this.description,
+            regex: this.regex,
+        };
+    }
+
+    key(): string {
+        return this.id.key();
+    }
+}

package/src/models/role.ts

@@ -0,0 +1,57 @@
+import type { Model } from '@omujs/omu/model.js';
+
+export type RoleJson = {
+    id?: string;
+    name: string;
+    is_owner: boolean;
+    is_moderator: boolean;
+    icon_url?: string;
+    color?: string;
+};
+
+export class Role implements Model<RoleJson> {
+    id?: string;
+    name: string;
+    isOwner: boolean;
+    isModerator: boolean;
+    iconUrl?: string;
+    color?: string;
+
+    constructor(options: {
+        id?: string;
+        name: string;
+        isOwner: boolean;
+        isModerator: boolean;
+        iconUrl?: string;
+        color?: string;
+    }) {
+        this.id = options.id;
+        this.name = options.name;
+        this.isOwner = options.isOwner;
+        this.isModerator = options.isModerator;
+        this.iconUrl = options.iconUrl;
+        this.color = options.color;
+    }
+
+    static fromJson(json: RoleJson): Role {
+        return new Role({
+            id: json.id,
+            name: json.name,
+            isOwner: json.is_owner,
+            isModerator: json.is_moderator,
+            iconUrl: json.icon_url,
+            color: json.color,
+        });
+    }
+
+    toJson(): RoleJson {
+        return {
+            id: this.id,
+            name: this.name,
+            color: this.color,
+            icon_url: this.iconUrl,
+            is_owner: this.isOwner,
+            is_moderator: this.isModerator,
+        };
+    }
+}