@lincode/events 1.0.21 → 1.0.24

package/.ambientsrc

@@ -10,5 +10,6 @@
 	"jsx": false,
 	"css": false,
 	"tailwind": false,
-	"3d": false
+	"contentLoader": false,
+	"urlLoader": 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>, Emit<T>, GetState<T>];
+export default _default;

package/lib/event.js

@@ -0,0 +1,41 @@
+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) => event.emit(val);
+    const on = (cb, once) => once ? event.once(cb) : event.on(cb);
+    const emitState = (val) => event.setState(val);
+    const getState = () => event.getState();
+    return [emit, on, emitState, getState];
+};

package/lib/index.d.ts

@@ -1,19 +1,2 @@
-import { Cancellable } from "@lincode/promiselikes";
-import { Callback } from "@lincode/utils";
-export default class Events<Payload = void, Names extends string = string> {
-    private cbsMap;
-    private states?;
-    on(name: Names | Array<Names>, cb: Callback<Payload>): Cancellable;
-    once(name: Names | Array<Names>, cb: Callback<Payload>): 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;
-}
-export { Events };
-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;
-export declare const event: <T = void>() => readonly [Emit<T>, On<T>, GetState<T>];
+export { default, default as Events } from "./Events";
+export { default as event } from "./event";

package/lib/index.js

@@ -1,99 +1,2 @@
-import { Cancellable } from "@lincode/promiselikes";
-import { forceGet } from "@lincode/utils";
-export default class Events {
-    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();
-    }
-}
-export { Events };
-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 const event = () => {
-    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];
-};
+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,43 @@
+"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) => event.emit(val);
+    const on = (cb, once) => once ? event.once(cb) : event.on(cb);
+    const emitState = (val) => event.setState(val);
+    const getState = () => event.getState();
+    return [emit, on, emitState, getState];
+};

package/lib-commonjs/index.js

@@ -1,104 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.event = exports.Events = void 0;
-const promiselikes_1 = require("@lincode/promiselikes");
-const utils_1 = require("@lincode/utils");
-class Events {
-    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 = 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 = Events;
-exports.Events = Events;
-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;
-    }
-}
-const event = () => {
-    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];
-};
-exports.event = event;
+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/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@lincode/events",
-	"version": "1.0.21",
+	"version": "1.0.24",
 	"description": "Generated by ambients-cli",
 	"author": "Lai Schwe",
 	"license": "MIT",
@@ -13,7 +13,6 @@
 	},
 	"peerDependencies": {},
 	"devDependencies": {
-		"@types/node": "*",
 		"typescript": "*"
 	},
 	"scripts": {

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,51 @@
+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) => event.emit(val)
+    const on: On<T> = (cb: (val: T) => void, once?: boolean) => once ? event.once(cb) : event.on(cb)
+    const emitState: Emit<T> = (val: T) => event.setState(val)
+    const getState: GetState<T> = () => event.getState()
+    return <const>[emit, on, emitState, getState]
+}

package/src/index.ts

@@ -1,113 +1,2 @@
-import { Cancellable } from "@lincode/promiselikes"
-import { forceGet, Callback } from "@lincode/utils"
-
-export default class Events<Payload = void, Names extends string = string> {
-    private cbsMap = new Map<string, Set<Callback<Payload>>>()
-    private states?: Map<string, Payload>
-
-    public on(name: Names | Array<Names>, cb: Callback<Payload>): 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<Callback<Payload>>())
-        
-        cbs.add(cb)
-        return new Cancellable(() => cbs.delete(cb))
-    }
-    
-    public once(name: Names | Array<Names>, cb: Callback<Payload>): 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()
-    }
-}
-export { Events }
-
-class Event<Payload = void> {
-    private cbs = new Set<Callback<Payload>>()
-    private state?: Payload
-
-    public on(cb: Callback<Payload>): Cancellable {
-        if ("state" in this)
-            cb(this.state!)
-        
-        this.cbs.add(cb)
-        return new Cancellable(() => this.cbs.delete(cb))
-    }
-    
-    public once(cb: Callback<Payload>): 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 const event = <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]
-}
+export { default, default as Events } from "./Events"
+export { default as event } from "./event"

package/tsconfig-commonjs.json

@@ -3,10 +3,11 @@
 		"module": "commonjs",
 		"moduleResolution": "node",
 		"strict": true,
+		"noImplicitOverride": true,
 		"skipLibCheck": true,
 		"allowSyntheticDefaultImports": true,
 		"experimentalDecorators": true,
-		"target": "es2018",
+		"target": "es2019",
 		"declaration": false,
 		"outDir": "lib-commonjs"
 	},

package/tsconfig.json

@@ -3,10 +3,11 @@
 		"module": "esnext",
 		"moduleResolution": "node",
 		"strict": true,
+		"noImplicitOverride": true,
 		"skipLibCheck": true,
 		"allowSyntheticDefaultImports": true,
 		"experimentalDecorators": true,
-		"target": "es2018",
+		"target": "es2019",
 		"declaration": true,
 		"outDir": "lib"
 	},