@rotorjs/dashboard 0.3.1 → 0.5.0

package/dist/DashboardAction.d.ts

@@ -14,6 +14,9 @@ export type NavigateDashboardAction = {
     href: string;
     replace?: boolean;
 };
+export type SyncDashboardAction = {
+    type: 'sync';
+};
 export type DashboardAction = {
     type: string;
     [key: string]: unknown;

package/dist/DashboardEngine.d.ts

@@ -10,12 +10,17 @@ import { DashboardVar } from './DashboardVar';
 export type DashboardStateReducerMap<Engine extends DashboardEngine = DashboardEngine> = {
     [type: string]: DashboardStateReducerConfig<Engine>;
 };
-export declare class DashboardEngine extends StateEngine<DashboardStateDescriptor, DashboardState, DashboardAction> implements DashboardEventTarget {
+export type DashboardEngineInit = {
+    vars?: {
+        [name: string]: DashboardVar;
+    };
+    facts?: {
+        [name: string]: DashboardFact;
+    };
+};
+export declare class DashboardEngine extends StateEngine<DashboardStateDescriptor, DashboardState, DashboardAction, DashboardEventTarget> {
     #private;
-    constructor(reducerInit: DashboardStateReducerMap);
-    protected onAction(action: DashboardAction): void;
-    dispatchVar(name: string, value: unknown, exposed?: boolean): void;
-    dispatchFact(name: string, value: unknown): void;
+    constructor(target: DashboardEventTarget, reducerInit: DashboardStateReducerMap, init?: DashboardEngineInit);
     hasVar(name: string): boolean;
     getVar(name: string): DashboardVar | undefined;
     hasFact(name: string): boolean;

package/dist/DashboardEnvironment.d.ts

@@ -0,0 +1,42 @@
+import { TypedEventTarget } from '@rotorjs/state';
+import { DashboardEventTarget } from './DashboardEventTarget';
+import { DashboardFact } from './DashboardFact';
+import { DashboardVar } from './DashboardVar';
+export type DashboardEnvironmentInit = {
+    vars?: {
+        [name: string]: DashboardVar;
+    };
+    facts?: {
+        [name: string]: DashboardFact;
+    };
+};
+export declare class DashboardEnvironment extends TypedEventTarget<{
+    var: VarEvent;
+    fact: FactEvent;
+}> {
+    #private;
+    constructor(target: DashboardEventTarget, init?: DashboardEnvironmentInit);
+    get target(): DashboardEventTarget;
+    get id(): string;
+    get signal(): AbortSignal;
+    hasVar(name: string): boolean;
+    getVar(name: string): DashboardVar | undefined;
+    getVars(): [name: string, value: DashboardVar][];
+    hasFact(name: string): boolean;
+    getFact(name: string): DashboardFact | undefined;
+    getFacts(): [name: string, value: DashboardFact][];
+    stop(): void;
+}
+export declare class VarEvent extends Event {
+    #private;
+    constructor(name: string, value: unknown, exposed: boolean);
+    get name(): string;
+    get value(): unknown;
+    get exposed(): boolean;
+}
+export declare class FactEvent extends Event {
+    #private;
+    constructor(name: string, value: unknown);
+    get name(): string;
+    get value(): unknown;
+}

package/dist/DashboardEventTarget.d.ts

@@ -5,4 +5,5 @@ import { DashboardStateDescriptor } from './DashboardStateDescriptor';
 export declare class DashboardEventTarget extends StateEventTarget<DashboardStateDescriptor, DashboardState, DashboardAction> {
     dispatchVar(name: string, value: unknown, exposed?: boolean): void;
     dispatchFact(name: string, value: unknown): void;
+    sync(): void;
 }

package/dist/DashboardStateConsumer.d.ts

@@ -1,7 +1,8 @@
-import { StateConsumer } from '@rotorjs/state';
+import { StateConsumer, StateCallback, StateEventTarget } from '@rotorjs/state';
 import { DashboardAction } from './DashboardAction';
 import { DashboardState } from './DashboardState';
 import { DashboardStateDescriptor } from './DashboardStateDescriptor';
 export declare class DashboardStateConsumer extends StateConsumer<DashboardStateDescriptor, DashboardState, DashboardAction> {
+    constructor(target: StateEventTarget<DashboardStateDescriptor, DashboardState, DashboardAction>, descriptor: DashboardStateDescriptor, callback: StateCallback<DashboardState>);
     protected compareStates(nextState: DashboardState, prevState: DashboardState): boolean;
 }

package/dist/main.js

@@ -1,63 +1,149 @@
-import { StateConsumer as e, StateEngine as t, StateEventTarget as n, StateReducer as r } from "@rotorjs/state";
-import i from "fast-deep-equal";
-import { v7 as a } from "uuid";
+import { ActionEvent as e, StateConsumer as t, StateEngine as n, StateEventTarget as r, StateReducer as i, TypedEventTarget as a } from "@rotorjs/state";
+import o from "fast-deep-equal";
+import { v7 as s } from "uuid";
+//#region lib/DashboardEnvironment.ts
+var c = class extends a {
+	#e;
+	#t = s();
+	#n;
+	#r;
+	#i = new AbortController();
+	constructor(t, n) {
+		super(), this.#e = t, this.#n = Object.fromEntries(Object.entries(n?.vars ?? {}).map(([e, t]) => [e, Object.freeze(t)])), this.#r = Object.fromEntries(Object.entries(n?.facts ?? {}).map(([e, t]) => [e, Object.freeze(t)]));
+		let r = this.signal;
+		this.target.addEventListener("action", (t) => {
+			if (t.emitter === this.#t) return;
+			let n = t.action;
+			switch (n.type) {
+				case "var": {
+					let e = this.#n[n.name], t = Object.freeze({
+						value: n.value,
+						exposed: n.exposed ?? !1
+					});
+					o(e, t) || (this.#n[n.name] = t, this.dispatchEvent(new l(n.name, t.value, t.exposed)));
+					return;
+				}
+				case "fact": {
+					let e = this.#r[n.name], t = Object.freeze({ value: n.value });
+					o(e, t) || (this.#r[n.name] = t, this.dispatchEvent(new u(n.name, t.value)));
+					return;
+				}
+				case "sync": Object.entries(this.#n).forEach(([t, { value: n, exposed: r }]) => {
+					let i = new e({
+						type: "var",
+						name: t,
+						value: n,
+						exposed: r
+					});
+					i.emitter = this.#t, this.target.dispatchEvent(i);
+				}), Object.entries(this.#r).forEach(([t, { value: n }]) => {
+					let r = new e({
+						type: "fact",
+						name: t,
+						value: n
+					});
+					r.emitter = this.#t, this.target.dispatchEvent(r);
+				});
+			}
+		}, { signal: r }), this.target.sync();
+	}
+	get target() {
+		return this.#e;
+	}
+	get id() {
+		return this.#t;
+	}
+	get signal() {
+		return this.#i.signal;
+	}
+	hasVar(e) {
+		return Object.hasOwn(this.#n, e);
+	}
+	getVar(e) {
+		return this.#n[e];
+	}
+	getVars() {
+		return Object.entries(this.#n);
+	}
+	hasFact(e) {
+		return Object.hasOwn(this.#r, e);
+	}
+	getFact(e) {
+		return this.#r[e];
+	}
+	getFacts() {
+		return Object.entries(this.#r);
+	}
+	stop() {
+		this.#i.abort();
+	}
+}, l = class extends Event {
+	#e;
+	#t;
+	#n;
+	constructor(e, t, n) {
+		super("var"), this.#e = e, this.#t = t, this.#n = n;
+	}
+	get name() {
+		return this.#e;
+	}
+	get value() {
+		return this.#t;
+	}
+	get exposed() {
+		return this.#n;
+	}
+}, u = class extends Event {
+	#e;
+	#t;
+	constructor(e, t) {
+		super("fact"), this.#e = e, this.#t = t;
+	}
+	get name() {
+		return this.#e;
+	}
+	get value() {
+		return this.#t;
+	}
+};
+//#endregion
 //#region lib/interests.ts
-function o(e) {
+function d(e) {
 	return `dashboard://var/${encodeURIComponent(e)}`;
 }
-function s(e) {
+function f(e) {
 	return `dashboard://fact/${encodeURIComponent(e)}`;
 }
 //#endregion
 //#region lib/DashboardEngine.ts
-var c = class extends t {
+var p = class extends n {
 	#e;
-	#t = {};
-	#n = {};
-	constructor(e) {
-		super(), this.#e = e;
-	}
-	onAction(e) {
-		super.onAction(e);
-		let t = e;
-		switch (t.type) {
-			case "var":
-				this.#t[t.name] = {
-					value: t.value,
-					exposed: t.exposed ?? !1
-				}, this.dispatchInterest(o(t.name));
-				return;
-			case "fact":
-				this.#n[t.name] = { value: t.value }, this.dispatchInterest(s(t.name));
-				return;
-		}
-	}
-	dispatchVar(e, t, n) {
-		this.dispatchAction({
-			type: "var",
-			name: e,
-			value: t,
-			exposed: n
+	#t;
+	constructor(e, t, n) {
+		super(e), this.#e = t, this.#t = new c(this.target, {
+			vars: n?.vars,
+			facts: n?.facts
 		});
-	}
-	dispatchFact(e, t) {
-		this.dispatchAction({
-			type: "fact",
-			name: e,
-			value: t
+		let r = this.signal;
+		this.#t.addEventListener("var", (e) => {
+			this.target.dispatchInterest(d(e.name));
+		}, { signal: r }), this.#t.addEventListener("fact", (e) => {
+			this.target.dispatchInterest(f(e.name));
+		}, { signal: r }), r.addEventListener("abort", () => {
+			this.#t.stop();
 		});
 	}
 	hasVar(e) {
-		return Object.hasOwn(this.#t, e);
+		return this.#t.hasVar(e);
 	}
 	getVar(e) {
-		return this.#t[e];
+		return this.#t.getVar(e);
 	}
 	hasFact(e) {
-		return Object.hasOwn(this.#n, e);
+		return this.#t.hasFact(e);
 	}
 	getFact(e) {
-		return this.#n[e];
+		return this.#t.getFact(e);
 	}
 	getReducerConfig(e) {
 		if (!Object.hasOwn(this.#e, e.type)) throw Error(`Unknown reducer type "${e.type}"`);
@@ -69,7 +155,7 @@ var c = class extends t {
 	createReducer(e) {
 		return this.getReducerConfig(e).createReducer(this, e);
 	}
-}, l = class extends n {
+}, m = class extends r {
 	dispatchVar(e, t, n) {
 		this.dispatchAction({
 			type: "var",
@@ -85,22 +171,34 @@ var c = class extends t {
 			value: t
 		});
 	}
-}, u = class extends e {
+	sync() {
+		this.dispatchAction({ type: "sync" });
+	}
+}, h = class extends t {
+	constructor(e, t, n) {
+		super(e, t, n), this.target.addEventListener("action", (e) => {
+			switch (e.action.type) {
+				case "sync":
+					this.target.subscribeState(this.id, this.descriptor);
+					return;
+			}
+		}, { signal: this.signal });
+	}
 	compareStates(e, t) {
-		return i(e, t);
+		return o(e, t);
 	}
-}, d = class extends r {
+}, g = class extends i {
 	recover(e, t) {
 		return [{
 			type: "error",
-			id: a(),
+			id: s(),
 			error: t
 		}];
 	}
 	compareStates(e, t) {
-		return i(e, t);
+		return o(e, t);
 	}
-}, f = "locale", p = class {
+}, _ = "locale", v = class {
 	#e;
 	constructor(e) {
 		this.#e = e ?? {};
@@ -108,19 +206,19 @@ var c = class extends t {
 	getLocale(e) {
 		if (e?.locale) return e.locale;
 		if (this.#e?.locale) return this.#e.locale;
-		let t = this.#e?.reducer?.engine.getFact(f)?.value;
-		return this.#e?.reducer?.addInterest(s(f)), typeof t == "string" ? t : void 0;
+		let t = this.#e?.reducer?.engine.getFact(_)?.value;
+		return this.#e?.reducer?.addInterest(f(_)), typeof t == "string" ? t : void 0;
 	}
 	getFormat(e) {
 		return new Intl.NumberFormat(this.getLocale(e));
 	}
 	format(e, t) {
 		switch (t?.type) {
-			default: return m(this.getFormat(t).format(e), t);
+			default: return y(this.getFormat(t).format(e), t);
 		}
 	}
 };
-function m(e, t) {
+function y(e, t) {
 	let n;
 	if (n = typeof t?.unit == "string" ? t.unit : t?.unit?.value, !n) return e;
 	let r;
@@ -138,4 +236,4 @@ function m(e, t) {
 	}
 }
 //#endregion
-export { c as DashboardEngine, l as DashboardEventTarget, u as DashboardStateConsumer, d as DashboardStateReducer, p as NumberFormatter, s as dashboardFactInterest, f as dashboardLocaleFact, o as dashboardVarInterest };
+export { p as DashboardEngine, m as DashboardEventTarget, h as DashboardStateConsumer, g as DashboardStateReducer, v as NumberFormatter, f as dashboardFactInterest, _ as dashboardLocaleFact, d as dashboardVarInterest };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rotorjs/dashboard",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Rotor",
   "author": {
     "name": "Aaron Burmeister"
@@ -63,7 +63,7 @@
     "vite": "^8.0.16"
   },
   "dependencies": {
-    "@rotorjs/state": "^0.6.1",
+    "@rotorjs/state": "^0.7.0",
     "fast-deep-equal": "^3.1.3",
     "uuid": "^14.0.0"
   }