@flexsurfer/reflex 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1097 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  clearGlobalInterceptors: () => clearGlobalInterceptors,
+  debounceAndDispatch: () => debounceAndDispatch,
+  defaultErrorHandler: () => defaultErrorHandler,
+  disableTracing: () => disableTracing,
+  dispatch: () => dispatch,
+  enableTracePrint: () => enableTracePrint,
+  enableTracing: () => enableTracing,
+  getGlobalInterceptors: () => getGlobalInterceptors,
+  initAppDb: () => initAppDb,
+  isDebugEnabled: () => isDebugEnabled,
+  regCoeffect: () => regCoeffect,
+  regEffect: () => regEffect,
+  regEvent: () => regEvent,
+  regEventErrorHandler: () => regEventErrorHandler,
+  regGlobalInterceptor: () => regGlobalInterceptor,
+  regSub: () => regSub,
+  registerTraceCb: () => registerTraceCb,
+  setDebugEnabled: () => setDebugEnabled,
+  throttleAndDispatch: () => throttleAndDispatch,
+  useSubscription: () => useSubscription
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/loggers.ts
+var hasGroup = typeof console.group === "function";
+var hasGroupEnd = typeof console.groupEnd === "function";
+var defaultLoggers = {
+  log: console.log.bind(console),
+  warn: console.warn.bind(console),
+  error: console.error.bind(console),
+  debug: console.debug.bind(console),
+  group: hasGroup ? console.group.bind(console) : console.log.bind(console),
+  groupEnd: hasGroupEnd ? console.groupEnd.bind(console) : () => {
+  }
+};
+var currentLoggers = { ...defaultLoggers };
+function consoleLog(level, ...args) {
+  if (!(level in currentLoggers)) {
+    throw new Error(`reflex: log called with unknown level: ${level}`);
+  }
+  currentLoggers[level](...args);
+}
+
+// src/registrar.ts
+var kindToIdToHandler = {
+  event: {},
+  fx: {},
+  cofx: {},
+  sub: {},
+  subDeps: {},
+  error: {}
+};
+function getHandler(kind, id) {
+  const handler = kindToIdToHandler[kind][id];
+  if (!handler) {
+    consoleLog("error", `[reflex] no ${kind} handler registered for:`, id);
+  }
+  return handler;
+}
+function registerHandler(kind, id, handlerFn) {
+  if (kindToIdToHandler[kind][id]) {
+    consoleLog("warn", `[reflex] overwriting ${kind} handler for:`, id);
+  }
+  kindToIdToHandler[kind][id] = handlerFn;
+  return handlerFn;
+}
+function hasHandler(kind, id) {
+  return !!kindToIdToHandler[kind][id];
+}
+var reactionsRegistry = /* @__PURE__ */ new Map();
+function getReaction(key) {
+  return reactionsRegistry.get(key);
+}
+function setReaction(key, reaction) {
+  reactionsRegistry.set(key, reaction);
+}
+var interceptorsRegistry = /* @__PURE__ */ new Map();
+function getInterceptors(eventId) {
+  return interceptorsRegistry.get(eventId) || [];
+}
+function setInterceptors(eventId, interceptors) {
+  interceptorsRegistry.set(eventId, interceptors);
+}
+
+// src/schedule.ts
+function scheduleAfterRender(f) {
+  if (typeof requestAnimationFrame !== "undefined") {
+    requestAnimationFrame(() => {
+      Promise.resolve().then(f);
+    });
+  } else {
+    setTimeout(f, 16);
+  }
+}
+function scheduleNextTick(f) {
+  if (typeof globalThis.setImmediate === "function") {
+    globalThis.setImmediate(f);
+    return;
+  }
+  if (typeof MessageChannel !== "undefined") {
+    const { port1, port2 } = new MessageChannel();
+    port1.onmessage = () => f();
+    port2.postMessage(void 0);
+    return;
+  }
+  setTimeout(f, 0);
+}
+
+// src/db.ts
+var appDb = {};
+var reactionsQueue = /* @__PURE__ */ new Set();
+var reactionsScheduled = false;
+function initAppDb(value) {
+  appDb = value;
+}
+function getAppDb() {
+  return appDb;
+}
+function updateAppDbWithPatches(newDb, patches) {
+  if (patches.length > 0) {
+    appDb = newDb;
+    for (const patch of patches) {
+      const pathSegments = patch.path;
+      if (pathSegments.length > 0) {
+        const rootKey = pathSegments[0];
+        const subVectorKey = JSON.stringify([rootKey]);
+        const reaction = getReaction(subVectorKey);
+        if (reaction) {
+          if (!reaction.isRoot) {
+            consoleLog("error", `[reflex] updateAppDb: root reaction id ${subVectorKey} registered with a computed function. This is not allowed.`);
+            continue;
+          }
+          reactionsQueue.add(subVectorKey);
+        }
+      }
+    }
+    if (reactionsQueue.size > 0 && !reactionsScheduled) {
+      reactionsScheduled = true;
+      scheduleAfterRender(() => {
+        for (const subVectorKey of reactionsQueue) {
+          const reaction = getReaction(subVectorKey);
+          if (reaction) {
+            reaction.markDirty();
+          }
+        }
+        reactionsQueue.clear();
+        reactionsScheduled = false;
+      });
+    }
+  }
+}
+
+// src/interceptor.ts
+function isInterceptor(m) {
+  if (typeof m !== "object" || m === null)
+    return false;
+  const keys = new Set(Object.keys(m));
+  if (!keys.has("id"))
+    return false;
+  if (!keys.has("before") && !keys.has("after"))
+    return false;
+  return true;
+}
+function exceptionToExInfo(e, interceptor, direction) {
+  const ex = new Error(`Interceptor Exception: ${e.message}`);
+  ex.data = { direction, interceptor: interceptor.id, originalError: e };
+  ex.cause = e;
+  return ex;
+}
+function mergeExData(e, ...ms) {
+  const ex = new Error(e.message);
+  ex.data = Object.assign({}, e.data, ...ms);
+  ex.cause = e.cause;
+  return ex;
+}
+function invokeInterceptorFn(context, interceptor, direction) {
+  const fn = interceptor[direction];
+  if (!fn)
+    return context;
+  if (context.originalException) {
+    return fn(context);
+  }
+  try {
+    return fn(context);
+  } catch (e) {
+    throw exceptionToExInfo(e, interceptor, direction);
+  }
+}
+function invokeInterceptors(context, direction) {
+  let ctx = { ...context };
+  while (ctx.queue.length > 0) {
+    const [next, ...rest] = ctx.queue;
+    ctx = invokeInterceptorFn(
+      {
+        ...ctx,
+        queue: rest,
+        stack: direction === "before" ? [...ctx.stack, next] : ctx.stack
+      },
+      next,
+      direction
+    );
+  }
+  return ctx;
+}
+function changeDirection(context) {
+  return {
+    ...context,
+    queue: [...context.stack].reverse(),
+    stack: []
+  };
+}
+function createContext(eventV, interceptors) {
+  const coeffects = {
+    event: eventV,
+    draftDb: {}
+  };
+  return {
+    coeffects,
+    effects: [],
+    queue: [...interceptors],
+    stack: [],
+    newDb: {},
+    patches: [],
+    originalException: false
+  };
+}
+function executeInterceptors(ctx) {
+  const ctxAfterBeforePhase = invokeInterceptors(ctx, "before");
+  const ctxChangedDirection = changeDirection(ctxAfterBeforePhase);
+  return invokeInterceptors(ctxChangedDirection, "after");
+}
+function execute(eventV, interceptors) {
+  const ctx = createContext(eventV, interceptors);
+  const errorHandler = getHandler("error", "event-handler");
+  if (!errorHandler) {
+    return executeInterceptors({ ...ctx, originalException: true });
+  }
+  try {
+    return executeInterceptors(ctx);
+  } catch (e) {
+    const reFrameError = mergeExData(e, { eventV });
+    errorHandler(e.cause || e, reFrameError);
+    return ctx;
+  }
+}
+
+// src/cofx.ts
+var KIND = "cofx";
+function regCoeffect(id, handler) {
+  registerHandler(KIND, id, handler);
+}
+function getInjectCofxInterceptor(id, value) {
+  return {
+    id: `inject-${id}`,
+    before: (context) => {
+      const handler = getHandler(KIND, id);
+      if (handler) {
+        try {
+          context.coeffects = handler({ ...context.coeffects }, value);
+        } catch (error) {
+          consoleLog("error", `[reflex] Error in :${id} coeffect handler:`, error);
+        }
+      } else {
+        consoleLog("error", "[reflex] No cofx handler registered for", id);
+      }
+      return context;
+    }
+  };
+}
+regCoeffect("now", (coeffects) => ({
+  ...coeffects,
+  now: Date.now()
+}));
+regCoeffect("random", (coeffects) => ({
+  ...coeffects,
+  random: Math.random()
+}));
+
+// src/router.ts
+var laterFns = {
+  flush: scheduleAfterRender,
+  yield: scheduleNextTick
+};
+var EventQueue = class {
+  constructor(eventHandler) {
+    this.eventHandler = eventHandler;
+  }
+  fsmState = "idle";
+  queue = [];
+  push(event) {
+    this.fsmTrigger("add-event", event);
+  }
+  purge() {
+    this.queue = [];
+  }
+  fsmTrigger(trigger, arg) {
+    let newState;
+    let actionFn;
+    switch (`${this.fsmState}:${trigger}`) {
+      case "idle:add-event":
+        newState = "scheduled";
+        actionFn = () => {
+          this.addEvent(arg);
+          this.runNextTick();
+        };
+        break;
+      case "scheduled:add-event":
+        newState = "scheduled";
+        actionFn = () => this.addEvent(arg);
+        break;
+      case "scheduled:run-queue":
+        newState = "running";
+        actionFn = () => this.runQueue();
+        break;
+      case "running:add-event":
+        newState = "running";
+        actionFn = () => this.addEvent(arg);
+        break;
+      case "running:pause":
+        newState = "paused";
+        actionFn = () => this.pause(arg);
+        break;
+      case "running:exception":
+        newState = "idle";
+        actionFn = () => this.exception(arg);
+        break;
+      case "running:finish-run":
+        if (this.queue.length === 0) {
+          newState = "idle";
+        } else {
+          newState = "scheduled";
+          actionFn = () => this.runNextTick();
+        }
+        break;
+      case "paused:add-event":
+        newState = "paused";
+        actionFn = () => this.addEvent(arg);
+        break;
+      case "paused:resume":
+        newState = "running";
+        actionFn = () => this.resume();
+        break;
+      default:
+        consoleLog("error", `[reflex] router state transition not found. ${this.fsmState} ${trigger}`);
+        return;
+    }
+    this.fsmState = newState;
+    if (actionFn)
+      actionFn();
+  }
+  addEvent(event) {
+    this.queue.push(event);
+  }
+  processFirstEvent() {
+    const event = this.queue[0];
+    try {
+      this.eventHandler(event);
+      this.queue.shift();
+    } catch (ex) {
+      this.fsmTrigger("exception", ex);
+    }
+  }
+  runNextTick() {
+    laterFns.yield(() => this.fsmTrigger("run-queue"));
+  }
+  runQueue() {
+    let n = this.queue.length;
+    while (n > 0) {
+      const nextEvent = this.queue[0];
+      const metaKeys = nextEvent.meta ? Object.keys(nextEvent.meta) : [];
+      const laterKey = metaKeys.find((k) => laterFns[k]);
+      if (laterKey) {
+        this.fsmTrigger("pause", laterFns[laterKey]);
+        return;
+      }
+      this.processFirstEvent();
+      n -= 1;
+    }
+    this.fsmTrigger("finish-run");
+  }
+  exception(ex) {
+    this.purge();
+    consoleLog("error", "[reflex] event processing exception:", ex);
+  }
+  pause(laterFn) {
+    laterFn(() => this.fsmTrigger("resume"));
+  }
+  resume() {
+    this.processFirstEvent();
+    this.runQueue();
+  }
+  /**
+   * Get current state for debugging
+   */
+  getState() {
+    return this.fsmState;
+  }
+  /**
+   * Get queue length for debugging
+   */
+  getQueueLength() {
+    return this.queue.length;
+  }
+};
+var eventQueue = new EventQueue(handle);
+function isValidEventVector(value) {
+  return Array.isArray(value) && value.length > 0;
+}
+function dispatch(event) {
+  if (!isValidEventVector(event)) {
+    consoleLog("error", "[reflex] invalid dispatch event vector.");
+    return;
+  }
+  eventQueue.push(event);
+}
+
+// src/fx.ts
+var KIND2 = "fx";
+function regEffect(id, handler) {
+  registerHandler(KIND2, id, handler);
+}
+var doFxInterceptor = {
+  id: "do-fx",
+  after: (context) => {
+    if (context.newDb && context.patches) {
+      updateAppDbWithPatches(context.newDb, context.patches);
+    }
+    const effects = context.effects;
+    if (!Array.isArray(effects)) {
+      consoleLog("warn", `[reflex] effects expects a vector, but was given ${typeof effects}`);
+      return context;
+    }
+    effects.filter((effect) => Array.isArray(effect) && effect.length === 2).forEach(([key, val]) => {
+      const effectFn = getHandler(KIND2, key);
+      if (effectFn) {
+        try {
+          effectFn(val);
+        } catch (error) {
+          consoleLog("error", `[reflex] error in effects for ${key}:`, error);
+        }
+      } else {
+        consoleLog("warn", `[reflex] in 'effects' found ${key} which has no associated handler. Ignoring.`);
+      }
+    });
+    return context;
+  }
+};
+function dispatchLater(effect) {
+  const { ms, dispatch: eventToDispatch } = effect;
+  if (!Array.isArray(eventToDispatch) || typeof ms !== "number") {
+    consoleLog("error", "[reflex] ignoring bad dispatch-later value:", effect);
+    return;
+  }
+  if (ms < 0) {
+    consoleLog("warn", "[reflex] dispatch-later effect with negative delay:", ms);
+  }
+  setTimeout(() => dispatch(eventToDispatch), Math.max(0, ms));
+}
+regEffect("dispatch-later", (value) => {
+  dispatchLater(value);
+});
+regEffect("dispatch", (value) => {
+  if (!Array.isArray(value)) {
+    consoleLog("error", "[reflex] ignoring bad dispatch value. Expected a vector, but got:", value);
+    return;
+  }
+  dispatch(value);
+});
+
+// src/events.ts
+var import_immer = require("immer");
+
+// src/settings.ts
+var store = {
+  globalInterceptors: [],
+  debugEnabled: true
+  // Default to true, can be configured via setDebugEnabled
+};
+function replaceGlobalInterceptor(globalInterceptors, interceptor) {
+  return globalInterceptors.reduce((ret, existingInterceptor) => {
+    if (interceptor.id === existingInterceptor.id) {
+      if (store.debugEnabled) {
+        consoleLog("warn", "[reflex] replacing duplicate global interceptor id:", interceptor.id);
+      }
+      return [...ret, interceptor];
+    } else {
+      return [...ret, existingInterceptor];
+    }
+  }, []);
+}
+function regGlobalInterceptor(interceptor) {
+  const { id } = interceptor;
+  const ids = store.globalInterceptors.map((i) => i.id);
+  if (ids.includes(id)) {
+    store.globalInterceptors = replaceGlobalInterceptor(store.globalInterceptors, interceptor);
+  } else {
+    store.globalInterceptors = [...store.globalInterceptors, interceptor];
+  }
+}
+function getGlobalInterceptors() {
+  return [...store.globalInterceptors];
+}
+function clearGlobalInterceptors(id) {
+  if (id === void 0) {
+    store.globalInterceptors = [];
+  } else {
+    store.globalInterceptors = store.globalInterceptors.filter((interceptor) => interceptor.id !== id);
+  }
+}
+function setDebugEnabled(enabled) {
+  store.debugEnabled = enabled;
+}
+function isDebugEnabled() {
+  return store.debugEnabled;
+}
+
+// src/trace.ts
+var nextId = 1;
+var traces = [];
+var currentTrace = null;
+var traceEnabled = false;
+var traceCbs = /* @__PURE__ */ new Map();
+var debounceTimer = null;
+var DEBOUNCE_TIME = 50;
+function enableTracing() {
+  traceEnabled = true;
+}
+function disableTracing() {
+  traceEnabled = false;
+  resetTracing();
+}
+function resetTracing() {
+  nextId = 1;
+  traces = [];
+  currentTrace = null;
+  if (debounceTimer) {
+    clearTimeout(debounceTimer);
+    debounceTimer = null;
+  }
+}
+function registerTraceCb(key, cb) {
+  if (!traceEnabled) {
+    console.warn(
+      "Tracing is not enabled; call enableTracing() before registering callbacks"
+    );
+    return;
+  }
+  traceCbs.set(key, cb);
+}
+function scheduleFlush() {
+  if (debounceTimer)
+    return;
+  debounceTimer = setTimeout(() => {
+    const batch = traces.slice();
+    traces = [];
+    debounceTimer = null;
+    for (const cb of traceCbs.values()) {
+      try {
+        cb(batch);
+      } catch (e) {
+        console.error("Error in trace callback", e);
+      }
+    }
+  }, DEBOUNCE_TIME);
+}
+function startTrace(opts) {
+  const parentId = opts.childOf ?? currentTrace?.id ?? null;
+  const trace = {
+    id: nextId++,
+    operation: opts.operation,
+    opType: opts.opType,
+    tags: opts.tags ?? {},
+    childOf: parentId ?? void 0,
+    start: Date.now()
+  };
+  return trace;
+}
+function finishTrace(trace) {
+  if (!traceEnabled)
+    return;
+  trace.end = Date.now();
+  trace.duration = trace.end - trace.start;
+  traces.push(trace);
+  scheduleFlush();
+}
+function withTrace(opts, fn) {
+  if (!traceEnabled) {
+    return fn();
+  }
+  const parent = currentTrace;
+  currentTrace = startTrace(opts);
+  try {
+    return fn();
+  } finally {
+    finishTrace(currentTrace);
+    currentTrace = parent;
+  }
+}
+function mergeTrace(update) {
+  if (!traceEnabled || !currentTrace) {
+    return;
+  }
+  if (update.tags) {
+    currentTrace.tags = { ...currentTrace.tags, ...update.tags };
+  }
+  for (const k of Object.keys(update)) {
+    if (k !== "tags") {
+      currentTrace[k] = update[k];
+    }
+  }
+}
+function enableTracePrint() {
+  registerTraceCb("reflex-default-tracer", (traces2) => {
+    console.log("%c[reflex] [trace] ", "font-weight: bold; color: blue;", traces2);
+  });
+}
+
+// src/events.ts
+var KIND3 = "event";
+function regEvent(id, handler, cofxOrInterceptors, interceptors) {
+  registerHandler(KIND3, id, handler);
+  registerInterceptors(id, cofxOrInterceptors, interceptors);
+}
+function isCofxArray(arr) {
+  return arr.length > 0 && Array.isArray(arr[0]);
+}
+function registerInterceptors(id, cofxOrInterceptors, interceptors) {
+  let cofx;
+  let finalInterceptors;
+  if (cofxOrInterceptors) {
+    if (isCofxArray(cofxOrInterceptors)) {
+      cofx = cofxOrInterceptors;
+      finalInterceptors = interceptors;
+    } else {
+      cofx = void 0;
+      finalInterceptors = cofxOrInterceptors;
+    }
+  }
+  const cofxInterceptors = [];
+  if (cofx) {
+    for (const cofxSpec of cofx) {
+      if (cofxSpec.length === 1) {
+        cofxInterceptors.push(getInjectCofxInterceptor(cofxSpec[0]));
+      } else if (cofxSpec.length === 2) {
+        cofxInterceptors.push(getInjectCofxInterceptor(cofxSpec[0], cofxSpec[1]));
+      } else {
+        consoleLog("warn", "[reflex] invalid cofx specification:", cofxSpec);
+      }
+    }
+  }
+  const validatedInterceptors = [];
+  if (finalInterceptors) {
+    for (const interceptorCandidate of finalInterceptors) {
+      if (isInterceptor(interceptorCandidate)) {
+        validatedInterceptors.push(interceptorCandidate);
+      } else {
+        consoleLog("error", "[reflex] invalid interceptor provided for event:", id, "interceptor:", interceptorCandidate);
+      }
+    }
+  }
+  const allInterceptors = [...cofxInterceptors, ...validatedInterceptors];
+  if (allInterceptors.length > 0) {
+    setInterceptors(id, allInterceptors);
+  }
+}
+(0, import_immer.enablePatches)();
+function eventHandlerInterceptor(handler) {
+  return {
+    id: "fx-handler",
+    before(context) {
+      const coeffects = context.coeffects;
+      const event = coeffects.event;
+      const params = event.slice(1);
+      let effects = [];
+      const [newDb, patches] = (0, import_immer.produceWithPatches)(
+        getAppDb(),
+        (draftDb) => {
+          coeffects.draftDb = draftDb;
+          effects = handler({ ...coeffects }, ...params) || [];
+        }
+      );
+      context.newDb = newDb;
+      context.patches = patches;
+      if (!Array.isArray(effects)) {
+        consoleLog("warn", `[reflex] effects expects a vector, but was given ${typeof effects}`);
+      } else {
+        context.effects = [...context.effects || [], ...effects];
+      }
+      return context;
+    }
+  };
+}
+var injectGlobalInterceptors = {
+  id: "inject-global-interceptors",
+  before(context) {
+    const globals = getGlobalInterceptors();
+    context.queue = [...globals, ...context.queue];
+    return context;
+  }
+};
+function handle(eventV) {
+  const eventId = eventV[0];
+  const handler = getHandler(KIND3, eventId);
+  if (!handler) {
+    consoleLog("error", `[reflex] no event handler registered for:`, eventId);
+    return;
+  }
+  const customInterceptors = getInterceptors(eventId);
+  const interceptors = [
+    doFxInterceptor,
+    injectGlobalInterceptors,
+    ...customInterceptors,
+    eventHandlerInterceptor(handler)
+  ];
+  withTrace(
+    { operation: eventId, opType: KIND3, tags: { event: eventV } },
+    () => {
+      mergeTrace({ tags: { "app-db-before": getAppDb() } });
+      execute(eventV, interceptors);
+      mergeTrace({ tags: { "app-db-after": getAppDb() } });
+    }
+  );
+}
+function regEventErrorHandler(handler) {
+  registerHandler("error", "event-handler", handler);
+}
+function defaultErrorHandler(originalError, reFrameError) {
+  consoleLog("error", "[reflex] Interceptor Exception:", {
+    originalError,
+    reFrameError,
+    data: reFrameError.data
+  });
+  throw originalError;
+}
+regEventErrorHandler(defaultErrorHandler);
+
+// src/reaction.ts
+var import_fast_deep_equal = __toESM(require("fast-deep-equal"), 1);
+var Reaction = class _Reaction {
+  id = "";
+  computeFn;
+  deps;
+  dependents = /* @__PURE__ */ new Set();
+  watchers = [];
+  dirty = false;
+  scheduled = false;
+  value = void 0;
+  version = 0;
+  depsVersions = [];
+  subVector;
+  componentName;
+  constructor(computeFn, deps) {
+    this.computeFn = computeFn;
+    this.deps = deps;
+  }
+  static create(fn, deps) {
+    return new _Reaction(fn, deps);
+  }
+  getValue() {
+    this.ensureDirty();
+    this.recomputeIfNeeded(false);
+    return this.value;
+  }
+  getDepValue(notifyWatchers = true) {
+    this.recomputeIfNeeded(notifyWatchers);
+    return [this.value, this.version];
+  }
+  watch(callback) {
+    const idx = this.watchers.indexOf(callback);
+    if (idx === -1) {
+      this.watchers.push(callback);
+      if (this.deps) {
+        for (const d of this.deps)
+          d.ensureAliveWith(this);
+      }
+    }
+  }
+  unwatch(fn) {
+    const idx = this.watchers.indexOf(fn);
+    if (idx !== -1) {
+      this.watchers.splice(idx, 1);
+      if (this.watchers.length === 0) {
+        this.disposeIfUnused();
+      }
+    }
+  }
+  markDirty() {
+    this.dirty = true;
+    for (const c of this.dependents)
+      c.markDirty();
+    if (!this.isAlive) {
+      return;
+    }
+    this.scheduleRecompute();
+  }
+  scheduleRecompute() {
+    if (this.scheduled)
+      return;
+    this.scheduled = true;
+    queueMicrotask(() => {
+      this.scheduled = false;
+      this.recomputeIfNeeded();
+    });
+  }
+  recomputeIfNeeded(notifyWatchers = true) {
+    if (!this.dirty)
+      return;
+    try {
+      let changed = false;
+      withTrace(
+        { operation: this.subVector?.[0] ?? "", opType: "sub/run", tags: { queryV: this.subVector, reaction: this.id } },
+        () => {
+          if (this.isRoot) {
+            changed = true;
+            this.value = this.computeFn();
+          } else {
+            const depValues = this.deps?.map((d) => d.getDepValue(notifyWatchers)) ?? [];
+            const values = depValues.map(([value]) => value);
+            const currentVersions = depValues.map(([, version]) => version);
+            const versionsChanged = !(0, import_fast_deep_equal.default)(currentVersions, this.depsVersions);
+            if (this.value === void 0 || versionsChanged) {
+              let newVal = this.computeFn(...values);
+              changed = !(0, import_fast_deep_equal.default)(newVal, this.value);
+              if (changed) {
+                this.value = newVal;
+              }
+              this.depsVersions = currentVersions;
+            }
+          }
+          mergeTrace({ tags: { "cached?": !changed, "version": this.version } });
+        }
+      );
+      this.dirty = false;
+      if (changed) {
+        this.version++;
+      }
+      if (notifyWatchers && changed && this.watchers.length > 0) {
+        for (const w of this.watchers) {
+          try {
+            withTrace(
+              {
+                opType: "render",
+                operation: this.componentName ?? "component",
+                tags: this.componentName ? { componentName: this.componentName } : {}
+              },
+              () => {
+                w(this.value);
+              }
+            );
+          } catch (error) {
+            consoleLog("error", "[reflex] Error in reaction watcher:", error);
+          }
+        }
+      }
+    } catch (error) {
+      consoleLog("error", `[reflex] Error in reaction computation ${this.id}:`, error);
+      throw error;
+    }
+  }
+  ensureDirty() {
+    this.dirty = true;
+    if (this.deps) {
+      for (const d of this.deps)
+        d.ensureDirty();
+    }
+  }
+  ensureAliveWith(child) {
+    if (this.value === void 0) {
+      this.dirty = true;
+    }
+    this.dependents.add(child);
+    if (this.deps) {
+      for (const d of this.deps)
+        d.ensureAliveWith(this);
+    }
+  }
+  disposeIfUnused() {
+    if (this.isAlive)
+      return;
+    this.value = void 0;
+    this.version = 0;
+    this.depsVersions = [];
+    this.dirty = false;
+    this.scheduled = false;
+    withTrace(
+      {
+        operation: this.subVector?.[0] ?? "",
+        opType: "sub/dispose",
+        tags: {
+          subVector: this.subVector,
+          reaction: this.id
+        }
+      },
+      () => {
+        if (this.deps) {
+          for (const d of this.deps) {
+            d.dependents.delete(this);
+            d.disposeIfUnused();
+          }
+        }
+      }
+    );
+  }
+  setId(id) {
+    this.id = id;
+  }
+  getId() {
+    return this.id;
+  }
+  getSubVector() {
+    return this.subVector;
+  }
+  setSubVector(subVector) {
+    this.subVector = subVector;
+  }
+  get isAlive() {
+    return this.hasWatchers || this.hasDependents;
+  }
+  get hasWatchers() {
+    return this.watchers.length > 0;
+  }
+  get hasDependents() {
+    return this.dependents.size > 0;
+  }
+  get isDirty() {
+    return this.dirty;
+  }
+  get isRoot() {
+    return this.deps === void 0 || this.deps.length === 0;
+  }
+  setComponentName(componentName) {
+    this.componentName = componentName;
+  }
+};
+
+// src/subs.ts
+var KIND4 = "sub";
+var KIND_DEPS = "subDeps";
+function regSub(id, computeFn, depsFn) {
+  if (hasHandler(KIND4, id)) {
+    consoleLog("warn", `[reflex] Overriding. Subscription '${id}' already registered.`);
+  }
+  if (!computeFn) {
+    registerHandler(KIND4, id, () => getAppDb()[id]);
+    registerHandler(KIND_DEPS, id, () => []);
+  } else {
+    if (!depsFn) {
+      consoleLog("error", `[reflex] Subscription '${id}' has computeFn but missing depsFn. Computed subscriptions must specify their dependencies.`);
+      return;
+    }
+    registerHandler(KIND4, id, computeFn);
+    registerHandler(KIND_DEPS, id, depsFn);
+  }
+}
+function getOrCreateReaction(subVector) {
+  const subId = subVector[0];
+  if (!hasHandler(KIND4, subId)) {
+    consoleLog("error", `[reflex] no sub handler registered for: ${subId}`);
+    return null;
+  }
+  withTrace({ operation: subVector[0], opType: KIND4, tags: { queryV: subVector } }, () => {
+  });
+  const computeFn = getHandler(KIND4, subId);
+  const subVectorKey = JSON.stringify(subVector);
+  const existingReaction = getReaction(subVectorKey);
+  if (existingReaction) {
+    mergeTrace({ tags: { "cached?": true, reaction: existingReaction.getId() } });
+    return existingReaction;
+  }
+  mergeTrace({ tags: { "cached?": false } });
+  const params = subVector.length > 1 ? subVector.slice(1) : [];
+  const depsFn = getHandler(KIND_DEPS, subId);
+  const depsVectors = depsFn(...params);
+  const depsReactions = depsVectors.map((depVector) => {
+    return getOrCreateReaction(depVector);
+  });
+  const reaction = Reaction.create(
+    (...depValues) => {
+      if (params.length > 0) {
+        return computeFn(...depValues, ...params);
+      } else {
+        return computeFn(...depValues);
+      }
+    },
+    depsReactions
+  );
+  mergeTrace({ reaction: reaction.getId() });
+  reaction.setId(subVectorKey);
+  reaction.setSubVector(subVector);
+  setReaction(subVectorKey, reaction);
+  return reaction;
+}
+
+// src/debounce.ts
+var timeout = /* @__PURE__ */ new Map();
+function clear(eventKey) {
+  const eventTimeout = timeout.get(eventKey);
+  if (eventTimeout) {
+    clearTimeout(eventTimeout);
+    timeout.delete(eventKey);
+  }
+}
+function debounceAndDispatch(event, durationMs) {
+  const eventKey = event[0];
+  clear(eventKey);
+  const timeoutId = setTimeout(() => {
+    timeout.delete(eventKey);
+    dispatch(event);
+  }, durationMs);
+  timeout.set(eventKey, timeoutId);
+}
+var throttle = /* @__PURE__ */ new Map();
+function throttleAndDispatch(event, durationMs) {
+  const eventKey = event[0];
+  if (!throttle.get(eventKey)) {
+    throttle.set(eventKey, true);
+    setTimeout(() => {
+      throttle.delete(eventKey);
+    }, durationMs);
+    dispatch(event);
+  }
+}
+
+// src/hook.ts
+var import_react = require("react");
+function useSubscription(subVector, componentName = "react component") {
+  const [val, setVal] = (0, import_react.useState)(() => {
+    const reaction = getOrCreateReaction(subVector);
+    return reaction ? reaction.getValue() : void 0;
+  });
+  (0, import_react.useEffect)(() => {
+    const reaction = getOrCreateReaction(subVector);
+    if (!reaction)
+      return;
+    reaction.setComponentName(componentName);
+    reaction.watch(setVal);
+    return () => {
+      reaction.unwatch(setVal);
+    };
+  }, []);
+  return val;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  clearGlobalInterceptors,
+  debounceAndDispatch,
+  defaultErrorHandler,
+  disableTracing,
+  dispatch,
+  enableTracePrint,
+  enableTracing,
+  getGlobalInterceptors,
+  initAppDb,
+  isDebugEnabled,
+  regCoeffect,
+  regEffect,
+  regEvent,
+  regEventErrorHandler,
+  regGlobalInterceptor,
+  regSub,
+  registerTraceCb,
+  setDebugEnabled,
+  throttleAndDispatch,
+  useSubscription
+});