assemblerjs 0.9.7 → 1.0.1

package/dist/index5.mjs

@@ -0,0 +1,90 @@
+import { clearInstance, conditionally, isDefined, pipe, isOfType, forIn, forOf, proxifyIterable } from '@assemblerjs/core';
+
+class ListenerCollection {
+    dispose() {
+        clearInstance(this, ListenerCollection);
+    }
+    add(...t) {
+        let e;
+        let l;
+        if (t.length === 2) {
+            e = t[0];
+            l = t[1];
+        } else {
+            const i = t[0];
+            e = i[0];
+            l = i[1];
+        }
+        if (!this.collection[e]) {
+            this.collection[e] = [];
+        }
+        this.collection[e].push(l);
+        return this;
+    }
+    remove(t, l) {
+        const i = (e)=>this.collection[t].splice(e, 1);
+        const n = conditionally({
+            if: ()=>this.collection[t] && this.collection[t].length === 0,
+            then: ()=>delete this.collection[t]
+        });
+        const s = conditionally({
+            if: ()=>isDefined(l),
+            then: ()=>i(this.collection[t].indexOf(l)),
+            else: ()=>delete this.collection[t]
+        });
+        const r = conditionally({
+            if: (t)=>this.has(t),
+            then: (t)=>this.collection[t]
+        });
+        pipe(r, s, n)();
+        return this;
+    }
+    has(...t) {
+        if (isOfType('string')(t[0])) {
+            return Object.keys(this.collection).includes(t[0]);
+        } else if (isOfType('function')(t[0])) {
+            return Object.values(this.collection).flat().includes(t[0]);
+        }
+        return false;
+    }
+    get(...t) {
+        if (isOfType('string')(t[0])) {
+            return this.collection[t[0]];
+        } else if (isOfType('function')(t[0])) {
+            return Object.values(this.collection).flat().filter((e)=>e === t[0]);
+        }
+        return [];
+    }
+    clear() {
+        const t = forIn(this.collection);
+        const e = (t)=>forOf(this.collection[t])((e)=>this.remove(t, e));
+        t((t)=>e(t));
+        return this;
+    }
+    get listeners() {
+        return Object.values(this.collection).flat();
+    }
+    get channels() {
+        return Object.keys(this.collection);
+    }
+    get length() {
+        return Object.values(this.collection).flat().length;
+    }
+    [Symbol.iterator]() {
+        let t = -1;
+        const e = this.collection ? Object.keys(this.collection) : [];
+        return {
+            next: ()=>({
+                    value: e[++t],
+                    done: !(t in e)
+                })
+        };
+    }
+    constructor(){
+        this.collection = {};
+        const t = proxifyIterable(this, ListenerCollection);
+        return t;
+    }
+}
+
+export { ListenerCollection };

package/dist/index6.js

@@ -0,0 +1,114 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const core = require('@assemblerjs/core');
+const listenerCollection = require('./index5.js');
+
+class EventManager {
+    dispose() {
+        this.listeners.dispose();
+        this.channels.clear();
+        this.channelCache.clear();
+        core.clearInstance(this, EventManager);
+    }
+    addChannels(...e) {
+        const s = core.forOf(e);
+        s((e)=>{
+            const n = this.cleanChannel(e);
+            if (this.channels.has(n)) {
+                throw new Error(`Channel '${n}' already exists.`);
+            }
+            this.channels.add(n);
+        });
+        return this;
+    }
+    removeChannels(...e) {
+        const s = core.forOf(e);
+        s((e)=>{
+            const n = this.cleanChannel(e);
+            if (n !== '*' && this.channels.has(n)) {
+                this.channels.delete(n);
+                this.listeners.remove(n);
+                this.onceListeners.remove(n);
+            }
+        });
+        return this;
+    }
+    on(e, n) {
+        const s = this.cleanChannel(e);
+        this.listeners.add(s, n);
+        return this;
+    }
+    once(e, n) {
+        const s = this.cleanChannel(e);
+        this.onceListeners.add(s, n);
+        return this;
+    }
+    off(e, n) {
+        const s = this.cleanChannel(e);
+        this.listeners.remove(s, n);
+        return this;
+    }
+    emit(e, ...n) {
+        const s = this.cleanChannel(e);
+        if (!this.channels.has(s)) {
+            return this;
+        }
+        const t = [
+            ...(this.onceListeners.get('*') || []).map((e)=>({
+                    listener: e,
+                    once: true,
+                    channel: '*'
+                })),
+            ...(this.listeners.get('*') || []).map((e)=>({
+                    listener: e,
+                    once: false,
+                    channel: '*'
+                })),
+            ...(this.onceListeners.get(s) || []).map((e)=>({
+                    listener: e,
+                    once: true,
+                    channel: s
+                })),
+            ...(this.listeners.get(s) || []).map((e)=>({
+                    listener: e,
+                    once: false,
+                    channel: s
+                }))
+        ];
+        for (const { listener: e, once: s, channel: h } of t){
+            this.run(e, ...n);
+            if (s) {
+                this.onceListeners.remove(h, e);
+            }
+        }
+        return this;
+    }
+    run(e, ...n) {
+        if (core.isAsync(e)) {
+            const s = e;
+            return s(...n).then(()=>Promise.resolve());
+        }
+        e(...n);
+    }
+    cleanChannel(e) {
+        if (this.channelCache.has(e)) {
+            return this.channelCache.get(e);
+        }
+        const n = core.onlyAlphanumeric(e, '*', ':', '.', '-', '_');
+        this.channelCache.set(e, n);
+        return n;
+    }
+    constructor(...e){
+        this.listeners = new listenerCollection.ListenerCollection();
+        this.onceListeners = new listenerCollection.ListenerCollection();
+        this.channelCache = new Map();
+        this.channels = new Set([
+            '*'
+        ]);
+        this.addChannels(...e);
+    }
+}
+
+exports.EventManager = EventManager;

package/dist/index6.mjs

@@ -0,0 +1,110 @@
+import { clearInstance, forOf, isAsync, onlyAlphanumeric } from '@assemblerjs/core';
+import { ListenerCollection } from './index5.mjs';
+
+class EventManager {
+    dispose() {
+        this.listeners.dispose();
+        this.channels.clear();
+        this.channelCache.clear();
+        clearInstance(this, EventManager);
+    }
+    addChannels(...e) {
+        const s = forOf(e);
+        s((e)=>{
+            const n = this.cleanChannel(e);
+            if (this.channels.has(n)) {
+                throw new Error(`Channel '${n}' already exists.`);
+            }
+            this.channels.add(n);
+        });
+        return this;
+    }
+    removeChannels(...e) {
+        const s = forOf(e);
+        s((e)=>{
+            const n = this.cleanChannel(e);
+            if (n !== '*' && this.channels.has(n)) {
+                this.channels.delete(n);
+                this.listeners.remove(n);
+                this.onceListeners.remove(n);
+            }
+        });
+        return this;
+    }
+    on(e, n) {
+        const s = this.cleanChannel(e);
+        this.listeners.add(s, n);
+        return this;
+    }
+    once(e, n) {
+        const s = this.cleanChannel(e);
+        this.onceListeners.add(s, n);
+        return this;
+    }
+    off(e, n) {
+        const s = this.cleanChannel(e);
+        this.listeners.remove(s, n);
+        return this;
+    }
+    emit(e, ...n) {
+        const s = this.cleanChannel(e);
+        if (!this.channels.has(s)) {
+            return this;
+        }
+        const t = [
+            ...(this.onceListeners.get('*') || []).map((e)=>({
+                    listener: e,
+                    once: true,
+                    channel: '*'
+                })),
+            ...(this.listeners.get('*') || []).map((e)=>({
+                    listener: e,
+                    once: false,
+                    channel: '*'
+                })),
+            ...(this.onceListeners.get(s) || []).map((e)=>({
+                    listener: e,
+                    once: true,
+                    channel: s
+                })),
+            ...(this.listeners.get(s) || []).map((e)=>({
+                    listener: e,
+                    once: false,
+                    channel: s
+                }))
+        ];
+        for (const { listener: e, once: s, channel: h } of t){
+            this.run(e, ...n);
+            if (s) {
+                this.onceListeners.remove(h, e);
+            }
+        }
+        return this;
+    }
+    run(e, ...n) {
+        if (isAsync(e)) {
+            const s = e;
+            return s(...n).then(()=>Promise.resolve());
+        }
+        e(...n);
+    }
+    cleanChannel(e) {
+        if (this.channelCache.has(e)) {
+            return this.channelCache.get(e);
+        }
+        const n = onlyAlphanumeric(e, '*', ':', '.', '-', '_');
+        this.channelCache.set(e, n);
+        return n;
+    }
+    constructor(...e){
+        this.listeners = new ListenerCollection();
+        this.onceListeners = new ListenerCollection();
+        this.channelCache = new Map();
+        this.channels = new Set([
+            '*'
+        ]);
+        this.addChannels(...e);
+    }
+}
+
+export { EventManager };

package/dist/index7.js

@@ -0,0 +1,9 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+class AbstractAssemblage {
+    static onRegister(s, t) {}
+}
+
+exports.AbstractAssemblage = AbstractAssemblage;

package/dist/index7.mjs

@@ -0,0 +1,5 @@
+class AbstractAssemblage {
+    static onRegister(s, t) {}
+}
+
+export { AbstractAssemblage };

package/dist/index8.js

@@ -0,0 +1,10 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const eventManager_abstract = require('./index10.js');
+
+class AbstractAssembler extends eventManager_abstract.AbstractEventManager {
+}
+
+exports.AbstractAssembler = AbstractAssembler;

package/dist/index8.mjs

@@ -0,0 +1,6 @@
+import { AbstractEventManager } from './index10.mjs';
+
+class AbstractAssembler extends AbstractEventManager {
+}
+
+export { AbstractAssembler };

package/dist/index9.js

@@ -0,0 +1,8 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+class AbstractListenerCollection {
+}
+
+exports.AbstractListenerCollection = AbstractListenerCollection;

package/dist/index9.mjs

@@ -0,0 +1,4 @@
+class AbstractListenerCollection {
+}
+
+export { AbstractListenerCollection };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "assemblerjs",
   "description": "A general purpose Dependency Injection library for node and browser.",
-  "version": "0.9.7",
+  "version": "1.0.1",
   "author": "Benoît LAHOZ <info@benoitlahoz.io>",
   "bugs": "https://github.com/benoitlahoz/assemblerjs/issues",
   "homepage": "https://github.com/benoitlahoz/assemblerjs#README",
@@ -28,6 +28,7 @@
     "reflect-metadata"
   ],
   "license": "MIT",
+  "sideEffects": false,
   "main": "./dist/index.js",
   "module": "./dist/index.mjs",
   "types": "./dist/index.d.ts",
@@ -47,13 +48,15 @@
   ],
   "scripts": {
     "test": "vitest --coverage --passWithNoTests",
-    "coverage": "vitest run --coverage --passWithNoTests && istanbul-badges-readme"
+    "bench": "vitest bench",
+    "coverage": "vitest run --coverage --passWithNoTests && istanbul-badges-readme && node scripts/update-performance-badges.mjs"
   },
   "dependencies": {
-    "@assemblerjs/core": "0.9.1"
+    "@assemblerjs/core": "^0.9.6",
+    "reflect-metadata": "0.2.2"
   },
   "devDependencies": {
-    "@types/cookie-parser": "^1.4.9",
-    "cookie-parser": "^1.4.7"
+    "istanbul-badges-readme": "^0.2.3",
+    "vitest": "^3.0.0"
   }
 }