@mantaq/sugar 0.1.0 → 0.2.0

package/dist/index.d.mts

@@ -17,21 +17,45 @@ interface SendableMap<T extends SendableEvent = SendableEvent> {
 declare function broadcast<const T extends SendableEvent>(map: SendableMap<T>, event: T): void;
 //#endregion
 //#region src/actors/actor-map.d.ts
+interface ActorMapOptions {
+  /**
+   * When true, a child that reaches a final state (or dies into `__error`)
+   * is removed from the map automatically. Without it, completed children
+   * linger until explicitly `kill`ed.
+   */
+  autoReap?: boolean;
+}
+/**
+ * Keyed registry of one actor type. `spawn(key)` builds a fresh instance via
+ * the factory — same actor shape, keyed by id. The factory receives the key.
+ */
 declare class ActorMap implements SendableMap<SendableEvent> {
   #private;
-  constructor(parent?: AnyActor);
-  spawn(key: string, factory: () => AnyActor): void;
+  constructor(factory: (id: string) => AnyActor, options?: ActorMapOptions);
+  spawn(key: string): void;
   send(key: string, event: SendableEvent): void;
   kill(key: string): void;
   get size(): number;
   has(key: string): boolean;
   keys(): string[];
-  ensure(key: string, factory: () => AnyActor): void;
+  ensure(key: string): void;
   snapshot(key: string): Snapshot | undefined;
 }
 //#endregion
 //#region src/state.d.ts
-declare function states<T extends string>(...names: T[]): { [K in T]: StateRef<K>; };
+interface StatesEntry {
+  name: string;
+  final?: boolean;
+}
+type StatesArg = string | StatesEntry;
+type NameOf<T> = T extends string ? T : T extends {
+  name: infer N extends string;
+} ? N : never;
+type FinalOf<T> = T extends {
+  final: true;
+} ? true : false;
+type StatesRecord<T extends StatesArg[]> = { [K in T[number] as NameOf<K>]: StateRef<NameOf<K>, unknown, FinalOf<K>>; };
+declare function states<const T extends StatesArg[]>(...entries: T): StatesRecord<T>;
 //#endregion
 //#region src/event.d.ts
 declare function events<T extends string>(...names: T[]): { [K in T]: EventRef<K>; };

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { abortEffects, setOutputHandler } from "@mantaq/core/internal";
+import { abortEffects } from "@mantaq/core/internal";
 import { Either } from "@mantaq/utils";
 import { event, state } from "@mantaq/core";
 //#region src/actors/matches.ts
@@ -21,29 +21,44 @@ function matches(actor, pattern) {
 }
 //#endregion
 //#region src/actors/actor-map.ts
+/**
+* Keyed registry of one actor type. `spawn(key)` builds a fresh instance via
+* the factory — same actor shape, keyed by id. The factory receives the key.
+*/
 var ActorMap = class {
 	#actors = /* @__PURE__ */ new Map();
-	#parent;
-	constructor(parent) {
-		this.#parent = parent ?? null;
+	#reapers = /* @__PURE__ */ new Map();
+	#factory;
+	#autoReap;
+	constructor(factory, options = {}) {
+		this.#factory = factory;
+		this.#autoReap = options.autoReap === true;
 	}
-	spawn(key, factory) {
-		if (this.#actors.has(key)) {
-			console.warn(`[ActorMap] spawning over existing key "${key}". Old actor will be aborted.`);
-			this.kill(key);
-		}
-		const child = factory();
-		if (this.#parent) Either.match(setOutputHandler(child, (event) => {
-			this.#parent.send(event);
-		}), (err) => console.error(err.message), () => {});
+	spawn(key) {
+		if (this.#actors.has(key)) this.kill(key);
+		const child = this.#factory(key);
 		this.#actors.set(key, child);
+		if (this.#autoReap) {
+			if (child.snapshot().done) {
+				this.#actors.delete(key);
+				return;
+			}
+			const off = child.on("done", () => {
+				if (this.#actors.get(key) === child) this.#actors.delete(key);
+			});
+			this.#reapers.set(key, off);
+		}
 	}
 	send(key, event) {
 		this.#actors.get(key)?.send(event);
 	}
 	kill(key) {
 		const actor = this.#actors.get(key);
-		if (actor) Either.match(abortEffects(actor), (err) => console.error(err.message), () => {});
+		if (actor) Either.match(abortEffects(actor), (err) => {
+			throw new Error(err.message);
+		}, () => {});
+		this.#reapers.get(key)?.();
+		this.#reapers.delete(key);
 		this.#actors.delete(key);
 	}
 	get size() {
@@ -55,8 +70,8 @@ var ActorMap = class {
 	keys() {
 		return [...this.#actors.keys()];
 	}
-	ensure(key, factory) {
-		if (!this.#actors.has(key)) this.spawn(key, factory);
+	ensure(key) {
+		if (!this.#actors.has(key)) this.spawn(key);
 	}
 	snapshot(key) {
 		return this.#actors.get(key)?.snapshot();
@@ -64,9 +79,13 @@ var ActorMap = class {
 };
 //#endregion
 //#region src/state.ts
-function states(...names) {
+function states(...entries) {
 	const result = {};
-	for (const name of names) result[name] = state(name)();
+	for (const entry of entries) {
+		const name = typeof entry === "string" ? entry : entry.name;
+		const ref = state(name)();
+		result[name] = typeof entry === "object" && entry.final ? ref.final() : ref;
+	}
 	return result;
 }
 //#endregion
@@ -88,11 +107,10 @@ function withPromise(promise, signal, emit, events) {
 //#endregion
 //#region src/effects/timeout.ts
 function withTimeout(ms, input, event) {
-	if (typeof ms !== "number" || ms < 0 || !Number.isFinite(ms)) console.warn(`[withTimeout] invalid ms value: ${ms}. Timeout may not fire.`);
 	input.clock.setTimeout(ms, () => {
 		if (input.signal.aborted) return;
 		input.emit(event());
-	});
+	}, { signal: input.signal });
 }
 //#endregion
 //#region src/transitions/broadcast.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mantaq/sugar",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "description": "Userland sugar for mantaq actors — matches, effect helpers, transition utilities.",
   "license": "MIT",
   "repository": {
@@ -20,7 +20,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@mantaq/core": "0.1.0",
+    "@mantaq/core": "0.2.0",
     "@mantaq/utils": "0.0.2"
   },
   "devDependencies": {