@omujs/chat 0.9.10 → 0.9.26

package/src/models/content.ts

@@ -1,226 +1,62 @@
-import { Identifier } from '@omujs/omu';
+import { JsonType } from '@omujs/omu/serialize';
 
-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;
+export type ComponentType<T extends string, D extends JsonType = JsonType> = {
+    type: T;
+    data: D;
 };
 
-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;
-    }
+export type Root = ComponentType<'root', Component[]>;
 
-    static of(text: string): Text {
-        return new Text(text);
-    }
-}
+export type Text = ComponentType<'text', string>;
 
-export type ImageData = {
+export type Image = ComponentType<'image', {
     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 AssetData = {
+export type Asset = ComponentType<'asset', {
     id: string;
-};
-
-export class Asset extends Component<'asset', AssetData> {
-    constructor(public id: Identifier) {
-        super('asset');
-    }
-
-    toJson(): AssetData {
-        return {
-            id: this.id.key(),
-        };
-    }
-}
+}>;
 
-export type LinkData = {
+export type Link = ComponentType<'link', {
     url: string;
-    children: ComponentJson[];
-};
-
-export class Link extends Component<'link', LinkData> implements Parent {
-    constructor(
-        public url: string,
-        public children: Component[],
-    ) {
-        super('link');
-    }
+    children: Component[];
+}>;
 
-    toJson(): LinkData {
-        return {
-            url: this.url,
-            children: this.children.map(serialize),
-        };
-    }
-}
+export type System = ComponentType<'system', Component[]>;
 
-export type SystemData = ComponentJson[];
+export type Component =
+                    | Root
+                    | Text
+                    | Image
+                    | Asset
+                    | Link
+                    | System;
 
-export class System extends Component<'system', SystemData> implements Parent {
-    constructor(public children: Component[]) {
-        super('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 [];
     }
+}
 
-    toJson(): SystemData {
-        return this.children.map(serialize);
+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());
     }
 }
 
-register('root', (data: RootData) => new Root(data.map(deserialize)));
-register('text', (data: TextData) => new Text(data));
-register('image', (data: ImageData) => new Image(data.url, data.id, data.name));
-register('asset', (data: AssetData) => new Asset(Identifier.fromKey(data.id)));
-register('link', (data: LinkData) => new Link(data.url, data.children.map(deserialize)));
-register('system', (data: SystemData) => new System(data.map(deserialize)));
+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,5 +1,3 @@
-import type { Model } from '@omujs/omu/model.js';
-
 export type GiftJson = {
     id: string;
     name?: string;
@@ -8,7 +6,7 @@ export type GiftJson = {
     image_url?: string;
 };
 
-export class Gift implements Model<GiftJson> {
+export class Gift {
     id: string;
     name?: string;
     amount?: number;

package/src/models/index.ts

@@ -1,11 +1,14 @@
-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 { Reaction } from './reaction.js';
-export { Provider } from './provider.js';
-export { Role } from './role.js';
-export { Room } from './room.js';
-export { Vote, Choice } from './vote.js';
+export { Author, AuthorJson } from './author.js';
+export { Channel, ChannelJson } from './channel.js';
+export { Asset, Component, ComponentType, Image, Link, Root, System, Text } from './content.js';
+export { Gift, GiftJson } from './gift.js';
+export { Message, MessageJson } from './message.js';
+export { Paid, PaidJson } from './paid.js';
+export { Provider, ProviderJson } from './provider.js';
+export { Reaction, ReactionJson } from './reaction.js';
+export { Role, RoleJson } from './role.js';
+export { Room, RoomJson } from './room.js';
+export { Choice, Vote, VoteJson } from './vote.js';
+export { Content };
+import * as Content from './content.js';
+

package/src/models/message.ts

@@ -1,7 +1,4 @@
-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 { Identifier } from '@omujs/omu';
 import * as content from './content.js';
 import type { GiftJson } from './gift.js';
 import { Gift } from './gift.js';
@@ -13,13 +10,13 @@ export type MessageJson = {
     id: string;
     created_at: string; // ISO 8601 date string
     author_id?: string;
-    content?: content.ComponentJson;
+    content?: content.Component;
     paid?: PaidJson;
     gifts?: GiftJson[];
     deleted?: boolean;
 };
 
-export class Message implements Model<MessageJson>, Keyable, Timestamped {
+export class Message {
     public roomId: Identifier;
     public id: Identifier;
     public authorId?: Identifier;
@@ -52,12 +49,25 @@ export class Message implements Model<MessageJson>, Keyable, Timestamped {
         this.deleted = options.deleted;
     }
 
-    static fromJson(info: MessageJson): Message {
+    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 && content.deserialize(info.content),
+            content: info.content,
             paid: info.paid && Paid.fromJson(info.paid),
             gifts: info.gifts?.map((gift) => Gift.fromJson(gift)),
             createdAt: new Date(info.created_at),
@@ -69,23 +79,10 @@ export class Message implements Model<MessageJson>, Keyable, Timestamped {
         if (!this.content) {
             return '';
         }
-        return this.content.toString();
+        return content.format(this.content);
     }
 
     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()),
-            deleted: this.deleted,
-        };
-    }
 }

package/src/models/paid.ts

@@ -1,11 +1,9 @@
-import type { Model } from '@omujs/omu/model.js';
-
 export type PaidJson = {
     amount: number;
     currency: string;
 };
 
-export class Paid implements Model<PaidJson> {
+export class Paid {
     constructor(
         public amount: number,
         public currency: string,

package/src/models/provider.ts

@@ -1,6 +1,4 @@
-import { Identifier } from '@omujs/omu/identifier.js';
-import type { Keyable } from '@omujs/omu/interface.js';
-import type { Model } from '@omujs/omu/model.js';
+import { Identifier } from '@omujs/omu';
 
 export type ProviderJson = {
     id: string;
@@ -13,7 +11,7 @@ export type ProviderJson = {
     regex: string;
 };
 
-export class Provider implements Keyable, Model<ProviderJson> {
+export class Provider {
     public id: Identifier;
     public url: string;
     public name: string;
@@ -43,7 +41,20 @@ export class Provider implements Keyable, Model<ProviderJson> {
         this.regex = options.regex;
     }
 
-    static fromJson(data: ProviderJson): Provider {
+    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,
@@ -56,19 +67,6 @@ export class Provider implements Keyable, Model<ProviderJson> {
         });
     }
 
-    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/reaction.ts

@@ -1,5 +1,4 @@
 import { Identifier } from '@omujs/omu';
-import type { Model } from '@omujs/omu/model.js';
 
 export type ReactionJson = {
     room_id: string;
@@ -8,7 +7,7 @@ export type ReactionJson = {
     };
 };
 
-export class Reaction implements Model<ReactionJson> {
+export class Reaction {
     public roomId: Identifier;
     public reactions: {
         [key: string]: number;
@@ -24,17 +23,17 @@ export class Reaction implements Model<ReactionJson> {
         this.reactions = options.reactions;
     }
 
-    static fromJson(data: ReactionJson): Reaction {
+    public static deserialize(data: ReactionJson): Reaction {
         return new Reaction({
             roomId: Identifier.fromKey(data.room_id),
             reactions: data.reactions,
         });
     }
 
-    toJson(): ReactionJson {
+    public static serialize(item: Reaction): ReactionJson {
         return {
-            room_id: this.roomId.key(),
-            reactions: this.reactions,
+            room_id: item.roomId.key(),
+            reactions: item.reactions,
         };
     }
 }

package/src/models/role.ts

@@ -1,5 +1,3 @@
-import type { Model } from '@omujs/omu/model.js';
-
 export type RoleJson = {
     id?: string;
     name: string;
@@ -9,7 +7,7 @@ export type RoleJson = {
     color?: string;
 };
 
-export class Role implements Model<RoleJson> {
+export class Role {
     id?: string;
     name: string;
     isOwner: boolean;

package/src/models/room.ts

@@ -1,6 +1,4 @@
-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 { Identifier } from '@omujs/omu';
 
 export type MetadataJson = {
     title?: string;
@@ -27,7 +25,7 @@ export type RoomJson = {
     created_at: string; // ISO 8601 date string
 };
 
-export class Room implements Model<RoomJson>, Keyable, Timestamped {
+export class Room {
     public id: Identifier;
     public providerId: Identifier;
     public connected: boolean;
@@ -54,7 +52,7 @@ export class Room implements Model<RoomJson>, Keyable, Timestamped {
         this.createdAt = options.createdAt;
     }
 
-    static fromJson(options: RoomJson): Room {
+    public static deserialize(options: RoomJson): Room {
         return new Room({
             id: Identifier.fromKey(options.id),
             providerId: Identifier.fromKey(options.provider_id),
@@ -66,15 +64,15 @@ export class Room implements Model<RoomJson>, Keyable, Timestamped {
         });
     }
 
-    toJson(): RoomJson {
+    public static serialize(item: Room): RoomJson {
         return {
-            id: this.id.key(),
-            provider_id: this.providerId.key(),
-            connected: this.connected,
-            status: this.status,
-            metadata: this.metadata,
-            channel_id: this.channelId,
-            created_at: this.createdAt.toISOString(),
+            id: item.id.key(),
+            provider_id: item.providerId.key(),
+            connected: item.connected,
+            status: item.status,
+            metadata: item.metadata,
+            channel_id: item.channelId,
+            created_at: item.createdAt.toISOString(),
         };
     }
 

package/src/models/vote.ts

@@ -1,6 +1,4 @@
 import { Identifier } from '@omujs/omu';
-import type { Keyable } from '@omujs/omu/interface.js';
-import type { Model } from '@omujs/omu/model.js';
 
 export type Choice = {
     text: string;
@@ -17,7 +15,7 @@ export type VoteJson = {
     total: number | null;
 };
 
-export class Vote implements Keyable, Model<VoteJson> {
+export class Vote {
     public readonly id: Identifier;
     public readonly roomId: Identifier;
     public title: string;
@@ -41,7 +39,7 @@ export class Vote implements Keyable, Model<VoteJson> {
         this.total = options.total;
     }
 
-    public static fromJson(options: VoteJson): Vote {
+    public static deserialize(options: VoteJson): Vote {
         return new Vote({
             id: Identifier.fromKey(options.id),
             roomId: Identifier.fromKey(options.room_id),
@@ -52,14 +50,14 @@ export class Vote implements Keyable, Model<VoteJson> {
         });
     }
 
-    public toJson(): VoteJson {
+    public static serialize(item: Vote): VoteJson {
         return {
-            id: this.id.key(),
-            room_id: this.roomId.key(),
-            title: this.title,
-            choices: this.choices,
-            ended: this.ended,
-            total: this.total,
+            id: item.id.key(),
+            room_id: item.roomId.key(),
+            title: item.title,
+            choices: item.choices,
+            ended: item.ended,
+            total: item.total,
         };
     }
 

package/src/permissions.ts

@@ -1,8 +1,9 @@
-import { IDENTIFIER } from './const.js';
+import { Identifier } from '@omujs/omu';
+import { PLUGIN_ID } from './const.js';
 
-export const CHAT_PERMISSION_ID = IDENTIFIER;
-export const CHAT_READ_PERMISSION_ID = IDENTIFIER.join('chat', 'read');
-export const CHAT_WRITE_PERMISSION_ID = IDENTIFIER.join('chat', 'write');
-export const CHAT_SEND_PERMISSION_ID = IDENTIFIER.join('chat', 'send');
-export const CHAT_CHANNEL_TREE_PERMISSION_ID = IDENTIFIER.join('create_channel_tree');
-export const CHAT_REACTION_PERMISSION_ID = IDENTIFIER.join('reaction');
+export const CHAT_PERMISSION_ID: Identifier = PLUGIN_ID;
+export const CHAT_READ_PERMISSION_ID: Identifier = PLUGIN_ID.join('chat', 'read');
+export const CHAT_WRITE_PERMISSION_ID: Identifier = PLUGIN_ID.join('chat', 'write');
+export const CHAT_SEND_PERMISSION_ID: Identifier = PLUGIN_ID.join('chat', 'send');
+export const CHAT_CHANNEL_TREE_PERMISSION_ID: Identifier = PLUGIN_ID.join('create_channel_tree');
+export const CHAT_REACTION_PERMISSION_ID: Identifier = PLUGIN_ID.join('reaction');

package/tsconfig.json

@@ -1,7 +1,10 @@
 {
     "$schema": "http://json.schemastore.org/tsconfig",
-    "extends": "../eslint-config/tsconfig.json",
-    "compilerOptions": {},
+    "extends": "../../tsconfig.json",
+    "compilerOptions": {
+        "isolatedDeclarations": true,
+        "declaration": true
+    },
     "compileOnSave": true,
     "include": [
         "./src/**/*"