@teqfw/di 0.22.0 → 0.30.1

package/README.md

@@ -1,265 +1,227 @@
 # @teqfw/di
 
-A Dependency Injection container for regular JavaScript is provided, which can be used in both _browser_ and _Node.js_
-applications. This library exclusively supports ES6 modules. The primary objective of this library is late binding with
-_minimal manual configuration_ for the container. All linking instructions are encapsulated within the dependency
-identifiers and source path resolver. Additionally, the container offers the capability to modify object identifiers
-(_preprocessing_) and the created objects (_postprocessing_). These features enable you to more comprehensively
-distribute the necessary functionality across npm packages and reuse npm packages in different projects, following a '
-_modular monolith_' architecture (see the [sample](https://github.com/flancer64/demo-di-app)).
-
-## Inversion of Control
-
-The primary motivation for creating this library was the concept that JavaScript is a language in which the entire
-application can be written, both on the front end and the back end. The idea was to enable the use of the same
-JavaScript code seamlessly on both the front end and the back end without requiring any changes, including additional
-transpilation.
-
-The main challenge encountered along this path was static importing. When the entire application can fit into a single
-npm package, all sources can be linked to each other through relative paths. However, if the sources are distributed
-across different npm packages, addressing them becomes problematic:
-
-```javascript
-import something from '@vendor/package/src/Module.js'; // backend style
-import something from 'https://domain.com/@vendor/package/src/Module.js'; // frontend style
-```
+![npms.io](https://img.shields.io/npm/dm/@teqfw/di)
+![jsdelivr](https://img.shields.io/jsdelivr/npm/hm/@teqfw/di)
+
+
+`@teqfw/di` is a dependency injection container for standard JavaScript. This library is compatible with both browser
+and Node.js environments.
+
+**This library only supports ES6 modules ([the live demo](https://flancer64.github.io/demo-di-app/)).**
+
+More samples:
+
+* [demo-wa-esm-openai](https://github.com/flancer64/demo-wa-esm-openai)
+* [pwa-wallet](https://github.com/flancer64/pwa-wallet)
+* [spa-remote-console](https://github.com/flancer64/spa-remote-console)
+* [demo-webauthn-pubkey](https://github.com/flancer64/demo-webauthn-pubkey)
+* [tg-bot-habr-demo-grammy](https://github.com/flancer64/tg-bot-habr-demo-grammy)
 
-The inversion of control (IoC) design pattern came to the rescue. In this pattern, any software object with external
-dependencies provides a mechanism for obtaining these dependencies. The external environment, whether it's a test unit
-or an object container, is responsible for creating these dependencies and providing them to the software object.
+This library is primarily designed to simplify the binding of code objects with minimal manual configuration required
+for the object container. All instructions related to connections are encapsulated within the dependency identifiers
+used in constructors or factory functions, as per the constructor injection scheme:
+
+```js
+export default class App_Main {
+    constructor(
+        {
+            App_Config$: config,
+            App_Logger$: logger,
+            App_Service_Customer$: servCustomer,
+            App_Service_Sale$: servSale,
+        }
+    ) { ... }
 
-```javascript
-// constructor-based injection
-class Service {
-  constructor(config, logger) {}
 }
 ```
 
-If all dependencies are added to software objects through a similar mechanism, there is no need to use static imports in
-the source code itself. Now, they can be used without any changes, both on the front end and on the back end.
+Corresponding files would look like this:
 
-## Object Container
+```
+./src/
+    ./Service/
+        ./Customer.js
+        ./Sale.js
+    ./Config.js
+    ./Logger.js
+    ./Main.js
+```
 
-Many programming languages implement the Dependency Injection pattern. In this pattern, an application typically
-utilizes an object container, responsible for creating all the application's objects and their dependencies. The
-`@teqfw/di` package provides precisely such an object container (`src/Container.js`). This object container is
-initialized and configured at the outset of application execution, after which it assumes responsibility for creating
-the remaining application objects:
+Setting up object mapping is fairly simple:
 
-```javascript
+```js
 import Container from '@teqfw/di';
 
 const container = new Container();
 const resolver = container.getResolver();
-resolver.addNamespaceRoot('App_', pathApp);
-resolver.addNamespaceRoot('Sample_Lib_', pathLib);
+resolver.addNamespaceRoot('App_', '/path/to/src'); // or 'https://cdn.jsdelivr.net/npm/@vendor/pkg@latest/src'
 const app = await container.get('App_Main$');
 ```
 
-Since JavaScript does not have its own namespaces, similar to packages in Java and namespaces in PHP, the experience of
-[Zend 1](https://framework.zend.com/manual/2.4/en/migration/namespacing-old-classes.html) is used as the basis for
-identifiers.
-
-## Namespaces
-
-The primary purpose of namespaces is to address code elements within an application. In JavaScript (JS) applications,
-code is organized into npm packages, within which the sources reside in files and directories. Each npm package and its
-root directory can be linked to a namespace:
-
-```
-Vendor_Package_ => /home/user/app/node_modules/@vendor/package/src/....
-```
-
-This way, you can reference any ES6 module in any npm package:
+While it could potentially be used with TypeScript, the current algorithm for composing
+dependency identifiers, designed for JavaScript, may not be suitable for TypeScript. A different approach for composing
+identifiers and mapping them to the corresponding objects in the transpiled codebase would be required, which is beyond
+the current scope of the package.
 
-```
-Venodr_Package_Shared_Dto_Service_Save => /home/user/app/node_modules/@vendor/package/src/Shared/Dto/Service/Save.js 
-```
+## Key Features
 
-Depending on the execution environment, the mapping may be different:
+* **Late Binding**: Experience all the usual benefits of late binding at runtime including flexibility, testability,
+  modularity, manageability, and a clear separation of concerns.
+* **ES6 Modules Integration**: Seamlessly utilize singletons and instances based on ES6 module exports.
+* **Interface Usage in Standard JavaScript**: Take advantage of "interfaces" in standard JavaScript, with the added
+  benefit of dependency substitution.
+* **Object Wrapping**: Enhance the functionality of created objects by adding wrappers (postprocessing).
 
-```
-Vendor_Package_ => /home/user/app/node_modules/@vendor/package/src    // Linux style
-Vendor_Package_ => C:\projects\app\node_modules\@vendor\package\src   // Window style
-Vendor_Package_ => https://unpkg.com/@vendor/package/src              // Web style
-```
+## Installation
 
-The source code employs namespaces to reference dependencies, while the object container utilizes a resolver to
-translate the namespace into the corresponding path to the source code file, contingent upon the runtime environment:
+Installation instructions for Node.js:
 
-```
-Venodr_Package_Shared_Dto_Service_Save => /home/user/app/node_modules/@vendor/package/src/Shared/Dto/Service/Save.js
-Venodr_Package_Shared_Dto_Service_Save => C:\projects\app\node_modules\@vendor\package\src\Shared\Dto\Service\Save.js
-Venodr_Package_Shared_Dto_Service_Save => https://unpkg.com/@vendor/package/src/Shared/Dto/Service/Save.js
+```shell
+$ npm i --save @teqfw/di
 ```
 
-## Dependency Specification
-
-JavaScript lacks reflection capabilities similar to Java or PHP. Consequently, to enable the object container to
-comprehend the necessary dependencies for creating a specific object, a distinct convention is employed - a dependency
-specification. A dependency specification is an object where each key represents the identifier of the required
-dependency:
+```js
+import Container from '@teqfw/di';
+import {platform} from 'node:process';
 
-```javascript
-class Service {
-  constructor(
-          {
-            App_Config: config,
-            App_Logger: logger
-          }
-  ) {}
-}
+/** @type {TeqFw_Di_Container} */
+const container = new Container();
+/** @type {TeqFw_Di_Container_Resolver} */
+const resolver = res.getResolver();
+resolver.setWindowsEnv(platform === 'win32');
+resolver.addNamespaceRoot('App_', '...');
+const app = await container.get('App_Main$');
 ```
 
-In the object container, the required object is created as follows:
+Installation instructions for Web as ESM (~5Kb):
 
-```javascript
-const App_Config = await container.get('App_Config');
-const App_Logger = await container.get('App_Logger');
-const spec = {App_Config, App_Logger};
-const obj = new Service(spec);
-```
+```html
 
-If dependencies are injected into a factory function, it appears as follows:
+<script type="module">
+    import {default as Container} from 'https://cdn.jsdelivr.net/npm/@teqfw/di@latest/+esm';
 
-```javascript
-function Factory({App_Config: config, App_Logger: logger}) {
-  // perform operations with dependencies and compose the result
-  return res;
-}
+    /** @type {TeqFw_Di_Container} */
+    const container = new Container();
+    /** @type {TeqFw_Di_Container_Resolver} */
+    const resolver = res.getResolver();
+    resolver.addNamespaceRoot('App_', 'https://cdn.jsdelivr.net/npm/@flancer64/demo-di-app@0.2/src');
+    resolver.addNamespaceRoot('Sample_Lib_', 'https://cdn.jsdelivr.net/npm/@flancer64/demo-di-lib@0.3/src');
+    const app = await container.get('App_Main$');
+    ...
+</script>
 ```
 
-## Es6 export
+Installation instructions for Web as UMD (~5Kb):
 
-In ES6+, a distinct building block in application development is the act
-of [exporting](https://flancer32.com/es6-export-as-code-brick-b33a8efb3510):
+```html
 
-```javascript
-export {
-  obj1 as default, obj2, obj3
-};
+<script src="https://cdn.jsdelivr.net/npm/@teqfw/di@latest/dist/umd.js"></script>
+<script type="module">
+    const {default: Container} = window.TeqFw_Di_Container;
+    /** @type {TeqFw_Di_Container} */
+    const container = new Container();
+    ...
+</script>
 ```
 
-Static linking through imports is performed at the level of these building blocks:
+## Dependency ID Types
 
-````javascript
-import obj1 from './mod.js';
-import {obj2} from './mod.js';
-````
+Different Dependency IDs can be used for different imports, such as:
 
-This implies that the dependency identifier must have the capability to reference not only the ES6 module itself but
-also a specific export within it, as illustrated in this example:
+### Import whole module as ES module
 
-```javascript
-const exp = 'Vendor_Package_Module.export';
-const def = 'Vendor_Package_Module.default';
-const obj2 = 'Vendor_Package_Module.obj2';
+```js
+// App_Service
+import * as Service from './App/Service.js';
 ```
 
-In this case, the dependency declaration in a constructor or factory function could look like this:
+### Import default export as is
 
-```javascript
-class Service {
-  constructor(
-          {
-            'App_Config.default': config,
-            'App_Util.logger': logger
-          }
-  ) {}
-}
+```js
+// App_Service.default
+import {default} from './App/Service.js';
 ```
 
-## Late binding
+### Import named export as is
 
-The object container links objects not at the source code level but in runtime mode. In my applications, I have
-encountered two particularly useful runtime object lifecycles:
+```js
+// App_Service.name
+import {name} from './App/Service.js';
+```
 
-* **Singleton**: It exists in a single instance within the application.
-* **Instance**: A new object is created each time.
+### Use default export as a singleton for container
 
-Since any string can be used as an object key in a dependency specification, various formats can be devised to specify
-the lifecycle of the required dependency. I have personally chosen the following format:
+```js
+// App_Service$
+import {default as Factory} from './App/Service.js';
 
-```javascript
-const asIs = 'Vendor_Package_Module.default';
-const asSingleton = 'Vendor_Package_Module.default$';
-const asInstance = 'Vendor_Package_Module.default$$';
+return res ?? (res = Factory({/* deps */}));
 ```
 
-In principle, each package can have its own format for describing the dependencies it uses internally. The
-`TeqFw_Di_Container_Parser` object is responsible for applying the appropriate format within the required namespace.
+### Create a new default export as Instance for each dependency
 
-## Transforming the Result
+```js
+// App_Service$$
+import {default as Factory} from './App/Service.js';
 
-Here are the steps for the object container:
+return Factory({/* deps */});
+```
 
-![processing steps](https://raw.githubusercontent.com/teqfw/di/main/doc/img/teqfw_di_container_steps.png)
+### Use named export as singleton.
 
-There are two stages involved here:
+```js
+// App_Service.name$
+import {name} from './App/Service.js';
 
-* **Preprocessing**: the modification of the dependency identifier
-* **Postprocessing**: the modification of the created object
+return res ?? (res = name({/* deps */}));
+```
 
-### Preprocessing
+### Create a new named export as instance
 
-At times, situations may arise, especially when utilizing various extensions of the core functionality, where it becomes
-necessary to redefine certain objects within the application. For such scenarios, `@teqfw/di` includes a preprocessor:
+```js
+// App_Service.name$$
+import {name} from './App/Service.js';
 
-```javascript
-/** @type {TeqFw_Di_Api_Container_PreProcessor} */
-const pre = container.getPreProcessor();
+return name({/* deps */});
 ```
 
-You can add handlers (chunks) to the preprocessor that are capable of modifying the initial `depId`:
+### Add custom wrappers to created objects in postprocessing
 
-```javascript
-/** @type {TeqFw_Di_Api_Container_PreProcessor_Chunk} */
-const replace = new ReplaceChunk(); // some implementation of the interface
-pre.addChunk(replace);
-```
+```js
+// App_Service.name$$(proxy)
+import {name} from './App/Service.js';
 
-The preprocessor calls the handlers sequentially and can, for example, replace a dependency from the base npm package
-(`App_Base_Mod_Api_Service_Auth`) with another dependency from one of the npm packages (`Auth_Password_Mod_Service` or
-`OAuth2_Mod_Service`), depending on the npm packages included in the application compilation.
-
-By using such replacements, you can implement the core functionality in one npm package, while in other npm packages,
-you can implement the additional functionality required by the core package.
-
-### Postprocessing
-
-Since the container creates all objects in the application, it can also perform additional actions on newly created
-objects, such as adding extra functionality to them in the form of a wrapper.
-
-`@teqfw/di` enables you to add individual handlers to the post-processing stage and modify the result. For example, you
-can wrap a finished object or perform various operations on it:
-
-```javascript
-// ./PostChunk.js
-/**
- * @implements TeqFw_Di_Api_Container_PostProcessor_Chunk
- */
-export default {
-    modify: function (obj, originalId, stack) {
-        if (originalId.wrappers.indexOf('proxy') !== -1)
-            return new Proxy(obj, {
-                get: async function (base, name) { /* do something */ }
-            });
-        else return obj;
-    }
-};
+const res = name({/* deps */});
+return proxy(res); // use a handler on the postprocessing
 ```
 
-```javascript
-// ./main.js
-import postChunk from './PostChunk.mjs';
+### Brief overview
 
-container.getPostProcessor().addChunk(postChunk);
+```js
+export default class App_Main {
+  constructor(
+          {
+            App_Service: EsModule,
+            'App_Service.default': defaultExportAsIs,
+            'App_Service.name': namedExportAsIs,
+            App_Service$: defaultExportAsSingleton,
+            App_Service$$: defaultExportAsInstance,
+            'App_Service.name$': namedExportAsSingleton,
+            'App_Service.name$$': namedExportAsInstance,
+            'App_Service.name(factory)': factoryToCreateInstancesFromNamedExport,
+          }
+  ) {
+    const {default: SrvDef, name: SrvName} = EsModule; // deconstruct the module and access the exports 
+  }
+
+}
 ```
 
-## Resume
+## Summary
 
-`@teqfw/di` offers Dependency Injection for regular JavaScript with minimal manual configuration, supporting both
-browser and Node.js environments. Its use of late binding and an object container in JavaScript applications, along with
-the ability to modify the behavior of created objects (via pseudo-interfaces and wrappers), allows you to apply
-architectural solutions from other languages (such as Java, PHP, C#) and fully harness the capabilities of npm packages
-and ES6 modules in JavaScript applications, particularly in the Node.js environment.
+The `@teqfw/di` module provides a Dependency Injection feature for JavaScript, which requires minimal manual setup. This
+library is functional in both browser and Node.js settings. The module utilizes late binding and an object container
+methodology in JavaScript applications. Furthermore, it equips users with the ability to alter object behaviors through
+pseudo-interfaces and wrappers. As a result, architectural solutions from other programming languages - namely Java,
+PHP, and C# - can be harnessed effectively. This also contributes significantly by maximizing the efficiency of npm
+packages and ES6 modules in JavaScript applications, especially within the Node.js environment.

package/RELEASE.md

@@ -1,5 +1,14 @@
 # @teqfw/di releases
 
+## 0.30.1
+
+* Improve the README.
+
+## 0.30.0
+
+* New format of the depId for default parser (`Ns_Module.export$$(post)`).
+* The rollup is added.
+
 ## 0.22.0
 
 * Add Windows paths to the Resolver.

package/bin/release/clean.sh

@@ -6,6 +6,7 @@ DIR_ROOT=${DIR_ROOT:-$(cd "$(dirname "$0")/../../" && pwd)}
 
 rm -fr "${DIR_ROOT}/demo/"
 rm -fr "${DIR_ROOT}/doc/"
+rm -fr "${DIR_ROOT}/docs/"
 rm -fr "${DIR_ROOT}/example/"
 rm -fr "${DIR_ROOT}/node_modules/"
 rm -fr "${DIR_ROOT}/test/"

package/dist/esm.js

@@ -0,0 +1 @@
+var e={COMP_A:"A",COMP_F:"F",ID:"container",ID_FQN:"TeqFw_Di_Container$",LIFE_I:"I",LIFE_S:"S",isClass(e){const t=Object.getOwnPropertyDescriptor(e,"prototype");return t&&!t.writable}};const t=/(function)*\s*\w*\s*\(\s*\{([^\}]*)\}/s,o=/constructor\s*\(\s*\{([^\}]*)\}/s;function s(e){const t=[];try{const o=new Function(`{${e}}`,"return");o(new Proxy({},{get:(e,o)=>t.push(o)}))}catch(t){throw new Error(`Cannot analyze the deps specification:${e}\n\nPlease, be sure that spec does not contain extra ')' in a comments.\n\nError: ${t}`)}return t}function n(n){return"function"==typeof n?e.isClass(n)?function(e){const t=[],n=e.toString(),r=o.exec(n);return r&&t.push(...s(r[1])),t}(n):function(e){const o=[],n=e.toString(),r=t.exec(n);return r&&o.push(...s(r[2])),o}(n):[]}class r{constructor(){let t=!1;this.create=async function(o,s,r,i){if(r.includes(o.value))throw new Error(`Circular dependency for '${o.value}'. Parents are: ${JSON.stringify(r)}`);if(o.exportName){const a=[...r,o.value],{[o.exportName]:u}=s;if(o.composition===e.COMP_F){if("function"==typeof u){const s=n(u);s.length&&(c=`Deps for object '${o.value}' are: ${JSON.stringify(s)}`,t&&console.log(c));const r={};for(const e of s)r[e]=await i.compose(e,a);const l=e.isClass(u)?new u(r):u(r);return l instanceof Promise?await l:l}return Object.assign({},u)}return u}return s;var c},this.setDebug=function(e){t=e}}}class i{exportName;composition;life;moduleName;value;wrappers=[]}const c=/^((([A-Z])[A-Za-z0-9_]*)((\.)?([A-Za-z0-9_]*)((\$)?(\$)?)?)?(\(([A-Za-z0-9_,]*)\))?)$/;class a{canParse(e){return!0}parse(t){const o=new i;o.value=t;const s=c.exec(t);if(s&&(o.moduleName=s[2],"."===s[5]?"$"===s[7]||"$$"===s[7]?(o.composition=e.COMP_F,o.exportName=s[6],o.life="$"===s[7]?e.LIFE_S:e.LIFE_I):(o.composition=e.COMP_A,o.life=e.LIFE_S,o.exportName=""!==s[6]?s[6]:"default"):"$"===s[7]||"$$"===s[7]?(o.composition=e.COMP_F,o.exportName="default",o.life="$"===s[7]?e.LIFE_S:e.LIFE_I):(o.composition=void 0,o.exportName=void 0,o.life=void 0),s[11]&&(o.wrappers=s[11].split(","))),o.composition===e.COMP_A&&o.life===e.LIFE_I)throw new Error(`Export is not a function and should be used as a singleton only: '${o.value}'.`);return o}}class u{constructor(){let e=new a;const t=[];this.addChunk=function(e){t.push(e)},this.parse=function(o){let s;for(const e of t)if(e.canParse(o)){s=e.parse(o);break}return s||(s=e?.parse(o)),s},this.setDefaultChunk=function(t){e=t}}}class l{constructor(){const e=[];this.addChunk=function(t){e.push(t)},this.modify=function(t,o){let s=t;for(const n of e)s=n.modify(s,t,o);return s}}}class f{constructor(){const e=[];this.addChunk=function(t){e.push(t)},this.modify=async function(t,o,s){let n=t;for(const t of e)n=t.modify(n,o,s),n instanceof Promise&&(n=await n);return n}}}const p="ext",m="ns",d="root";class h{constructor(){const e={};let t=!1,o=[],s="/";this.addNamespaceRoot=function(s,n,r){const i=(t?n.replace(/^\\/,""):n).replace(/\\/g,"/"),c=t?`file://${i}`:i;e[s]={[p]:r??"js",[m]:s,[d]:c},o=Object.keys(e).sort(((e,t)=>t.localeCompare(e)))},this.resolve=function(t){let n,r,i;for(i of o)if(t.startsWith(i)){n=e[i][d],r=e[i].ext;break}if(n&&r){let e=t.replace(i,"");0===e.indexOf("_")&&(e=e.replace("_",""));const o=e.replaceAll("_",s);return`${n}${s}${o}.${r}`}return t},this.setWindowsEnv=function(e=!0){t=e,s=e?"\\":"/"}}}function $(e){return`${e.moduleName}#${e.exportName}`}class w{constructor(){let t=new r,o=!1,s=new u,n=new l,i=new f;const c={},a={};let p=new h;function m(){o&&console.log(...arguments)}this.get=async function(e){return this.compose(e,[])},this.compose=async function(o,r=[]){if(m(`Object '${o}' is requested.`),o===e.ID||o===e.ID_FQN)return m("Container itself is returned."),a[e.ID];const u=s.parse(o),l=n.modify(u,r);if(l.life===e.LIFE_S){const e=$(l);if(a[e])return m(`Existing singleton '${e}' is returned.`),a[e]}let f;c[l.moduleName]||(m(`ES6 module '${l.moduleName}' is not resolved yet`),c[l.moduleName]=p.resolve(l.moduleName));const d=c[l.moduleName];try{f=await import(d),m(`ES6 module '${l.moduleName}' is loaded from '${d}'.`)}catch(e){throw console.error(e?.message,`Object key: "${o}".`,`Path: "${d}".`,`Stack: ${JSON.stringify(r)}`),e}let h=await t.create(l,f,r,this);if(h=await i.modify(h,l,r),m(`Object '${o}' is created.`),l.life===e.LIFE_S){const e=$(l);a[e]=h,m(`Object '${o}' is saved as singleton.`)}return h},this.getParser=()=>s,this.getPreProcessor=()=>n,this.getPostProcessor=()=>i,this.getResolver=()=>p,this.setDebug=function(e){o=e,t.setDebug(e)},this.setParser=e=>s=e,this.setPreProcessor=e=>n=e,this.setPostProcessor=e=>i=e,this.setResolver=e=>p=e,a[e.ID]=this}}export{w as default};

package/dist/umd.js

@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"undefined"!=typeof module?module.exports=t():"function"==typeof define&&define.amd?define(t):(e="undefined"!=typeof globalThis?globalThis:e||self).TeqFw_Di_Container=t()}(this,(function(){"use strict";var e={COMP_A:"A",COMP_F:"F",ID:"container",ID_FQN:"TeqFw_Di_Container$",LIFE_I:"I",LIFE_S:"S",isClass(e){const t=Object.getOwnPropertyDescriptor(e,"prototype");return t&&!t.writable}};const t=/(function)*\s*\w*\s*\(\s*\{([^\}]*)\}/s,o=/constructor\s*\(\s*\{([^\}]*)\}/s;function n(e){const t=[];try{const o=new Function(`{${e}}`,"return");o(new Proxy({},{get:(e,o)=>t.push(o)}))}catch(t){throw new Error(`Cannot analyze the deps specification:${e}\n\nPlease, be sure that spec does not contain extra ')' in a comments.\n\nError: ${t}`)}return t}function s(s){return"function"==typeof s?e.isClass(s)?function(e){const t=[],s=e.toString(),r=o.exec(s);return r&&t.push(...n(r[1])),t}(s):function(e){const o=[],s=e.toString(),r=t.exec(s);return r&&o.push(...n(r[2])),o}(s):[]}class r{constructor(){let t=!1;this.create=async function(o,n,r,i){if(r.includes(o.value))throw new Error(`Circular dependency for '${o.value}'. Parents are: ${JSON.stringify(r)}`);if(o.exportName){const a=[...r,o.value],{[o.exportName]:u}=n;if(o.composition===e.COMP_F){if("function"==typeof u){const n=s(u);n.length&&(c=`Deps for object '${o.value}' are: ${JSON.stringify(n)}`,t&&console.log(c));const r={};for(const e of n)r[e]=await i.compose(e,a);const l=e.isClass(u)?new u(r):u(r);return l instanceof Promise?await l:l}return Object.assign({},u)}return u}return n;var c},this.setDebug=function(e){t=e}}}class i{exportName;composition;life;moduleName;value;wrappers=[]}const c=/^((([A-Z])[A-Za-z0-9_]*)((\.)?([A-Za-z0-9_]*)((\$)?(\$)?)?)?(\(([A-Za-z0-9_,]*)\))?)$/;class a{canParse(e){return!0}parse(t){const o=new i;o.value=t;const n=c.exec(t);if(n&&(o.moduleName=n[2],"."===n[5]?"$"===n[7]||"$$"===n[7]?(o.composition=e.COMP_F,o.exportName=n[6],o.life="$"===n[7]?e.LIFE_S:e.LIFE_I):(o.composition=e.COMP_A,o.life=e.LIFE_S,o.exportName=""!==n[6]?n[6]:"default"):"$"===n[7]||"$$"===n[7]?(o.composition=e.COMP_F,o.exportName="default",o.life="$"===n[7]?e.LIFE_S:e.LIFE_I):(o.composition=void 0,o.exportName=void 0,o.life=void 0),n[11]&&(o.wrappers=n[11].split(","))),o.composition===e.COMP_A&&o.life===e.LIFE_I)throw new Error(`Export is not a function and should be used as a singleton only: '${o.value}'.`);return o}}class u{constructor(){let e=new a;const t=[];this.addChunk=function(e){t.push(e)},this.parse=function(o){let n;for(const e of t)if(e.canParse(o)){n=e.parse(o);break}return n||(n=e?.parse(o)),n},this.setDefaultChunk=function(t){e=t}}}class l{constructor(){const e=[];this.addChunk=function(t){e.push(t)},this.modify=function(t,o){let n=t;for(const s of e)n=s.modify(n,t,o);return n}}}class f{constructor(){const e=[];this.addChunk=function(t){e.push(t)},this.modify=async function(t,o,n){let s=t;for(const t of e)s=t.modify(s,o,n),s instanceof Promise&&(s=await s);return s}}}const p="ext",d="ns",m="root";class h{constructor(){const e={};let t=!1,o=[],n="/";this.addNamespaceRoot=function(n,s,r){const i=(t?s.replace(/^\\/,""):s).replace(/\\/g,"/"),c=t?`file://${i}`:i;e[n]={[p]:r??"js",[d]:n,[m]:c},o=Object.keys(e).sort(((e,t)=>t.localeCompare(e)))},this.resolve=function(t){let s,r,i;for(i of o)if(t.startsWith(i)){s=e[i][m],r=e[i].ext;break}if(s&&r){let e=t.replace(i,"");0===e.indexOf("_")&&(e=e.replace("_",""));const o=e.replaceAll("_",n);return`${s}${n}${o}.${r}`}return t},this.setWindowsEnv=function(e=!0){t=e,n=e?"\\":"/"}}}function $(e){return`${e.moduleName}#${e.exportName}`}return class{constructor(){let t=new r,o=!1,n=new u,s=new l,i=new f;const c={},a={};let p=new h;function d(){o&&console.log(...arguments)}this.get=async function(e){return this.compose(e,[])},this.compose=async function(o,r=[]){if(d(`Object '${o}' is requested.`),o===e.ID||o===e.ID_FQN)return d("Container itself is returned."),a[e.ID];const u=n.parse(o),l=s.modify(u,r);if(l.life===e.LIFE_S){const e=$(l);if(a[e])return d(`Existing singleton '${e}' is returned.`),a[e]}let f;c[l.moduleName]||(d(`ES6 module '${l.moduleName}' is not resolved yet`),c[l.moduleName]=p.resolve(l.moduleName));const m=c[l.moduleName];try{f=await import(m),d(`ES6 module '${l.moduleName}' is loaded from '${m}'.`)}catch(e){throw console.error(e?.message,`Object key: "${o}".`,`Path: "${m}".`,`Stack: ${JSON.stringify(r)}`),e}let h=await t.create(l,f,r,this);if(h=await i.modify(h,l,r),d(`Object '${o}' is created.`),l.life===e.LIFE_S){const e=$(l);a[e]=h,d(`Object '${o}' is saved as singleton.`)}return h},this.getParser=()=>n,this.getPreProcessor=()=>s,this.getPostProcessor=()=>i,this.getResolver=()=>p,this.setDebug=function(e){o=e,t.setDebug(e)},this.setParser=e=>n=e,this.setPreProcessor=e=>s=e,this.setPostProcessor=e=>i=e,this.setResolver=e=>p=e,a[e.ID]=this}}}));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@teqfw/di",
-  "version": "0.22.0",
+  "version": "0.30.1",
   "description": "Dependency Injection container for ES6 modules that works in both browser and Node.js apps.",
   "keywords": [
     "dependency injection",
@@ -27,19 +27,16 @@
     "url": "git+https://github.com/teqfw/di.git"
   },
   "scripts": {
-    "build": "rm -fr ./dist/ && webpack build",
+    "rollup": "rollup -c",
     "test": "mocha --recursive './test/**/*.test.mjs'"
   },
   "devDependencies": {
-    "babel-eslint": "latest",
-    "eslint": "latest",
-    "esm": "latest",
-    "mocha": "latest",
-    "webpack": "latest",
-    "webpack-cli": "latest"
+    "@rollup/plugin-node-resolve": "^15.2.3",
+    "mocha": "^10.7.0",
+    "rollup": "^2.79.1",
+    "rollup-plugin-terser": "^7.0.2"
   },
-  "mocha":{
-    "require": "esm",
+  "mocha": {
     "spec": "./test/**/*.test.mjs",
     "timeout": 5000
   }

package/rollup.config.js

@@ -0,0 +1,21 @@
+import resolve from '@rollup/plugin-node-resolve';
+import {terser} from 'rollup-plugin-terser';
+
+export default {
+    input: 'src/Container.js',
+    output: [
+        {
+            file: 'dist/esm.js',
+            format: 'es'
+        },
+        {
+            file: 'dist/umd.js',
+            format: 'umd',
+            name: 'TeqFw_Di_Container',
+        }
+    ],
+    plugins: [
+        resolve(),
+        terser()
+    ]
+};

package/src/Api/Container/Resolver.js

@@ -0,0 +1,16 @@
+/**
+ * Interface for the resolver to map a module name of the dependency ID into the path to the sources.
+ *
+ * This is not executable code, it is just for documentation purposes (similar to .h files in the C/C++ language).
+ * @interface
+ */
+export default class TeqFw_Di_Api_Container_Resolver {
+
+    /**
+     * Convert the module name to the path of the source files .
+     * @param {string} moduleName 'Vendor_Package_Module'
+     * @return {string} '/home/user/app/node_modules/@vendor/package/src/Module.js'
+     */
+    resolve(moduleName) {}
+
+}

package/src/Api/Container.js

@@ -29,7 +29,7 @@ export default class TeqFw_Di_Api_Container {
     getPostProcessor() {};
 
     /**
-     * @return {TeqFw_Di_Container_Resolver}
+     * @return {TeqFw_Di_Container_Resolver} - the default resolver
      */
     getResolver() {};
 
@@ -55,7 +55,7 @@ export default class TeqFw_Di_Api_Container {
     setPostProcessor(data) {};
 
     /**
-     * @param {TeqFw_Di_Container_Resolver} data
+     * @param {TeqFw_Di_Api_Container_Resolver} data
      */
     setResolver(data) {};
 };

package/src/Container/A/Composer.js

@@ -35,7 +35,7 @@ export default class TeqFw_Di_Container_A_Composer {
                 // use export from the es6-module
                 const stackNew = [...stack, depId.value];
                 const {[depId.exportName]: exp} = module;
-                if (depId.composition === Defs.COMPOSE_FACTORY) {
+                if (depId.composition === Defs.COMP_F) {
                     if (typeof exp === 'function') {
                         // create deps for factory function
                         const deps = specParser(exp);
@@ -56,7 +56,6 @@ export default class TeqFw_Di_Container_A_Composer {
                     // just return the export (w/o factory function)
                     return exp;
             } else {
-                // TODO: this is almost useless option
                 return module;
             }
         };