@kotori-bot/core 1.1.0 → 1.3.0

package/README.md

@@ -0,0 +1,17 @@
+# @kotori-bot/core
+
+- Context
+- Symbols
+- Service
+- Modules
+- Core
+- Config
+- Message
+- Adapter
+- Api
+- Elements
+- Cache
+
+## Reference
+
+- [Kotori Docs](https://kotori.js.org/)

package/lib/components/config.d.ts

@@ -0,0 +1,16 @@
+import Tsu from 'tsukiko';
+import { CoreConfig } from '../types';
+declare const packageInfoSchema: import("tsukiko").ObjectParser<{
+    name: import("tsukiko").StringParser;
+    version: import("tsukiko").StringParser;
+    description: import("tsukiko").StringParser;
+    main: import("tsukiko").StringParser;
+    license: import("tsukiko").LiteralParser<"GPL-3.0">;
+    author: import("tsukiko").StringParser;
+}>;
+export declare class Config {
+    readonly config: CoreConfig;
+    readonly pkg: Tsu.infer<typeof packageInfoSchema>;
+    constructor(config?: CoreConfig);
+}
+export default Config;

package/lib/components/config.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Config = void 0;
+const tsukiko_1 = __importDefault(require("tsukiko"));
+const path_1 = require("path");
+const tools_1 = require("@kotori-bot/tools");
+const consts_1 = require("../consts");
+const packageInfoSchema = tsukiko_1.default.Object({
+    name: tsukiko_1.default.String(),
+    version: tsukiko_1.default.String(),
+    description: tsukiko_1.default.String(),
+    main: tsukiko_1.default.String(),
+    license: tsukiko_1.default.Literal('GPL-3.0'),
+    author: tsukiko_1.default.String()
+});
+class Config {
+    config;
+    pkg;
+    constructor(config = consts_1.DEFAULT_CORE_CONFIG) {
+        this.config = config;
+        /* load package.json */
+        const info = (0, tools_1.loadConfig)((0, path_1.join)(__dirname, '../../package.json'));
+        if (!info || Object.values(info).length === 0) {
+            process.stderr.write(`Cannot find kotori-bot package.json\n`);
+            process.exit();
+        }
+        const result = packageInfoSchema.parseSafe(info);
+        if (!result.value) {
+            process.stderr.write(`File package.json format error: ${result.error.message}\n`);
+            process.exit();
+        }
+        this.pkg = result.data;
+    }
+}
+exports.Config = Config;
+exports.default = Config;

package/lib/components/core.d.ts

@@ -0,0 +1,31 @@
+import { Http } from '@kotori-bot/tools';
+import I18n from '@kotori-bot/i18n';
+import type { Parser } from 'tsukiko';
+import { Context, Symbols } from '../context';
+import Config from './config';
+import Message from './message';
+import type { AdapterClass } from '../types';
+import { Cache, type Api } from '../service';
+declare module '../context' {
+    interface Context {
+        readonly [Symbols.adapter]: Core[typeof Symbols.adapter];
+        readonly [Symbols.bot]: Core[typeof Symbols.bot];
+        readonly config: Config['config'];
+        readonly pkg: Config['pkg'];
+        readonly [Symbols.midware]: Message[typeof Symbols.midware];
+        readonly [Symbols.command]: Message[typeof Symbols.command];
+        readonly [Symbols.regexp]: Message[typeof Symbols.regexp];
+        midware: Message['midware'];
+        command: Message['command'];
+        regexp: Message['regexp'];
+        http: Http;
+        i18n: I18n;
+        cache: Cache;
+    }
+}
+export declare class Core extends Context {
+    readonly [Symbols.adapter]: Map<string, [AdapterClass, Parser<unknown>?]>;
+    readonly [Symbols.bot]: Map<string, Set<Api>>;
+    constructor(config?: ConstructorParameters<typeof Config>[0]);
+}
+export default Core;

package/lib/components/core.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Core = void 0;
+const tools_1 = require("@kotori-bot/tools");
+const i18n_1 = __importDefault(require("@kotori-bot/i18n"));
+const context_1 = require("../context");
+const config_1 = __importDefault(require("./config"));
+const message_1 = __importDefault(require("./message"));
+const service_1 = require("../service");
+class Core extends context_1.Context {
+    [context_1.Symbols.adapter] = new Map();
+    [context_1.Symbols.bot] = new Map();
+    constructor(config) {
+        super();
+        this.provide('config', new config_1.default(config));
+        this.mixin('config', ['config', 'pkg']);
+        this.provide('message', new message_1.default(this));
+        this.mixin('message', ['midware', 'command', 'regexp']);
+        this.provide('http', new tools_1.Http({ validateStatus: () => true }));
+        this.inject('http');
+        this.provide('i18n', new i18n_1.default({ lang: this.config.global.lang }));
+        this.inject('i18n');
+        this.service('cache', new service_1.Cache(this.extends()));
+    }
+}
+exports.Core = Core;
+exports.default = Core;

package/lib/components/index.d.ts

@@ -0,0 +1 @@
+export * from './core';

package/lib/components/index.js

@@ -0,0 +1,17 @@
+"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 });
+__exportStar(require("./core"), exports);

package/lib/components/message.d.ts

@@ -0,0 +1,25 @@
+import { type Context, Symbols } from '../context';
+import { type CommandConfig, type MidwareCallback, type RegexpCallback } from '../types';
+import { Command } from '../utils/command';
+interface MidwareData {
+    callback: MidwareCallback;
+    priority: number;
+}
+interface RegexpData {
+    match: RegExp;
+    callback: RegexpCallback;
+}
+export declare class Message {
+    readonly [Symbols.midware]: Set<MidwareData>;
+    readonly [Symbols.command]: Set<Command>;
+    readonly [Symbols.regexp]: Set<RegexpData>;
+    private handleMidware;
+    private handleRegexp;
+    private handleCommand;
+    private readonly ctx;
+    constructor(ctx: Context);
+    midware(callback: MidwareCallback, priority?: number): () => boolean;
+    command(template: string, config?: CommandConfig): Command;
+    regexp(match: RegExp, callback: RegexpCallback): () => boolean;
+}
+export default Message;

package/lib/components/message.js

@@ -0,0 +1,135 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+const tools_1 = require("@kotori-bot/tools");
+const context_1 = require("../context");
+const factory_1 = require("../utils/factory");
+const command_1 = require("../utils/command");
+const commandError_1 = __importDefault(require("../utils/commandError"));
+class Message {
+    [context_1.Symbols.midware] = new Set();
+    [context_1.Symbols.command] = new Set();
+    [context_1.Symbols.regexp] = new Set();
+    handleMidware(session) {
+        const { api } = session;
+        api.adapter.status.receivedMsg += 1;
+        let isPass = true;
+        let midwares = [];
+        this[context_1.Symbols.midware].forEach((val) => midwares.push(val));
+        midwares = midwares.sort((first, second) => first.priority - second.priority);
+        let lastMidwareNum = -1;
+        while (midwares.length > 0) {
+            if (lastMidwareNum === midwares.length) {
+                isPass = false;
+                break;
+            }
+            lastMidwareNum = midwares.length;
+            session.quick(midwares[0].callback(() => midwares.shift(), session));
+        }
+        this.ctx.emit('midwares', { isPass, session });
+    }
+    async handleRegexp(data) {
+        const { session } = data;
+        if (!data.isPass)
+            return;
+        this[context_1.Symbols.regexp].forEach((data) => {
+            const match = session.message.match(data.match);
+            if (!match)
+                return;
+            session.quick(data.callback(match, session));
+        });
+    }
+    handleCommand(data) {
+        const { session } = data;
+        const prefix = session.api.adapter.config['command-prefix'] ?? this.ctx.config.global['command-prefix'];
+        if (!session.message.startsWith(prefix))
+            return;
+        const params = {
+            session,
+            raw: (0, tools_1.stringRightSplit)(session.message, prefix)
+        };
+        this.ctx.emit('before_parse', params);
+        const cancel = (0, factory_1.cancelFactory)();
+        this.ctx.emit('before_command', { cancel: cancel.get(), ...params });
+        if (cancel.value)
+            return;
+        let matched;
+        this[context_1.Symbols.command].forEach(async (cmd) => {
+            if (matched || !cmd.meta.action)
+                return;
+            const result = command_1.Command.run(params.raw, cmd.meta);
+            if (result instanceof commandError_1.default && result.value.type === 'unknown')
+                return;
+            matched = cmd;
+            this.ctx.emit('parse', { command: cmd, result, ...params, cancel: cancel.get() });
+            if (cancel.value || result instanceof commandError_1.default)
+                return;
+            try {
+                const executed = await cmd.meta.action({ args: result.args, options: result.options }, session);
+                if (executed instanceof commandError_1.default) {
+                    this.ctx.emit('command', { command: cmd, result: executed, ...params });
+                    return;
+                }
+                if (executed !== undefined)
+                    session.quick(executed);
+                this.ctx.emit('command', {
+                    command: cmd,
+                    result: executed instanceof commandError_1.default ? result : executed,
+                    ...params
+                });
+            }
+            catch (error) {
+                this.ctx.emit('command', {
+                    command: matched,
+                    result: new commandError_1.default({ type: 'error', error }),
+                    ...params
+                });
+            }
+        });
+        if (matched)
+            return;
+        this.ctx.emit('parse', {
+            command: new command_1.Command(''),
+            result: new commandError_1.default({ type: 'unknown', input: params.raw }),
+            ...params,
+            cancel: cancel.get()
+        });
+    }
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+        this.ctx.on('on_message', (session) => this.handleMidware(session));
+        this.ctx.on('midwares', (data) => this.handleCommand(data));
+        this.ctx.on('midwares', (data) => this.handleRegexp(data));
+        this.ctx.on('before_send', (data) => {
+            const { api } = data;
+            api.adapter.status.sentMsg += 1;
+        });
+    }
+    midware(callback, priority = 100) {
+        const data = { callback, priority };
+        this[context_1.Symbols.midware].add(data);
+        const dispose = () => this[context_1.Symbols.midware].delete(data);
+        (0, factory_1.disposeFactory)(this.ctx, dispose);
+        return dispose;
+    }
+    command(template, config) {
+        const command = new command_1.Command(template, config);
+        this[context_1.Symbols.command].add(command);
+        const dispose = () => this[context_1.Symbols.command].delete(command);
+        (0, factory_1.disposeFactory)(this.ctx, dispose);
+        return command;
+    }
+    regexp(match, callback) {
+        const data = { match, callback };
+        this[context_1.Symbols.regexp].add(data);
+        const dispose = () => this[context_1.Symbols.regexp].delete(data);
+        (0, factory_1.disposeFactory)(this.ctx, dispose);
+        return dispose;
+    }
+}
+exports.Message = Message;
+exports.default = Message;

package/lib/components/modules.d.ts

@@ -0,0 +1,12 @@
+import type { ModuleInstance, ModuleConfig } from '../types';
+import { type Context } from '../context';
+type ModuleInstanceClass = new (ctx: Context, config: ModuleConfig) => void;
+type ModuleInstanceFunction = (ctx: Context, config: ModuleConfig) => void;
+export declare class Modules {
+    private handleExports;
+    private readonly ctx;
+    constructor(ctx: Context);
+    use(modules: ModuleInstance | string | ModuleInstanceFunction | ModuleInstanceClass, config: ModuleConfig): Promise<void>;
+    dispose(modules: ModuleInstance | string): void;
+}
+export default Modules;

package/lib/components/modules.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Modules = void 0;
+const tools_1 = require("@kotori-bot/tools");
+const tsukiko_1 = require("tsukiko");
+const path_1 = require("path");
+const errror_1 = require("../utils/errror");
+const context_1 = require("../context");
+const service_1 = require("../service");
+const consts_1 = require("../consts");
+const factory_1 = require("../utils/factory");
+function isServiceConsructor(Fn) {
+    return service_1.Service.isPrototypeOf.call(service_1.Service, Fn);
+}
+function isAdapterClass(Fn) {
+    return service_1.Adapter.isPrototypeOf.call(service_1.Adapter, Fn);
+}
+/*   static isDatabaseClass(Obj: object): Obj is DatabaseClass {
+    return Database.isPrototypeOf.call(Database, Obj);
+  } */
+function handleFunction(func, ctx, config) {
+    func(ctx, config);
+}
+function handleCconstructor(Class, ctx, config) {
+    (0, tools_1.none)(new Class(ctx, config));
+}
+function checkConfig(schema, config) {
+    if (!(schema instanceof tsukiko_1.Parser))
+        return config;
+    const result = schema.parseSafe(config);
+    if (result && !result.value)
+        return result.error;
+    return result.data;
+}
+class Modules {
+    handleExports(identity, ctx, exports, config) {
+        /* before handle */
+        const { lang, inject, config: schema, default: defaults, main, Main } = exports.default;
+        if (lang)
+            this.ctx.i18n.use(Array.isArray(lang) ? (0, path_1.resolve)(...lang) : (0, path_1.resolve)(lang));
+        /* handle */
+        /* service */
+        if (isServiceConsructor(defaults)) {
+            return undefined;
+        }
+        /* adapter */
+        if (isAdapterClass(defaults)) {
+            const adapterName = identity.split(consts_1.ADAPTER_PREFIX)[1];
+            if (adapterName)
+                this.ctx[context_1.Symbols.adapter].set(adapterName, [defaults, schema]);
+            return undefined;
+        }
+        /* plugin */
+        if (inject && Array.isArray(inject)) {
+            inject.forEach((identity) => {
+                ctx[context_1.Symbols.container].forEach((service, name) => {
+                    if (!(service instanceof service_1.Service) || service.identity !== identity)
+                        return;
+                    ctx.inject(name);
+                });
+            });
+        }
+        const moduleConfig = checkConfig(schema, config);
+        if (moduleConfig instanceof tsukiko_1.TsuError)
+            return new errror_1.ModuleError(`Config format of module ${identity} is error: ${moduleConfig.message}`);
+        if (defaults !== undefined) {
+            if ((0, tools_1.isClass)(defaults)) {
+                return handleCconstructor(defaults, ctx, moduleConfig);
+            }
+            if (defaults instanceof Function) {
+                return handleFunction(defaults, ctx, moduleConfig);
+            }
+            return new errror_1.DevError(`Module instance of default export is not function or constructor at ${identity}`);
+        }
+        if (main instanceof Function) {
+            if ((0, tools_1.isClass)(main)) {
+                return new errror_1.DevError(`Module instance is constructor,export name should be 'Main' not 'main' at ${identity}`);
+            }
+            return handleFunction(main, ctx, moduleConfig);
+        }
+        if (Main instanceof Function) {
+            if (!(0, tools_1.isClass)(Main)) {
+                return new errror_1.DevError(`Module instance is function,export name should be 'main' not 'Main' at ${identity}`);
+            }
+            return handleCconstructor(Main, ctx, moduleConfig);
+        }
+        return undefined;
+    }
+    ctx;
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async use(modules, config) {
+        const isObject = typeof modules === 'object';
+        const ctx = this.ctx.extends({}, !this.ctx.identity && isObject ? modules.pkg.name : this.ctx.identity);
+        if (modules instanceof Function) {
+            if ((0, tools_1.isClass)(modules))
+                handleCconstructor(modules, ctx, config);
+            else
+                handleFunction(modules, ctx, config);
+            return;
+        }
+        (0, factory_1.disposeFactory)(this.ctx, () => this.dispose(modules));
+        const identity = isObject ? modules.pkg.name : modules;
+        try {
+            const exports = await import(`file://${isObject ? modules.main : (0, path_1.resolve)(modules)}`);
+            const error = this.handleExports(identity, ctx, exports, config);
+            if (error)
+                throw error;
+            this.ctx.emit('ready_module', { module: modules });
+        }
+        catch (error) {
+            this.ctx.emit('ready_module', { module: modules, error });
+        }
+    }
+    dispose(modules) {
+        if (typeof modules === 'object') {
+            modules.files.forEach((file) => delete require.cache[require.resolve(file)]);
+        }
+        else {
+            delete require.cache[require.resolve(modules)];
+        }
+        this.ctx.emit('dispose_module', { module: modules });
+    }
+}
+exports.Modules = Modules;
+exports.default = Modules;

package/lib/consts.d.ts

@@ -1,11 +1,15 @@
-import { LocaleType } from '@kotori-bot/i18n';
 export declare const OFFICIAL_MODULES_SCOPE = "@kotori-bot/";
 export declare const PLUGIN_PREFIX = "kotori-plugin-";
+export declare const DATABASE_PREFIX = "kotori-plugin-database-";
 export declare const ADAPTER_PREFIX = "kotori-plugin-adapter-";
-export declare const LOAD_MODULE_MAX_TIME: number;
-export declare const LOAD_MODULE_SLEEP_TIME = 150;
-export declare const DEFAULT_LANG: LocaleType;
-export declare const DEFAULT_ROOT_DIR = "./";
-export declare const DEFAULT_MODULES_DIR = "./modules";
-export declare const DEFAULT_COMMAND_PREFIX = "/";
-export declare const DEFAULT_ENV = "dev";
+export declare const CUSTOM_PREFIX = "kotori-plugin-custom-";
+export declare const DEFAULT_PORT = 720;
+export declare const DEFAULT_CORE_CONFIG: {
+    global: {
+        lang: "en_US" | "en_GB" | "en_AU" | "zh_CN" | "zh_HK" | "zh_TW" | "zh_SG" | "es_ES" | "es_MX" | "ar_EG" | "ar_AE" | "ru_RU" | "fr_FR" | "fr_CA" | "de_DE" | "de_CH" | "it_IT" | "it_CH" | "hi_IN" | "pt_BR" | "pt_PT" | "tr_TR" | "ja_JP" | "id_ID" | "uk_UA" | "vi_VN" | "th_TH" | "sv_SE" | "nb_NO" | "da_DK" | "fi_FI" | "he_IL" | "sk_SK" | "bg_BG" | "lt_LT" | "sl_SI" | "sr_RS" | "mk_MK" | "sq_AL" | "et_EE" | "mt_MT";
+        'command-prefix': string;
+        port: number;
+    };
+    adapter: {};
+    plugin: {};
+};

package/lib/consts.js

@@ -1,13 +1,19 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULT_ENV = exports.DEFAULT_COMMAND_PREFIX = exports.DEFAULT_MODULES_DIR = exports.DEFAULT_ROOT_DIR = exports.DEFAULT_LANG = exports.LOAD_MODULE_SLEEP_TIME = exports.LOAD_MODULE_MAX_TIME = exports.ADAPTER_PREFIX = exports.PLUGIN_PREFIX = exports.OFFICIAL_MODULES_SCOPE = void 0;
+exports.DEFAULT_CORE_CONFIG = exports.DEFAULT_PORT = exports.CUSTOM_PREFIX = exports.ADAPTER_PREFIX = exports.DATABASE_PREFIX = exports.PLUGIN_PREFIX = exports.OFFICIAL_MODULES_SCOPE = void 0;
+const i18n_1 = require("@kotori-bot/i18n");
 exports.OFFICIAL_MODULES_SCOPE = '@kotori-bot/';
 exports.PLUGIN_PREFIX = 'kotori-plugin-';
+exports.DATABASE_PREFIX = `${exports.PLUGIN_PREFIX}database-`;
 exports.ADAPTER_PREFIX = `${exports.PLUGIN_PREFIX}adapter-`;
-exports.LOAD_MODULE_MAX_TIME = 10 * 1000;
-exports.LOAD_MODULE_SLEEP_TIME = 150;
-exports.DEFAULT_LANG = 'en_US';
-exports.DEFAULT_ROOT_DIR = './';
-exports.DEFAULT_MODULES_DIR = './modules';
-exports.DEFAULT_COMMAND_PREFIX = '/';
-exports.DEFAULT_ENV = 'dev';
+exports.CUSTOM_PREFIX = `${exports.PLUGIN_PREFIX}custom-`;
+exports.DEFAULT_PORT = 720;
+exports.DEFAULT_CORE_CONFIG = {
+    global: {
+        lang: i18n_1.DEFAULT_LANG,
+        'command-prefix': '/',
+        port: exports.DEFAULT_PORT
+    },
+    adapter: {},
+    plugin: {}
+};

package/lib/context/context.d.ts

@@ -0,0 +1,35 @@
+import Symbols from './symbols';
+import './events';
+interface obj {
+    [propName: string | number | symbol]: any;
+}
+interface ContextOrigin {
+    readonly [Symbols.container]: Map<string, obj>;
+    readonly [Symbols.table]: Map<string, string[]>;
+    root: Context;
+    get(prop: string): obj | undefined;
+    inject<T extends Keys>(prop: T): void;
+    provide<T extends obj>(prop: string, value: T): void;
+    mixin<K extends Keys>(prop: string, keys: K[]): void;
+    extends<T extends obj>(meta?: T, identity?: string): Context;
+}
+interface ContextImpl extends ContextOrigin {
+}
+declare module './context' {
+    interface Context {
+        identity?: string;
+    }
+}
+type Keys = keyof Omit<Context, keyof ContextOrigin> & string;
+export declare class Context implements ContextImpl {
+    readonly [Symbols.container]: Map<string, obj>;
+    readonly [Symbols.table]: Map<string, string[]>;
+    root: Context;
+    constructor(root?: Context);
+    get<T = obj | undefined>(prop: string): T;
+    inject<T extends Keys>(prop: T): void;
+    provide<T extends obj>(prop: string, value: T): void;
+    mixin<K extends Keys>(prop: string, keys: K[]): void;
+    extends<T extends obj = object>(meta?: T, identity?: string): Context;
+}
+export default Context;

package/lib/context/context.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Context = void 0;
+/*
+ * @Author: Hotaru biyuehuya@gmail.com
+ * @Blog: https://hotaru.icu
+ * @Date: 2024-02-07 13:44:38
+ * @LastEditors: Hotaru biyuehuya@gmail.com
+ * @LastEditTime: 2024-02-21 10:38:39
+ */
+const tools_1 = require("@kotori-bot/tools");
+const symbols_1 = __importDefault(require("./symbols"));
+const modules_1 = __importDefault(require("./modules"));
+const handler = (value, ctx) => {
+    if (!value || typeof value !== 'object' || !(value.ctx instanceof Context))
+        return value;
+    return new Proxy(value, {
+        get(target, prop, receiver) {
+            if (prop === 'ctx')
+                return ctx;
+            return Reflect.get(target, prop, receiver);
+        }
+    });
+};
+class Context {
+    [symbols_1.default.container] = new Map();
+    [symbols_1.default.table] = new Map();
+    root;
+    constructor(root) {
+        this.root = root || this;
+        this.provide('events', root ? root.get('events') : new tools_1.Events());
+        this.mixin('events', ['emit', 'on', 'once', 'off', 'offAll']);
+        this.provide('modules', new modules_1.default(this));
+        this.mixin('modules', ['load', 'unload', 'service']);
+    }
+    get(prop) {
+        return this[symbols_1.default.container].get(prop);
+    }
+    inject(prop) {
+        if (this[prop] && !this[symbols_1.default.container].has(prop))
+            return;
+        this[prop] = this.get(prop);
+    }
+    provide(prop, value) {
+        if (this[symbols_1.default.container].has(prop))
+            return;
+        this[symbols_1.default.container].set(prop, value);
+    }
+    mixin(prop, keys) {
+        this[symbols_1.default.table].set(prop, keys);
+        const instance = this.get(prop);
+        if (!instance)
+            return;
+        this[symbols_1.default.table].set(prop, keys);
+        keys.forEach((key) => {
+            if (this[key] || !instance[key])
+                return;
+            this[key] = instance[key];
+            if (typeof this[key] === 'function') {
+                this[key] = this[key]?.bind(instance);
+            }
+        });
+    }
+    extends(meta, identity) {
+        const metaHandle = meta ?? {};
+        /* clear function */
+        Object.keys(metaHandle).forEach((key) => {
+            if (typeof this[key] === 'function')
+                delete metaHandle[key];
+        });
+        /* set proxy */
+        const ctx = new Proxy(new Context(this.root), {
+            get: (target, prop) => {
+                if (prop === 'identity')
+                    return identity ?? this.identity ?? 'sub';
+                if (target[prop])
+                    return handler(target[prop], ctx);
+                let value;
+                this[symbols_1.default.table].forEach((keys, key) => {
+                    if (value || (typeof prop === 'string' && !keys.includes(prop)))
+                        return;
+                    const instance = ctx[symbols_1.default.container].get(key);
+                    if (!instance)
+                        return;
+                    value = instance[prop];
+                    if (typeof value === 'function')
+                        value = value.bind(instance);
+                });
+                if (value !== undefined)
+                    return value;
+                if (metaHandle[prop])
+                    return handler(metaHandle[prop], ctx);
+                return handler(this[prop], ctx);
+            }
+        });
+        /* set table */
+        this[symbols_1.default.table].forEach((value, key) => ctx[symbols_1.default.table].set(key, value));
+        /* set container */
+        this[symbols_1.default.container].forEach((value, key) => {
+            if (!value.ctx)
+                return ctx[symbols_1.default.container].set(key, value);
+            return ctx[symbols_1.default.container].set(key, handler(value, ctx));
+        });
+        return ctx;
+    }
+}
+exports.Context = Context;
+exports.default = Context;