floating-live 0.15.11 → 0.16.0-alpha.0

package/dist/plugin/context/SafePluginContext.js

@@ -0,0 +1,91 @@
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _SafePluginContext_permissions;
+import { AppError } from "../../error";
+import { CommonPluginContext } from "./CommonPluginContext";
+export class SafePluginContext extends CommonPluginContext {
+    get safe() {
+        return true;
+    }
+    constructor(app, pluginName, options) {
+        super(app, pluginName);
+        _SafePluginContext_permissions.set(this, {});
+        __classPrivateFieldSet(this, _SafePluginContext_permissions, options.permissions, "f");
+    }
+    throwNotPermitted(permission, cause) {
+        this.throw(new AppError("plugin:no_permission", {
+            message: "插件权限不足",
+            cause,
+            permission,
+        }));
+    }
+    register(plugin, options) {
+        if (!__classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["plugin.register"]) {
+            this.throwNotPermitted("plugin.register", "无插件安装权限");
+        }
+        return super.register(plugin, options);
+    }
+    unregister(pluginName) {
+        if (!__classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["plugin.register"]) {
+            this.throwNotPermitted("plugin.register", "无插件安装权限");
+        }
+        return super.unregister(pluginName);
+    }
+    emit(type, detail, options) {
+        if (!(__classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["event.emit.advanced"] ||
+            __classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["event.emit"]?.includes(type))) {
+            this.throwNotPermitted(`event.emit:${type}`, `无事件[${type}]的发送权限`);
+        }
+        if (!__classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["event.emit.advanced"] && options) {
+            this.throwNotPermitted("event.emit.advanced", `无事件高级发送权限`);
+        }
+        return super.emit(type, detail, options);
+    }
+    call(name, ...args) {
+        if (!(__classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["command.call.advanced"] ||
+            __classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["command.call"]?.includes(name))) {
+            this.throwNotPermitted(`command.call:${name}`, `无命令[${name}]的调用权限`);
+        }
+        return super.call(name, ...args);
+    }
+    callWithOptions(name, options, ...args) {
+        if (!__classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["command.call.advanced"]) {
+            this.throwNotPermitted("command.call.advanced", "无命令高级调用权限");
+        }
+        return super.callWithOptions(name, options, ...args);
+    }
+    registerCommand(name, func, options) {
+        if (!__classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["command.register"]?.includes(name)) {
+            this.throwNotPermitted(`command.call:${name}`, `无命令[${name}]的注册权限`);
+        }
+        return super.registerCommand(name, func, options);
+    }
+    useHook(name, func, options) {
+        if (!__classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["hook.use"]?.includes(name)) {
+            this.throwNotPermitted(`hook.use:${name}`, `无钩子[${name}]的挂载权限`);
+        }
+        return super.useHook(name, func, options);
+    }
+    unuseHook(name, func) {
+        if (!__classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["hook.use"]?.includes(name)) {
+            this.throwNotPermitted(`hook.use:${name}`, `无钩子[${name}]的挂载权限`);
+        }
+        return super.unuseHook(name, func);
+    }
+    callHook(name, ctx, options) {
+        if (!__classPrivateFieldGet(this, _SafePluginContext_permissions, "f")["hook.call"]?.includes(name)) {
+            this.throwNotPermitted(`hook.call:${name}`, `无钩子[${name}]的调用权限`);
+        }
+        return super.callHook(name, ctx);
+    }
+}
+_SafePluginContext_permissions = new WeakMap();

package/dist/plugin/index.d.ts

@@ -0,0 +1,8 @@
+import type { PluginItem, PluginContext } from "./types";
+export type * from "./types";
+export declare class BasePlugin implements PluginItem {
+    static pluginName: string;
+    pluginName: string;
+    ctx: PluginContext;
+    constructor(ctx: PluginContext, options?: any);
+}

package/dist/plugin/index.js

@@ -0,0 +1,5 @@
+export class BasePlugin {
+    constructor(ctx, options) {
+        this.ctx = ctx;
+    }
+}

package/dist/plugin/manager.d.ts

@@ -0,0 +1,31 @@
+import type { App } from "../app";
+import { AppError, ErrorOptions } from "../error";
+import { PluginItem, PluginConstructor, PluginContext } from "./types";
+export interface PluginErrorOptions extends ErrorOptions {
+    pluginName: string;
+}
+export declare class PluginError extends AppError {
+    pluginName: string;
+    constructor(id: string, options: PluginErrorOptions);
+}
+export interface PluginData<T> {
+    plugin: PluginItem;
+    context: PluginContext;
+    exposes?: T;
+}
+export declare class PluginManager {
+    /** 插件列表 */
+    private list;
+    protected readonly app: App;
+    constructor(app: App);
+    /** 注册插件 */
+    register(pluginConstructor: PluginConstructor, options?: Record<string, any>): Promise<PluginItem | undefined>;
+    /** 移除插件 */
+    unregister(pluginName: string): Promise<void>;
+    /** 获取插件实例 */
+    get(pluginName: string): PluginData<any> | undefined;
+    has(pluginName: string): boolean;
+    getPlugin(pluginName: string): PluginItem | undefined;
+    getExposes(pluginName: string): any;
+    toData(): string[];
+}

package/dist/plugin/manager.js

@@ -0,0 +1,93 @@
+import { CommonPluginContext } from "./context/CommonPluginContext";
+import { AppError } from "../error";
+export class PluginError extends AppError {
+    constructor(id, options) {
+        super(id, options);
+        this.pluginName = options.pluginName;
+    }
+}
+export class PluginManager {
+    constructor(app) {
+        /** 插件列表 */
+        this.list = new Map();
+        this.app = app;
+    }
+    /** 注册插件 */
+    async register(pluginConstructor, options = {}) {
+        const pluginName = pluginConstructor.pluginName;
+        if (!pluginName) {
+            throw new PluginError("plugin:register_id_missing", {
+                message: "插件注册失败",
+                cause: "插件缺少pluginName字段",
+                pluginName: "",
+            });
+        }
+        if (this.list.has(pluginName)) {
+            throw new PluginError("plugin:register_id_duplicate", {
+                message: `插件注册失败: ${pluginName}`,
+                cause: "已存在相同id的插件",
+                pluginName,
+            });
+        }
+        const registerCtx = { pluginName, options };
+        const pluginCtx = new CommonPluginContext(this.app, pluginName);
+        return await this.app
+            .callHook("plugin.register", registerCtx)
+            .then(async (ctx) => {
+            if (ctx.defaultPrevented)
+                return;
+            // 执行插件函数
+            const plugin = new pluginConstructor(pluginCtx, registerCtx.options || {});
+            // 调用插件的register钩子
+            await plugin.register?.(pluginCtx, registerCtx.options || {});
+            this.list.set(pluginName, { plugin, context: pluginCtx });
+            this.app.emit("plugin:register", { pluginName });
+            return plugin;
+        })
+            .catch((err) => {
+            throw new PluginError("plugin:register_fail", {
+                message: `插件注册失败: ${pluginName}`,
+                cause: err,
+                pluginName,
+            });
+        });
+    }
+    /** 移除插件 */
+    async unregister(pluginName) {
+        const pluginData = this.list.get(pluginName);
+        // 检测插件是否存在
+        if (!pluginData) {
+            throw new PluginError("plugin:unregister_unexist", {
+                message: `插件移除失败: ${pluginName}`,
+                cause: "插件不存在",
+                pluginName,
+            });
+        }
+        else {
+            const { plugin, context } = pluginData;
+            // 调用插件和上下文的destroy钩子
+            plugin.destroy?.(context);
+            context.destroy();
+            // 从列表中移除插件
+            this.list.delete(pluginName);
+            // 移除插件注册事件
+            this.app.emit("plugin:unregister", { pluginName });
+        }
+    }
+    /** 获取插件实例 */
+    get(pluginName) {
+        return this.list.get(pluginName);
+    }
+    has(pluginName) {
+        return this.list.has(pluginName);
+    }
+    getPlugin(pluginName) {
+        return this.list.get(pluginName)?.plugin;
+    }
+    getExposes(pluginName) {
+        return this.list.get(pluginName)?.exposes;
+    }
+    toData() {
+        return [...this.list.keys()];
+    }
+}

package/dist/plugin/types.d.ts

@@ -0,0 +1,73 @@
+import { CommandOptions, CommandCallOptions, AppCommandMap, CommandFunction } from "../command";
+import { AppError, ErrorOptions } from "../error";
+import { AppEventListener, AppEventEmitOptions, AppEventDetailMap } from "../event";
+import { AppHookMap, HookCallOptions, HookContext, HookFunction, HookUseOptions } from "../hook";
+import { AppValueMap, ValueOptions } from "../value";
+/** 插件对象 */
+export interface PluginItem {
+    pluginName: string;
+    register?(ctx: PluginContext, options?: Record<string, any>): void;
+    destroy?(ctx: PluginContext): void;
+}
+/** 插件构造器 */
+export interface PluginConstructor {
+    pluginName: string;
+    new (ctx: PluginContext, options: any): PluginItem;
+}
+/** 插件注册选项 */
+export interface PluginRegisterOptions {
+}
+/** 插件上下文 */
+export interface PluginContext {
+    /** 监听事件 */
+    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, options: ErrorOptions): AppError;
+    /** 注册插件 */
+    register(plugin: PluginConstructor, options?: PluginRegisterOptions): void;
+    /** 取消注册插件 */
+    unregister(pluginName: string): void;
+    /** 获取插件暴露对象 */
+    getPluginExposes<T>(pluginName: string): T;
+    /** 等待plugin注册 */
+    whenRegister(pluginName: string, callback: (exposes: any) => (() => void) | void): void;
+    /** 是否存在插件 */
+    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<K extends keyof AppValueMap>(name: K, value: AppValueMap[K]): void;
+    destroy(): void;
+}

package/dist/plugin/types.js

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

package/dist/plugins/room/index.d.ts

@@ -0,0 +1,116 @@
+import { LiveMessage } from "../../live/message";
+import { LiveRoom, LiveRoomDetailInfo, LiveRoomData, LiveRoomStatsInfo, LiveRoomStatus } from "../../live/room";
+import { BasePlugin } from "../../plugin";
+import { PluginContext } from "../../plugin/types";
+declare module "../.." {
+    interface AppCommandMap {
+        add: (platform: string, id: number, options?: boolean | Record<string, any>) => void;
+        remove: (key: string) => void;
+        move: (key: string, position: number) => void;
+        open: (key: string) => void;
+        close: (key: string) => void;
+        update: (key: string) => void;
+        "room.snapshot": () => LiveRoomData[];
+        [name: `${string}.room.create`]: (id: string | number, options: Record<string, any>) => LiveRoom | Promise<LiveRoom>;
+    }
+    interface AppEventDetailMap {
+        "live:message": {
+            message: LiveMessage.All;
+        };
+        "live:raw": {
+            platform: string;
+            roomId: string | number;
+            data: any;
+        };
+        "room:connecting": {
+            key: string;
+        };
+        "room:connected": {
+            key: string;
+        };
+        "room:disconnect": {
+            key: string;
+        };
+        "room:enter": {
+            key: string;
+        };
+        "room:add": {
+            key: string;
+            room: LiveRoomData;
+        };
+        "room:remove": {
+            key: string;
+        };
+        "room:move": {
+            key: string;
+            position: number;
+        };
+        "room:open": {
+            key: string;
+            room: LiveRoomData;
+        };
+        "room:close": {
+            key: string;
+            room: LiveRoomData;
+        };
+        "room:update": {
+            key: string;
+            room: LiveRoomData;
+        };
+        "room:detail": {
+            key: string;
+            detail: LiveRoomDetailInfo;
+        };
+        "room:stats": {
+            key: string;
+            stats: LiveRoomStatsInfo;
+        };
+        "room:status": {
+            key: string;
+            status: LiveRoomStatus;
+            liveId?: string | number;
+            timestamp: number;
+        };
+    }
+    interface AppHookMap {
+        "live.message": {
+            message: LiveMessage.All;
+        };
+        "room.add": {
+            platform: string;
+            id: string | number;
+            options: Record<string, any>;
+        };
+    }
+}
+export default class Room extends BasePlugin {
+    static pluginName: string;
+    private map;
+    private symbolRoomEventHandlers;
+    constructor(ctx: PluginContext);
+    /** 添加房间监听实例 */
+    attachRoom(room: LiveRoom, open?: boolean): void;
+    /** 添加房间 */
+    add(platform: string, id: number, options?: boolean | Record<string, any>): Promise<void>;
+    /** 移除房间 */
+    remove(key: string): void;
+    /** 获取房间 */
+    get(key: string): LiveRoom | undefined;
+    has(key: string): boolean;
+    /** 获取房间信息 */
+    info(key: string): LiveRoomData | undefined;
+    /** 更新房间信息 */
+    update(key: string): void;
+    /** 获取房间key列表 */
+    get keys(): Array<string>;
+    /** 获取房间列表 */
+    getList(): Array<LiveRoom>;
+    /** 打开房间连接 */
+    open(key: string): void;
+    /** 关闭房间连接 */
+    close(key: string): void;
+    /** 更改某个房间的顺序 */
+    move(key: string, position: number): void;
+    /** 获取快照 */
+    getSnapshot(): LiveRoomData[];
+}

package/dist/plugins/room/index.js

@@ -0,0 +1,172 @@
+import { AppError } from "../../error";
+import { BasePlugin } from "../../plugin";
+import { bindCommand } from "../../utils";
+class Room extends BasePlugin {
+    constructor(ctx) {
+        super(ctx);
+        this.map = new Map();
+        this.symbolRoomEventHandlers = Symbol("room.roomEventHandlers");
+        ctx.registerCommand("add", bindCommand(this.add, this));
+        ctx.registerCommand("remove", bindCommand(this.remove, this));
+        ctx.registerCommand("open", bindCommand(this.open, this));
+        ctx.registerCommand("close", bindCommand(this.close, this));
+        ctx.registerCommand("update", bindCommand(this.update, this));
+        ctx.registerCommand("room.snapshot", bindCommand(this.getSnapshot, this));
+    }
+    /** 添加房间监听实例 */
+    attachRoom(room, open) {
+        let key = room.key;
+        if (this.map.has(key)) {
+            this.ctx.throw(new AppError("room:add_exist", {
+                message: "房间已存在",
+            }));
+            return;
+        }
+        this.map.set(key, room);
+        const eventHandlers = [];
+        room[this.symbolRoomEventHandlers] = eventHandlers;
+        const setHandler = (type, listener) => {
+            room.on(type, listener);
+            eventHandlers.push([type, listener]);
+        };
+        // 添加监听事件
+        // 直播消息
+        setHandler("message", ({ message }) => {
+            const ctx = { message };
+            this.ctx.callHook("live.message", ctx).then((ctx) => {
+                !ctx.defaultPrevented &&
+                    this.ctx.emit("live:message", { message: ctx.message });
+            });
+        });
+        // 直播消息源数据
+        setHandler("raw", ({ platform, roomId, data }) => {
+            this.ctx.emit("live:raw", { platform, roomId, data });
+        });
+        // 正在连接服务器
+        setHandler("connecting", () => {
+            this.ctx.emit("room:connecting", { key });
+        });
+        // 连接到服务器
+        setHandler("connected", () => {
+            this.ctx.emit("room:connected", { key });
+        });
+        // 与服务器的连接已断开
+        setHandler("disconnect", () => {
+            this.ctx.emit("room:disconnect", { key });
+        });
+        // 连接到直播间
+        setHandler("enter", () => {
+            this.ctx.emit("room:enter", { key });
+        });
+        // 获取房间信息
+        setHandler("update", () => {
+            this.ctx.emit("room:update", { key, room: room.toData() });
+        });
+        // 直播展示信息更改
+        setHandler("detail", ({ detail }) => {
+            this.ctx.emit("room:detail", { key, detail });
+        });
+        // 直播状态更改
+        setHandler("status", ({ liveId, timestamp, status }) => {
+            this.ctx.emit("room:status", { key, status, liveId, timestamp });
+        });
+        // 统计数据更新
+        setHandler("stats", ({ stats }) => {
+            this.ctx.emit("room:stats", { key, stats });
+        });
+        // 房间被打开
+        setHandler("open", () => {
+            this.ctx.emit("room:open", { key, room: room.toData() });
+        });
+        // 房间被关闭
+        setHandler("close", () => {
+            this.ctx.emit("room:close", { key, room: room.toData() });
+        });
+        if (open) {
+            room.open();
+        }
+        this.ctx.emit("room:add", { key, room: room.toData() });
+    }
+    /** 添加房间 */
+    async add(platform, id, options) {
+        const opt = typeof options == "boolean" ? { open: options } : options || {};
+        const ctx = { platform, id, options: opt };
+        const res = await this.ctx.callHook("room.add", ctx);
+        if (!res.defaultPrevented) {
+            this.ctx.throw(this.ctx.error("room:add_fail", { message: "无法添加房间" }));
+        }
+        const room = await this.ctx.call(`${platform}.room.create`, id, opt);
+        if (!room) {
+            this.ctx.throw(this.ctx.error("room:create_fail", { message: "无法创建房间" }));
+        }
+        else {
+            this.attachRoom(room);
+        }
+    }
+    /** 移除房间 */
+    remove(key) {
+        let room = this.map.get(key);
+        if (!room) {
+            this.ctx.throw(this.ctx.error("room:remove_unexist", {
+                message: "房间不存在",
+            }));
+        }
+        this.map.delete(key); // 从表中删除房间
+        room[this.symbolRoomEventHandlers].forEach(([type, listener]) => {
+            room?.removeEventListener(type, listener);
+        }); // 移除房间监听实例
+        this.ctx.emit("room:remove", { key });
+    }
+    /** 获取房间 */
+    get(key) {
+        return this.map.get(key);
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    /** 获取房间信息 */
+    info(key) {
+        let room = this.map.get(key);
+        return room ? room.toData() : undefined;
+    }
+    /** 更新房间信息 */
+    update(key) {
+        let room = this.map.get(key);
+        room && room.getInfo();
+    }
+    /** 获取房间key列表 */
+    get keys() {
+        return [...this.map.keys()];
+    }
+    /** 获取房间列表 */
+    getList() {
+        return [...this.map.values()];
+    }
+    /** 打开房间连接 */
+    open(key) {
+        let room = this.map.get(key);
+        room?.available && !room.opened && room.open();
+    }
+    /** 关闭房间连接 */
+    close(key) {
+        let room = this.map.get(key);
+        room?.opened && room.close();
+    }
+    /** 更改某个房间的顺序 */
+    move(key, position) {
+        const arr = [...this.map];
+        const index = arr.findIndex(([k]) => k == key);
+        if (index == -1)
+            return;
+        const [item] = arr.splice(index, 1);
+        arr.splice(position, 0, item);
+        this.map = new Map(arr);
+        this.ctx.emit("room:move", { key, position });
+    }
+    /** 获取快照 */
+    getSnapshot() {
+        return this.getList().map((room) => room.toData());
+    }
+}
+Room.pluginName = "room";
+export default Room;

package/dist/utils/EventEmitter.d.ts

@@ -0,0 +1,6 @@
+export declare class CustomEventEmitter extends EventTarget {
+    on(type: string, listener: (e: any) => void): void;
+    once(type: string, listener: (e: any) => void): void;
+    off(type: string, listener: (e: any) => void): void;
+    emit(type: string, detail: any, options?: EventInit): void;
+}

package/dist/utils/EventEmitter.js

@@ -0,0 +1,26 @@
+const listenerMap = new WeakMap();
+function getListenerCallback(listener) {
+    const existed = listenerMap.get(listener);
+    if (existed)
+        return existed;
+    const newItem = (e) => {
+        listener(e.detail);
+    };
+    listenerMap.set(listener, newItem);
+    return newItem;
+}
+export class CustomEventEmitter extends EventTarget {
+    on(type, listener) {
+        this.addEventListener(type, getListenerCallback(listener));
+    }
+    once(type, listener) {
+        this.addEventListener(type, getListenerCallback(listener), { once: true });
+    }
+    off(type, listener) {
+        this.removeEventListener(type, getListenerCallback(listener));
+    }
+    emit(type, detail, options) {
+        const event = new CustomEvent(type, { detail, ...options });
+        this.dispatchEvent(event);
+    }
+}

package/dist/utils/index.d.ts

@@ -0,0 +1,2 @@
+import { CommandContext } from "../command";
+export declare function bindCommand<T extends (...args: any) => any>(command: T, thisArg: any): (e: CommandContext, ...args: Parameters<T>) => ReturnType<T>;

package/dist/utils/index.js

@@ -0,0 +1,4 @@
+export function bindCommand(command, thisArg) {
+    const c = ((e, ...args) => command(...args)).bind(thisArg);
+    return c;
+}

package/dist/value/index.d.ts

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

package/dist/value/index.js

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

package/dist/value/manager.d.ts

@@ -0,0 +1,24 @@
+import { App } from "../app";
+import { ValueAccessOptions, ValueOptions } from "./types";
+export declare class ValueManager {
+    private list;
+    protected readonly app: App;
+    constructor(app: App);
+    /** 注册值 */
+    register<T>(name: string, { get, set, pluginName }: ValueOptions<T>): void;
+    /** 取消注册 */
+    unregister(name: string): void;
+    /** 获取值 */
+    get(name: string, options?: ValueAccessOptions): any;
+    /** 获取值(不存在则返回undefined) */
+    getNullable(name: string, options?: ValueAccessOptions): any;
+    /** 设置值 */
+    set(name: string, value: any, options?: ValueAccessOptions): boolean;
+    /** 检测值是否存在 */
+    has(name: string): boolean;
+    emit(name: string, value: any): void;
+    watch(name: string, listener: (value: any) => void): void;
+    unwatch(name: string, listener: (value: any) => void): void;
+    /** 获取注册的所有值 */
+    getData(): Record<string, any>;
+}