slapflow 1.1.0 → 1.2.1

package/dist/index.js

@@ -1,9 +1,6 @@
 // src/helpers/config/defineConfig.ts
 var defineConfig = (config) => config;
 
-// src/helpers/trace/cloneData.ts
-var cloneData = (data) => ({ ...data });
-
 // src/helpers/trace/createMemoryTraceSink.ts
 var createMemoryTraceSink = () => {
   const items = [];
@@ -15,22 +12,9 @@ var createMemoryTraceSink = () => {
   };
 };
 
-// src/helpers/errors/slapError.ts
-var slapError = (code, message, extras = {}) => ({ code, message, ...extras });
-
 // src/helpers/errors/defineErrorReporter.ts
 var defineErrorReporter = (handlers) => typeof handlers === "function" ? handlers : handlers.report;
 
-// src/errors.ts
-var SyncAsyncError = class extends Error {
-  slapError;
-  constructor(error) {
-    super(error.message);
-    this.name = "SyncAsyncError";
-    this.slapError = error;
-  }
-};
-
 // src/helpers/ids/createId.ts
 var alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
 var idLength = 12;
@@ -70,7 +54,7 @@ var serializeError = (error) => ({
   error: error instanceof Error ? error.message : String(error)
 });
 
-// src/pubSub.ts
+// src/createPubSub.ts
 var createPubSub = (options = {}) => {
   const subscribers = /* @__PURE__ */ new Map();
   const wildcardSubscribers = /* @__PURE__ */ new Map();
@@ -168,6 +152,16 @@ var createPubSub = (options = {}) => {
 };
 var PubSub = createPubSub();
 
+// src/helpers/errors/syncAsyncError.ts
+var SyncAsyncError = class extends Error {
+  slapError;
+  constructor(error) {
+    super(error.message);
+    this.name = "SyncAsyncError";
+    this.slapError = error;
+  }
+};
+
 // src/helpers/actions/coreDelay.ts
 var coreDelay = async ({
   props,
@@ -204,10 +198,7 @@ var coreEmit = ({
 };
 
 // src/helpers/actions/coreFail.ts
-var coreFail = ({
-  props,
-  runtime
-}) => runtime.fail(String(props.reason ?? "failed"), props.data);
+var coreFail = ({ props, runtime }) => runtime.fail(String(props.reason ?? "failed"), props.data);
 
 // src/helpers/retry/getRetryDelay.ts
 var getRetryDelay = (attempt, options) => {
@@ -414,10 +405,7 @@ var corePatch = ({
 };
 
 // src/helpers/actions/coreSet.ts
-var coreSet = ({
-  props,
-  runtime
-}) => {
+var coreSet = ({ props, runtime }) => {
   const path = props.path;
   if (typeof path === "string") {
     runtime.set(path, props.value);
@@ -438,13 +426,10 @@ var coreSetData = ({
 };
 
 // src/helpers/actions/coreStop.ts
-var coreStop = ({
-  props,
-  runtime
-}) => runtime.stop(String(props.reason ?? "stopped"));
+var coreStop = ({ props, runtime }) => runtime.stop(String(props.reason ?? "stopped"));
 
-// src/registry/actions.ts
-var createActionsRegistry = () => /* @__PURE__ */ new Map([
+// src/helpers/actions/index.ts
+var BUILTIN_ACTIONS = [
   ["core.noop", coreNoop],
   ["core.stop", coreStop],
   ["core.fail", coreFail],
@@ -458,7 +443,8 @@ var createActionsRegistry = () => /* @__PURE__ */ new Map([
   ["core.emit", coreEmit],
   ["core.patch", corePatch],
   ["core.delay", coreDelay]
-]);
+];
+var BUILTIN_ACTION_NAMES = new Set(BUILTIN_ACTIONS.map(([name]) => name));
 
 // src/helpers/conditions/changedCondition.ts
 var changedCondition = (_args, current, previous) => !Object.is(current, previous);
@@ -552,8 +538,8 @@ var typeIsCondition = (_args, value, expected) => {
   return expected === "string" || expected === "number" || expected === "boolean" ? typeof value === expected : false;
 };
 
-// src/registry/conditions.ts
-var createConditionsRegistry = () => /* @__PURE__ */ new Map([
+// src/helpers/conditions/index.ts
+var BUILTIN_CONDITIONS = [
   ["eq", eqCondition],
   ["neq", neqCondition],
   ["gt", gtCondition],
@@ -570,7 +556,8 @@ var createConditionsRegistry = () => /* @__PURE__ */ new Map([
   ["typeIs", typeIsCondition],
   ["changed", changedCondition],
   ["cooldownReady", cooldownReadyCondition]
-]);
+];
+var BUILTIN_CONDITION_NAMES = new Set(BUILTIN_CONDITIONS.map(([name]) => name));
 
 // src/helpers/runner/applyResult.ts
 var applyResult = (result, state, mergeData) => {
@@ -584,6 +571,9 @@ var applyResult = (result, state, mergeData) => {
   state.events.push(...result.events);
 };
 
+// src/helpers/errors/slapError.ts
+var slapError = (code, message, extras = {}) => ({ code, message, ...extras });
+
 // src/helpers/path/resolveValue.ts
 import { pick as pick3 } from "objwalk";
 
@@ -1022,7 +1012,7 @@ var executeNext = (item, depth, state, environment) => {
   const id = typeof item === "string" ? item : item.strategy;
   if (typeof item !== "string" && item.when) {
     const runtime = createRuntime(state);
-    const condition = evaluateCondition(item.when, environment.conditionsRegistry, { ...state, runtime, strategy: id });
+    const condition = evaluateCondition(item.when, environment.registry.conditions, { ...state, runtime, strategy: id });
     if (!condition.ok) {
       return { status: "failed", error: condition.error, patches: [], events: [] };
     }
@@ -1274,6 +1264,9 @@ var normalizeActionResult = (raw) => {
   };
 };
 
+// src/helpers/trace/cloneData.ts
+var cloneData = (data) => ({ ...data });
+
 // src/helpers/runner/pushTrace.ts
 var pushTrace = (state, step, depth, strategyId, strategy, status, props, dataBefore, startedAt, reason) => {
   state.traceSink?.push({
@@ -1456,7 +1449,7 @@ var executeStrategy = (id, extraProps, depth, state, environment) => {
       events: []
     };
   }
-  const action = environment.actionsRegistry.get(strategy.fn);
+  const action = environment.registry.actions.get(strategy.fn);
   if (!action) {
     return {
       status: "failed",
@@ -1511,7 +1504,7 @@ var executeStrategy = (id, extraProps, depth, state, environment) => {
   const dataBefore = cloneData(state.data);
   const traceStep = state.stepCounter.current + 1;
   const startedAt = Date.now();
-  const condition = evaluateCondition(strategy.when, environment.conditionsRegistry, {
+  const condition = evaluateCondition(strategy.when, environment.registry.conditions, {
     ...state,
     runtime,
     strategy: id
@@ -1825,7 +1818,12 @@ var validateCondition = (expression, strategy, path, conditionsRegistry, errors)
   const [operator, ...args] = expression;
   if (operator === "guard") {
     if (args.length !== 1 || typeof args[0] !== "string") {
-      errors.push({ code: "CONDITION_INVALID", message: "Guard reference must be a single string name", strategy, path });
+      errors.push({
+        code: "CONDITION_INVALID",
+        message: "Guard reference must be a single string name",
+        strategy,
+        path
+      });
     }
     return;
   }
@@ -1878,7 +1876,9 @@ var validateNextList = (config, list, path, strategy, conditionsRegistry, errors
 var isGuardRef = (expression) => Array.isArray(expression) && expression.length === 2 && expression[0] === "guard" && typeof expression[1] === "string";
 var resolveRef = (config, name, visiting, path) => {
   if (visiting.includes(name)) {
-    return { issue: { code: "GUARD_CYCLE", message: `Guard "${name}" is part of a reference cycle`, guard: name, path } };
+    return {
+      issue: { code: "GUARD_CYCLE", message: `Guard "${name}" is part of a reference cycle`, guard: name, path }
+    };
   }
   const guard = config.guards?.[name];
   if (guard === void 0) {
@@ -2101,10 +2101,10 @@ var createRunCancellation = (source) => {
   };
 };
 
-// src/helpers/runner/createRunner.ts
+// src/createRunner.ts
 var createRunner = (options = {}) => {
-  const actionsRegistry = createActionsRegistry();
-  const conditionsRegistry = createConditionsRegistry();
+  const actionsRegistry = new Map(BUILTIN_ACTIONS);
+  const conditionsRegistry = new Map(BUILTIN_CONDITIONS);
   const configRef = {};
   const timeout = options.timeout ?? options.timeoutMs;
   const runnerOptions = timeout === void 0 ? options : { ...options, timeout };
@@ -2114,19 +2114,24 @@ var createRunner = (options = {}) => {
     console.warn("timeoutMs is deprecated; use timeout. It will be removed in a future major release.");
   }
   const environment = {
-    actionsRegistry,
-    conditionsRegistry,
+    registry: { actions: actionsRegistry, conditions: conditionsRegistry },
     configRef,
     options: runnerOptions,
     mergeData
   };
   const registerAction = (name, action) => {
+    if (BUILTIN_ACTION_NAMES.has(name)) {
+      throw new Error(`Cannot override built-in action "${name}"`);
+    }
     actionsRegistry.set(name, action);
   };
   const registerActions = (items) => {
     Object.entries(items).forEach(([name, action]) => registerAction(name, action));
   };
   const registerCondition = (name, condition) => {
+    if (BUILTIN_CONDITION_NAMES.has(name)) {
+      throw new Error(`Cannot override built-in condition "${name}"`);
+    }
     conditionsRegistry.set(name, condition);
   };
   const registerConditions = (items) => {
@@ -2223,7 +2228,7 @@ var parseDomBinding = (binding, prefix) => {
   return separator <= 0 || separator === source.length - 1 ? void 0 : { selector: source.slice(0, separator), eventType: source.slice(separator + 1) };
 };
 
-// src/flow.ts
+// src/createFlow.ts
 var busBindingPrefix = "[bus] ";
 var domBindingPrefix = "[dom] ";
 var defaultMaxQueueSize = 50;
@@ -2464,10 +2469,11 @@ var createFlow = (definition, options) => {
   return { runner, start, stop };
 };
 
-// src/ws.ts
+// src/createWS.ts
 var openState = 1;
 var maxSeenEvents = 1e3;
 var createWS = (options) => {
+  console.warn("[slapflow] createWS is deprecated and will be removed soon. Use createWebSocket instead.");
   const inboundTopics = new Set(options.inboundTopics ?? []);
   const outboundTopics = new Set(options.outboundTopics ?? []);
   const seenEventIds = /* @__PURE__ */ new Set();
@@ -2631,7 +2637,150 @@ var createWS = (options) => {
   return { start, stop, reconnect, status: () => currentStatus };
 };
 
-// src/catchError.ts
+// src/helpers/parsePayload.ts
+var parsePayload = (data) => {
+  if (typeof data === "string") {
+    try {
+      return JSON.parse(data);
+    } catch {
+      return data;
+    }
+  }
+  return data;
+};
+
+// src/createWebSocket.ts
+var WebSocketConnection = class {
+  constructor(options) {
+    this.options = options;
+  }
+  options;
+  _socket;
+  _retryTimer;
+  _retryAttempt = 0;
+  _queue = [];
+  _started = false;
+  _status = "idle";
+  start() {
+    if (!this._started) {
+      this._started = true;
+      this.connect();
+    }
+  }
+  stop() {
+    this._started = false;
+    this.clearTimer();
+    this.clearQueue();
+    const current = this._socket;
+    this._socket = void 0;
+    current?.close();
+    this.setStatus("stopped");
+  }
+  reconnect() {
+    if (this._started) {
+      this.clearTimer();
+      const current = this._socket;
+      this._socket = void 0;
+      current?.close();
+      this.connect();
+    }
+  }
+  status() {
+    return this._status;
+  }
+  send(data) {
+    if (this._socket?.readyState === WebSocket.OPEN) {
+      this._socket.send(data);
+    } else {
+      this._queue.push(data);
+    }
+  }
+  connect() {
+    if (!this._started || this._socket) {
+      return;
+    }
+    const { url, protocols } = this.options;
+    const current = new WebSocket(url, protocols ?? []);
+    this._socket = current;
+    this.setStatus("connecting");
+    current.addEventListener("open", () => this.onOpen(current));
+    current.addEventListener("message", (event) => this.onMessage(current, event));
+    current.addEventListener("close", (event) => this.onClose(current, event));
+    current.addEventListener("error", (event) => this.onError(current, event));
+  }
+  onOpen(current) {
+    if (this._socket === current) {
+      this._retryAttempt = 0;
+      this.setStatus("connected");
+      this.flush();
+      this.dispatch("open", { url: this.options.url });
+    }
+  }
+  onMessage(current, event) {
+    if (this._socket === current) {
+      this.dispatch("message", parsePayload(event.data));
+    }
+  }
+  onClose(current, event) {
+    if (this._socket === current) {
+      this._socket = void 0;
+      this.dispatch("close", event);
+      if (this._started) {
+        this.retry();
+      }
+    }
+  }
+  onError(current, event) {
+    if (this._socket === current) {
+      this.dispatch("error", serializeError(event.error));
+    }
+  }
+  dispatch(topic, parsed) {
+    const { bus, origin } = this.options;
+    bus.dispatch({
+      id: createId(),
+      topic,
+      occurredAt: Date.now(),
+      ...origin ? { origin } : {},
+      parsed,
+      serialized: JSON.stringify(parsed)
+    });
+  }
+  flush() {
+    if (this._socket && this._socket.readyState === WebSocket.OPEN) {
+      for (const message of this._queue) {
+        this._socket.send(message);
+      }
+      this.clearQueue();
+    }
+  }
+  retry() {
+    this.setStatus("reconnecting");
+    this._retryTimer = setTimeout(
+      () => {
+        this._retryTimer = void 0;
+        this.connect();
+      },
+      getRetryDelay(this._retryAttempt, this.options.reconnect ?? {})
+    );
+    this._retryAttempt = this._retryAttempt + 1;
+  }
+  setStatus(status) {
+    this._status = status || "idle";
+  }
+  clearQueue() {
+    this._queue = [];
+  }
+  clearTimer() {
+    if (this._retryTimer) {
+      clearTimeout(this._retryTimer);
+    }
+    this._retryTimer = void 0;
+  }
+};
+var createWebSocket = (options) => new WebSocketConnection(options);
+
+// src/helpers/catchError.ts
 var catchError = (callback) => new Promise((resolve, reject) => {
   try {
     resolve(callback());
@@ -2640,14 +2789,17 @@ var catchError = (callback) => new Promise((resolve, reject) => {
   }
 });
 export {
+  BUILTIN_ACTIONS,
+  BUILTIN_ACTION_NAMES,
+  BUILTIN_CONDITIONS,
+  BUILTIN_CONDITION_NAMES,
   PubSub,
   catchError,
-  createActionsRegistry,
-  createConditionsRegistry,
   createFlow,
   createMemoryTraceSink,
   createPubSub,
   createWS,
+  createWebSocket,
   defineConfig,
   defineErrorReporter
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "slapflow",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Chain actions behavior runtime",
   "license": "ISC",
   "author": "Sergey Khalilov",
@@ -57,7 +57,9 @@
     "test": "npm run typecheck && vitest run",
     "build": "tsup src/index.ts --format esm,cjs --dts --clean",
     "pack:check": "npm pack --dry-run",
-    "prepublishOnly": "npm test && npm run build"
+    "prepublishOnly": "npm test && npm run build",
+    "format": "prettier --write .",
+    "check": "prettier --check ."
   },
   "devDependencies": {
     "@types/node": "^26.1.0",