floating-live 0.15.10 → 0.16.0-alpha.0

package/README.md

@@ -1,32 +1,36 @@
 # Floating Live
-一个用于处理和保存直播弹幕的Node.js小工具，开箱即用。
+
+一个用于处理和保存直播弹幕的 Web 小工具，开箱即用。
 
 本体无弹幕获取功能，需要配合[floating-live-plugins](https://github.com/Minteea/floating-live-plugins)中的插件使用。
 
-目前插件库支持bilibili和AcFun的直播弹幕，不同平台的弹幕会转换为同一种格式便于保存。
+目前插件库支持 bilibili 和 AcFun 的直播弹幕，不同平台的弹幕会转换为同一种格式便于保存。
 
 项目仍在开发中，功能尚未完善，目前除了记录保存直播弹幕外暂时没有别的用处啦，敬请期待。
 
 注意：当前项目未进入正式版本阶段，程序结构及导出数据结构可能随时改动，**非常不建议用于正式项目中**。
 
-GUI版本：[Minteea/floating-live-gui](https://github.com/Minteea/floating-live-gui)
+GUI 版本：[Minteea/floating-live-gui](https://github.com/Minteea/floating-live-gui)
 
 ## 使用方法
-### npm安装
+
+### npm 安装
+
 ```
 npm install floating-live
 ```
-``` javascript
+
+```javascript
 // 导入FloatingLive本体
-const { FloatingLive } = require("floating-live")
+import { FloatingLive } from "floating-live";
 // 导入bilibili房间生成插件
-const bilibili = require("@floating-live/bilibili")   
+import bilibili from "@floating-live/bilibili";
 
 // 创建一个FloatingLive实例
-const live = new FloatingLive()
+const live = new FloatingLive();
 // 注册插件
-live.plugin.register(bilibili)
+live.plugin.register(bilibili);
 
 // 添加房间并自动打开
-live.room.add("bilibili", 6, true)
+live.room.add("bilibili", 6, true);
 ```

package/dist/FloatingLive.d.ts

@@ -0,0 +1,6 @@
+import { App } from "./app";
+import Room from "./plugins/room";
+export declare class FloatingLive extends App {
+    room: Room;
+    constructor();
+}

package/dist/FloatingLive.js

@@ -0,0 +1,8 @@
+import { App } from "./app";
+import Room from "./plugins/room";
+export class FloatingLive extends App {
+    constructor() {
+        super();
+        this.room = new Room(this);
+    }
+}

package/dist/app.d.ts

@@ -0,0 +1,46 @@
+import { CommandOptions, CommandCallOptions, AppCommandMap, CommandFunction } from "./command";
+import { AppError } from "./error";
+import { AppEventDetailMap, AppEventEmitOptions, AppEventListener } from "./event";
+import { AppHookMap, HookCallOptions, HookContext, HookFunction, HookUseOptions } from "./hook";
+import { PluginContext, PluginRegisterOptions } from "./plugin";
+import { CustomEventEmitter } from "./utils/EventEmitter";
+import { AppValueMap, ValueOptions } from "./value";
+export declare class App extends CustomEventEmitter implements PluginContext {
+    private hookManager;
+    private pluginManager;
+    private commandManager;
+    private valueManager;
+    constructor();
+    on<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
+    once<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
+    off<K extends keyof AppEventDetailMap>(type: K, listener: AppEventListener<AppEventDetailMap[K]>): void;
+    emit<K extends keyof AppEventDetailMap>(type: K, detail: AppEventDetailMap[K], options?: AppEventEmitOptions & EventInit): void;
+    /** 发送错误 */
+    throw(err?: Error): void;
+    error(id: string, detail?: Record<string, any>): AppError;
+    /** 注册插件 */
+    register(plugin: any, options?: PluginRegisterOptions): void;
+    /** 取消注册插件 */
+    unregister(pluginName: string): void;
+    getPlugin(pluginName: string): void;
+    whenRegister(pluginName: string, callback: (exposes: any) => (() => void) | undefined): void;
+    getPluginExposes(pluginName: string): any;
+    hasPlugin(pluginName: string): boolean;
+    registerCommand<T extends keyof AppCommandMap>(name: T, func: CommandFunction<AppCommandMap[T]>, options?: CommandOptions): void;
+    unregisterCommand(name: string): void;
+    call<T extends keyof AppCommandMap>(name: T, ...args: Parameters<AppCommandMap[T]>): ReturnType<AppCommandMap[T]>;
+    callWithOptions<T extends keyof AppCommandMap>(name: T, options: CommandCallOptions, ...args: Parameters<AppCommandMap[T]>): ReturnType<AppCommandMap[T]>;
+    useHook<T extends keyof AppHookMap>(name: T, func: HookFunction<AppHookMap[T]>, options?: HookUseOptions): void;
+    unuseHook<T extends keyof AppHookMap>(name: T, func: HookFunction<AppHookMap[T]>): void;
+    callHook<T extends keyof AppHookMap>(name: T, ctx: AppHookMap[T], options?: HookCallOptions): Promise<HookContext<AppHookMap[T]>>;
+    callHookSync<T extends keyof AppHookMap>(name: T, ctx: AppHookMap[T], options?: HookCallOptions): HookContext<AppHookMap[T]>;
+    registerValue<K extends keyof AppValueMap>(name: K, options: ValueOptions<AppValueMap[K]>): void;
+    unregisterValue(name: string): void;
+    watch<K extends keyof AppValueMap>(name: K, watcher: (value: AppValueMap[K]) => void): void;
+    unwatch<K extends keyof AppValueMap>(name: K, watcher: (value: AppValueMap[K]) => void): void;
+    getValue<K extends keyof AppValueMap>(name: K): AppValueMap[K];
+    setValue(name: string, value: any): void;
+    destroy(): void;
+    /** 拓展值 */
+    define(): void;
+}

package/dist/app.js

@@ -0,0 +1,126 @@
+import { CommandManager } from "./command/manager";
+import { AppError } from "./error";
+import { HookManager } from "./hook/manager";
+import { PluginManager } from "./plugin/manager";
+import { CustomEventEmitter } from "./utils/EventEmitter";
+import { ValueManager } from "./value/manager";
+export class App extends CustomEventEmitter {
+    constructor() {
+        super();
+        this.hookManager = new HookManager(this);
+        this.pluginManager = new PluginManager(this);
+        this.commandManager = new CommandManager(this);
+        this.valueManager = new ValueManager(this);
+    }
+    on(type, listener) {
+        super.on(type, listener);
+    }
+    once(type, listener) {
+        super.once(type, listener);
+    }
+    off(type, listener) {
+        super.off(type, listener);
+    }
+    emit(type, detail, options) {
+        const { source, remote } = options || {};
+        super.emit(type, { ...detail, source, remote }, options);
+    }
+    //--- 错误机制 ---//
+    /** 发送错误 */
+    throw(err) {
+        throw err;
+    }
+    error(id, detail) {
+        return new AppError(id, detail || {});
+    }
+    //--- 插件机制 ---//
+    /** 注册插件 */
+    register(plugin, options) {
+        this.pluginManager.register(plugin, options);
+    }
+    /** 取消注册插件 */
+    unregister(pluginName) {
+        this.pluginManager.unregister(pluginName);
+    }
+    getPlugin(pluginName) {
+        this.pluginManager.getPlugin(pluginName);
+    }
+    whenRegister(pluginName, callback) {
+        let registered = this.hasPlugin(pluginName);
+        let whenUnregistered;
+        if (registered) {
+            whenUnregistered = callback(this.getPluginExposes(pluginName));
+        }
+        this.on("plugin:register", ({ pluginName: name }) => {
+            if (pluginName == name) {
+                if (registered) {
+                    whenUnregistered?.();
+                }
+                whenUnregistered = callback(this.getPluginExposes(pluginName));
+                registered = true;
+            }
+        });
+        this.on("plugin:unregister", ({ pluginName: name }) => {
+            if (pluginName == name) {
+                whenUnregistered?.();
+                whenUnregistered = undefined;
+                registered = false;
+            }
+        });
+    }
+    getPluginExposes(pluginName) {
+        this.pluginManager.getExposes(pluginName);
+    }
+    hasPlugin(pluginName) {
+        return this.pluginManager.has(pluginName);
+    }
+    //--- 指令机制 ---//
+    registerCommand(name, func, options) {
+        this.commandManager.register(name, func, options);
+    }
+    unregisterCommand(name) {
+        this.commandManager.unregister(name);
+    }
+    call(name, ...args) {
+        return this.commandManager.call(name, ...args);
+    }
+    callWithOptions(name, options, ...args) {
+        return this.commandManager.callWithOptions(name, options, ...args);
+    }
+    //--- 钩子机制 ---//
+    useHook(name, func, options) {
+        this.hookManager.use(name, func, options);
+    }
+    unuseHook(name, func) {
+        this.hookManager.unuse(name, func);
+    }
+    callHook(name, ctx, options) {
+        return this.hookManager.call(name, ctx);
+    }
+    callHookSync(name, ctx, options) {
+        return this.hookManager.callSync(name, ctx);
+    }
+    //--- 值机制 ---//
+    registerValue(name, options) {
+        this.valueManager.register(name, options);
+    }
+    unregisterValue(name) {
+        this.valueManager.unregister(name);
+    }
+    watch(name, watcher) {
+        this.valueManager.watch(name, watcher);
+    }
+    unwatch(name, watcher) {
+        this.valueManager.unwatch(name, watcher);
+    }
+    getValue(name) {
+        return this.valueManager.get(name);
+    }
+    setValue(name, value) {
+        this.valueManager.set(name, value);
+    }
+    destroy() { }
+    //--- 其他 ---//
+    /** 拓展值 */
+    define() { }
+}

package/dist/command/index.d.ts

@@ -0,0 +1 @@
+export * from "./types";

package/dist/command/index.js

@@ -0,0 +1 @@
+export * from "./types";

package/dist/command/manager.d.ts

@@ -0,0 +1,23 @@
+import { App } from "../app";
+import { CommandFunction, CommandCallOptions, CommandOptions } from "./types";
+export declare class CommandManager {
+    /** 功能列表 */
+    private readonly list;
+    protected readonly app: App;
+    constructor(app: App);
+    /** 注册命令 */
+    register(name: string, call: CommandFunction<any>, options?: CommandOptions): void;
+    /** 取消注册命令 */
+    unregister(name: string): void;
+    /** 调用命令 */
+    call(name: string, ...args: any[]): any;
+    /** 调用命令(可配置) */
+    callWithOptions(name: string, options: CommandCallOptions, ...args: any[]): any;
+    /** 检测命令是否存在 */
+    has(name: string): boolean;
+    /** 获取数据 */
+    getData(): {
+        name: string;
+        pluginName: string | undefined;
+    }[];
+}

package/dist/command/manager.js

@@ -0,0 +1,46 @@
+export class CommandManager {
+    constructor(app) {
+        /** 功能列表 */
+        this.list = new Map();
+        this.app = app;
+    }
+    /** 注册命令 */
+    register(name, call, options) {
+        const { pluginName } = options || {};
+        this.list.set(name, { call, pluginName });
+        this.app.emit("command:register", { name });
+    }
+    /** 取消注册命令 */
+    unregister(name) {
+        this.list.delete(name);
+        this.app.emit("command:unregister", { name });
+    }
+    /** 调用命令 */
+    call(name, ...args) {
+        return this.callWithOptions(name, {}, ...args);
+    }
+    /** 调用命令(可配置) */
+    callWithOptions(name, options, ...args) {
+        const command = this.list.get(name);
+        if (!command) {
+            throw {
+                message: "命令不存在",
+                id: "command:call_unexist",
+            };
+        }
+        else {
+            return command.call({ source: options.source, client: options.client }, ...args);
+        }
+    }
+    /** 检测命令是否存在 */
+    has(name) {
+        return this.list.has(name);
+    }
+    /** 获取数据 */
+    getData() {
+        return [...this.list].map(([name, { pluginName }]) => ({
+            name,
+            pluginName,
+        }));
+    }
+}

package/dist/command/types.d.ts

@@ -0,0 +1,25 @@
+import { AppValueMap } from "../value";
+export interface CommandOptions {
+    pluginName?: string;
+}
+export interface CommandCallOptions {
+    /** 命令来源 */
+    source?: string;
+    /** 命令发起客户端 */
+    client?: any;
+}
+export interface CommandContext {
+    /** 命令来源 */
+    source?: string;
+    /** 命令发起客户端 */
+    client?: any;
+}
+export type CommandFunction<T extends (...args: any) => any> = (e: CommandContext, ...args: Parameters<T>) => ReturnType<T>;
+export interface CommandItem {
+    call: CommandFunction<any>;
+    pluginName?: string;
+}
+export interface AppCommandMap {
+    get: <T extends keyof AppValueMap>(name: T) => AppValueMap[T];
+    set: <T extends keyof AppValueMap>(name: T, value: AppValueMap[T]) => boolean;
+}

package/{esm/types/command.js → dist/command/types.js}

@@ -1 +1 @@
-export {};
+export {};

package/dist/error/index.d.ts

@@ -0,0 +1,11 @@
+import { ErrorOptions } from "./types";
+export * from "./types";
+export declare class AppError extends Error {
+    /** 错误来源 */
+    source?: string;
+    /** 错误id */
+    id: string;
+    /** 错误原因 */
+    cause?: Error | string;
+    constructor(id: string, options: ErrorOptions);
+}

package/dist/error/index.js

@@ -0,0 +1,9 @@
+export * from "./types";
+export class AppError extends Error {
+    constructor(id, options) {
+        super(options.message);
+        this.id = id;
+        this.source = options?.source;
+        this.cause = options?.cause;
+    }
+}

package/dist/error/types.d.ts

@@ -0,0 +1,6 @@
+export interface ErrorOptions {
+    message?: string;
+    cause?: string | Error;
+    source?: string;
+    [key: string]: any;
+}

package/{esm/types/error.js → dist/error/types.js}

@@ -1 +1 @@
-export {};
+export {};

package/dist/event/index.d.ts

@@ -0,0 +1 @@
+export * from "./types";

package/dist/event/index.js

@@ -0,0 +1 @@
+export * from "./types";

package/dist/event/manager.d.ts

@@ -0,0 +1,9 @@
+import { App } from "../app";
+export declare class EventManager {
+    constructor(app: App);
+    private registerMap;
+    private generalRegisterSet;
+    register(eventName: string, pluginName: string): void;
+    unregister(eventName: string): void;
+    has(eventName: string): boolean;
+}

package/dist/event/manager.js

@@ -0,0 +1,17 @@
+export class EventManager {
+    constructor(app) {
+        this.registerMap = new Map();
+        this.generalRegisterSet = new Set();
+    }
+    register(eventName, pluginName) {
+        if (this.registerMap.has(eventName))
+            throw new Error("事件名已注册");
+        this.registerMap.set(eventName, pluginName);
+    }
+    unregister(eventName) {
+        this.registerMap.delete(eventName);
+    }
+    has(eventName) {
+        return this.registerMap.has(eventName);
+    }
+}

package/dist/event/types.d.ts

@@ -0,0 +1,42 @@
+export interface AppEventEmitOptions {
+    /** 事件来源 */
+    source?: string;
+    /** 远程事件 */
+    remote?: boolean;
+}
+export interface AppEventBaseDetail {
+    /** 事件来源 */
+    source?: string;
+    /** 远程事件 */
+    remote?: boolean;
+}
+export type AppEventDetail<T> = T & AppEventBaseDetail;
+export type AppEventListener<T> = (e: AppEventDetail<T>) => void;
+export interface AppEventDetailMap {
+    "command:register": {
+        name: string;
+    };
+    "command:unregister": {
+        name: string;
+    };
+    "plugin:register": {
+        pluginName: string;
+    };
+    "plugin:unregister": {
+        pluginName: string;
+    };
+    "value:register": {
+        name: string;
+        value: any;
+    };
+    "value:change": {
+        name: string;
+        value: any;
+    };
+    "value:unregister": {
+        name: string;
+    };
+    [name: `change:${string}`]: {
+        value: any;
+    };
+}

package/{esm/types/events.js → dist/event/types.js}

@@ -1 +1 @@
-export {};
+export {};

package/dist/hook/index.d.ts

@@ -0,0 +1 @@
+export * from "./types";

package/dist/hook/index.js

@@ -0,0 +1 @@
+export * from "./types";

package/dist/hook/manager.d.ts

@@ -0,0 +1,25 @@
+import { App } from "../app";
+import { AppError, ErrorOptions } from "../error";
+import { HookFunction, HookUseOptions } from "./types";
+export interface HookErrorOptions extends ErrorOptions {
+    hookName: string;
+}
+export declare class HookError extends AppError {
+    hookName: string;
+    constructor(id: string, options: HookErrorOptions);
+}
+export declare class HookManager {
+    private list;
+    private pluginMap;
+    protected readonly app: App;
+    constructor(app: App);
+    /** 挂载钩子函数 */
+    use(name: string, call: HookFunction<any>, options?: HookUseOptions): void;
+    /** 取消挂载钩子函数 */
+    unuse(name: string, call: HookFunction<any>): void;
+    /** 调用钩子函数 */
+    call(name: string, ctx: any): Promise<any>;
+    /** 同步调用钩子函数 */
+    callSync(name: string, ctx: any): any;
+    getData(): void[];
+}

package/dist/hook/manager.js

@@ -0,0 +1,79 @@
+import { AppError } from "../error";
+export class HookError extends AppError {
+    constructor(id, options) {
+        super(id, options);
+        this.hookName = options.hookName;
+    }
+}
+export class HookManager {
+    constructor(app) {
+        this.list = new Map();
+        this.pluginMap = new Map();
+        this.app = app;
+    }
+    /** 挂载钩子函数 */
+    use(name, call, options) {
+        const { pluginName } = options || {};
+        let hooks = this.list.get(name);
+        if (!hooks) {
+            hooks = [];
+            this.list.set(name, hooks);
+        }
+        else if (hooks.includes(call)) {
+            throw new HookError("hook:use_duplicate", {
+                message: `钩子函数挂载失败: ${name}`,
+                cause: "重复挂载同一函数",
+                hookName: name,
+            });
+        }
+        hooks.push({ call, pluginName });
+    }
+    /** 取消挂载钩子函数 */
+    unuse(name, call) {
+        let hooks = this.list.get(name);
+        if (!hooks)
+            throw new HookError("hook:unuse_unexisted", {
+                message: `钩子函数卸载失败: ${name}`,
+                cause: "卸载不存在的钩子函数",
+                hookName: name,
+            });
+        const index = hooks.findIndex((item) => item.call == call);
+        if (index < 0)
+            throw {};
+        hooks.splice(index, 1);
+    }
+    /** 调用钩子函数 */
+    async call(name, ctx) {
+        const hooks = this.list.get(name);
+        if (!hooks) {
+            return ctx;
+        }
+        for (const item of hooks) {
+            const skip = await item.call(ctx);
+            if (skip) {
+                return ctx;
+            }
+        }
+        return ctx;
+    }
+    /** 同步调用钩子函数 */
+    callSync(name, ctx) {
+        const hooks = this.list.get(name);
+        if (!hooks) {
+            return ctx;
+        }
+        for (const item of hooks) {
+            const skip = item.call(ctx);
+            if (skip) {
+                return ctx;
+            }
+        }
+        return ctx;
+    }
+    getData() {
+        const map = {};
+        return [...this.list].map(([name, fnList]) => {
+            map[name] = fnList.length;
+        });
+    }
+}

package/dist/hook/types.d.ts

@@ -0,0 +1,22 @@
+export type HookFunction<T> = (ctx: T) => boolean | void | Promise<boolean | void>;
+export interface HookItem<T> {
+    call: HookFunction<T>;
+    pluginName?: string;
+}
+export interface HookUseOptions {
+    pluginName?: string;
+}
+export interface HookCallOptions {
+    pluginName?: string;
+}
+export interface BaseHookContext {
+    pluginName?: string;
+    defaultPrevented?: boolean;
+}
+export type HookContext<T> = BaseHookContext & T;
+export interface AppHookMap {
+    "plugin.register": {
+        pluginName: string;
+        options: Record<string, any>;
+    };
+}

package/{esm/types/hook.js → dist/hook/types.js}

@@ -1 +1 @@
-export {};
+export {};

package/dist/index.d.ts

@@ -1,5 +1,8 @@
-export { FloatingLive } from "./live";
-export * from "./types";
-export * from "./enums";
-export * from "./core/LiveRoom";
-export * from "./utils";
+export * from "./app";
+export * from "./value";
+export * from "./plugin";
+export * from "./hook";
+export * from "./event";
+export * from "./error";
+export * from "./command";
+export * from "./FloatingLive";

package/dist/index.js

@@ -1,23 +1,8 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FloatingLive = void 0;
-var live_1 = require("./live");
-Object.defineProperty(exports, "FloatingLive", { enumerable: true, get: function () { return live_1.FloatingLive; } });
-__exportStar(require("./types"), exports);
-__exportStar(require("./enums"), exports);
-__exportStar(require("./core/LiveRoom"), exports);
-__exportStar(require("./utils"), exports);
+export * from "./app";
+export * from "./value";
+export * from "./plugin";
+export * from "./hook";
+export * from "./event";
+export * from "./error";
+export * from "./command";
+export * from "./FloatingLive";