vona-core 1.0.0 → 5.0.9

package/dist/lib/bean/beanContainer.js

@@ -0,0 +1,578 @@
+import { 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 { isClass } from "../utils/isClass.js";
+import { compose } from "../utils/util.js";
+import { BeanAopBase } from "./beanAopBase.js";
+import { BeanBase } from "./beanBase.js";
+import { SymbolBeanFullName } 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) {
+            if (prop.startsWith('$$'))
+                continue;
+            const beanInstance = cast(beanInstances[prop]);
+            if (beanInstance && !(beanInstance instanceof BeanAopBase) && beanInstance.__dispose__) {
+                await beanInstance.__dispose__();
+            }
+        }
+        this[SymbolBeanContainerInstances] = {};
+    }
+    // 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]);
+                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 _aopChainsProp = this._getAopChainsProp(beanFullName, prop, undefined, '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-aspect.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-aspect.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]);
+                }
+                else 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-aspect.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.d.ts

@@ -0,0 +1,7 @@
+import type { VonaContext } from '../../types/index.ts';
+import type { VonaApplication } from '../core/application.ts';
+export declare class BeanSimple {
+    protected app: VonaApplication;
+    protected get ctx(): VonaContext;
+    protected get bean(): import("./beanContainer.ts").BeanContainer;
+}

package/dist/lib/bean/beanSimple.js

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

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

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

package/dist/lib/bean/index.js

@@ -0,0 +1,9 @@
+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.d.ts

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

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

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

package/dist/lib/bean/resource/config/type.d.ts

@@ -0,0 +1,2 @@
+import type { VonaApplication } from '../../../../index.ts';
+export type TypeModuleConfig<T extends (app: VonaApplication) => object> = ReturnType<T>;

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

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

package/dist/lib/bean/resource/constant/index.d.ts

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

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

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

package/dist/lib/bean/resource/constant/type.d.ts

@@ -0,0 +1 @@
+export type TypeModuleConstants<T> = T;

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

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