@actor-system/behaviors 0.0.1

package/dist/__bundle__/shared/dist/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bivariance hack for ergonomic action and guard typing in strict TypeScript mode.
+ * Allows config-based functions to be less strictly parameterized.
+ */
+type Bivariant<Fn extends (...args: any[]) => any> = {
+    bivarianceHack(...args: Parameters<Fn>): ReturnType<Fn>;
+}["bivarianceHack"];
+
+export type { Bivariant };

package/dist/__bundle__/shared/dist/types.internal.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Bivariance hack for ergonomic action and guard typing in strict TypeScript mode.
+ * Allows config-based functions to be less strictly parameterized.
+ */
+type Bivariant<Fn extends (...args: any[]) => any> = {
+    bivarianceHack(...args: Parameters<Fn>): ReturnType<Fn>;
+}["bivarianceHack"];
+
+export type { Bivariant };

package/dist/empty.d.ts

@@ -0,0 +1,5 @@
+import { behavior } from '@actor-system/core';
+
+declare const empty: behavior.Receive<never>;
+
+export { empty };

package/dist/empty.internal.d.ts

@@ -0,0 +1,5 @@
+import { behavior } from '@actor-system/core/internal';
+
+declare const empty: behavior.Receive<never>;
+
+export { empty };

package/dist/empty.js

@@ -0,0 +1,5 @@
+import { behavior } from '@actor-system/core';
+
+const empty = behavior._empty;
+
+export { empty };

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+export { empty } from './empty.js';
+export { intercept } from './intercept.js';
+export { ReceiveMessage, ReceiveSignal, receive, receiveMessage, receiveSignal } from './receive.js';
+export { restart } from './restart.js';
+export { same } from './same.js';
+export { setup } from './setup.js';
+export { stopped } from './stopped.js';
+export { supervise } from './supervise.js';
+export { Stash, withStash } from './with-stash.js';
+export { Timers, withTimers } from './with-timers.js';
+export { Behavior } from '@actor-system/core';

package/dist/index.internal.d.ts

@@ -0,0 +1,11 @@
+export { empty } from './empty.internal.js';
+export { intercept } from './intercept.internal.js';
+export { ReceiveMessage, ReceiveSignal, receive, receiveMessage, receiveSignal } from './receive.internal.js';
+export { restart } from './restart.internal.js';
+export { same } from './same.internal.js';
+export { setup } from './setup.internal.js';
+export { stopped } from './stopped.internal.js';
+export { supervise } from './supervise.internal.js';
+export { Stash, withStash } from './with-stash.internal.js';
+export { Timers, withTimers } from './with-timers.internal.js';
+export { Behavior } from '@actor-system/core/internal';

package/dist/index.js

@@ -0,0 +1,10 @@
+export { empty } from './empty.js';
+export { intercept } from './intercept.js';
+export { receive, receiveMessage, receiveSignal } from './receive.js';
+export { restart } from './restart.js';
+export { same } from './same.js';
+export { setup } from './setup.js';
+export { stopped } from './stopped.js';
+export { supervise } from './supervise.js';
+export { withStash } from './with-stash.js';
+export { withTimers } from './with-timers.js';

package/dist/intercept.d.ts

@@ -0,0 +1,10 @@
+import { behavior, signal, ActorContext } from '@actor-system/core';
+import { Bivariant } from './__bundle__/shared/dist/types.js';
+
+type Interceptor<Input, Output = Input> = Bivariant<(post: Output | signal.Signal, context: ActorContext<Output>) => Input | signal.Signal | behavior.Behavior<Input>>;
+declare function intercept<Input, Output = Input>(inner: behavior.Folded<Input>, interceptor: Interceptor<Input, Output>): behavior.Folded<Output>;
+declare function intercept<Input, Output = Input>(inner: behavior.Control<Input>, interceptor: Interceptor<Input, Output>): behavior.Control<Output>;
+declare function intercept<Input, Output = Input>(inner: behavior.Receive<Input>, interceptor: Interceptor<Input, Output>): behavior.Receive<Output>;
+declare function intercept<Input, Output = Input>(inner: behavior.Behavior<Input>, interceptor: Interceptor<Input, Output>): behavior.Behavior<Output>;
+
+export { intercept };

package/dist/intercept.internal.d.ts

@@ -0,0 +1,10 @@
+import { behavior, signal, ActorContext } from '@actor-system/core/internal';
+import { Bivariant } from './__bundle__/shared/dist/types.internal.js';
+
+type Interceptor<Input, Output = Input> = Bivariant<(post: Output | signal.Signal, context: ActorContext<Output>) => Input | signal.Signal | behavior.Behavior<Input>>;
+declare function intercept<Input, Output = Input>(inner: behavior.Folded<Input>, interceptor: Interceptor<Input, Output>): behavior.Folded<Output>;
+declare function intercept<Input, Output = Input>(inner: behavior.Control<Input>, interceptor: Interceptor<Input, Output>): behavior.Control<Output>;
+declare function intercept<Input, Output = Input>(inner: behavior.Receive<Input>, interceptor: Interceptor<Input, Output>): behavior.Receive<Output>;
+declare function intercept<Input, Output = Input>(inner: behavior.Behavior<Input>, interceptor: Interceptor<Input, Output>): behavior.Behavior<Output>;
+
+export { intercept };

package/dist/intercept.js

@@ -0,0 +1,23 @@
+import { behavior } from '@actor-system/core';
+import { receive } from './receive.js';
+import { setup } from './setup.js';
+
+function intercept(inner, interceptor) {
+    if (behavior.isControl(inner)) {
+        return inner;
+    }
+    if (behavior.isFolded(inner)) {
+        return setup((ctx) => intercept(behavior.unfold(inner, ctx), interceptor));
+    }
+    if (behavior.isReceive(inner)) {
+        return receive((message, context) => {
+            const intercepted = interceptor(message, context);
+            return behavior.isBehavior(intercepted)
+                ? intercept(intercepted, interceptor)
+                : intercept(behavior.delegate(inner, intercepted, context), interceptor);
+        });
+    }
+    throw new Error(`Cannot intercept behavior of type ${inner} with interceptor`);
+}
+
+export { intercept };

package/dist/receive.d.ts

@@ -0,0 +1,15 @@
+import { signal, ActorContext, behavior } from '@actor-system/core';
+import { Bivariant } from './__bundle__/shared/dist/types.js';
+
+interface ReceiveMessage<T> extends behavior.Receive<T> {
+    receiveSignal(handler: Bivariant<(signal: signal.Signal, ctx: ActorContext<T>) => behavior.Behavior<T> | void>): behavior.Receive<T>;
+}
+interface ReceiveSignal<T> extends behavior.Receive<T> {
+    receiveMessage(handler: Bivariant<(message: T, ctx: ActorContext<T>) => behavior.Behavior<T> | void>): behavior.Receive<T>;
+}
+declare const receiveMessage: <T>(onMessage: Bivariant<(message: T, context: ActorContext<T>) => behavior.Behavior<T> | void>) => ReceiveMessage<T>;
+declare const receiveSignal: <T>(onSignal: Bivariant<(signal: signal.Signal, context: ActorContext<T>) => behavior.Behavior<T> | void>) => ReceiveSignal<T>;
+declare const receive: <T>(handler: Bivariant<(messageOrSignal: T | signal.Signal, context: ActorContext<T>) => behavior.Behavior<T> | void>) => behavior.Receive<T>;
+
+export { receive, receiveMessage, receiveSignal };
+export type { ReceiveMessage, ReceiveSignal };

package/dist/receive.internal.d.ts

@@ -0,0 +1,15 @@
+import { signal, ActorContext, behavior } from '@actor-system/core/internal';
+import { Bivariant } from './__bundle__/shared/dist/types.internal.js';
+
+interface ReceiveMessage<T> extends behavior.Receive<T> {
+    receiveSignal(handler: Bivariant<(signal: signal.Signal, ctx: ActorContext<T>) => behavior.Behavior<T> | void>): behavior.Receive<T>;
+}
+interface ReceiveSignal<T> extends behavior.Receive<T> {
+    receiveMessage(handler: Bivariant<(message: T, ctx: ActorContext<T>) => behavior.Behavior<T> | void>): behavior.Receive<T>;
+}
+declare const receiveMessage: <T>(onMessage: Bivariant<(message: T, context: ActorContext<T>) => behavior.Behavior<T> | void>) => ReceiveMessage<T>;
+declare const receiveSignal: <T>(onSignal: Bivariant<(signal: signal.Signal, context: ActorContext<T>) => behavior.Behavior<T> | void>) => ReceiveSignal<T>;
+declare const receive: <T>(handler: Bivariant<(messageOrSignal: T | signal.Signal, context: ActorContext<T>) => behavior.Behavior<T> | void>) => behavior.Receive<T>;
+
+export { receive, receiveMessage, receiveSignal };
+export type { ReceiveMessage, ReceiveSignal };

package/dist/receive.js

@@ -0,0 +1,18 @@
+import { behavior, signal } from '@actor-system/core';
+import { same } from './same.js';
+
+const receiveMessage = (onMessage) => ({
+    ...behavior.receive((message, ctx) => !signal.isSignal(message) ? (onMessage(message, ctx) ?? same) : same),
+    receiveSignal: (onSignal) => behavior.receive((message, context) => (!signal.isSignal(message)
+        ? onMessage(message, context)
+        : onSignal(message, context)) ?? same),
+});
+const receiveSignal = (onSignal) => ({
+    ...behavior.receive((message, ctx) => signal.isSignal(message) ? (onSignal(message, ctx) ?? same) : same),
+    receiveMessage: (onMessage) => behavior.receive((message, context) => (signal.isSignal(message)
+        ? onSignal(message, context)
+        : onMessage(message, context)) ?? same),
+});
+const receive = (handler) => behavior.receive((message, ctx) => handler(message, ctx) ?? same);
+
+export { receive, receiveMessage, receiveSignal };

package/dist/restart.d.ts

@@ -0,0 +1,5 @@
+import { behavior } from '@actor-system/core';
+
+declare const restart: <T>(checkpoint: behavior.Behavior<T>) => behavior.Control<T>;
+
+export { restart };

package/dist/restart.internal.d.ts

@@ -0,0 +1,5 @@
+import { behavior } from '@actor-system/core/internal';
+
+declare const restart: <T>(checkpoint: behavior.Behavior<T>) => behavior.Control<T>;
+
+export { restart };

package/dist/restart.js

@@ -0,0 +1,7 @@
+import { behavior } from '@actor-system/core';
+
+const restart = (checkpoint) => behavior.control((runtime) => {
+    runtime.restart(checkpoint);
+});
+
+export { restart };

package/dist/same.d.ts

@@ -0,0 +1,5 @@
+import { behavior } from '@actor-system/core';
+
+declare const same: behavior.Control<never>;
+
+export { same };

package/dist/same.internal.d.ts

@@ -0,0 +1,5 @@
+import { behavior } from '@actor-system/core/internal';
+
+declare const same: behavior.Control<never>;
+
+export { same };

package/dist/same.js

@@ -0,0 +1,5 @@
+import { behavior } from '@actor-system/core';
+
+const same = behavior._same;
+
+export { same };

package/dist/setup.d.ts

@@ -0,0 +1,8 @@
+import { ActorContext, behavior } from '@actor-system/core';
+import { Bivariant } from './__bundle__/shared/dist/types.js';
+
+type SetupFactory<T> = Bivariant<(context: ActorContext<T>) => behavior.Behavior<T> | void>;
+declare const setup: <T>(factory: SetupFactory<T>) => behavior.Folded<T>;
+
+export { setup };
+export type { SetupFactory };

package/dist/setup.internal.d.ts

@@ -0,0 +1,8 @@
+import { ActorContext, behavior } from '@actor-system/core/internal';
+import { Bivariant } from './__bundle__/shared/dist/types.internal.js';
+
+type SetupFactory<T> = Bivariant<(context: ActorContext<T>) => behavior.Behavior<T> | void>;
+declare const setup: <T>(factory: SetupFactory<T>) => behavior.Folded<T>;
+
+export { setup };
+export type { SetupFactory };

package/dist/setup.js

@@ -0,0 +1,6 @@
+import { behavior } from '@actor-system/core';
+import { empty } from './empty.js';
+
+const setup = (factory) => behavior.folded((ctx) => factory(ctx) ?? empty);
+
+export { setup };

package/dist/stopped.d.ts

@@ -0,0 +1,5 @@
+import { behavior } from '@actor-system/core';
+
+declare const stopped: behavior.Control<never>;
+
+export { stopped };

package/dist/stopped.internal.d.ts

@@ -0,0 +1,5 @@
+import { behavior } from '@actor-system/core/internal';
+
+declare const stopped: behavior.Control<never>;
+
+export { stopped };

package/dist/stopped.js

@@ -0,0 +1,7 @@
+import { behavior } from '@actor-system/core';
+
+const stopped = behavior.control((runtime) => {
+    runtime.stopSelf();
+});
+
+export { stopped };

package/dist/supervise.d.ts

@@ -0,0 +1,14 @@
+import { behavior, ActorContext } from '@actor-system/core';
+
+/**
+ * Supervision Decision Types
+ */
+type SupervisionDecision = "restart" | "resume" | "stop" | "escalate";
+type SupervisionStrategy<T> = (error: unknown, ctx: ActorContext<T>) => SupervisionDecision;
+declare function supervise<T>(inner: behavior.Control<T>, strategy: SupervisionStrategy<T> | SupervisionDecision): behavior.Control<T>;
+declare function supervise<T>(inner: behavior.Receive<T>, strategy: SupervisionStrategy<T> | SupervisionDecision): behavior.Receive<T>;
+declare function supervise<T>(inner: behavior.Folded<T>, strategy: SupervisionStrategy<T> | SupervisionDecision): behavior.Folded<T>;
+declare function supervise<T>(inner: behavior.Behavior<T>, strategy: SupervisionStrategy<T> | SupervisionDecision): behavior.Behavior<T>;
+
+export { supervise };
+export type { SupervisionDecision, SupervisionStrategy };

package/dist/supervise.internal.d.ts

@@ -0,0 +1,14 @@
+import { behavior, ActorContext } from '@actor-system/core/internal';
+
+/**
+ * Supervision Decision Types
+ */
+type SupervisionDecision = "restart" | "resume" | "stop" | "escalate";
+type SupervisionStrategy<T> = (error: unknown, ctx: ActorContext<T>) => SupervisionDecision;
+declare function supervise<T>(inner: behavior.Control<T>, strategy: SupervisionStrategy<T> | SupervisionDecision): behavior.Control<T>;
+declare function supervise<T>(inner: behavior.Receive<T>, strategy: SupervisionStrategy<T> | SupervisionDecision): behavior.Receive<T>;
+declare function supervise<T>(inner: behavior.Folded<T>, strategy: SupervisionStrategy<T> | SupervisionDecision): behavior.Folded<T>;
+declare function supervise<T>(inner: behavior.Behavior<T>, strategy: SupervisionStrategy<T> | SupervisionDecision): behavior.Behavior<T>;
+
+export { supervise };
+export type { SupervisionDecision, SupervisionStrategy };

package/dist/supervise.js

@@ -0,0 +1,36 @@
+import { behavior } from '@actor-system/core';
+import { restart } from './restart.js';
+import { stopped } from './stopped.js';
+
+function supervise(inner, strategy) {
+    if (behavior.isControl(inner)) {
+        return inner;
+    }
+    if (behavior.isFolded(inner)) {
+        return behavior.folded((context) => supervise(behavior.unfold(inner, context), strategy));
+    }
+    if (behavior.isReceive(inner)) {
+        return behavior.receive((message, context) => {
+            try {
+                const nextBehavior = inner._receive(message, context);
+                return supervise(nextBehavior, strategy);
+            }
+            catch (error) {
+                const decision = typeof strategy === "string" ? strategy : strategy(error, context);
+                switch (decision) {
+                    case "restart":
+                        return restart(supervise(inner, strategy));
+                    case "resume":
+                        return supervise(inner, strategy);
+                    case "stop":
+                        return stopped;
+                    case "escalate":
+                        throw error;
+                }
+            }
+        });
+    }
+    throw new Error(`Unknown behavior type: ${inner}`);
+}
+
+export { supervise };

package/dist/with-stash.d.ts

@@ -0,0 +1,12 @@
+import { ActorContext, behavior } from '@actor-system/core';
+
+interface Stash<T> {
+    push(msg: T): void;
+    dropAll(): void;
+    popAll(): void;
+    readonly size: number;
+}
+declare const withStash: <T>(factory: (stash: Stash<T>, context: ActorContext<T>) => behavior.Behavior<T>) => behavior.Behavior<T>;
+
+export { withStash };
+export type { Stash };

package/dist/with-stash.internal.d.ts

@@ -0,0 +1,12 @@
+import { ActorContext, behavior } from '@actor-system/core/internal';
+
+interface Stash<T> {
+    push(msg: T): void;
+    dropAll(): void;
+    popAll(): void;
+    readonly size: number;
+}
+declare const withStash: <T>(factory: (stash: Stash<T>, context: ActorContext<T>) => behavior.Behavior<T>) => behavior.Behavior<T>;
+
+export { withStash };
+export type { Stash };

package/dist/with-stash.js

@@ -0,0 +1,45 @@
+import { signal } from '@actor-system/core';
+import { setup } from './setup.js';
+import { intercept } from './intercept.js';
+
+const $stash = Symbol("stash");
+const withStash = (factory) => setup((context) => {
+    const stash = useStash(context);
+    const innerBehavior = factory(stash, context);
+    return intercept(innerBehavior, (post) => {
+        if (signal.isPostStop(post)) {
+            stash.dropAll();
+        }
+        return post;
+    });
+});
+const useStash = (context, capacity = 100) => {
+    if (context[$stash])
+        return context[$stash];
+    const stack = [];
+    const stash = {
+        /** Stash a message for later processing */
+        push: (msg) => {
+            if (stack.length < capacity) {
+                stack.push(msg);
+            }
+        },
+        /** Drop all stashed messages */
+        dropAll: () => {
+            stack.length = 0;
+        },
+        /** Unstash all messages, sending them to the actor's mailbox */
+        popAll: () => {
+            stack.forEach((msg) => context.self.tell(msg));
+            stack.length = 0;
+        },
+        /** Get current stash size */
+        get size() {
+            return stack.length;
+        },
+    };
+    context[$stash] = stash;
+    return stash;
+};
+
+export { useStash, withStash };

package/dist/with-timers.d.ts

@@ -0,0 +1,11 @@
+import { ActorContext, behavior } from '@actor-system/core';
+
+interface Timers<T> {
+    startSingleTimer(key: PropertyKey, post: T, delay: number): void;
+    cancel(key: PropertyKey): void;
+    cancelAll(): void;
+}
+declare const withTimers: <T>(factory: (timers: Timers<T>, context: ActorContext<T>) => behavior.Behavior<T>) => behavior.Folded<T>;
+
+export { withTimers };
+export type { Timers };

package/dist/with-timers.internal.d.ts

@@ -0,0 +1,11 @@
+import { ActorContext, behavior } from '@actor-system/core/internal';
+
+interface Timers<T> {
+    startSingleTimer(key: PropertyKey, post: T, delay: number): void;
+    cancel(key: PropertyKey): void;
+    cancelAll(): void;
+}
+declare const withTimers: <T>(factory: (timers: Timers<T>, context: ActorContext<T>) => behavior.Behavior<T>) => behavior.Folded<T>;
+
+export { withTimers };
+export type { Timers };

package/dist/with-timers.js

@@ -0,0 +1,50 @@
+import { signal } from '@actor-system/core';
+import { intercept } from './intercept.js';
+import { setup } from './setup.js';
+
+const $timers = Symbol("timers");
+const withTimers = (factory) => setup((context) => {
+    const timers = useTimers(context);
+    const innerBehavior = factory(timers, context);
+    return intercept(innerBehavior, (post) => {
+        if (signal.isPostStop(post)) {
+            timers.cancelAll();
+        }
+        return post;
+    });
+});
+const useTimers = (context) => {
+    if (context[$timers])
+        return context[$timers];
+    const buffer = new Map();
+    const timers = {
+        startSingleTimer: (key, post, delay) => {
+            if (buffer.has(key)) {
+                clearTimeout(buffer.get(key));
+            }
+            const timeout = setTimeout(() => {
+                context.self.tell(post);
+                buffer.delete(key);
+            }, delay);
+            buffer.set(key, timeout);
+        },
+        cancel: (key) => {
+            const timeout = buffer.get(key);
+            if (timeout) {
+                clearTimeout(timeout);
+                buffer.delete(key);
+            }
+        },
+        cancelAll() {
+            for (const timeout of buffer.values()) {
+                clearTimeout(timeout);
+            }
+            buffer.clear();
+            return;
+        },
+    };
+    context[$timers] = timers;
+    return timers;
+};
+
+export { useTimers, withTimers };

package/package.json

@@ -0,0 +1,38 @@
+{
+  "name": "@actor-system/behaviors",
+  "version": "0.0.1",
+  "type": "module",
+  "scripts": {
+    "type-check": "tsc -b src",
+    "lint": "eslint src",
+    "lint:fix": "eslint src --fix",
+    "publint": "publint",
+    "build:tsc:internal": "tsc -b src/tsconfig.lib.json",
+    "build:tsc:trimmed": "tsc -b src/tsconfig.lib.trimmed.json",
+    "build:rollup": "rollup -c node:config/rollup-config"
+  },
+  "module": "./dist/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "bundleDependencies": [
+    "@actor-system/shared"
+  ],
+  "dependencies": {
+    "@actor-system/core": "0.0.1"
+  },
+  "devDependencies": {
+    "@actor-system/testing": "0.0.1",
+    "@actor-system/shared": "0.0.1",
+    "config": "^1.0.0"
+  }
+}