@lincode/events 1.0.22

package/.ambientsrc

@@ -0,0 +1,14 @@
+{
+	"name": "@lincode/events",
+	"strict": true,
+	"esnext": true,
+	"es2015": false,
+	"es5": false,
+	"library": true,
+	"node": true,
+	"react": false,
+	"jsx": false,
+	"css": false,
+	"tailwind": false,
+	"3d": false
+}

package/lib/Events.d.ts

@@ -0,0 +1,13 @@
+import { Cancellable } from "@lincode/promiselikes";
+export default class<Payload = void, Names extends string = string> {
+    private cbsMap;
+    private states?;
+    on(name: Names | Array<Names>, cb: (val: Payload) => void): Cancellable;
+    once(name: Names | Array<Names>, cb: (val: Payload) => void): Cancellable;
+    emit(name: Names, value: Payload): void;
+    hasState(name: Names): boolean;
+    setState(name: Names, value: Payload): void;
+    getState(name: Names): Payload | undefined;
+    deleteState(name: Names): void;
+    clear(): void;
+}

package/lib/Events.js

@@ -0,0 +1,59 @@
+import { Cancellable } from "@lincode/promiselikes";
+import { forceGet } from "@lincode/utils";
+export default class {
+    constructor() {
+        this.cbsMap = new Map();
+    }
+    on(name, cb) {
+        var _a;
+        if (Array.isArray(name)) {
+            const handle = new Cancellable();
+            for (const n of name)
+                handle.watch(this.on(n, cb));
+            return handle;
+        }
+        if ((_a = this.states) === null || _a === void 0 ? void 0 : _a.has(name))
+            cb(this.states.get(name));
+        const cbs = forceGet(this.cbsMap, name, () => new Set());
+        cbs.add(cb);
+        return new Cancellable(() => cbs.delete(cb));
+    }
+    once(name, cb) {
+        const handle = new Cancellable();
+        handle.watch(this.on(name, value => {
+            handle.cancel();
+            cb(value);
+        }));
+        return handle;
+    }
+    emit(name, value) {
+        if (this.cbsMap.has(name))
+            for (const cb of this.cbsMap.get(name))
+                cb(value);
+    }
+    hasState(name) {
+        var _a;
+        return !!((_a = this.states) === null || _a === void 0 ? void 0 : _a.has(name));
+    }
+    setState(name, value) {
+        var _a;
+        (_a = this.states) !== null && _a !== void 0 ? _a : (this.states = new Map());
+        if (this.states.has(name) && this.states.get(name) === value)
+            return;
+        this.states.set(name, value);
+        this.emit(name, value);
+    }
+    getState(name) {
+        var _a;
+        return (_a = this.states) === null || _a === void 0 ? void 0 : _a.get(name);
+    }
+    deleteState(name) {
+        var _a;
+        (_a = this.states) === null || _a === void 0 ? void 0 : _a.delete(name);
+    }
+    clear() {
+        var _a;
+        this.cbsMap.clear();
+        (_a = this.states) === null || _a === void 0 ? void 0 : _a.clear();
+    }
+}

package/lib/event.d.ts

@@ -0,0 +1,6 @@
+import { Cancellable } from "@lincode/promiselikes";
+declare type Emit<T> = (val: T, isState?: boolean) => void;
+declare type On<T> = (cb: (val: T) => void, once?: boolean) => Cancellable;
+declare type GetState<T> = () => T | undefined;
+declare const _default: <T = void>() => readonly [Emit<T>, On<T>, GetState<T>];
+export default _default;

package/lib/event.js

@@ -0,0 +1,40 @@
+import { Cancellable } from "@lincode/promiselikes";
+class Event {
+    constructor() {
+        this.cbs = new Set();
+    }
+    on(cb) {
+        if ("state" in this)
+            cb(this.state);
+        this.cbs.add(cb);
+        return new Cancellable(() => this.cbs.delete(cb));
+    }
+    once(cb) {
+        const handle = new Cancellable();
+        handle.watch(this.on(value => {
+            handle.cancel();
+            cb(value);
+        }));
+        return handle;
+    }
+    emit(value) {
+        for (const cb of this.cbs)
+            cb(value);
+    }
+    setState(value) {
+        if ("state" in this && this.state === value)
+            return;
+        this.state = value;
+        this.emit(value);
+    }
+    getState() {
+        return this.state;
+    }
+}
+export default () => {
+    const event = new Event();
+    const emit = (val, isState) => isState ? event.setState(val) : event.emit(val);
+    const on = (cb, once) => once ? event.once(cb) : event.on(cb);
+    const getState = () => event.getState();
+    return [emit, on, getState];
+};

package/lib/index.d.ts

@@ -0,0 +1,2 @@
+export { default, default as Events } from "./Events";
+export { default as event } from "./event";

package/lib/index.js

@@ -0,0 +1,2 @@
+export { default, default as Events } from "./Events";
+export { default as event } from "./event";

package/lib-commonjs/Events.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promiselikes_1 = require("@lincode/promiselikes");
+const utils_1 = require("@lincode/utils");
+class default_1 {
+    constructor() {
+        this.cbsMap = new Map();
+    }
+    on(name, cb) {
+        var _a;
+        if (Array.isArray(name)) {
+            const handle = new promiselikes_1.Cancellable();
+            for (const n of name)
+                handle.watch(this.on(n, cb));
+            return handle;
+        }
+        if ((_a = this.states) === null || _a === void 0 ? void 0 : _a.has(name))
+            cb(this.states.get(name));
+        const cbs = (0, utils_1.forceGet)(this.cbsMap, name, () => new Set());
+        cbs.add(cb);
+        return new promiselikes_1.Cancellable(() => cbs.delete(cb));
+    }
+    once(name, cb) {
+        const handle = new promiselikes_1.Cancellable();
+        handle.watch(this.on(name, value => {
+            handle.cancel();
+            cb(value);
+        }));
+        return handle;
+    }
+    emit(name, value) {
+        if (this.cbsMap.has(name))
+            for (const cb of this.cbsMap.get(name))
+                cb(value);
+    }
+    hasState(name) {
+        var _a;
+        return !!((_a = this.states) === null || _a === void 0 ? void 0 : _a.has(name));
+    }
+    setState(name, value) {
+        var _a;
+        (_a = this.states) !== null && _a !== void 0 ? _a : (this.states = new Map());
+        if (this.states.has(name) && this.states.get(name) === value)
+            return;
+        this.states.set(name, value);
+        this.emit(name, value);
+    }
+    getState(name) {
+        var _a;
+        return (_a = this.states) === null || _a === void 0 ? void 0 : _a.get(name);
+    }
+    deleteState(name) {
+        var _a;
+        (_a = this.states) === null || _a === void 0 ? void 0 : _a.delete(name);
+    }
+    clear() {
+        var _a;
+        this.cbsMap.clear();
+        (_a = this.states) === null || _a === void 0 ? void 0 : _a.clear();
+    }
+}
+exports.default = default_1;

package/lib-commonjs/event.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promiselikes_1 = require("@lincode/promiselikes");
+class Event {
+    constructor() {
+        this.cbs = new Set();
+    }
+    on(cb) {
+        if ("state" in this)
+            cb(this.state);
+        this.cbs.add(cb);
+        return new promiselikes_1.Cancellable(() => this.cbs.delete(cb));
+    }
+    once(cb) {
+        const handle = new promiselikes_1.Cancellable();
+        handle.watch(this.on(value => {
+            handle.cancel();
+            cb(value);
+        }));
+        return handle;
+    }
+    emit(value) {
+        for (const cb of this.cbs)
+            cb(value);
+    }
+    setState(value) {
+        if ("state" in this && this.state === value)
+            return;
+        this.state = value;
+        this.emit(value);
+    }
+    getState() {
+        return this.state;
+    }
+}
+exports.default = () => {
+    const event = new Event();
+    const emit = (val, isState) => isState ? event.setState(val) : event.emit(val);
+    const on = (cb, once) => once ? event.once(cb) : event.on(cb);
+    const getState = () => event.getState();
+    return [emit, on, getState];
+};

package/lib-commonjs/index.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.event = exports.Events = exports.default = void 0;
+var Events_1 = require("./Events");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return Events_1.default; } });
+Object.defineProperty(exports, "Events", { enumerable: true, get: function () { return Events_1.default; } });
+var event_1 = require("./event");
+Object.defineProperty(exports, "event", { enumerable: true, get: function () { return event_1.default; } });

package/lib-commonjs/test.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const _1 = require(".");
+const events = new _1.default();
+events.on("hello", (val) => {
+    console.log(val);
+    console.log("awesome");
+});

package/package.json

@@ -0,0 +1,27 @@
+{
+	"name": "@lincode/events",
+	"version": "1.0.22",
+	"description": "Generated by ambients-cli",
+	"author": "Lai Schwe",
+	"license": "MIT",
+	"keywords": [
+		"ambients"
+	],
+	"dependencies": {
+		"@lincode/promiselikes": "*",
+		"@lincode/utils": "*"
+	},
+	"peerDependencies": {},
+	"devDependencies": {
+		"typescript": "*"
+	},
+	"scripts": {
+		"build": "ambients clean && yarn tsc && yarn tsc -p tsconfig-commonjs.json",
+		"start": "node lib-commonjs/test.js",
+		"dev": "yarn build && yarn start dev"
+	},
+	"private": false,
+	"main": "lib-commonjs/index.js",
+	"module": "lib/index.js",
+	"types": "lib/index.d.ts"
+}

package/src/Events.ts

@@ -0,0 +1,63 @@
+import { Cancellable } from "@lincode/promiselikes"
+import { forceGet } from "@lincode/utils"
+
+export default class <Payload = void, Names extends string = string> {
+    private cbsMap = new Map<string, Set<(val: Payload) => void>>()
+    private states?: Map<string, Payload>
+
+    public on(name: Names | Array<Names>, cb: (val: Payload) => void): Cancellable {
+        if (Array.isArray(name)) {
+            const handle = new Cancellable()
+            for (const n of name)
+                handle.watch(this.on(n, cb))
+
+            return handle
+        }
+        if (this.states?.has(name))
+            cb(this.states.get(name)!)
+
+        const cbs = forceGet(this.cbsMap, name, () => new Set<(val: Payload) => void>())
+        
+        cbs.add(cb)
+        return new Cancellable(() => cbs.delete(cb))
+    }
+    
+    public once(name: Names | Array<Names>, cb: (val: Payload) => void): Cancellable {
+        const handle = new Cancellable()
+        handle.watch(this.on(name, value => {
+            handle.cancel()
+            cb(value)
+        }))
+        return handle
+    }
+
+    public emit(name: Names, value: Payload): void {
+        if (this.cbsMap.has(name))
+            for (const cb of this.cbsMap.get(name)!)
+                cb(value)
+    }
+
+    public hasState(name: Names): boolean {
+        return !!this.states?.has(name)
+    }
+
+    public setState(name: Names, value: Payload): void {
+        this.states ??= new Map()
+        if (this.states.has(name) && this.states.get(name) === value) return
+        this.states.set(name, value)
+        this.emit(name, value)
+    }
+
+    public getState(name: Names): Payload | undefined {
+        return this.states?.get(name)
+    }
+
+    public deleteState(name: Names): void {
+        this.states?.delete(name)
+    }
+
+    public clear(): void {
+        this.cbsMap.clear()
+        this.states?.clear()
+    }
+}

package/src/event.ts

@@ -0,0 +1,50 @@
+import { Cancellable } from "@lincode/promiselikes"
+
+class Event<Payload = void> {
+    private cbs = new Set<(val: Payload) => void>()
+    private state?: Payload
+
+    public on(cb: (val: Payload) => void): Cancellable {
+        if ("state" in this)
+            cb(this.state!)
+        
+        this.cbs.add(cb)
+        return new Cancellable(() => this.cbs.delete(cb))
+    }
+    
+    public once(cb: (val: Payload) => void): Cancellable {
+        const handle = new Cancellable()
+        handle.watch(this.on(value => {
+            handle.cancel()
+            cb(value)
+        }))
+        return handle
+    }
+
+    public emit(value: Payload): void {
+        for (const cb of this.cbs)
+            cb(value)
+    }
+
+    public setState(value: Payload): void {
+        if ("state" in this && this.state === value) return
+        this.state = value
+        this.emit(value)
+    }
+
+    public getState(): Payload | undefined {
+        return this.state
+    }
+}
+
+type Emit<T> = (val: T, isState?: boolean) => void
+type On<T> = (cb: (val: T) => void, once?: boolean) => Cancellable
+type GetState<T> = () => T | undefined
+
+export default <T = void>() => {
+    const event = new Event<T>()
+    const emit: Emit<T> = (val: T, isState?: boolean) => isState ? event.setState(val) : event.emit(val)
+    const on: On<T> = (cb: (val: T) => void, once?: boolean) => once ? event.once(cb) : event.on(cb)
+    const getState: GetState<T> = () => event.getState()
+    return <const>[emit, on, getState]
+}

package/src/index.ts

@@ -0,0 +1,2 @@
+export { default, default as Events } from "./Events"
+export { default as event } from "./event"

package/src/test.ts

@@ -0,0 +1,7 @@
+import Events from "."
+
+const events = new Events<string | undefined, "hello">()
+events.on("hello", (val) => {
+    console.log(val)
+    console.log("awesome")
+})

package/tsconfig-commonjs.json

@@ -0,0 +1,17 @@
+{
+	"compilerOptions": {
+		"module": "commonjs",
+		"moduleResolution": "node",
+		"strict": true,
+		"noImplicitOverride": true,
+		"skipLibCheck": true,
+		"allowSyntheticDefaultImports": true,
+		"experimentalDecorators": true,
+		"target": "es2019",
+		"declaration": false,
+		"outDir": "lib-commonjs"
+	},
+	"include": [
+		"src"
+	]
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+	"compilerOptions": {
+		"module": "esnext",
+		"moduleResolution": "node",
+		"strict": true,
+		"noImplicitOverride": true,
+		"skipLibCheck": true,
+		"allowSyntheticDefaultImports": true,
+		"experimentalDecorators": true,
+		"target": "es2019",
+		"declaration": true,
+		"outDir": "lib"
+	},
+	"include": [
+		"src"
+	],
+	"exclude": [
+		"src/test.ts"
+	]
+}