vona 1.0.0 → 5.0.4

package/dist/lib/bean/beanBase.d.ts

@@ -0,0 +1,11 @@
+import { BeanBaseSimple } from './beanBaseSimple.js';
+import { IModuleLocaleText } from './resource/locale/type.js';
+import { IBeanScopeRecord, TypeBeanScopeRecordKeys } from './type.js';
+export declare class BeanBase<TScopeModule = unknown> extends BeanBaseSimple {
+    protected get $text(): IModuleLocaleText;
+    protected get scope(): TScopeModule;
+    protected getScope<K extends TypeBeanScopeRecordKeys>(moduleScope: K): IBeanScopeRecord[K];
+    protected getScope(): TScopeModule;
+    protected __get__(prop: PropertyKey): undefined;
+}
+//# sourceMappingURL=beanBase.d.ts.map

package/dist/lib/bean/beanBase.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeanBase = void 0;
+const word_utils_1 = require("@cabloy/word-utils");
+const beanBaseSimple_js_1 = require("./beanBaseSimple.js");
+const SymbolText = Symbol('SymbolText');
+class BeanBase extends beanBaseSimple_js_1.BeanBaseSimple {
+    get $text() {
+        if (!this[SymbolText]) {
+            this[SymbolText] = this.ctx.meta.locale.createLocaleText(this.moduleBelong);
+        }
+        return this[SymbolText];
+    }
+    get scope() {
+        return this.getScope();
+    }
+    getScope(moduleScope) {
+        if (!moduleScope) {
+            return this.bean.scope(this.moduleBelong);
+        }
+        return this.bean.scope(moduleScope);
+    }
+    __get__(prop) {
+        if (typeof prop === 'string' && prop.startsWith('$scope')) {
+            let moduleName = (0, word_utils_1.splitWords)(prop.substring('$scope'.length), true, '-');
+            if (!moduleName?.includes('-')) {
+                moduleName = 'a-' + moduleName;
+            }
+            return this.getScope(moduleName);
+        }
+    }
+}
+exports.BeanBase = BeanBase;
+//# sourceMappingURL=beanBase.js.map

package/dist/lib/bean/beanBaseSimple.d.ts

@@ -0,0 +1,8 @@
+import { BeanSimple } from './beanSimple.js';
+export declare class BeanBaseSimple extends BeanSimple {
+    private __beanFullName__;
+    private __moduleBelong__?;
+    constructor(moduleBelong?: string);
+    protected get moduleBelong(): string;
+}
+//# sourceMappingURL=beanBaseSimple.d.ts.map

package/dist/lib/bean/beanBaseSimple.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeanBaseSimple = void 0;
+const resource_js_1 = require("../core/resource.js");
+const beanSimple_js_1 = require("./beanSimple.js");
+class BeanBaseSimple extends beanSimple_js_1.BeanSimple {
+    constructor(moduleBelong) {
+        super();
+        Object.defineProperty(this, "__beanFullName__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "__moduleBelong__", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        if (moduleBelong && typeof moduleBelong !== 'string') {
+            throw new Error(`moduleBelong not valid: ${moduleBelong}`);
+        }
+        this.__moduleBelong__ = moduleBelong;
+    }
+    get moduleBelong() {
+        return this.__moduleBelong__ || resource_js_1.appResource._getModuleBelong(this.__beanFullName__);
+    }
+}
+exports.BeanBaseSimple = BeanBaseSimple;
+//# sourceMappingURL=beanBaseSimple.js.map

package/dist/lib/bean/beanContainer.d.ts

@@ -0,0 +1,39 @@
+import { VonaApplication, VonaContext } from '../../types/index.js';
+import { Constructable } from '../decorator/index.js';
+import { IBeanRecord, IBeanRecordGlobal, IBeanScopeRecord, TypeBeanScopeRecordKeys } from './type.js';
+declare const BeanContainerInstances: unique symbol;
+export interface BeanContainer extends IBeanRecordGlobal {
+}
+export declare class BeanContainer {
+    private app;
+    private ctx;
+    private [BeanContainerInstances];
+    static create(app: VonaApplication, ctx: VonaContext | null): BeanContainer;
+    protected constructor(app: VonaApplication, ctx: VonaContext | null);
+    /** get specific module's scope */
+    scope<K extends TypeBeanScopeRecordKeys>(moduleScope: K): IBeanScopeRecord[K];
+    scope<T>(moduleScope: string): T;
+    _getBean<T>(A: Constructable<T>): T;
+    _getBean<K extends keyof IBeanRecord>(beanFullName: K): IBeanRecord[K];
+    _getBeanSelector<T>(A: Constructable<T>, selector?: string): T;
+    _getBeanSelector<K extends keyof IBeanRecord>(beanFullName: K, selector?: string): IBeanRecord[K];
+    _newBean<T>(A: Constructable<T>, ...args: any[]): T;
+    _newBean<K extends keyof IBeanRecord>(beanFullName: K, ...args: any[]): IBeanRecord[K];
+    _newBeanSelector<T>(A: Constructable<T>, selector?: string, ...args: any[]): T;
+    _newBeanSelector<K extends keyof IBeanRecord>(beanFullName: K, selector?: string, ...args: any[]): IBeanRecord[K];
+    private _createBeanInstance;
+    private _injectBeanInstance;
+    private _injectBeanInstancePropLazy;
+    private _injectBeanInstanceProp;
+    private _patchBeanInstance;
+    private _newBeanProxy;
+    private _getInstanceMethodProxy;
+    private _prepareAopChains;
+    private _getAopChains;
+    private _getAopChainsProp;
+    private __composeForPropAdapter;
+    private __composeForProp;
+    private __composeForPropAsync;
+}
+export {};
+//# sourceMappingURL=beanContainer.d.ts.map

package/dist/lib/bean/beanContainer.js

@@ -0,0 +1,514 @@
+"use strict";
+var _a;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeanContainer = void 0;
+const resource_js_1 = require("../core/resource.js");
+const beanBase_js_1 = require("./beanBase.js");
+const beanSimple_js_1 = require("./beanSimple.js");
+const isClass_js_1 = require("../utils/isClass.js");
+const ProxyMagic = Symbol.for('Bean#ProxyMagic');
+const BeanContainerInstances = Symbol.for('Bean#Instances');
+class BeanContainer {
+    static create(app, ctx) {
+        const beanContainer = new BeanContainer(app, ctx);
+        return new Proxy(beanContainer, {
+            get(obj, prop) {
+                if (typeof prop === 'symbol')
+                    return obj[prop];
+                if (obj[prop])
+                    return obj[prop];
+                return obj._getBean(prop);
+            },
+        });
+    }
+    constructor(app, ctx) {
+        Object.defineProperty(this, "app", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "ctx", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, _a, {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: {}
+        });
+        Object.defineProperty(this, "__composeForPropAdapter", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: (_context, chain) => {
+                const [aopKey, methodName] = chain;
+                // ProxyMagic
+                if (aopKey === ProxyMagic)
+                    return null;
+                // chain
+                const aop = this._getBean(aopKey);
+                if (!aop)
+                    throw new Error(`aop not found: ${chain}`);
+                if (!aop[methodName])
+                    return null;
+                return {
+                    receiver: aop,
+                    fn: aop[methodName],
+                };
+            }
+        });
+        this.app = app;
+        this.ctx = ctx;
+    }
+    scope(moduleScope) {
+        return this._getBean(`${moduleScope}.scope.module`);
+    }
+    // _getBean<T>(beanFullName: string): T;
+    _getBean(beanFullName) {
+        return this._getBeanSelector(beanFullName);
+    }
+    // _getBeanSelector<T>(beanFullName: string, selector?: string): T;
+    _getBeanSelector(beanFullName, selector) {
+        // bean options
+        const beanOptions = resource_js_1.appResource.getBean(beanFullName);
+        if (!beanOptions) {
+            // not found
+            return null;
+        }
+        const fullName = beanOptions.beanFullName;
+        // same as _getBean if selector is undefined/null/'', as as to get the same bean instance
+        //   not use !selector which maybe is 0
+        const isSelectorValid = !this.app.meta.util.isNullOrEmptyString(selector);
+        const key = !isSelectorValid ? fullName : `${fullName}#${selector}`;
+        if (this[BeanContainerInstances][key] === undefined) {
+            let beanInstance;
+            if (isSelectorValid) {
+                beanInstance = this._newBean(fullName, selector);
+            }
+            else {
+                beanInstance = this._newBean(fullName);
+            }
+            this[BeanContainerInstances][key] = beanInstance;
+        }
+        return this[BeanContainerInstances][key];
+    }
+    // _newBean<T>(beanFullName: string, ...args): T;
+    _newBean(beanFullName, ...args) {
+        // bean options
+        const beanOptions = resource_js_1.appResource.getBean(beanFullName);
+        if (!beanOptions) {
+            // class
+            if (typeof beanFullName === 'function' && (0, isClass_js_1.isClass)(beanFullName)) {
+                const beanInstance = this._createBeanInstance(beanFullName, beanFullName, args);
+                return this._patchBeanInstance(beanFullName, beanInstance, false);
+            }
+            // throw new Error(`bean not found: ${beanFullName}`);
+            return null;
+        }
+        // instance
+        const beanInstance = this._createBeanInstance(beanOptions.beanFullName, beanOptions.beanClass, args);
+        // patch
+        return this._patchBeanInstance(beanOptions.beanFullName, beanInstance, beanOptions.aop);
+    }
+    // _newBeanSelector<T>(beanFullName: string, selector?: string, ...args): T;
+    _newBeanSelector(beanFullName, selector, ...args) {
+        return this._newBean(beanFullName, selector, ...args);
+    }
+    _createBeanInstance(beanFullName, beanClass, args) {
+        // create
+        let beanInstance;
+        if (beanClass.prototype.__init__) {
+            beanInstance = new beanClass();
+        }
+        else {
+            beanInstance = new beanClass(...args);
+        }
+        // app/ctx
+        if (beanInstance instanceof beanSimple_js_1.BeanSimple) {
+            // app
+            beanInstance.app = this.app;
+            // ctx: always set even if is null, so as to prevent magic method __get__ take effect.
+            beanInstance.ctx = this.ctx;
+        }
+        // beanFullName
+        if (typeof beanFullName === 'string') {
+            __setPropertyValue(beanInstance, '__beanFullName__', beanFullName);
+        }
+        /// / scope
+        // this._injectBeanInstanceScope(beanInstance, beanFullName);
+        // inject
+        this._injectBeanInstance(beanInstance, beanFullName);
+        // init
+        if (beanInstance.__init__) {
+            beanInstance.__init__(...args);
+        }
+        // ok
+        return beanInstance;
+    }
+    _injectBeanInstance(beanInstance, beanFullName) {
+        const beanOptions = resource_js_1.appResource.getBean(beanFullName);
+        if (!beanOptions)
+            return;
+        const uses = resource_js_1.appResource.getUses(beanOptions.beanClass.prototype);
+        if (!uses)
+            return;
+        for (const key in uses) {
+            const useOptions = uses[key];
+            const selector = useOptions.selector;
+            const injectionScope = useOptions.injectionScope;
+            this._injectBeanInstancePropLazy(beanInstance, useOptions.prop, useOptions.beanFullName, selector, injectionScope);
+        }
+    }
+    _injectBeanInstancePropLazy(instance, prop, targetBeanFullName, selector, injectionScope) {
+        const self = this;
+        Object.defineProperty(instance, prop, {
+            enumerable: true,
+            configurable: true,
+            get() {
+                const symbol = Symbol.for(`__bean_use__#${prop}`);
+                if (!instance[symbol]) {
+                    instance[symbol] = self._injectBeanInstanceProp(targetBeanFullName, selector, injectionScope);
+                }
+                return instance[symbol];
+            },
+        });
+    }
+    _injectBeanInstanceProp(targetBeanFullName, selector, injectionScope) {
+        // injectionScope
+        if (!injectionScope) {
+            const targetOptions = resource_js_1.appResource.getBean(targetBeanFullName);
+            if (!targetOptions) {
+                throw new Error(`not found bean class: ${targetBeanFullName}`);
+            }
+            injectionScope = targetOptions.containerScope || 'ctx';
+        }
+        // targetInstance
+        let targetInstance;
+        // selector maybe empty string
+        if (injectionScope === 'app') {
+            targetInstance = this.app.bean._getBeanSelector(targetBeanFullName, selector);
+        }
+        else if (injectionScope === 'ctx') {
+            targetInstance = this._getBeanSelector(targetBeanFullName, selector);
+        }
+        else if (injectionScope === 'new') {
+            targetInstance = this._newBean(targetBeanFullName, selector);
+        }
+        return targetInstance;
+    }
+    // private _injectBeanInstanceScope(beanInstance, beanFullName) {
+    //   if (typeof beanFullName !== 'string' || beanFullName.indexOf('.scope.module') > -1) return;
+    //   Object.defineProperty(beanInstance, 'scope', {
+    //     enumerable: false,
+    //     configurable: true,
+    //     get() {
+    //       if (!this[BeanInstanceScope]) {
+    //         this[BeanInstanceScope] = this.bean._getBean(`${this.moduleBelong}.scope.module`);
+    //       }
+    //       return this[BeanInstanceScope];
+    //     },
+    //   });
+    // }
+    _patchBeanInstance(beanFullNameOrBeanClass, beanInstance, aop) {
+        if (!beanFullNameOrBeanClass)
+            return beanInstance;
+        // not aop on aop
+        if (aop)
+            return beanInstance;
+        // aop chains
+        const _aopChains = this._prepareAopChains(beanFullNameOrBeanClass, beanInstance);
+        // no aop
+        if (_aopChains.length === 0)
+            return beanInstance;
+        // aop
+        return this._newBeanProxy(beanFullNameOrBeanClass, beanInstance);
+    }
+    _newBeanProxy(beanFullName, beanInstance) {
+        const self = this;
+        return new Proxy(beanInstance, {
+            get(target, prop, receiver) {
+                if (typeof prop === 'symbol') {
+                    return target[prop];
+                }
+                if (__isInnerMethod(prop)) {
+                    return target[prop];
+                }
+                // descriptorInfo
+                const descriptorInfo = __getPropertyDescriptor(target, prop);
+                if (!__checkAopOfDescriptorInfo(descriptorInfo))
+                    return target[prop];
+                const methodType = __methodTypeOfDescriptor(descriptorInfo);
+                // get prop
+                if (!methodType) {
+                    const methodName = `__get_${prop}__`;
+                    const methodNameMagic = '__magic_get__';
+                    const _aopChainsProp = self._getAopChainsProp(beanFullName, methodName, methodNameMagic);
+                    if (_aopChainsProp.length === 0)
+                        return target[prop];
+                    // context
+                    const context = {
+                        target,
+                        receiver,
+                        prop,
+                        value: undefined,
+                    };
+                    // aop
+                    self.__composeForProp(_aopChainsProp)(context, (context, next) => {
+                        if (context.value === undefined) {
+                            if (!descriptorInfo && target.__get__) {
+                                context.value = target.__get__(prop);
+                            }
+                            else {
+                                context.value = target[prop];
+                            }
+                        }
+                        next();
+                    });
+                    // ok
+                    return context.value;
+                }
+                // method
+                return self._getInstanceMethodProxy(beanFullName, target, prop, methodType);
+            },
+            set(target, prop, value, receiver) {
+                if (typeof prop === 'symbol') {
+                    target[prop] = value;
+                    return true;
+                }
+                if (__isInnerMethod(prop)) {
+                    target[prop] = value;
+                    return true;
+                }
+                // descriptorInfo
+                const descriptorInfo = __getPropertyDescriptor(target, prop);
+                if (!__checkAopOfDescriptorInfo(descriptorInfo)) {
+                    target[prop] = value;
+                    return true;
+                }
+                const methodName = `__set_${prop}__`;
+                const methodNameMagic = '__magic_set__';
+                const _aopChainsProp = self._getAopChainsProp(beanFullName, methodName, methodNameMagic);
+                if (_aopChainsProp.length === 0) {
+                    target[prop] = value;
+                    return true;
+                }
+                // context
+                const context = {
+                    target,
+                    receiver,
+                    prop,
+                    value,
+                };
+                // aop
+                self.__composeForProp(_aopChainsProp)(context, (context, next) => {
+                    if (!descriptorInfo && target.__set__) {
+                        const res = target.__set__(prop, context.value);
+                        if (res === undefined)
+                            throw new Error('__set__ must return true/false');
+                        if (!res) {
+                            target[prop] = context.value;
+                        }
+                    }
+                    else {
+                        target[prop] = context.value;
+                    }
+                    next();
+                });
+                // ok
+                return true;
+            },
+        });
+    }
+    _getInstanceMethodProxy(beanFullName, beanInstance, prop, methodType) {
+        const self = this;
+        // not aop magic methods
+        if (__isInnerMethod(prop)) {
+            return beanInstance[prop];
+        }
+        // aop chains
+        const _aopChainsProp = this._getAopChainsProp(beanFullName, prop, null);
+        if (_aopChainsProp.length === 0)
+            return beanInstance[prop];
+        // proxy
+        const methodProxyKey = `__aopproxy_method_${prop}__`;
+        if (beanInstance[methodProxyKey])
+            return beanInstance[methodProxyKey];
+        const methodProxy = new Proxy(beanInstance[prop], {
+            apply(target, thisArg, args) {
+                // context
+                const context = {
+                    target: beanInstance,
+                    receiver: thisArg,
+                    prop,
+                    arguments: args,
+                    result: undefined,
+                };
+                // aop
+                if (methodType === 'Function') {
+                    self.__composeForProp(_aopChainsProp)(context, (context, next) => {
+                        if (context.result === undefined) {
+                            context.result = target.apply(thisArg, args);
+                        }
+                        next();
+                    });
+                    // ok
+                    return context.result;
+                }
+                if (methodType === 'AsyncFunction') {
+                    return new Promise((resolve, reject) => {
+                        self
+                            .__composeForPropAsync(_aopChainsProp)(context, async (context, next) => {
+                            if (context.result === undefined) {
+                                context.result = await target.apply(thisArg, args);
+                            }
+                            await next();
+                        })
+                            .then(() => {
+                            resolve(context.result);
+                        })
+                            .catch(err => {
+                            reject(err);
+                        });
+                    });
+                }
+            },
+        });
+        __setPropertyValue(beanInstance, methodProxyKey, methodProxy);
+        return methodProxy;
+    }
+    _prepareAopChains(beanFullNameOrBeanClass, beanInstance) {
+        if (!beanFullNameOrBeanClass)
+            return [];
+        // beanFullName maybe class
+        const beanOptions = resource_js_1.appResource.getBean(beanFullNameOrBeanClass);
+        const host = beanOptions || beanFullNameOrBeanClass;
+        if (host.__aopChains__)
+            return host.__aopChains__;
+        // chains
+        let chains = [];
+        if (beanOptions && !beanOptions.aop) {
+            const aops = resource_js_1.appResource.findAopsMatched(beanOptions.beanFullName);
+            if (aops) {
+                chains = chains.concat(aops);
+            }
+        }
+        // magic self
+        if (__hasMagicMothod(beanInstance)) {
+            chains.push(ProxyMagic);
+        }
+        // hold
+        host.__aopChains__ = chains;
+        return chains;
+    }
+    _getAopChains(beanFullName) {
+        // beanFullName maybe class
+        const beanOptions = resource_js_1.appResource.getBean(beanFullName);
+        const host = beanOptions || beanFullName;
+        return host.__aopChains__;
+    }
+    _getAopChainsProp(beanFullName, methodName, methodNameMagic) {
+        const chainsKey = `__aopChains_${methodName}__`;
+        const beanOptions = resource_js_1.appResource.getBean(beanFullName);
+        const host = beanOptions || beanFullName;
+        if (!host.__aopChainsKey__)
+            host.__aopChainsKey__ = {};
+        if (host.__aopChainsKey__[chainsKey])
+            return host.__aopChainsKey__[chainsKey];
+        const _aopChains = this._getAopChains(beanFullName);
+        const chains = [];
+        for (const aopKey of _aopChains) {
+            if (aopKey === ProxyMagic) {
+                chains.push([aopKey, methodName]);
+            }
+            else {
+                const aop = this._getBean(aopKey);
+                if (aop[methodName]) {
+                    chains.push([aopKey, methodName]);
+                }
+                else if (methodNameMagic && aop[methodNameMagic]) {
+                    chains.push([aopKey, methodNameMagic]);
+                }
+            }
+        }
+        host.__aopChainsKey__[chainsKey] = chains;
+        return chains;
+    }
+    __composeForProp(chains) {
+        return this.app.meta.util.compose(chains, this.__composeForPropAdapter);
+    }
+    __composeForPropAsync(chains) {
+        return this.app.meta.util.composeAsync(chains, this.__composeForPropAdapter);
+    }
+}
+exports.BeanContainer = BeanContainer;
+_a = BeanContainerInstances;
+function __checkAopOfDescriptorInfo(descriptorInfo) {
+    if (!descriptorInfo)
+        return true;
+    return !descriptorInfo.dynamic && !descriptorInfo.ofBeanBase;
+}
+function __getPropertyDescriptor(obj, prop) {
+    // dynamic
+    const descriptor = Object.getOwnPropertyDescriptor(obj, prop);
+    if (descriptor)
+        return { descriptor, dynamic: true };
+    // static
+    return __getPropertyDescriptorStatic(obj, prop);
+}
+function __getPropertyDescriptorStatic(obj, prop) {
+    let proto = Object.getPrototypeOf(obj);
+    let ofBeanBase = false;
+    while (proto) {
+        if (proto.constructor.name === beanBase_js_1.BeanBase.name) {
+            ofBeanBase = true;
+        }
+        const descriptor = Object.getOwnPropertyDescriptor(proto, prop);
+        if (descriptor)
+            return { descriptor, dynamic: false, ofBeanBase };
+        proto = Object.getPrototypeOf(proto);
+    }
+    return null;
+}
+function __setPropertyValue(obj, prop, value) {
+    Object.defineProperty(obj, prop, {
+        enumerable: false,
+        configurable: true,
+        get() {
+            return value;
+        },
+    });
+}
+function __hasMagicMothod(instance) {
+    return !!instance.__get__ || !!instance.__set__;
+}
+function __isInnerMethod(prop) {
+    return [
+        '__get__',
+        '__set__',
+        '__init__',
+        '__dispose__',
+        'then',
+        '__v_isShallow',
+        '__v_isReadonly',
+        '__v_raw',
+    ].includes(prop);
+}
+function __methodTypeOfDescriptor(descriptorInfo) {
+    if (!descriptorInfo)
+        return null;
+    const { descriptor, dynamic } = descriptorInfo;
+    if (dynamic)
+        return null;
+    if (descriptor.get)
+        return null;
+    const methodType = descriptor.value?.constructor?.name;
+    if (['Function', 'AsyncFunction'].includes(methodType)) {
+        return methodType;
+    }
+    return null;
+}
+//# sourceMappingURL=beanContainer.js.map

package/dist/lib/bean/beanLocal.d.ts

@@ -0,0 +1,6 @@
+import { BeanModuleScopeBase } from './beanModuleScopeBase.js';
+export declare class BeanLocal extends BeanModuleScopeBase {
+    protected __get__(prop: any): unknown;
+    module(moduleScope: string): typeof this;
+}
+//# sourceMappingURL=beanLocal.d.ts.map

package/dist/lib/bean/beanLocal.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BeanLocal = void 0;
+const beanModuleScopeBase_js_1 = require("./beanModuleScopeBase.js");
+class BeanLocal extends beanModuleScopeBase_js_1.BeanModuleScopeBase {
+    // magic
+    __get__(prop) {
+        return this.bean._getBean(`${this.moduleScope}.local.${prop}`);
+    }
+    // beanLocal has no __beanFullName__
+    module(moduleScope) {
+        return this.bean._newBeanScope(BeanLocal, moduleScope);
+    }
+}
+exports.BeanLocal = BeanLocal;
+//# sourceMappingURL=beanLocal.js.map

package/dist/lib/bean/beanModuleScopeBase.d.ts

@@ -0,0 +1,10 @@
+import { BeanBase } from './beanBase.js';
+declare const BeanModuleScope: unique symbol;
+export declare class BeanModuleScopeBase<T = unknown> extends BeanBase<T> {
+    private [BeanModuleScope]?;
+    constructor(moduleScope?: string);
+    protected get moduleScope(): string;
+    module(moduleScope: string): typeof this;
+}
+export {};
+//# sourceMappingURL=beanModuleScopeBase.d.ts.map