vona-core 5.0.104 → 5.0.105

package/dist/lib/bean/beanContainer.js

@@ -1,586 +0,0 @@
-import { isClass, isNilOrEmptyString } from '@cabloy/utils';
-import { cast } from "../../types/index.js";
-import { appMetadata } from "../core/metadata.js";
-import { appResource, SymbolDecoratorProxyDisable } from "../core/resource.js";
-import { __prepareInjectSelectorInfo } from "../decorator/index.js";
-import { compose } from "../utils/util.js";
-import { BeanAopBase } from "./beanAopBase.js";
-import { BeanBase } from "./beanBase.js";
-import { SymbolBeanFullName, SymbolBeanInstanceKey } from "./beanBaseSimple.js";
-import { BeanSimple } from "./beanSimple.js";
-const SymbolProxyMagic = Symbol('SymbolProxyMagic');
-const SymbolProxyAopMethod = Symbol('SymbolProxyAopMethod');
-const SymbolCacheAopChains = Symbol('SymbolCacheAopChains');
-const SymbolCacheAopChainsKey = Symbol('SymbolCacheAopChainsKey');
-const SymbolBeanContainerInstances = Symbol('SymbolBeanContainerInstances');
-const SymbolBeanInstancePropsLazy = Symbol('SymbolBeanInstancePropsLazy');
-export class BeanContainer {
-    app;
-    ctx;
-    [SymbolBeanContainerInstances] = {};
-    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) {
-        this.app = app;
-        this.ctx = ctx;
-    }
-    /** @internal */
-    async dispose() {
-        const beanInstances = this[SymbolBeanContainerInstances];
-        for (const prop in beanInstances) {
-            const beanInstance = cast(beanInstances[prop]);
-            if (beanInstance && !(beanInstance instanceof BeanAopBase) && beanInstance.__dispose__) {
-                await beanInstance.__dispose__();
-            }
-        }
-        this[SymbolBeanContainerInstances] = {};
-    }
-    async disposeInstance(beanInstanceKey) {
-        const beanInstance = this[SymbolBeanContainerInstances][beanInstanceKey];
-        if (beanInstance) {
-            if (!(beanInstance instanceof BeanAopBase) && beanInstance.__dispose__) {
-                await beanInstance.__dispose__();
-            }
-            delete this[SymbolBeanContainerInstances][beanInstanceKey];
-        }
-    }
-    // scope<T>(moduleScope: string): T;
-    scope(moduleScope) {
-        return this._getBean(`${moduleScope}.scope.module`);
-    }
-    // _getBean<T>(beanFullName: string, ...args): T;
-    _getBean(beanFullName, ...args) {
-        return this._getBeanSelectorInner(beanFullName, false, ...args);
-    }
-    // _getBeanSelector<T>(beanFullName: string, selector?: string, ...args): T;
-    _getBeanSelector(beanFullName, selector, ...args) {
-        return this._getBeanSelectorInner(beanFullName, true, selector, ...args);
-    }
-    _getBeanSelectorInner(beanFullName, withSelector, ...args) {
-        // bean options
-        const beanOptions = appResource.getBean(beanFullName);
-        if (!beanOptions) {
-            // not found
-            return null;
-        }
-        const fullName = beanOptions.beanFullName;
-        const key = __getSelectorKey(fullName, withSelector, args[0]);
-        if (this[SymbolBeanContainerInstances][key] === undefined) {
-            this._newBeanInner(true, fullName, withSelector, ...args);
-        }
-        return this[SymbolBeanContainerInstances][key];
-    }
-    // _newBean<T>(beanFullName: string, ...args): T;
-    _newBean(beanFullName, ...args) {
-        return this._newBeanInner(false, beanFullName, false, ...args);
-    }
-    // _newBeanSelector<T>(beanFullName: string, selector?: string, ...args): T;
-    _newBeanSelector(beanFullName, selector, ...args) {
-        return this._newBean(beanFullName, selector, ...args);
-    }
-    /** @internal */
-    _newBeanInner(record, beanFullName, withSelector, ...args) {
-        // bean options
-        const beanOptions = appResource.getBean(beanFullName);
-        if (!beanOptions) {
-            // class
-            if (typeof beanFullName === 'function' && isClass(beanFullName)) {
-                return this._createBeanInstance(record, undefined, beanFullName, args, false, withSelector);
-            }
-            // throw new Error(`bean not found: ${beanFullName}`);
-            return null;
-        }
-        // instance
-        return this._createBeanInstance(record, beanOptions.beanFullName, beanOptions.beanClass, args, cast(beanOptions.scene) === 'aop', withSelector);
-    }
-    _createBeanInstance(record, beanFullName, beanClass, args, aop, withSelector) {
-        // prepare
-        const beanInstance = this._prepareBeanInstance(beanFullName, beanClass, args, aop);
-        // record
-        if (record) {
-            // fullName
-            const fullName = appResource.getBeanFullName(beanFullName);
-            if (fullName) {
-                const key = __getSelectorKey(fullName, withSelector, args[0]);
-                __setPropertyValue(beanInstance, SymbolBeanInstanceKey, key);
-                this[SymbolBeanContainerInstances][key] = beanInstance;
-            }
-        }
-        // init
-        this._initBeanInstance(beanFullName, beanInstance, args);
-        // ok
-        return beanInstance;
-    }
-    _prepareBeanInstance(beanFullName, BeanClass, args, aop) {
-        // create
-        let beanInstance;
-        if (BeanClass.prototype.__init__) {
-            beanInstance = new BeanClass();
-        }
-        else {
-            beanInstance = new BeanClass(...args);
-        }
-        // app/ctx
-        if (beanInstance instanceof BeanSimple) {
-            beanInstance.app = this.app;
-            if (this.ctx) {
-                __setPropertyValue(beanInstance, 'ctx', this.ctx);
-            }
-        }
-        // beanFullName
-        if (typeof beanFullName === 'string') {
-            __setPropertyValue(beanInstance, SymbolBeanFullName, beanFullName);
-        }
-        // aop: proxy
-        return this._patchBeanInstance(beanFullName || BeanClass, beanInstance, aop);
-    }
-    _initBeanInstance(beanFullName, beanInstance, args) {
-        // inject
-        this._injectBeanInstance(beanInstance, beanFullName);
-        // init
-        if (!(beanInstance instanceof BeanAopBase) && beanInstance.__init__) {
-            beanInstance.__init__(...args);
-        }
-        // ok
-        return beanInstance;
-    }
-    _injectBeanInstance(beanInstance, beanFullName) {
-        const beanOptions = appResource.getBean(beanFullName);
-        if (!beanOptions)
-            return;
-        const uses = appResource.getUses(beanOptions.beanClass.prototype);
-        if (!uses)
-            return;
-        for (const key in uses) {
-            const useOptions = uses[key];
-            this._injectBeanInstancePropLazy(beanInstance, useOptions.prop, useOptions.beanFullName, useOptions);
-        }
-    }
-    _injectBeanInstancePropLazy(beanInstance, prop, targetBeanFullName, useOptions) {
-        const self = this;
-        Object.defineProperty(beanInstance, prop, {
-            enumerable: true,
-            configurable: true,
-            get() {
-                if (!beanInstance[SymbolBeanInstancePropsLazy])
-                    beanInstance[SymbolBeanInstancePropsLazy] = {};
-                if (!beanInstance[SymbolBeanInstancePropsLazy][prop]) {
-                    beanInstance[SymbolBeanInstancePropsLazy][prop] = self._injectBeanInstanceProp(beanInstance, targetBeanFullName, useOptions);
-                }
-                return beanInstance[SymbolBeanInstancePropsLazy][prop];
-            },
-        });
-    }
-    _injectBeanInstanceProp(beanInstance, targetBeanFullName, useOptions) {
-        // injectionScope
-        const injectionScope = useOptions.injectionScope ?? 'app';
-        // options: selectorInfo
-        const selectorInfo = __prepareInjectSelectorInfo(beanInstance, useOptions);
-        // targetInstance
-        let targetInstance;
-        // selector maybe empty string
-        if (injectionScope === 'app') {
-            targetInstance = this.app.bean._getBeanSelectorInner(targetBeanFullName, selectorInfo.withSelector, ...selectorInfo.args);
-        }
-        else if (injectionScope === 'ctx') {
-            targetInstance = this._getBeanSelectorInner(targetBeanFullName, selectorInfo.withSelector, ...selectorInfo.args);
-        }
-        else if (injectionScope === 'new') {
-            targetInstance = this._newBeanInner(false, targetBeanFullName, selectorInfo.withSelector, ...selectorInfo.args);
-        }
-        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[SymbolModuleBelong]}.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 Reflect.get(target, prop, receiver);
-                }
-                if (__isInnerMethod(prop)) {
-                    return Reflect.get(target, prop, receiver);
-                }
-                // descriptorInfo
-                const descriptorInfo = __getPropertyDescriptor(target, prop);
-                if (!__checkAopOfDescriptorInfo(descriptorInfo))
-                    return Reflect.get(target, prop, receiver);
-                const methodType = __methodTypeOfDescriptor(descriptorInfo);
-                // get prop
-                if (!methodType) {
-                    if (__isLifeCycleMethod(prop))
-                        return Reflect.get(target, prop, receiver);
-                    const methodName = `__get_${prop}__`;
-                    const methodNameMagic = '__get__';
-                    const _aopChainsProp = self._getAopChainsProp(beanFullName, methodName, methodNameMagic, 'get', prop);
-                    if (!_aopChainsProp)
-                        return Reflect.get(target, prop, receiver);
-                    // aop
-                    return _aopChainsProp([receiver, undefined], ([receiver, _]) => {
-                        if (!descriptorInfo && target.__get__) {
-                            return Reflect.apply(target.__get__, receiver, [prop, target]);
-                        }
-                        else {
-                            return Reflect.get(target, prop, receiver);
-                        }
-                    });
-                }
-                // method
-                return self._getInstanceMethodProxy(beanFullName, target, prop, receiver);
-            },
-            set(target, prop, value, receiver) {
-                if (typeof prop === 'symbol') {
-                    Reflect.set(target, prop, value, receiver);
-                    return true;
-                }
-                if (__isInnerMethod(prop)) {
-                    Reflect.set(target, prop, value, receiver);
-                    return true;
-                }
-                // descriptorInfo
-                const descriptorInfo = __getPropertyDescriptor(target, prop);
-                if (!__checkAopOfDescriptorInfo(descriptorInfo)) {
-                    Reflect.set(target, prop, value, receiver);
-                    return true;
-                }
-                const methodName = `__set_${prop}__`;
-                const methodNameMagic = '__set__';
-                const _aopChainsProp = self._getAopChainsProp(beanFullName, methodName, methodNameMagic, 'set', prop);
-                if (!_aopChainsProp) {
-                    Reflect.set(target, prop, value, receiver);
-                    return true;
-                }
-                // aop
-                return _aopChainsProp([receiver, value], ([receiver, value]) => {
-                    if (!descriptorInfo && target.__set__) {
-                        const res = Reflect.apply(target.__set__, receiver, [prop, value, target]);
-                        if (res === undefined)
-                            throw new Error('__set__ must return true/false');
-                        if (!res) {
-                            Reflect.set(target, prop, value, receiver);
-                        }
-                    }
-                    else {
-                        Reflect.set(target, prop, value, receiver);
-                    }
-                    // ok: prop be set
-                    return true;
-                });
-            },
-        });
-    }
-    _getInstanceMethodProxy(beanFullName, target, prop, receiver) {
-        // not aop magic methods
-        if (__isInnerMethod(prop)) {
-            return Reflect.get(target, prop, receiver);
-        }
-        // aop chains
-        const methodNameMagic = '__method__';
-        const _aopChainsProp = this._getAopChainsProp(beanFullName, prop, methodNameMagic, 'method', prop);
-        if (!_aopChainsProp)
-            return Reflect.get(target, prop, receiver);
-        // proxy
-        const methodProxyKey = `__aopproxy_method_${prop}__`;
-        if (target[methodProxyKey])
-            return target[methodProxyKey];
-        const methodProxy = new Proxy(target[prop], {
-            apply(target, thisArg, args) {
-                // aop
-                return _aopChainsProp([thisArg, args], ([thisArg, args]) => {
-                    return Reflect.apply(target, thisArg, args);
-                });
-            },
-        });
-        __setPropertyValue(target, methodProxyKey, methodProxy);
-        return methodProxy;
-    }
-    _prepareAopChains(beanFullNameOrBeanClass, beanInstance) {
-        if (!beanFullNameOrBeanClass)
-            return [];
-        // beanFullName maybe class
-        const beanOptions = appResource.getBean(beanFullNameOrBeanClass);
-        const cacheKey = beanOptions?.beanFullName || beanFullNameOrBeanClass;
-        // ProxyDisable
-        const proxyDisable = beanOptions?.beanClass ? appMetadata.getMetadata(SymbolDecoratorProxyDisable, beanOptions?.beanClass) : false;
-        // host
-        const host = this._aopCacheHost();
-        if (!host[SymbolCacheAopChains])
-            host[SymbolCacheAopChains] = {};
-        if (host[SymbolCacheAopChains][cacheKey])
-            return host[SymbolCacheAopChains][cacheKey];
-        // chains
-        let chains = [];
-        // aop
-        if (!proxyDisable && beanOptions && cast(beanOptions.scene) !== 'aop') {
-            const beanAop = this.app.bean._getBean('a-aspectutils.service.aop');
-            const aops = beanAop.findAopsMatched(beanOptions.beanFullName);
-            if (aops) {
-                chains = chains.concat(aops);
-            }
-        }
-        // aop method
-        if (!proxyDisable && beanOptions) {
-            const beanAop = this.app.bean._getBean('a-aspectutils.service.aop');
-            if (beanAop.hasAopMethods(beanOptions?.beanFullName)) {
-                chains.push(SymbolProxyAopMethod);
-            }
-        }
-        // magic self
-        if (__hasMagicMethod(beanInstance)) {
-            chains.push(SymbolProxyMagic);
-        }
-        // hold
-        host[SymbolCacheAopChains][cacheKey] = chains;
-        return chains;
-    }
-    _getAopChains(beanFullName) {
-        // beanFullName maybe class
-        const beanOptions = appResource.getBean(beanFullName);
-        const cacheKey = beanOptions?.beanFullName || beanFullName;
-        const host = this._aopCacheHost();
-        return host[SymbolCacheAopChains]?.[cacheKey] || [];
-    }
-    _aopCacheHost() {
-        if (!this.app)
-            throw new Error('Perhaps missing await');
-        return this.app;
-    }
-    _getAopChainsProp(beanFullName, methodName, methodNameMagic, methodType, prop) {
-        const chainsKey = `__aopChains_${methodName}__`;
-        const beanOptions = appResource.getBean(beanFullName);
-        const cacheKey = beanOptions?.beanFullName || beanFullName;
-        const host = this._aopCacheHost();
-        if (!host[SymbolCacheAopChainsKey])
-            host[SymbolCacheAopChainsKey] = {};
-        if (!host[SymbolCacheAopChainsKey][cacheKey])
-            host[SymbolCacheAopChainsKey][cacheKey] = {};
-        if (host[SymbolCacheAopChainsKey][cacheKey][chainsKey] !== undefined)
-            return host[SymbolCacheAopChainsKey][cacheKey][chainsKey];
-        const _aopChains = this._getAopChains(beanFullName);
-        const chains = [];
-        for (const aopKey of _aopChains) {
-            if (aopKey === SymbolProxyMagic) {
-                if (!__isLifeCycleMethod(methodName)) {
-                    chains.push([aopKey, methodName]);
-                }
-            }
-            else if (aopKey === SymbolProxyAopMethod) {
-                this._getAopChainsProp_aopMethods(chains, aopKey, beanFullName, methodType, prop);
-            }
-            else {
-                // singleton
-                const aop = this.app.bean._getBean(aopKey);
-                if (aop[methodName]) {
-                    let fn;
-                    if (methodType === 'get') {
-                        fn = function ([receiver, _], next) {
-                            return aop[methodName](_patchAopNext([receiver, _], next), receiver);
-                        };
-                    }
-                    else if (methodType === 'set') {
-                        fn = function ([receiver, value], next) {
-                            return aop[methodName](value, _patchAopNext([receiver, value], next), receiver);
-                        };
-                    }
-                    else if (methodType === 'method') {
-                        fn = function ([receiver, args], next) {
-                            return aop[methodName](args, _patchAopNext([receiver, args], next), receiver);
-                        };
-                    }
-                    chains.push([aopKey, fn]);
-                }
-                if (methodNameMagic && aop[methodNameMagic]) {
-                    if (!__isLifeCycleMethod(methodName)) {
-                        let fn;
-                        if (methodType === 'get') {
-                            fn = function ([receiver, _], next) {
-                                return aop[methodNameMagic](prop, _patchAopNext([receiver, _], next), receiver);
-                            };
-                        }
-                        else if (methodType === 'set') {
-                            fn = function ([receiver, value], next) {
-                                return aop[methodNameMagic](prop, value, _patchAopNext([receiver, value], next), receiver);
-                            };
-                        }
-                        else if (methodType === 'method') {
-                            fn = function ([receiver, args], next) {
-                                return aop[methodNameMagic](prop, args, _patchAopNext([receiver, args], next), receiver);
-                            };
-                        }
-                        chains.push([aopKey, fn]);
-                    }
-                }
-            }
-        }
-        let result;
-        if (chains.length === 0) {
-            result = null;
-        }
-        else {
-            result = __composeForProp(chains);
-        }
-        host[SymbolCacheAopChainsKey][cacheKey][chainsKey] = result;
-        return result;
-    }
-    _getAopChainsProp_aopMethods(chains, aopKey, beanFullName, methodType, prop) {
-        const beanAop = this.app.bean._getBean('a-aspectutils.service.aop');
-        const aopMethods = beanAop.findAopMethodsMatched(beanFullName, prop);
-        for (const aopMethod of aopMethods) {
-            let fn;
-            if (methodType === 'get') {
-                fn = function ([receiver, _], next) {
-                    if (!aopMethod.beanInstance.get)
-                        throw new Error(`get property accessor not exists: ${aopMethod.onionName}`);
-                    return aopMethod.beanInstance.get(aopMethod.options, _patchAopNext([receiver, _], next), receiver, prop);
-                };
-            }
-            else if (methodType === 'set') {
-                fn = function ([receiver, value], next) {
-                    if (!aopMethod.beanInstance.set)
-                        throw new Error(`set property accessor not exists: ${aopMethod.onionName}`);
-                    return aopMethod.beanInstance.set(aopMethod.options, value, _patchAopNext([receiver, value], next), receiver, prop);
-                };
-            }
-            else if (methodType === 'method') {
-                fn = function ([receiver, args], next) {
-                    if (!aopMethod.beanInstance.execute)
-                        throw new Error(`execute method not exists: ${aopMethod.onionName}`);
-                    return aopMethod.beanInstance.execute(aopMethod.options, args, _patchAopNext([receiver, args], next), receiver, prop);
-                };
-            }
-            chains.push([aopKey, fn]);
-        }
-    }
-}
-function __composeForPropAdapter(_context, chain) {
-    const [aopKey, fn] = chain;
-    // SymbolProxyMagic
-    if (aopKey === SymbolProxyMagic)
-        return;
-    // chain
-    return {
-        receiver: undefined,
-        fn,
-    };
-}
-function __composeForProp(chains) {
-    return compose(chains, __composeForPropAdapter);
-}
-function _patchAopNext([receiver, context], next) {
-    return (...args) => {
-        context = args.length === 0 ? context : args[0];
-        return next([receiver, context]);
-    };
-}
-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.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 __hasMagicMethod(instance) {
-    return !!instance.__get__ || !!instance.__set__;
-}
-function __isInnerMethod(prop) {
-    return [
-        '__get__',
-        '__set__',
-        // '__init__',
-        // '__dispose__',
-        'then',
-        '__v_isShallow',
-        '__v_isReadonly',
-        '__v_raw',
-    ].includes(prop);
-}
-function __isLifeCycleMethod(prop) {
-    return ['__init__', '__dispose__'].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;
-}
-// same as _getBean if selector is undefined/null/'', as as to get the same bean instance
-//   not use !selector which maybe is 0
-function __getSelectorKey(beanFullName, withSelector, selector) {
-    if (!withSelector)
-        return beanFullName;
-    const isSelectorValid = !isNilOrEmptyString(selector);
-    return !isSelectorValid ? beanFullName : `${beanFullName}#${selector}`;
-}

package/dist/lib/bean/beanSimple.js

@@ -1,9 +0,0 @@
-export class BeanSimple {
-    app;
-    get ctx() {
-        return this.app.currentContext;
-    }
-    get bean() {
-        return this.app.bean;
-    }
-}

package/dist/lib/bean/index.js

@@ -1,9 +0,0 @@
-export * from "./beanAopBase.js";
-export * from "./beanAopMethodBase.js";
-export * from "./beanBase.js";
-export * from "./beanBaseSimple.js";
-export * from "./beanContainer.js";
-export * from "./beanSimple.js";
-export * from "./resource/index.js";
-export * from "./scope/index.js";
-export * from "./type.js";

package/dist/lib/bean/resource/config/index.js

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

package/dist/lib/bean/resource/config/type.js

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

package/dist/lib/bean/resource/constant/index.js

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

package/dist/lib/bean/resource/constant/type.js

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

package/dist/lib/bean/resource/error/beanScopeError.js

@@ -1,17 +0,0 @@
-import { BeanSimple } from "../../beanSimple.js";
-import { BeanScopeErrorImpl } from "./beanScopeErrorImpl.js";
-const BeanModuleScope = Symbol('BeanScopeError#ModuleScope');
-export class BeanScopeError extends BeanSimple {
-    [BeanModuleScope];
-    __instances = {};
-    constructor(moduleScope) {
-        super();
-        this[BeanModuleScope] = moduleScope;
-    }
-    __get__(prop) {
-        if (!this.__instances[prop]) {
-            this.__instances[prop] = this.bean._newBean(BeanScopeErrorImpl, this[BeanModuleScope], prop);
-        }
-        return this.__instances[prop];
-    }
-}

package/dist/lib/bean/resource/error/beanScopeErrorImpl.js

@@ -1,18 +0,0 @@
-import { BeanSimple } from "../../beanSimple.js";
-const BeanModuleScope = Symbol('BeanScopeError#ModuleScope');
-const BeanErrorCode = Symbol('BeanScopeError#BeanErrorCode');
-export class BeanScopeErrorImpl extends BeanSimple {
-    [BeanModuleScope];
-    [BeanErrorCode];
-    constructor(moduleScope, errorCode) {
-        super();
-        this[BeanModuleScope] = moduleScope;
-        this[BeanErrorCode] = errorCode;
-    }
-    throw(...args) {
-        return this.app.meta.error.throw(this[BeanModuleScope], this[BeanErrorCode], ...args);
-    }
-    parseFail(...args) {
-        return this.app.meta.error.parseFail(this[BeanModuleScope], this[BeanErrorCode], ...args);
-    }
-}

package/dist/lib/bean/resource/error/errorApplication.js

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