@codella-software/react 2.0.0

package/dist/index.cjs

@@ -0,0 +1,2121 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const react = require("react");
+const core = require("@codella/core");
+const jsxRuntime = require("react/jsx-runtime");
+const rxjs = require("rxjs");
+const operators = require("rxjs/operators");
+function useFiltersAndSort(options) {
+  const { service } = options;
+  const [state, setState] = react.useState(() => {
+    return service.getState();
+  });
+  react.useEffect(() => {
+    const subscription = service.state$.subscribe((newState) => {
+      setState(newState);
+    });
+    return () => subscription.unsubscribe();
+  }, [service]);
+  const callbacks = react.useMemo(() => ({
+    setFilter: (key, value) => {
+      service.setFilter(key, value);
+    },
+    clearFilter: (key) => {
+      service.clearFilter(key);
+    },
+    clearAllFilters: () => {
+      service.clearAllFilters();
+    },
+    setSort: (field, direction) => {
+      service.setSort(field, direction);
+    },
+    toggleSort: (field) => {
+      service.toggleSort(field);
+    },
+    setPage: (page) => {
+      service.setPage(page);
+    },
+    setPageSize: (size) => {
+      service.setPageSize(size);
+    },
+    nextPage: () => {
+      service.nextPage();
+    },
+    prevPage: () => {
+      service.prevPage();
+    }
+  }), [service]);
+  const memoizedReturn = react.useMemo(() => ({
+    filters: state.filters,
+    sortBy: state.sortBy,
+    sortDirection: state.sortDirection,
+    page: state.page,
+    pageSize: state.pageSize,
+    ...callbacks
+  }), [state, callbacks]);
+  return memoizedReturn;
+}
+function useFormBuilder(options) {
+  const { builder } = options;
+  const [state, setState] = react.useState(() => builder.getState());
+  const [isSubmitting, setIsSubmitting] = react.useState(false);
+  react.useEffect(() => {
+    const subscription = builder.stateChanged$.subscribe((newState) => {
+      setState(newState);
+    });
+    return () => subscription.unsubscribe();
+  }, [builder]);
+  const memoizedReturn = react.useMemo(() => ({
+    values: state.values,
+    errors: state.errors,
+    touched: state.touched,
+    currentStep: state.currentStep,
+    totalSteps: state.totalSteps,
+    isSubmitting,
+    isValid: Object.keys(state.errors).length === 0,
+    setFieldValue: async (field, value) => {
+      builder.setFieldValue(field, value);
+    },
+    setFieldTouched: (field, touched) => {
+      builder.setFieldTouched(field, touched);
+    },
+    validate: async () => {
+      return builder.validate();
+    },
+    submit: async () => {
+      setIsSubmitting(true);
+      try {
+        const result = await builder.submit();
+        setIsSubmitting(false);
+        return result;
+      } catch (error) {
+        setIsSubmitting(false);
+        throw error;
+      }
+    },
+    reset: () => {
+      builder.reset();
+    },
+    nextStep: () => {
+      if (builder.nextStep) {
+        builder.nextStep();
+      }
+    },
+    prevStep: () => {
+      if (builder.prevStep) {
+        builder.prevStep();
+      }
+    }
+  }), [builder, state, isSubmitting]);
+  return memoizedReturn;
+}
+class LiveUpdateService {
+  constructor(wsService, sseService) {
+    this.wsService = wsService;
+    this.sseService = sseService;
+    this.activeType = null;
+    this.isInitialized = false;
+    this.eventMappings = {};
+  }
+  initialize(config2) {
+    if (this.isInitialized) {
+      return;
+    }
+    this.eventMappings = config2.eventMappings ?? {};
+    if (config2.sseEnabled) {
+      this.activeType = "SSE";
+      this.sseService.connect().catch((error) => {
+        console.error("[LiveUpdateService] SSE connection failed:", error);
+        if (config2.wsEnabled) {
+          this.activeType = "WebSocket";
+          this.wsService.connect();
+        }
+      });
+    } else if (config2.wsEnabled) {
+      this.activeType = "WebSocket";
+      this.wsService.connect();
+    }
+    this.isInitialized = true;
+  }
+  get type() {
+    return this.activeType;
+  }
+  get isConnected$() {
+    switch (this.activeType) {
+      case "SSE":
+        return this.sseService.isConnected$;
+      case "WebSocket":
+        return this.wsService.isConnected$;
+      default:
+        return rxjs.of(false);
+    }
+  }
+  get canSend() {
+    return this.activeType === "WebSocket";
+  }
+  /**
+   * Subscribe to a named event using configured mappings
+   */
+  on(eventName) {
+    const mapping = this.eventMappings[eventName];
+    if (!mapping) {
+      console.warn(`[LiveUpdateService] No mapping found for event: ${eventName}`);
+      return rxjs.EMPTY;
+    }
+    switch (this.activeType) {
+      case "SSE":
+        if (mapping.sseEvent) {
+          return this.sseService.on(mapping.sseEvent);
+        }
+        break;
+      case "WebSocket":
+        if (mapping.wsAction) {
+          return this.wsService.on(mapping.wsAction);
+        }
+        break;
+    }
+    return rxjs.EMPTY;
+  }
+  /**
+   * Send a message via WebSocket (if available)
+   */
+  send(action, payload) {
+    if (!this.canSend) {
+      console.warn("[LiveUpdateService] WebSocket not available for sending");
+      return;
+    }
+    this.wsService.sendMessage(action, payload);
+  }
+  disconnect() {
+    this.sseService.disconnect();
+    this.wsService.disconnect();
+    this.activeType = null;
+    this.isInitialized = false;
+  }
+  destroy() {
+    this.sseService.destroy();
+    this.wsService.destroy();
+    this.activeType = null;
+    this.isInitialized = false;
+  }
+}
+const DEFAULT_CONFIG = {
+  maxReconnectAttempts: 5,
+  initialReconnectDelay: 1e3,
+  maxReconnectDelay: 3e4
+};
+class BaseConnectionService {
+  constructor(config2 = {}) {
+    this.destroySubject$ = new rxjs.Subject();
+    this.messagesSubject$ = new rxjs.Subject();
+    this.connectionStatusSubject$ = new rxjs.BehaviorSubject(false);
+    this.reconnectAttempts = 0;
+    this.messages$ = this.messagesSubject$.asObservable();
+    this.isConnected$ = this.connectionStatusSubject$.asObservable();
+    this.config = { ...DEFAULT_CONFIG, ...config2 };
+  }
+  getReconnectDelay(attempt) {
+    return Math.min(
+      this.config.initialReconnectDelay * Math.pow(2, attempt),
+      this.config.maxReconnectDelay
+    );
+  }
+  scheduleReconnect(connectFn) {
+    if (this.reconnectAttempts >= this.config.maxReconnectAttempts) {
+      console.error(`[${this.serviceName}] Max reconnection attempts reached`);
+      return;
+    }
+    const delay = this.getReconnectDelay(this.reconnectAttempts);
+    this.reconnectAttempts++;
+    console.log(
+      `[${this.serviceName}] Reconnecting in ${delay}ms (attempt ${this.reconnectAttempts})`
+    );
+    rxjs.timer(delay).pipe(operators.take(1), operators.takeUntil(this.destroySubject$)).subscribe(() => connectFn());
+  }
+  resetReconnectAttempts() {
+    this.reconnectAttempts = 0;
+  }
+  destroy() {
+    this.disconnect();
+    this.destroySubject$.next();
+    this.destroySubject$.complete();
+    this.messagesSubject$.complete();
+    this.connectionStatusSubject$.complete();
+  }
+}
+class FetchEventSource {
+  constructor(url, headers) {
+    this.url = url;
+    this.headers = headers;
+    this.eventTarget = new EventTarget();
+    this.abortController = null;
+  }
+  async connect() {
+    var _a;
+    this.abortController = new AbortController();
+    try {
+      const response = await fetch(this.url, {
+        method: "GET",
+        headers: this.headers,
+        signal: this.abortController.signal
+      });
+      if (!response.ok) {
+        const error = new Event("error");
+        this.eventTarget.dispatchEvent(error);
+        return;
+      }
+      const openEvent = new Event("open");
+      this.eventTarget.dispatchEvent(openEvent);
+      const reader = (_a = response.body) == null ? void 0 : _a.getReader();
+      if (!reader) {
+        const error = new Event("error");
+        this.eventTarget.dispatchEvent(error);
+        return;
+      }
+      const decoder = new TextDecoder();
+      let buffer = "";
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        for (let i = 0; i < lines.length - 1; i++) {
+          this.processLine(lines[i]);
+        }
+        buffer = lines[lines.length - 1];
+      }
+      if (buffer.length > 0) {
+        this.processLine(buffer);
+      }
+    } catch (error) {
+      if (error instanceof Error && error.name !== "AbortError") {
+        const errorEvent = new Event("error");
+        this.eventTarget.dispatchEvent(errorEvent);
+      }
+    }
+  }
+  processLine(line) {
+    line = line.trim();
+    if (line === "" || line.startsWith(":")) {
+      return;
+    }
+    const colonIndex = line.indexOf(":");
+    if (colonIndex === -1) {
+      return;
+    }
+    const field = line.substring(0, colonIndex);
+    let value = line.substring(colonIndex + 1);
+    if (value.startsWith(" ")) {
+      value = value.substring(1);
+    }
+    if (field === "data") {
+      const event = new MessageEvent("message", {
+        data: value
+      });
+      this.eventTarget.dispatchEvent(event);
+    }
+  }
+  addEventListener(type, listener) {
+    this.eventTarget.addEventListener(type, listener);
+  }
+  removeEventListener(type, listener) {
+    this.eventTarget.removeEventListener(type, listener);
+  }
+  get onopen() {
+    return this.eventTarget.onopen;
+  }
+  set onopen(handler) {
+    if (this.eventTarget.onopen) {
+      this.eventTarget.removeEventListener("open", this.eventTarget.onopen);
+    }
+    if (handler) {
+      this.eventTarget.addEventListener("open", handler);
+      this.eventTarget.onopen = handler;
+    }
+  }
+  get onerror() {
+    return this.eventTarget.onerror;
+  }
+  set onerror(handler) {
+    if (this.eventTarget.onerror) {
+      this.eventTarget.removeEventListener("error", this.eventTarget.onerror);
+    }
+    if (handler) {
+      this.eventTarget.addEventListener("error", handler);
+      this.eventTarget.onerror = handler;
+    }
+  }
+  close() {
+    var _a;
+    (_a = this.abortController) == null ? void 0 : _a.abort();
+    this.abortController = null;
+  }
+}
+class SSEService extends BaseConnectionService {
+  constructor(config2) {
+    super();
+    this.eventSource = null;
+    this.sseConfig = {
+      headerName: "Authorization",
+      headerPrefix: "Bearer",
+      ...config2
+    };
+  }
+  get serviceName() {
+    return "SSE";
+  }
+  async connect() {
+    if (this.eventSource) {
+      return;
+    }
+    try {
+      if (!this.sseConfig.authProvider.isAuthenticated()) {
+        console.error("[SSE] Not authenticated");
+        return;
+      }
+      const idToken = await this.sseConfig.authProvider.getIdToken();
+      if (!idToken) {
+        console.error("[SSE] No auth token available");
+        return;
+      }
+      const headers = {
+        [this.sseConfig.headerName]: `${this.sseConfig.headerPrefix} ${idToken}`
+      };
+      const url = new URL(this.sseConfig.url);
+      this.eventSource = new FetchEventSource(url.toString(), headers);
+      this.setupEventListeners();
+      await this.eventSource.connect();
+    } catch (error) {
+      console.error("[SSE] Connection error:", error);
+      this.scheduleReconnect(() => this.connect());
+    }
+  }
+  setupEventListeners() {
+    if (!this.eventSource) return;
+    this.eventSource.onopen = () => {
+      console.log("[SSE] Connected");
+      this.connectionStatusSubject$.next(true);
+      this.resetReconnectAttempts();
+    };
+    this.eventSource.onerror = (event) => {
+      console.error("[SSE] Error:", event);
+      this.connectionStatusSubject$.next(false);
+      this.cleanup();
+      this.scheduleReconnect(() => this.connect());
+    };
+    rxjs.fromEvent(this.eventSource, "message").pipe(
+      operators.takeUntil(this.destroySubject$),
+      operators.map((event) => {
+        try {
+          return JSON.parse(event.data);
+        } catch (error) {
+          console.error("[SSE] Parse error:", error);
+          return null;
+        }
+      }),
+      operators.filter((msg) => msg !== null)
+    ).subscribe((message) => {
+      this.messagesSubject$.next(message);
+    });
+  }
+  cleanup() {
+    var _a;
+    (_a = this.eventSource) == null ? void 0 : _a.close();
+    this.eventSource = null;
+  }
+  on(eventType) {
+    return this.messages$.pipe(
+      operators.filter((msg) => msg.eventType === eventType),
+      operators.map((msg) => msg.data)
+    );
+  }
+  disconnect() {
+    this.cleanup();
+    this.connectionStatusSubject$.next(false);
+    this.resetReconnectAttempts();
+  }
+  destroy() {
+    this.cleanup();
+    this.destroySubject$.next();
+    this.destroySubject$.complete();
+  }
+}
+var extendStatics = function(d, b) {
+  extendStatics = Object.setPrototypeOf || { __proto__: [] } instanceof Array && function(d2, b2) {
+    d2.__proto__ = b2;
+  } || function(d2, b2) {
+    for (var p in b2) if (Object.prototype.hasOwnProperty.call(b2, p)) d2[p] = b2[p];
+  };
+  return extendStatics(d, b);
+};
+function __extends(d, b) {
+  if (typeof b !== "function" && b !== null)
+    throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+  extendStatics(d, b);
+  function __() {
+    this.constructor = d;
+  }
+  d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+var __assign = function() {
+  __assign = Object.assign || function __assign2(t) {
+    for (var s, i = 1, n = arguments.length; i < n; i++) {
+      s = arguments[i];
+      for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+    }
+    return t;
+  };
+  return __assign.apply(this, arguments);
+};
+function __values(o) {
+  var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+  if (m) return m.call(o);
+  if (o && typeof o.length === "number") return {
+    next: function() {
+      if (o && i >= o.length) o = void 0;
+      return { value: o && o[i++], done: !o };
+    }
+  };
+  throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+}
+function __read(o, n) {
+  var m = typeof Symbol === "function" && o[Symbol.iterator];
+  if (!m) return o;
+  var i = m.call(o), r, ar = [], e;
+  try {
+    while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+  } catch (error) {
+    e = { error };
+  } finally {
+    try {
+      if (r && !r.done && (m = i["return"])) m.call(i);
+    } finally {
+      if (e) throw e.error;
+    }
+  }
+  return ar;
+}
+function __spreadArray(to, from, pack) {
+  if (arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+    if (ar || !(i in from)) {
+      if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+      ar[i] = from[i];
+    }
+  }
+  return to.concat(ar || Array.prototype.slice.call(from));
+}
+typeof SuppressedError === "function" ? SuppressedError : function(error, suppressed, message) {
+  var e = new Error(message);
+  return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+function isFunction(value) {
+  return typeof value === "function";
+}
+function createErrorClass(createImpl) {
+  var _super = function(instance) {
+    Error.call(instance);
+    instance.stack = new Error().stack;
+  };
+  var ctorFunc = createImpl(_super);
+  ctorFunc.prototype = Object.create(Error.prototype);
+  ctorFunc.prototype.constructor = ctorFunc;
+  return ctorFunc;
+}
+var UnsubscriptionError = createErrorClass(function(_super) {
+  return function UnsubscriptionErrorImpl(errors) {
+    _super(this);
+    this.message = errors ? errors.length + " errors occurred during unsubscription:\n" + errors.map(function(err, i) {
+      return i + 1 + ") " + err.toString();
+    }).join("\n  ") : "";
+    this.name = "UnsubscriptionError";
+    this.errors = errors;
+  };
+});
+function arrRemove(arr, item) {
+  if (arr) {
+    var index = arr.indexOf(item);
+    0 <= index && arr.splice(index, 1);
+  }
+}
+var Subscription = (function() {
+  function Subscription2(initialTeardown) {
+    this.initialTeardown = initialTeardown;
+    this.closed = false;
+    this._parentage = null;
+    this._finalizers = null;
+  }
+  Subscription2.prototype.unsubscribe = function() {
+    var e_1, _a, e_2, _b;
+    var errors;
+    if (!this.closed) {
+      this.closed = true;
+      var _parentage = this._parentage;
+      if (_parentage) {
+        this._parentage = null;
+        if (Array.isArray(_parentage)) {
+          try {
+            for (var _parentage_1 = __values(_parentage), _parentage_1_1 = _parentage_1.next(); !_parentage_1_1.done; _parentage_1_1 = _parentage_1.next()) {
+              var parent_1 = _parentage_1_1.value;
+              parent_1.remove(this);
+            }
+          } catch (e_1_1) {
+            e_1 = { error: e_1_1 };
+          } finally {
+            try {
+              if (_parentage_1_1 && !_parentage_1_1.done && (_a = _parentage_1.return)) _a.call(_parentage_1);
+            } finally {
+              if (e_1) throw e_1.error;
+            }
+          }
+        } else {
+          _parentage.remove(this);
+        }
+      }
+      var initialFinalizer = this.initialTeardown;
+      if (isFunction(initialFinalizer)) {
+        try {
+          initialFinalizer();
+        } catch (e) {
+          errors = e instanceof UnsubscriptionError ? e.errors : [e];
+        }
+      }
+      var _finalizers = this._finalizers;
+      if (_finalizers) {
+        this._finalizers = null;
+        try {
+          for (var _finalizers_1 = __values(_finalizers), _finalizers_1_1 = _finalizers_1.next(); !_finalizers_1_1.done; _finalizers_1_1 = _finalizers_1.next()) {
+            var finalizer = _finalizers_1_1.value;
+            try {
+              execFinalizer(finalizer);
+            } catch (err) {
+              errors = errors !== null && errors !== void 0 ? errors : [];
+              if (err instanceof UnsubscriptionError) {
+                errors = __spreadArray(__spreadArray([], __read(errors)), __read(err.errors));
+              } else {
+                errors.push(err);
+              }
+            }
+          }
+        } catch (e_2_1) {
+          e_2 = { error: e_2_1 };
+        } finally {
+          try {
+            if (_finalizers_1_1 && !_finalizers_1_1.done && (_b = _finalizers_1.return)) _b.call(_finalizers_1);
+          } finally {
+            if (e_2) throw e_2.error;
+          }
+        }
+      }
+      if (errors) {
+        throw new UnsubscriptionError(errors);
+      }
+    }
+  };
+  Subscription2.prototype.add = function(teardown) {
+    var _a;
+    if (teardown && teardown !== this) {
+      if (this.closed) {
+        execFinalizer(teardown);
+      } else {
+        if (teardown instanceof Subscription2) {
+          if (teardown.closed || teardown._hasParent(this)) {
+            return;
+          }
+          teardown._addParent(this);
+        }
+        (this._finalizers = (_a = this._finalizers) !== null && _a !== void 0 ? _a : []).push(teardown);
+      }
+    }
+  };
+  Subscription2.prototype._hasParent = function(parent) {
+    var _parentage = this._parentage;
+    return _parentage === parent || Array.isArray(_parentage) && _parentage.includes(parent);
+  };
+  Subscription2.prototype._addParent = function(parent) {
+    var _parentage = this._parentage;
+    this._parentage = Array.isArray(_parentage) ? (_parentage.push(parent), _parentage) : _parentage ? [_parentage, parent] : parent;
+  };
+  Subscription2.prototype._removeParent = function(parent) {
+    var _parentage = this._parentage;
+    if (_parentage === parent) {
+      this._parentage = null;
+    } else if (Array.isArray(_parentage)) {
+      arrRemove(_parentage, parent);
+    }
+  };
+  Subscription2.prototype.remove = function(teardown) {
+    var _finalizers = this._finalizers;
+    _finalizers && arrRemove(_finalizers, teardown);
+    if (teardown instanceof Subscription2) {
+      teardown._removeParent(this);
+    }
+  };
+  Subscription2.EMPTY = (function() {
+    var empty = new Subscription2();
+    empty.closed = true;
+    return empty;
+  })();
+  return Subscription2;
+})();
+var EMPTY_SUBSCRIPTION = Subscription.EMPTY;
+function isSubscription(value) {
+  return value instanceof Subscription || value && "closed" in value && isFunction(value.remove) && isFunction(value.add) && isFunction(value.unsubscribe);
+}
+function execFinalizer(finalizer) {
+  if (isFunction(finalizer)) {
+    finalizer();
+  } else {
+    finalizer.unsubscribe();
+  }
+}
+var config = {
+  Promise: void 0
+};
+var timeoutProvider = {
+  setTimeout: function(handler, timeout) {
+    var args = [];
+    for (var _i = 2; _i < arguments.length; _i++) {
+      args[_i - 2] = arguments[_i];
+    }
+    return setTimeout.apply(void 0, __spreadArray([handler, timeout], __read(args)));
+  },
+  clearTimeout: function(handle) {
+    return clearTimeout(handle);
+  },
+  delegate: void 0
+};
+function reportUnhandledError(err) {
+  timeoutProvider.setTimeout(function() {
+    {
+      throw err;
+    }
+  });
+}
+function noop() {
+}
+function errorContext(cb) {
+  {
+    cb();
+  }
+}
+var Subscriber = (function(_super) {
+  __extends(Subscriber2, _super);
+  function Subscriber2(destination) {
+    var _this = _super.call(this) || this;
+    _this.isStopped = false;
+    if (destination) {
+      _this.destination = destination;
+      if (isSubscription(destination)) {
+        destination.add(_this);
+      }
+    } else {
+      _this.destination = EMPTY_OBSERVER;
+    }
+    return _this;
+  }
+  Subscriber2.create = function(next, error, complete) {
+    return new SafeSubscriber(next, error, complete);
+  };
+  Subscriber2.prototype.next = function(value) {
+    if (this.isStopped) ;
+    else {
+      this._next(value);
+    }
+  };
+  Subscriber2.prototype.error = function(err) {
+    if (this.isStopped) ;
+    else {
+      this.isStopped = true;
+      this._error(err);
+    }
+  };
+  Subscriber2.prototype.complete = function() {
+    if (this.isStopped) ;
+    else {
+      this.isStopped = true;
+      this._complete();
+    }
+  };
+  Subscriber2.prototype.unsubscribe = function() {
+    if (!this.closed) {
+      this.isStopped = true;
+      _super.prototype.unsubscribe.call(this);
+      this.destination = null;
+    }
+  };
+  Subscriber2.prototype._next = function(value) {
+    this.destination.next(value);
+  };
+  Subscriber2.prototype._error = function(err) {
+    try {
+      this.destination.error(err);
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  Subscriber2.prototype._complete = function() {
+    try {
+      this.destination.complete();
+    } finally {
+      this.unsubscribe();
+    }
+  };
+  return Subscriber2;
+})(Subscription);
+var ConsumerObserver = (function() {
+  function ConsumerObserver2(partialObserver) {
+    this.partialObserver = partialObserver;
+  }
+  ConsumerObserver2.prototype.next = function(value) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.next) {
+      try {
+        partialObserver.next(value);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  ConsumerObserver2.prototype.error = function(err) {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.error) {
+      try {
+        partialObserver.error(err);
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    } else {
+      handleUnhandledError(err);
+    }
+  };
+  ConsumerObserver2.prototype.complete = function() {
+    var partialObserver = this.partialObserver;
+    if (partialObserver.complete) {
+      try {
+        partialObserver.complete();
+      } catch (error) {
+        handleUnhandledError(error);
+      }
+    }
+  };
+  return ConsumerObserver2;
+})();
+var SafeSubscriber = (function(_super) {
+  __extends(SafeSubscriber2, _super);
+  function SafeSubscriber2(observerOrNext, error, complete) {
+    var _this = _super.call(this) || this;
+    var partialObserver;
+    if (isFunction(observerOrNext) || !observerOrNext) {
+      partialObserver = {
+        next: observerOrNext !== null && observerOrNext !== void 0 ? observerOrNext : void 0,
+        error: error !== null && error !== void 0 ? error : void 0,
+        complete: complete !== null && complete !== void 0 ? complete : void 0
+      };
+    } else {
+      {
+        partialObserver = observerOrNext;
+      }
+    }
+    _this.destination = new ConsumerObserver(partialObserver);
+    return _this;
+  }
+  return SafeSubscriber2;
+})(Subscriber);
+function handleUnhandledError(error) {
+  {
+    reportUnhandledError(error);
+  }
+}
+function defaultErrorHandler(err) {
+  throw err;
+}
+var EMPTY_OBSERVER = {
+  closed: true,
+  next: noop,
+  error: defaultErrorHandler,
+  complete: noop
+};
+var observable = (function() {
+  return typeof Symbol === "function" && Symbol.observable || "@@observable";
+})();
+function identity(x) {
+  return x;
+}
+function pipeFromArray(fns) {
+  if (fns.length === 0) {
+    return identity;
+  }
+  if (fns.length === 1) {
+    return fns[0];
+  }
+  return function piped(input) {
+    return fns.reduce(function(prev, fn) {
+      return fn(prev);
+    }, input);
+  };
+}
+var Observable = (function() {
+  function Observable2(subscribe) {
+    if (subscribe) {
+      this._subscribe = subscribe;
+    }
+  }
+  Observable2.prototype.lift = function(operator) {
+    var observable2 = new Observable2();
+    observable2.source = this;
+    observable2.operator = operator;
+    return observable2;
+  };
+  Observable2.prototype.subscribe = function(observerOrNext, error, complete) {
+    var _this = this;
+    var subscriber = isSubscriber(observerOrNext) ? observerOrNext : new SafeSubscriber(observerOrNext, error, complete);
+    errorContext(function() {
+      var _a = _this, operator = _a.operator, source = _a.source;
+      subscriber.add(operator ? operator.call(subscriber, source) : source ? _this._subscribe(subscriber) : _this._trySubscribe(subscriber));
+    });
+    return subscriber;
+  };
+  Observable2.prototype._trySubscribe = function(sink) {
+    try {
+      return this._subscribe(sink);
+    } catch (err) {
+      sink.error(err);
+    }
+  };
+  Observable2.prototype.forEach = function(next, promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var subscriber = new SafeSubscriber({
+        next: function(value) {
+          try {
+            next(value);
+          } catch (err) {
+            reject(err);
+            subscriber.unsubscribe();
+          }
+        },
+        error: reject,
+        complete: resolve
+      });
+      _this.subscribe(subscriber);
+    });
+  };
+  Observable2.prototype._subscribe = function(subscriber) {
+    var _a;
+    return (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber);
+  };
+  Observable2.prototype[observable] = function() {
+    return this;
+  };
+  Observable2.prototype.pipe = function() {
+    var operations = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+      operations[_i] = arguments[_i];
+    }
+    return pipeFromArray(operations)(this);
+  };
+  Observable2.prototype.toPromise = function(promiseCtor) {
+    var _this = this;
+    promiseCtor = getPromiseCtor(promiseCtor);
+    return new promiseCtor(function(resolve, reject) {
+      var value;
+      _this.subscribe(function(x) {
+        return value = x;
+      }, function(err) {
+        return reject(err);
+      }, function() {
+        return resolve(value);
+      });
+    });
+  };
+  Observable2.create = function(subscribe) {
+    return new Observable2(subscribe);
+  };
+  return Observable2;
+})();
+function getPromiseCtor(promiseCtor) {
+  var _a;
+  return (_a = promiseCtor !== null && promiseCtor !== void 0 ? promiseCtor : config.Promise) !== null && _a !== void 0 ? _a : Promise;
+}
+function isObserver(value) {
+  return value && isFunction(value.next) && isFunction(value.error) && isFunction(value.complete);
+}
+function isSubscriber(value) {
+  return value && value instanceof Subscriber || isObserver(value) && isSubscription(value);
+}
+var ObjectUnsubscribedError = createErrorClass(function(_super) {
+  return function ObjectUnsubscribedErrorImpl() {
+    _super(this);
+    this.name = "ObjectUnsubscribedError";
+    this.message = "object unsubscribed";
+  };
+});
+var Subject = (function(_super) {
+  __extends(Subject2, _super);
+  function Subject2() {
+    var _this = _super.call(this) || this;
+    _this.closed = false;
+    _this.currentObservers = null;
+    _this.observers = [];
+    _this.isStopped = false;
+    _this.hasError = false;
+    _this.thrownError = null;
+    return _this;
+  }
+  Subject2.prototype.lift = function(operator) {
+    var subject = new AnonymousSubject(this, this);
+    subject.operator = operator;
+    return subject;
+  };
+  Subject2.prototype._throwIfClosed = function() {
+    if (this.closed) {
+      throw new ObjectUnsubscribedError();
+    }
+  };
+  Subject2.prototype.next = function(value) {
+    var _this = this;
+    errorContext(function() {
+      var e_1, _a;
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        if (!_this.currentObservers) {
+          _this.currentObservers = Array.from(_this.observers);
+        }
+        try {
+          for (var _b = __values(_this.currentObservers), _c = _b.next(); !_c.done; _c = _b.next()) {
+            var observer = _c.value;
+            observer.next(value);
+          }
+        } catch (e_1_1) {
+          e_1 = { error: e_1_1 };
+        } finally {
+          try {
+            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+          } finally {
+            if (e_1) throw e_1.error;
+          }
+        }
+      }
+    });
+  };
+  Subject2.prototype.error = function(err) {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.hasError = _this.isStopped = true;
+        _this.thrownError = err;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().error(err);
+        }
+      }
+    });
+  };
+  Subject2.prototype.complete = function() {
+    var _this = this;
+    errorContext(function() {
+      _this._throwIfClosed();
+      if (!_this.isStopped) {
+        _this.isStopped = true;
+        var observers = _this.observers;
+        while (observers.length) {
+          observers.shift().complete();
+        }
+      }
+    });
+  };
+  Subject2.prototype.unsubscribe = function() {
+    this.isStopped = this.closed = true;
+    this.observers = this.currentObservers = null;
+  };
+  Object.defineProperty(Subject2.prototype, "observed", {
+    get: function() {
+      var _a;
+      return ((_a = this.observers) === null || _a === void 0 ? void 0 : _a.length) > 0;
+    },
+    enumerable: false,
+    configurable: true
+  });
+  Subject2.prototype._trySubscribe = function(subscriber) {
+    this._throwIfClosed();
+    return _super.prototype._trySubscribe.call(this, subscriber);
+  };
+  Subject2.prototype._subscribe = function(subscriber) {
+    this._throwIfClosed();
+    this._checkFinalizedStatuses(subscriber);
+    return this._innerSubscribe(subscriber);
+  };
+  Subject2.prototype._innerSubscribe = function(subscriber) {
+    var _this = this;
+    var _a = this, hasError = _a.hasError, isStopped = _a.isStopped, observers = _a.observers;
+    if (hasError || isStopped) {
+      return EMPTY_SUBSCRIPTION;
+    }
+    this.currentObservers = null;
+    observers.push(subscriber);
+    return new Subscription(function() {
+      _this.currentObservers = null;
+      arrRemove(observers, subscriber);
+    });
+  };
+  Subject2.prototype._checkFinalizedStatuses = function(subscriber) {
+    var _a = this, hasError = _a.hasError, thrownError = _a.thrownError, isStopped = _a.isStopped;
+    if (hasError) {
+      subscriber.error(thrownError);
+    } else if (isStopped) {
+      subscriber.complete();
+    }
+  };
+  Subject2.prototype.asObservable = function() {
+    var observable2 = new Observable();
+    observable2.source = this;
+    return observable2;
+  };
+  Subject2.create = function(destination, source) {
+    return new AnonymousSubject(destination, source);
+  };
+  return Subject2;
+})(Observable);
+var AnonymousSubject = (function(_super) {
+  __extends(AnonymousSubject2, _super);
+  function AnonymousSubject2(destination, source) {
+    var _this = _super.call(this) || this;
+    _this.destination = destination;
+    _this.source = source;
+    return _this;
+  }
+  AnonymousSubject2.prototype.next = function(value) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.next) === null || _b === void 0 ? void 0 : _b.call(_a, value);
+  };
+  AnonymousSubject2.prototype.error = function(err) {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.error) === null || _b === void 0 ? void 0 : _b.call(_a, err);
+  };
+  AnonymousSubject2.prototype.complete = function() {
+    var _a, _b;
+    (_b = (_a = this.destination) === null || _a === void 0 ? void 0 : _a.complete) === null || _b === void 0 ? void 0 : _b.call(_a);
+  };
+  AnonymousSubject2.prototype._subscribe = function(subscriber) {
+    var _a, _b;
+    return (_b = (_a = this.source) === null || _a === void 0 ? void 0 : _a.subscribe(subscriber)) !== null && _b !== void 0 ? _b : EMPTY_SUBSCRIPTION;
+  };
+  return AnonymousSubject2;
+})(Subject);
+var dateTimestampProvider = {
+  now: function() {
+    return (dateTimestampProvider.delegate || Date).now();
+  },
+  delegate: void 0
+};
+var ReplaySubject = (function(_super) {
+  __extends(ReplaySubject2, _super);
+  function ReplaySubject2(_bufferSize, _windowTime, _timestampProvider) {
+    if (_bufferSize === void 0) {
+      _bufferSize = Infinity;
+    }
+    if (_windowTime === void 0) {
+      _windowTime = Infinity;
+    }
+    if (_timestampProvider === void 0) {
+      _timestampProvider = dateTimestampProvider;
+    }
+    var _this = _super.call(this) || this;
+    _this._bufferSize = _bufferSize;
+    _this._windowTime = _windowTime;
+    _this._timestampProvider = _timestampProvider;
+    _this._buffer = [];
+    _this._infiniteTimeWindow = true;
+    _this._infiniteTimeWindow = _windowTime === Infinity;
+    _this._bufferSize = Math.max(1, _bufferSize);
+    _this._windowTime = Math.max(1, _windowTime);
+    return _this;
+  }
+  ReplaySubject2.prototype.next = function(value) {
+    var _a = this, isStopped = _a.isStopped, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow, _timestampProvider = _a._timestampProvider, _windowTime = _a._windowTime;
+    if (!isStopped) {
+      _buffer.push(value);
+      !_infiniteTimeWindow && _buffer.push(_timestampProvider.now() + _windowTime);
+    }
+    this._trimBuffer();
+    _super.prototype.next.call(this, value);
+  };
+  ReplaySubject2.prototype._subscribe = function(subscriber) {
+    this._throwIfClosed();
+    this._trimBuffer();
+    var subscription = this._innerSubscribe(subscriber);
+    var _a = this, _infiniteTimeWindow = _a._infiniteTimeWindow, _buffer = _a._buffer;
+    var copy = _buffer.slice();
+    for (var i = 0; i < copy.length && !subscriber.closed; i += _infiniteTimeWindow ? 1 : 2) {
+      subscriber.next(copy[i]);
+    }
+    this._checkFinalizedStatuses(subscriber);
+    return subscription;
+  };
+  ReplaySubject2.prototype._trimBuffer = function() {
+    var _a = this, _bufferSize = _a._bufferSize, _timestampProvider = _a._timestampProvider, _buffer = _a._buffer, _infiniteTimeWindow = _a._infiniteTimeWindow;
+    var adjustedBufferSize = (_infiniteTimeWindow ? 1 : 2) * _bufferSize;
+    _bufferSize < Infinity && adjustedBufferSize < _buffer.length && _buffer.splice(0, _buffer.length - adjustedBufferSize);
+    if (!_infiniteTimeWindow) {
+      var now = _timestampProvider.now();
+      var last = 0;
+      for (var i = 1; i < _buffer.length && _buffer[i] <= now; i += 2) {
+        last = i;
+      }
+      last && _buffer.splice(0, last + 1);
+    }
+  };
+  return ReplaySubject2;
+})(Subject);
+var DEFAULT_WEBSOCKET_CONFIG = {
+  url: "",
+  deserializer: function(e) {
+    return JSON.parse(e.data);
+  },
+  serializer: function(value) {
+    return JSON.stringify(value);
+  }
+};
+var WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT = "WebSocketSubject.error must be called with an object with an error code, and an optional reason: { code: number, reason: string }";
+var WebSocketSubject = (function(_super) {
+  __extends(WebSocketSubject2, _super);
+  function WebSocketSubject2(urlConfigOrSource, destination) {
+    var _this = _super.call(this) || this;
+    _this._socket = null;
+    if (urlConfigOrSource instanceof Observable) {
+      _this.destination = destination;
+      _this.source = urlConfigOrSource;
+    } else {
+      var config2 = _this._config = __assign({}, DEFAULT_WEBSOCKET_CONFIG);
+      _this._output = new Subject();
+      if (typeof urlConfigOrSource === "string") {
+        config2.url = urlConfigOrSource;
+      } else {
+        for (var key in urlConfigOrSource) {
+          if (urlConfigOrSource.hasOwnProperty(key)) {
+            config2[key] = urlConfigOrSource[key];
+          }
+        }
+      }
+      if (!config2.WebSocketCtor && WebSocket) {
+        config2.WebSocketCtor = WebSocket;
+      } else if (!config2.WebSocketCtor) {
+        throw new Error("no WebSocket constructor can be found");
+      }
+      _this.destination = new ReplaySubject();
+    }
+    return _this;
+  }
+  WebSocketSubject2.prototype.lift = function(operator) {
+    var sock = new WebSocketSubject2(this._config, this.destination);
+    sock.operator = operator;
+    sock.source = this;
+    return sock;
+  };
+  WebSocketSubject2.prototype._resetState = function() {
+    this._socket = null;
+    if (!this.source) {
+      this.destination = new ReplaySubject();
+    }
+    this._output = new Subject();
+  };
+  WebSocketSubject2.prototype.multiplex = function(subMsg, unsubMsg, messageFilter) {
+    var self = this;
+    return new Observable(function(observer) {
+      try {
+        self.next(subMsg());
+      } catch (err) {
+        observer.error(err);
+      }
+      var subscription = self.subscribe({
+        next: function(x) {
+          try {
+            if (messageFilter(x)) {
+              observer.next(x);
+            }
+          } catch (err) {
+            observer.error(err);
+          }
+        },
+        error: function(err) {
+          return observer.error(err);
+        },
+        complete: function() {
+          return observer.complete();
+        }
+      });
+      return function() {
+        try {
+          self.next(unsubMsg());
+        } catch (err) {
+          observer.error(err);
+        }
+        subscription.unsubscribe();
+      };
+    });
+  };
+  WebSocketSubject2.prototype._connectSocket = function() {
+    var _this = this;
+    var _a = this._config, WebSocketCtor = _a.WebSocketCtor, protocol = _a.protocol, url = _a.url, binaryType = _a.binaryType;
+    var observer = this._output;
+    var socket = null;
+    try {
+      socket = protocol ? new WebSocketCtor(url, protocol) : new WebSocketCtor(url);
+      this._socket = socket;
+      if (binaryType) {
+        this._socket.binaryType = binaryType;
+      }
+    } catch (e) {
+      observer.error(e);
+      return;
+    }
+    var subscription = new Subscription(function() {
+      _this._socket = null;
+      if (socket && socket.readyState === 1) {
+        socket.close();
+      }
+    });
+    socket.onopen = function(evt) {
+      var _socket = _this._socket;
+      if (!_socket) {
+        socket.close();
+        _this._resetState();
+        return;
+      }
+      var openObserver = _this._config.openObserver;
+      if (openObserver) {
+        openObserver.next(evt);
+      }
+      var queue = _this.destination;
+      _this.destination = Subscriber.create(function(x) {
+        if (socket.readyState === 1) {
+          try {
+            var serializer = _this._config.serializer;
+            socket.send(serializer(x));
+          } catch (e) {
+            _this.destination.error(e);
+          }
+        }
+      }, function(err) {
+        var closingObserver = _this._config.closingObserver;
+        if (closingObserver) {
+          closingObserver.next(void 0);
+        }
+        if (err && err.code) {
+          socket.close(err.code, err.reason);
+        } else {
+          observer.error(new TypeError(WEBSOCKETSUBJECT_INVALID_ERROR_OBJECT));
+        }
+        _this._resetState();
+      }, function() {
+        var closingObserver = _this._config.closingObserver;
+        if (closingObserver) {
+          closingObserver.next(void 0);
+        }
+        socket.close();
+        _this._resetState();
+      });
+      if (queue && queue instanceof ReplaySubject) {
+        subscription.add(queue.subscribe(_this.destination));
+      }
+    };
+    socket.onerror = function(e) {
+      _this._resetState();
+      observer.error(e);
+    };
+    socket.onclose = function(e) {
+      if (socket === _this._socket) {
+        _this._resetState();
+      }
+      var closeObserver = _this._config.closeObserver;
+      if (closeObserver) {
+        closeObserver.next(e);
+      }
+      if (e.wasClean) {
+        observer.complete();
+      } else {
+        observer.error(e);
+      }
+    };
+    socket.onmessage = function(e) {
+      try {
+        var deserializer = _this._config.deserializer;
+        observer.next(deserializer(e));
+      } catch (err) {
+        observer.error(err);
+      }
+    };
+  };
+  WebSocketSubject2.prototype._subscribe = function(subscriber) {
+    var _this = this;
+    var source = this.source;
+    if (source) {
+      return source.subscribe(subscriber);
+    }
+    if (!this._socket) {
+      this._connectSocket();
+    }
+    this._output.subscribe(subscriber);
+    subscriber.add(function() {
+      var _socket = _this._socket;
+      if (_this._output.observers.length === 0) {
+        if (_socket && (_socket.readyState === 1 || _socket.readyState === 0)) {
+          _socket.close();
+        }
+        _this._resetState();
+      }
+    });
+    return subscriber;
+  };
+  WebSocketSubject2.prototype.unsubscribe = function() {
+    var _socket = this._socket;
+    if (_socket && (_socket.readyState === 1 || _socket.readyState === 0)) {
+      _socket.close();
+    }
+    this._resetState();
+    _super.prototype.unsubscribe.call(this);
+  };
+  return WebSocketSubject2;
+})(AnonymousSubject);
+function webSocket(urlConfigOrSource) {
+  return new WebSocketSubject(urlConfigOrSource);
+}
+class WebsocketService extends BaseConnectionService {
+  constructor(config2) {
+    super();
+    this.socket$ = null;
+    this.wsConfig = config2;
+  }
+  get serviceName() {
+    return "WS";
+  }
+  connect() {
+    if (this.socket$) {
+      return;
+    }
+    this.socket$ = webSocket({
+      url: this.wsConfig.url,
+      openObserver: {
+        next: () => {
+          console.log("[WS] Connected");
+          this.connectionStatusSubject$.next(true);
+          this.resetReconnectAttempts();
+          this.sendMessage("INIT_CONNECTION");
+        }
+      },
+      closeObserver: {
+        next: (event) => {
+          console.log("[WS] Closed:", event.code, event.reason);
+          this.connectionStatusSubject$.next(false);
+          this.socket$ = null;
+          if (event.code !== 1e3 && event.reason !== "Closing duplicate connection") {
+            this.scheduleReconnect(() => this.connect());
+          }
+        }
+      }
+    });
+    this.socket$.pipe(
+      operators.takeUntil(this.destroySubject$),
+      operators.tap({
+        error: (err) => {
+          console.error("[WS] Error:", err);
+          this.connectionStatusSubject$.next(false);
+        }
+      })
+    ).subscribe({
+      next: (message) => {
+        if (this.isIncomingMessage(message)) {
+          this.messagesSubject$.next(message);
+        }
+      },
+      error: (err) => console.error("[WS] Stream error:", err)
+    });
+  }
+  isIncomingMessage(msg) {
+    return "action" in msg && !("Authorization" in msg);
+  }
+  async sendMessage(action, payload) {
+    if (!this.socket$ || !this.connectionStatusSubject$.value) {
+      console.warn("[WS] Cannot send message - not connected");
+      return;
+    }
+    try {
+      if (!this.wsConfig.authProvider.isAuthenticated()) {
+        console.warn(`[WS] Cannot send message - not authenticated for action: ${action}`);
+        return;
+      }
+      const idToken = await this.wsConfig.authProvider.getIdToken();
+      if (!idToken) {
+        console.warn(`[WS] Cannot send message - no auth token available for action: ${action}`);
+        return;
+      }
+      this.socket$.next({
+        Authorization: idToken,
+        action,
+        payload
+      });
+    } catch (error) {
+      console.error("[WS] Error sending message:", error);
+    }
+  }
+  on(action) {
+    return this.messages$.pipe(
+      operators.filter((msg) => msg.action === action),
+      operators.map((msg) => msg.payload)
+    );
+  }
+  request(sendAction, responseAction, payload) {
+    return new rxjs.Observable((subscriber) => {
+      const sub = this.on(responseAction).pipe(operators.take(1)).subscribe(subscriber);
+      this.sendMessage(sendAction, payload);
+      return () => sub.unsubscribe();
+    });
+  }
+  disconnect() {
+    var _a;
+    (_a = this.socket$) == null ? void 0 : _a.complete();
+    this.socket$ = null;
+    this.connectionStatusSubject$.next(false);
+    this.resetReconnectAttempts();
+  }
+  destroy() {
+    var _a;
+    (_a = this.socket$) == null ? void 0 : _a.complete();
+    this.socket$ = null;
+    this.destroySubject$.next();
+    this.destroySubject$.complete();
+    this.messagesSubject$.complete();
+    this.connectionStatusSubject$.complete();
+  }
+}
+const LiveUpdateContext = react.createContext(null);
+const useLiveUpdateContext = () => {
+  const context = react.useContext(LiveUpdateContext);
+  if (!context) {
+    throw new Error("useLiveUpdateContext must be used within LiveUpdateProvider");
+  }
+  return context;
+};
+const LiveUpdateProvider = ({
+  children,
+  authProvider,
+  sseUrl = "http://localhost:3000/sse",
+  wsUrl = "ws://localhost:3000/ws",
+  sseEnabled = true,
+  wsEnabled = true,
+  eventMappings = {}
+}) => {
+  const [isConnected, setIsConnected] = react.useState(false);
+  const [service] = react.useState(() => {
+    const sseService = new SSEService({
+      url: sseUrl,
+      authProvider
+    });
+    const wsService = new WebsocketService({
+      url: wsUrl,
+      authProvider
+    });
+    return new LiveUpdateService(wsService, sseService);
+  });
+  react.useEffect(() => {
+    if (authProvider.isAuthenticated()) {
+      service.initialize({
+        sseEnabled,
+        wsEnabled,
+        authProvider,
+        eventMappings
+      });
+    } else {
+      service.disconnect();
+    }
+    const subscription = service.isConnected$.subscribe(setIsConnected);
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [authProvider, sseEnabled, wsEnabled, service, eventMappings]);
+  react.useEffect(() => {
+    return () => {
+      service.disconnect();
+    };
+  }, [service]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    LiveUpdateContext.Provider,
+    {
+      value: {
+        service,
+        isConnected,
+        type: service.type,
+        canSend: service.canSend
+      },
+      children
+    }
+  );
+};
+const useLiveListener = (action, enabled = true) => {
+  const { service } = useLiveUpdateContext();
+  const [data, setData] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    if (!enabled) {
+      return;
+    }
+    const subscription = service.on(action).subscribe({
+      next: (value) => {
+        setData(value);
+        setError(null);
+      },
+      error: (err) => {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [action, enabled, service]);
+  return { data, error };
+};
+const useLiveRequest = () => {
+  const { service, canSend } = useLiveUpdateContext();
+  const request = react.useCallback(
+    (sendAction, responseAction, payload) => {
+      if (!canSend) {
+        return Promise.reject(new Error("WebSocket not available for sending"));
+      }
+      return service.on(responseAction).toPromise().catch(() => {
+        throw new Error(`No response received for action: ${responseAction}`);
+      });
+    },
+    [canSend, service]
+  );
+  return { request, canSend };
+};
+const useLiveUpdateListener = (action, onUpdate, { enabled = true } = {}) => {
+  const { service } = useLiveUpdateContext();
+  const handleUpdate = react.useCallback(
+    (data) => {
+      onUpdate(data);
+    },
+    [onUpdate]
+  );
+  const subscribe = react.useCallback(() => {
+    if (!enabled) {
+      return () => {
+      };
+    }
+    const subscription = service.on(action).subscribe(handleUpdate);
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [action, enabled, service, handleUpdate]);
+  return { subscribe };
+};
+const useLiveUpdates = (eventName) => {
+  const { service } = useLiveUpdateContext();
+  const [data, setData] = react.useState(null);
+  const [error, setError] = react.useState(null);
+  react.useEffect(() => {
+    const subscription = service.on(eventName).subscribe({
+      next: (value) => {
+        setData(value);
+        setError(null);
+      },
+      error: (err) => {
+        setError(err instanceof Error ? err : new Error(String(err)));
+      }
+    });
+    return () => {
+      subscription.unsubscribe();
+    };
+  }, [eventName, service]);
+  return { data, error };
+};
+function useTableService(options) {
+  const { config: config2, data } = options;
+  const builder = react.useMemo(() => {
+    const tb = new core.TableBuilder(config2);
+    tb.setData(data);
+    return tb;
+  }, [config2]);
+  const [state, setState] = react.useState(() => builder.getState());
+  const [selectedRows, setSelectedRows] = react.useState([]);
+  const [allSelected, setAllSelected] = react.useState(false);
+  react.useEffect(() => {
+    const subscription = builder.stateChanged$.subscribe((newState) => {
+      setState(newState);
+    });
+    return () => subscription.unsubscribe();
+  }, [builder]);
+  react.useEffect(() => {
+    builder.setData(data);
+  }, [builder, data]);
+  const memoizedMethods = react.useMemo(() => ({
+    toggleRowSelection: (rowId) => {
+      setSelectedRows(
+        (prev) => prev.includes(rowId) ? prev.filter((id) => id !== rowId) : [...prev, rowId]
+      );
+    },
+    toggleAllSelection: () => {
+      if (allSelected) {
+        setSelectedRows([]);
+        setAllSelected(false);
+      } else {
+        setSelectedRows(state.rows.map((row) => row.id || String(row)));
+        setAllSelected(true);
+      }
+    },
+    clearSelection: () => {
+      setSelectedRows([]);
+      setAllSelected(false);
+    },
+    setSort: (field, direction) => {
+      builder.setSort(field, direction);
+    },
+    toggleSort: (field) => {
+      builder.toggleSort(field);
+    },
+    setFilter: (field, value) => {
+      builder.setFilter(field, value);
+    },
+    clearFilter: (field) => {
+      builder.clearFilter(field);
+    },
+    clearAllFilters: () => {
+      builder.clearAllFilters();
+    },
+    setPage: (page) => {
+      builder.setPage(page);
+    },
+    setPageSize: (size) => {
+      builder.setPageSize(size);
+    },
+    nextPage: () => {
+      builder.nextPage();
+    },
+    prevPage: () => {
+      builder.prevPage();
+    }
+  }), [builder, allSelected, state.rows]);
+  const memoizedReturn = react.useMemo(() => ({
+    rows: state.rows,
+    selectedRows,
+    allSelected,
+    currentPage: state.currentPage,
+    pageSize: state.pageSize,
+    totalPages: state.totalPages,
+    totalItems: state.totalItems,
+    hasNextPage: state.hasNextPage,
+    hasPrevPage: state.hasPrevPage,
+    sortBy: state.sortBy,
+    sortDirection: state.sortDirection,
+    filters: state.filters,
+    ...memoizedMethods
+  }), [state, selectedRows, allSelected, memoizedMethods]);
+  return memoizedReturn;
+}
+class TabsService {
+  constructor(config2) {
+    this.config = config2;
+    this.urlParam = config2.urlParam || "tab";
+    this.tabsSubject = new rxjs.BehaviorSubject(config2.tabs);
+    const initialTabId = this.getInitialTabId();
+    this.activeTabSubject = new rxjs.BehaviorSubject(initialTabId);
+    this.tabChangeSubject = new rxjs.BehaviorSubject(null);
+    if (this.config.enableUrlRouting) {
+      this.setupUrlRouting();
+    }
+  }
+  /**
+   * Get initial tab ID from URL or config
+   */
+  getInitialTabId() {
+    var _a;
+    if (this.config.enableUrlRouting && typeof window !== "undefined") {
+      const params = new URLSearchParams(window.location.search);
+      const urlTabId = params.get(this.urlParam);
+      if (urlTabId && this.config.tabs.some((t) => t.id === urlTabId)) {
+        return urlTabId;
+      }
+    }
+    return this.config.defaultTabId || ((_a = this.config.tabs[0]) == null ? void 0 : _a.id) || "";
+  }
+  /**
+   * Setup URL routing listener
+   */
+  setupUrlRouting() {
+    if (typeof window === "undefined") return;
+    const handleUrlChange = () => {
+      const params = new URLSearchParams(window.location.search);
+      const urlTabId = params.get(this.urlParam);
+      if (urlTabId && urlTabId !== this.activeTabSubject.value) {
+        this.setActiveTab(urlTabId);
+      }
+    };
+    window.addEventListener("popstate", handleUrlChange);
+  }
+  /**
+   * Update URL with current active tab
+   */
+  updateUrl(tabId) {
+    if (!this.config.enableUrlRouting || typeof window === "undefined") return;
+    const params = new URLSearchParams(window.location.search);
+    params.set(this.urlParam, tabId);
+    const newUrl = `${window.location.pathname}?${params.toString()}`;
+    window.history.pushState({ tab: tabId }, "", newUrl);
+  }
+  /**
+   * Set active tab by ID
+   */
+  setActiveTab(tabId) {
+    const tab = this.config.tabs.find((t) => t.id === tabId);
+    if (!tab || tab.disabled) return;
+    const previousTabId = this.activeTabSubject.value;
+    this.activeTabSubject.next(tabId);
+    if (this.config.enableUrlRouting) {
+      this.updateUrl(tabId);
+    }
+    this.tabChangeSubject.next({
+      previousTabId,
+      currentTabId: tabId,
+      tab
+    });
+  }
+  /**
+   * Set active tab by index
+   */
+  setActiveTabByIndex(index) {
+    const tab = this.config.tabs[index];
+    if (tab) {
+      this.setActiveTab(tab.id);
+    }
+  }
+  /**
+   * Get active tab ID
+   */
+  getActiveTabId() {
+    return this.activeTabSubject.value;
+  }
+  /**
+   * Get active tab
+   */
+  getActiveTab() {
+    return this.config.tabs.find((t) => t.id === this.activeTabSubject.value);
+  }
+  /**
+   * Get active tab index
+   */
+  getActiveTabIndex() {
+    return this.config.tabs.findIndex((t) => t.id === this.activeTabSubject.value);
+  }
+  /**
+   * Get all tabs
+   */
+  getTabs() {
+    return this.tabsSubject.value;
+  }
+  /**
+   * Observable of active tab ID
+   */
+  getActiveTabId$() {
+    return this.activeTabSubject.asObservable().pipe(operators.distinctUntilChanged());
+  }
+  /**
+   * Observable of active tab
+   */
+  getActiveTab$() {
+    return this.activeTabSubject.asObservable().pipe(
+      operators.distinctUntilChanged(),
+      operators.map((tabId) => this.config.tabs.find((t) => t.id === tabId))
+    );
+  }
+  /**
+   * Observable of tab change events
+   */
+  onTabChange$() {
+    return this.tabChangeSubject.asObservable();
+  }
+  /**
+   * Observable of all tabs
+   */
+  getTabs$() {
+    return this.tabsSubject.asObservable().pipe(operators.distinctUntilChanged());
+  }
+  /**
+   * Update tabs
+   */
+  updateTabs(tabs) {
+    var _a;
+    this.config.tabs = tabs;
+    this.tabsSubject.next(tabs);
+    if (!tabs.find((t) => t.id === this.activeTabSubject.value)) {
+      const newActiveTabId = ((_a = tabs[0]) == null ? void 0 : _a.id) || "";
+      this.setActiveTab(newActiveTabId);
+    }
+  }
+  /**
+   * Add a tab
+   */
+  addTab(tab, index) {
+    const tabs = [...this.config.tabs];
+    if (index !== void 0) {
+      tabs.splice(index, 0, tab);
+    } else {
+      tabs.push(tab);
+    }
+    this.updateTabs(tabs);
+  }
+  /**
+   * Remove a tab
+   */
+  removeTab(tabId) {
+    const tabs = this.config.tabs.filter((t) => t.id !== tabId);
+    this.updateTabs(tabs);
+  }
+  /**
+   * Enable/disable a tab
+   */
+  setTabDisabled(tabId, disabled) {
+    const tabs = this.config.tabs.map(
+      (t) => t.id === tabId ? { ...t, disabled } : t
+    );
+    this.updateTabs(tabs);
+    if (disabled && this.activeTabSubject.value === tabId) {
+      const enabledTab = tabs.find((t) => !t.disabled);
+      if (enabledTab) {
+        this.setActiveTab(enabledTab.id);
+      }
+    }
+  }
+  /**
+   * Update tab badge
+   */
+  setTabBadge(tabId, badge) {
+    const tabs = this.config.tabs.map(
+      (t) => t.id === tabId ? { ...t, badge } : t
+    );
+    this.updateTabs(tabs);
+  }
+  /**
+   * Move to next tab
+   */
+  nextTab() {
+    const currentIndex = this.getActiveTabIndex();
+    const nextIndex = (currentIndex + 1) % this.config.tabs.length;
+    this.setActiveTabByIndex(nextIndex);
+  }
+  /**
+   * Move to previous tab
+   */
+  previousTab() {
+    const currentIndex = this.getActiveTabIndex();
+    const prevIndex = currentIndex === 0 ? this.config.tabs.length - 1 : currentIndex - 1;
+    this.setActiveTabByIndex(prevIndex);
+  }
+  /**
+   * Destroy service and cleanup
+   */
+  destroy() {
+    this.activeTabSubject.complete();
+    this.tabsSubject.complete();
+    this.tabChangeSubject.complete();
+  }
+}
+const TabsContext = react.createContext(void 0);
+function TabsProvider({ config: config2, children }) {
+  const [service] = react.useState(() => new TabsService(config2));
+  const [activeTabId, setActiveTabId] = react.useState(() => service.getActiveTabId());
+  const [tabs, setTabs] = react.useState(() => service.getTabs());
+  react.useEffect(() => {
+    const activeTabSubscription = service.getActiveTabId$().subscribe(setActiveTabId);
+    const tabsSubscription = service.getTabs$().subscribe(setTabs);
+    return () => {
+      activeTabSubscription.unsubscribe();
+      tabsSubscription.unsubscribe();
+    };
+  }, [service]);
+  react.useEffect(() => {
+    return () => {
+      service.destroy();
+    };
+  }, [service]);
+  return /* @__PURE__ */ jsxRuntime.jsx(TabsContext.Provider, { value: { service, activeTabId, tabs }, children });
+}
+function useTabsContext() {
+  const context = react.useContext(TabsContext);
+  if (!context) {
+    throw new Error("useTabsContext must be used within a TabsProvider");
+  }
+  return context;
+}
+function useTabsService() {
+  const { service } = useTabsContext();
+  return service;
+}
+function useActiveTab() {
+  const { service } = useTabsContext();
+  const [activeTab, setActiveTab] = react.useState(() => service.getActiveTab());
+  react.useEffect(() => {
+    const subscription = service.getActiveTab$().subscribe(setActiveTab);
+    return () => subscription.unsubscribe();
+  }, [service]);
+  return activeTab;
+}
+function useTabs() {
+  const { tabs } = useTabsContext();
+  return tabs;
+}
+function useTabChange() {
+  const { service } = useTabsContext();
+  const [changeEvent, setChangeEvent] = react.useState(null);
+  react.useEffect(() => {
+    const subscription = service.onTabChange$().subscribe(setChangeEvent);
+    return () => subscription.unsubscribe();
+  }, [service]);
+  return changeEvent;
+}
+function useSetActiveTab() {
+  const { service } = useTabsContext();
+  return {
+    setActiveTab: (tabId) => service.setActiveTab(tabId),
+    setActiveTabByIndex: (index) => service.setActiveTabByIndex(index),
+    nextTab: () => service.nextTab(),
+    previousTab: () => service.previousTab()
+  };
+}
+function ResponsiveTabs({
+  className = "",
+  tabClassName = "",
+  activeTabClassName = "",
+  selectClassName = "",
+  breakpoint = 768,
+  showBadges = true,
+  icon = true
+}) {
+  const [isMobile, setIsMobile] = react.useState(false);
+  const activeTab = useActiveTab();
+  const tabs = useTabs();
+  const { setActiveTab } = useSetActiveTab();
+  react.useEffect(() => {
+    const handleResize = () => {
+      setIsMobile(window.innerWidth < breakpoint);
+    };
+    handleResize();
+    window.addEventListener("resize", handleResize);
+    return () => {
+      window.removeEventListener("resize", handleResize);
+    };
+  }, [breakpoint]);
+  if (!activeTab) {
+    return null;
+  }
+  return isMobile ? /* @__PURE__ */ jsxRuntime.jsx(
+    TabsSelect,
+    {
+      tabs,
+      activeTabId: activeTab.id,
+      onTabChange: setActiveTab,
+      className: selectClassName
+    }
+  ) : /* @__PURE__ */ jsxRuntime.jsx(
+    TabsList,
+    {
+      tabs,
+      activeTabId: activeTab.id,
+      onTabChange: setActiveTab,
+      className,
+      tabClassName,
+      activeTabClassName,
+      showBadges,
+      icon
+    }
+  );
+}
+function TabsList({
+  tabs,
+  activeTabId,
+  onTabChange,
+  className = "",
+  tabClassName = "",
+  activeTabClassName = "",
+  showBadges = true,
+  icon = true
+}) {
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "div",
+    {
+      role: "tablist",
+      className: `flex border-b border-gray-200 ${className}`,
+      "aria-label": "Tabs",
+      children: tabs.map((tab) => /* @__PURE__ */ jsxRuntime.jsx(
+        "button",
+        {
+          role: "tab",
+          "aria-selected": tab.id === activeTabId,
+          "aria-controls": `tabpanel-${tab.id}`,
+          id: `tab-${tab.id}`,
+          onClick: () => !tab.disabled && onTabChange(tab.id),
+          disabled: tab.disabled,
+          className: `
+            relative px-4 py-2 text-sm font-medium transition-colors
+            ${tab.disabled ? "text-gray-400 cursor-not-allowed" : "text-gray-700 hover:text-gray-900"}
+            ${tab.id === activeTabId ? `text-blue-600 border-b-2 border-blue-600 ${activeTabClassName}` : ""}
+            ${tabClassName}
+          `,
+          children: /* @__PURE__ */ jsxRuntime.jsxs("span", { className: "flex items-center gap-2", children: [
+            icon && tab.icon && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "text-lg", children: tab.icon }),
+            /* @__PURE__ */ jsxRuntime.jsx("span", { children: tab.label }),
+            showBadges && tab.badge && /* @__PURE__ */ jsxRuntime.jsx("span", { className: "ml-1 inline-flex items-center justify-center px-2 py-1 text-xs font-semibold leading-none text-white transform translate-y-px bg-red-600 rounded-full", children: tab.badge })
+          ] })
+        },
+        tab.id
+      ))
+    }
+  );
+}
+function TabsSelect({
+  tabs,
+  activeTabId,
+  onTabChange,
+  className = ""
+}) {
+  tabs.find((t) => t.id === activeTabId);
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { className: `w-full ${className}`, children: /* @__PURE__ */ jsxRuntime.jsx(
+    "select",
+    {
+      value: activeTabId,
+      onChange: (e) => onTabChange(e.target.value),
+      "aria-label": "Select a tab",
+      className: `
+          w-full px-3 py-2 text-sm font-medium border border-gray-300 rounded-md
+          bg-white text-gray-900 hover:border-gray-400 focus:outline-none focus:ring-2
+          focus:ring-blue-500 focus:ring-offset-0
+        `,
+      children: tabs.map((tab) => /* @__PURE__ */ jsxRuntime.jsxs("option", { value: tab.id, disabled: tab.disabled, children: [
+        tab.label,
+        " ",
+        tab.badge ? `(${tab.badge})` : ""
+      ] }, tab.id))
+    }
+  ) });
+}
+exports.LiveUpdateProvider = LiveUpdateProvider;
+exports.ResponsiveTabs = ResponsiveTabs;
+exports.TabsList = TabsList;
+exports.TabsProvider = TabsProvider;
+exports.TabsSelect = TabsSelect;
+exports.useActiveTab = useActiveTab;
+exports.useFiltersAndSort = useFiltersAndSort;
+exports.useFormBuilder = useFormBuilder;
+exports.useLiveListener = useLiveListener;
+exports.useLiveRequest = useLiveRequest;
+exports.useLiveUpdateContext = useLiveUpdateContext;
+exports.useLiveUpdateListener = useLiveUpdateListener;
+exports.useLiveUpdates = useLiveUpdates;
+exports.useSetActiveTab = useSetActiveTab;
+exports.useTabChange = useTabChange;
+exports.useTableService = useTableService;
+exports.useTabs = useTabs;
+exports.useTabsContext = useTabsContext;
+exports.useTabsService = useTabsService;
+//# sourceMappingURL=index.cjs.map