@emmanuel-nike/ark-notify-js 0.1.0

package/dist/react/index.js

@@ -0,0 +1,951 @@
+import { createContext, useMemo, useRef, useEffect, useCallback, useState, useSyncExternalStore, useContext } from 'react';
+import { jsx } from 'react/jsx-runtime';
+
+// src/config.ts
+var DEFAULT_BASE_URL = "https://ark-notify-933303906015.europe-north1.run.app";
+var configuredBaseUrl;
+function configureArkNotify(config) {
+  if (config.baseUrl !== void 0) {
+    configuredBaseUrl = config.baseUrl;
+  }
+}
+function resolveBaseUrl(baseUrl) {
+  return (baseUrl ?? configuredBaseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+}
+
+// src/utils.ts
+var ArkNotifyError = class extends Error {
+  constructor(status, body) {
+    super(body.message);
+    this.name = "ArkNotifyError";
+    this.status = status;
+    this.code = body.error;
+    this.retryAfterSec = body.retryAfterSec;
+    this.reason = body.reason;
+  }
+};
+function toWebSocketUrl(baseUrl, path) {
+  const url = new URL(path, baseUrl);
+  url.protocol = url.protocol === "https:" ? "wss:" : "ws:";
+  return url.toString();
+}
+function resolveValue(value) {
+  return typeof value === "function" ? value() : value;
+}
+function isPrivateChannel(channel) {
+  return channel.startsWith("private-");
+}
+
+// src/client.ts
+var ArkNotifyClient = class {
+  constructor(config) {
+    this.baseUrl = resolveBaseUrl(config.baseUrl);
+    this.token = config.token;
+    this.fetchFn = config.fetch ?? globalThis.fetch.bind(globalThis);
+  }
+  setToken(token) {
+    this.token = token ?? void 0;
+  }
+  getAuthHeader() {
+    const token = resolveValue(this.token);
+    return token ? `Bearer ${token}` : void 0;
+  }
+  async request(path, options = {}) {
+    const headers = {
+      "Content-Type": "application/json",
+      ...options.headers
+    };
+    const auth = this.getAuthHeader();
+    if (auth) {
+      headers.Authorization = auth;
+    }
+    if (options.credentials) {
+      headers["X-App-Key"] = options.credentials.appKey;
+      headers["X-App-Secret"] = options.credentials.secret;
+    }
+    const response = await this.fetchFn(`${this.baseUrl}${path}`, {
+      method: options.method ?? "GET",
+      headers,
+      body: options.body !== void 0 ? JSON.stringify(options.body) : void 0
+    });
+    if (!response.ok) {
+      let body;
+      try {
+        body = await response.json();
+      } catch {
+        body = { error: "request_failed", message: response.statusText };
+      }
+      throw new ArkNotifyError(response.status, body);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  }
+  // ── Health ──────────────────────────────────────────────────────────────
+  health() {
+    return this.request("/health");
+  }
+  // ── Platform auth ───────────────────────────────────────────────────────
+  login(input) {
+    return this.request("/api/v1/auth/login", { method: "POST", body: input });
+  }
+  me() {
+    return this.request("/api/v1/auth/me");
+  }
+  // ── Applications ────────────────────────────────────────────────────────
+  listApplications() {
+    return this.request("/api/v1/applications");
+  }
+  createApplication(input) {
+    return this.request("/api/v1/applications", { method: "POST", body: input });
+  }
+  getApplication(id) {
+    return this.request(`/api/v1/applications/${id}`);
+  }
+  updateApplication(id, input) {
+    return this.request(`/api/v1/applications/${id}`, { method: "PUT", body: input });
+  }
+  deleteApplication(id) {
+    return this.request(`/api/v1/applications/${id}`, { method: "DELETE" });
+  }
+  regenerateSecret(id) {
+    return this.request(`/api/v1/applications/${id}/regenerate-secret`, {
+      method: "POST"
+    });
+  }
+  // ── System admin ────────────────────────────────────────────────────────
+  adminChannels() {
+    return this.request("/api/v1/admin/channels");
+  }
+  // ── Data plane ──────────────────────────────────────────────────────────
+  publishEvent(appKey, credentials, input) {
+    return this.request(`/api/v1/apps/${appKey}/events`, {
+      method: "POST",
+      body: input,
+      credentials
+    });
+  }
+  authorizeChannel(appKey, credentials, input) {
+    return this.request(`/api/v1/apps/${appKey}/auth`, {
+      method: "POST",
+      body: input,
+      credentials
+    });
+  }
+  issueConnectionToken(appKey, credentials, input) {
+    return this.request(`/api/v1/apps/${appKey}/connection-token`, {
+      method: "POST",
+      body: input,
+      credentials
+    });
+  }
+};
+
+// src/connection-token.ts
+async function fetchConnectionToken(options) {
+  const {
+    baseUrl,
+    appKey,
+    credentials,
+    fetch: fetchFn = globalThis.fetch.bind(globalThis),
+    client_id,
+    clientId,
+    user_data,
+    userData,
+    ttl,
+    capabilities,
+    serverAuthUrl
+  } = options;
+  const resolvedClientId = client_id ?? clientId;
+  if (!resolvedClientId) {
+    throw new Error("client_id is required to fetch a connection token");
+  }
+  const body = {
+    client_id: resolvedClientId,
+    user_data: user_data ?? userData,
+    ttl,
+    capabilities,
+    serverAuthUrl
+  };
+  const url = `${resolveBaseUrl(baseUrl)}/api/v1/apps/${appKey}/connection-token`;
+  const response = await fetchFn(url, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/json",
+      "X-App-Key": credentials.appKey,
+      "X-App-Secret": credentials.secret
+    },
+    body: JSON.stringify(body)
+  });
+  if (!response.ok) {
+    let errorBody;
+    try {
+      errorBody = await response.json();
+    } catch {
+      errorBody = { error: "request_failed", message: response.statusText };
+    }
+    throw new ArkNotifyError(response.status, errorBody);
+  }
+  return response.json();
+}
+
+// src/connection.ts
+var ArkNotifyConnection = class {
+  constructor(config) {
+    this.ws = null;
+    this.state = "disconnected";
+    this.connectionId = null;
+    this.clientId = null;
+    this.authenticated = false;
+    this.subscribedChannels = /* @__PURE__ */ new Set();
+    this.pendingSubscriptions = /* @__PURE__ */ new Map();
+    this.listeners = /* @__PURE__ */ new Map();
+    this.reconnectAttempt = 0;
+    this.reconnectTimer = null;
+    this.intentionalClose = false;
+    this.connectPromise = null;
+    this.config = {
+      autoReconnect: true,
+      reconnectDelayMs: 1e3,
+      maxReconnectDelayMs: 3e4,
+      ...config,
+      baseUrl: resolveBaseUrl(config.baseUrl)
+    };
+    this.WebSocketCtor = config.WebSocket ?? globalThis.WebSocket;
+  }
+  getConnectionState() {
+    return this.state;
+  }
+  getConnectionId() {
+    return this.connectionId;
+  }
+  getClientId() {
+    return this.clientId;
+  }
+  isAuthenticated() {
+    return this.authenticated;
+  }
+  getSubscribedChannels() {
+    return [...this.subscribedChannels];
+  }
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+  }
+  emit(event, ...args) {
+    for (const handler of this.listeners.get(event) ?? []) {
+      handler(...args);
+    }
+  }
+  setState(state) {
+    if (this.state !== state) {
+      this.state = state;
+      this.emit("state", state);
+    }
+  }
+  connect() {
+    if (this.ws?.readyState === WebSocket.OPEN || this.ws?.readyState === WebSocket.CONNECTING) {
+      return Promise.resolve();
+    }
+    if (this.connectPromise) {
+      return this.connectPromise;
+    }
+    this.connectPromise = this.doConnect().finally(() => {
+      this.connectPromise = null;
+    });
+    return this.connectPromise;
+  }
+  async doConnect() {
+    this.intentionalClose = false;
+    this.clearReconnectTimer();
+    this.setState(this.reconnectAttempt > 0 ? "reconnecting" : "connecting");
+    const url = new URL(
+      toWebSocketUrl(this.config.baseUrl, `/app/${this.config.appKey}`)
+    );
+    let token = resolveValue(this.config.token);
+    if (!token && this.config.clientId && this.config.credentials) {
+      const result = await fetchConnectionToken({
+        baseUrl: this.config.baseUrl,
+        appKey: this.config.appKey,
+        credentials: this.config.credentials,
+        client_id: this.config.clientId,
+        user_data: this.config.user_data,
+        fetch: this.config.fetch
+      });
+      token = result.token;
+    }
+    if (token) {
+      url.searchParams.set("token", token);
+    } else if (this.config.clientId) {
+      url.searchParams.set("clientId", this.config.clientId);
+    }
+    this.ws = new this.WebSocketCtor(url.toString());
+    this.ws.onopen = () => {
+      this.reconnectAttempt = 0;
+    };
+    this.ws.onmessage = (event) => {
+      this.handleMessage(event.data);
+    };
+    this.ws.onerror = () => {
+      this.emit("error", { code: "websocket_error", message: "WebSocket error" });
+    };
+    this.ws.onclose = (event) => {
+      this.ws = null;
+      this.connectionId = null;
+      this.emit("close", { code: event.code, reason: event.reason });
+      if (!this.intentionalClose && this.config.autoReconnect) {
+        this.scheduleReconnect();
+      } else {
+        this.setState("failed");
+      }
+    };
+  }
+  disconnect() {
+    this.intentionalClose = true;
+    this.clearReconnectTimer();
+    this.subscribedChannels.clear();
+    this.pendingSubscriptions.clear();
+    if (this.ws) {
+      this.ws.close();
+      this.ws = null;
+    }
+    this.setState("disconnected");
+  }
+  scheduleReconnect() {
+    this.setState("reconnecting");
+    const delay = Math.min(
+      this.config.reconnectDelayMs * 2 ** this.reconnectAttempt,
+      this.config.maxReconnectDelayMs
+    );
+    this.reconnectAttempt++;
+    this.reconnectTimer = setTimeout(() => void this.connect(), delay);
+  }
+  clearReconnectTimer() {
+    if (this.reconnectTimer) {
+      clearTimeout(this.reconnectTimer);
+      this.reconnectTimer = null;
+    }
+  }
+  send(payload) {
+    if (this.ws?.readyState !== WebSocket.OPEN) {
+      throw new Error("WebSocket is not connected");
+    }
+    this.ws.send(JSON.stringify(payload));
+  }
+  handleMessage(raw) {
+    let message;
+    try {
+      message = JSON.parse(raw);
+    } catch {
+      this.emit("error", { code: "invalid_json", message: "Invalid JSON from server" });
+      return;
+    }
+    this.emit("message", message);
+    switch (message.type) {
+      case "connected": {
+        this.connectionId = message.connection_id;
+        this.clientId = message.client_id;
+        this.authenticated = message.authenticated;
+        this.setState("connected");
+        this.emit("connected", message);
+        this.resubscribeAll();
+        break;
+      }
+      case "event":
+        this.emit("event", message);
+        break;
+      case "presence":
+        this.emit("presence", message);
+        break;
+      case "subscribed":
+        this.subscribedChannels.add(message.channel);
+        break;
+      case "unsubscribed":
+        this.subscribedChannels.delete(message.channel);
+        break;
+      case "error":
+        this.emit("error", { code: message.code, message: message.message });
+        break;
+      case "ping":
+        this.send({ action: "ping" });
+        break;
+    }
+  }
+  resubscribeAll() {
+    for (const [channel, options] of this.pendingSubscriptions) {
+      void this.subscribe(channel, options);
+    }
+  }
+  async subscribe(channel, options = {}) {
+    this.pendingSubscriptions.set(channel, options);
+    if (this.state !== "connected" || !this.connectionId) {
+      return;
+    }
+    const payload = {
+      action: "subscribe",
+      channel
+    };
+    if (options.history) payload.history = true;
+    if (options.presence) {
+      payload.presence = true;
+      if (options.presence_data) payload.presence_data = options.presence_data;
+    }
+    if (isPrivateChannel(channel)) {
+      if (options.auth) {
+        payload.auth = options.auth;
+      } else if (this.config.onPrivateChannelAuth) {
+        payload.auth = await this.config.onPrivateChannelAuth(channel, this.connectionId);
+      } else {
+        throw new Error(
+          `Private channel "${channel}" requires auth. Provide options.auth or onPrivateChannelAuth.`
+        );
+      }
+    }
+    this.send(payload);
+  }
+  unsubscribe(channel) {
+    this.pendingSubscriptions.delete(channel);
+    this.subscribedChannels.delete(channel);
+    if (this.state === "connected") {
+      this.send({ action: "unsubscribe", channel });
+    }
+  }
+  publish(channel, event, data) {
+    this.send({ action: "publish", channel, event, data });
+  }
+  presenceEnter(channel, data) {
+    this.send({ action: "presence_enter", channel, data });
+  }
+  presenceUpdate(channel, data) {
+    this.send({ action: "presence_update", channel, data });
+  }
+  presenceLeave(channel) {
+    this.send({ action: "presence_leave", channel });
+  }
+  presenceSync(channel) {
+    this.send({ action: "presence_sync", channel });
+  }
+  ping() {
+    this.send({ action: "ping" });
+  }
+  bind(channel, event, handler) {
+    const listener = (message) => {
+      if (message.channel === channel && message.event === event) {
+        handler(message.data, message);
+      }
+    };
+    return this.on("event", listener);
+  }
+  bindAll(channel, handler) {
+    const listener = (message) => {
+      if (message.channel === channel) {
+        handler(message.data, message);
+      }
+    };
+    return this.on("event", listener);
+  }
+};
+
+// src/sse.ts
+var ArkNotifySSE = class {
+  constructor(config) {
+    this.es = null;
+    this.connectionId = null;
+    this.listeners = /* @__PURE__ */ new Map();
+    this.config = { ...config, baseUrl: resolveBaseUrl(config.baseUrl) };
+    this.EventSourceCtor = config.EventSource ?? globalThis.EventSource;
+  }
+  getConnectionId() {
+    return this.connectionId;
+  }
+  on(event, handler) {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, /* @__PURE__ */ new Set());
+    }
+    this.listeners.get(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  off(event, handler) {
+    this.listeners.get(event)?.delete(handler);
+  }
+  emit(event, ...args) {
+    for (const handler of this.listeners.get(event) ?? []) {
+      handler(...args);
+    }
+  }
+  async connect() {
+    if (this.es) return;
+    const base = this.config.baseUrl.replace(/\/$/, "");
+    const url = new URL(`${base}/app/${this.config.appKey}/stream`);
+    url.searchParams.set("channels", this.config.channels.join(","));
+    const token = resolveValue(this.config.token);
+    if (token) {
+      url.searchParams.set("token", token);
+    } else if (this.config.clientId) {
+      url.searchParams.set("clientId", this.config.clientId);
+    }
+    if (this.config.history) {
+      url.searchParams.set("history", "true");
+    }
+    if (this.config.user_data) {
+      url.searchParams.set("user_data", JSON.stringify(this.config.user_data));
+    }
+    let authMap = this.config.auth ? { ...this.config.auth } : {};
+    const privateChannels = this.config.channels.filter(isPrivateChannel);
+    if (privateChannels.length > 0 && this.config.onPrivateChannelAuth && !this.config.auth) ;
+    if (Object.keys(authMap).length > 0) {
+      url.searchParams.set("auth", JSON.stringify(authMap));
+    }
+    this.es = new this.EventSourceCtor(url.toString());
+    this.es.addEventListener("connected", (e) => {
+      const message = JSON.parse(e.data);
+      this.connectionId = message.connection_id;
+      this.emit("connected", message);
+      this.emit("message", message);
+    });
+    this.es.addEventListener("event", (e) => {
+      const message = JSON.parse(e.data);
+      this.emit("event", message);
+      this.emit("message", message);
+    });
+    this.es.addEventListener("presence", (e) => {
+      const message = JSON.parse(e.data);
+      this.emit("presence", message);
+      this.emit("message", message);
+    });
+    this.es.onerror = () => {
+      this.emit("error", new Error("SSE connection error"));
+    };
+  }
+  disconnect() {
+    if (this.es) {
+      this.es.close();
+      this.es = null;
+      this.connectionId = null;
+      this.emit("close");
+    }
+  }
+  bind(channel, event, handler) {
+    const listener = (message) => {
+      if (message.channel === channel && message.event === event) {
+        handler(message.data, message);
+      }
+    };
+    return this.on("event", listener);
+  }
+  bindAll(channel, handler) {
+    const listener = (message) => {
+      if (message.channel === channel) {
+        handler(message.data, message);
+      }
+    };
+    return this.on("event", listener);
+  }
+};
+var ArkNotifyContext = createContext(null);
+function useArkNotifyContext() {
+  const ctx = useContext(ArkNotifyContext);
+  if (!ctx) {
+    throw new Error("useArkNotify must be used within an ArkNotifyProvider");
+  }
+  return ctx;
+}
+function ArkNotifyProvider({
+  children,
+  baseUrl,
+  token,
+  fetch: fetchFn
+}) {
+  const resolvedBaseUrl = useMemo(() => resolveBaseUrl(baseUrl), [baseUrl]);
+  const clientRef = useRef(null);
+  clientRef.current ?? (clientRef.current = new ArkNotifyClient({ baseUrl: resolvedBaseUrl, token, fetch: fetchFn }));
+  const client = clientRef.current;
+  useEffect(() => {
+    if (token === void 0) return;
+    const resolved = typeof token === "function" ? token() ?? null : token ?? null;
+    client.setToken(resolved);
+  }, [client, token]);
+  const createConnection = useCallback(
+    (config) => new ArkNotifyConnection({ baseUrl: resolvedBaseUrl, ...config }),
+    [resolvedBaseUrl]
+  );
+  const createSSE = useCallback(
+    (config) => new ArkNotifySSE({ baseUrl: resolvedBaseUrl, ...config }),
+    [resolvedBaseUrl]
+  );
+  const value = useMemo(
+    () => ({ baseUrl: resolvedBaseUrl, client, createConnection, createSSE }),
+    [resolvedBaseUrl, client, createConnection, createSSE]
+  );
+  return /* @__PURE__ */ jsx(ArkNotifyContext.Provider, { value, children });
+}
+
+// src/react/useArkNotify.ts
+function useArkNotify() {
+  return useArkNotifyContext();
+}
+function useConnection(options) {
+  const { createConnection } = useArkNotify();
+  const { enabled = true, ...connectionConfig } = options;
+  const connectionRef = useRef(null);
+  const [connectedMessage, setConnectedMessage] = useState(null);
+  if (!connectionRef.current) {
+    connectionRef.current = createConnection(connectionConfig);
+  }
+  const connection = connectionRef.current;
+  const subscribe = useCallback(
+    (onStoreChange) => {
+      const unsubscribers = [
+        connection.on("state", onStoreChange),
+        connection.on("connected", (msg) => {
+          setConnectedMessage(msg);
+          onStoreChange();
+        })
+      ];
+      return () => unsubscribers.forEach((u) => u());
+    },
+    [connection]
+  );
+  const getSnapshot = useCallback(() => connection.getConnectionState(), [connection]);
+  const state = useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
+  useEffect(() => {
+    if (enabled) {
+      connection.connect();
+    }
+    return () => connection.disconnect();
+  }, [connection, enabled]);
+  const connect = useCallback(() => connection.connect(), [connection]);
+  const disconnect = useCallback(() => connection.disconnect(), [connection]);
+  return {
+    connection,
+    state,
+    connectionId: connection.getConnectionId(),
+    clientId: connection.getClientId(),
+    authenticated: connection.isAuthenticated(),
+    connectedMessage,
+    connect,
+    disconnect
+  };
+}
+function useChannel(connection, channel, options = {}) {
+  const { enabled = true, onEvent, ...subscribeOptions } = options;
+  const [subscribed, setSubscribed] = useState(false);
+  const subscribeOptionsRef = useRef(subscribeOptions);
+  subscribeOptionsRef.current = subscribeOptions;
+  const subscribe = useCallback(
+    async (opts) => {
+      if (!connection) return;
+      await connection.subscribe(channel, { ...subscribeOptionsRef.current, ...opts });
+      setSubscribed(true);
+    },
+    [connection, channel]
+  );
+  const unsubscribe = useCallback(() => {
+    connection?.unsubscribe(channel);
+    setSubscribed(false);
+  }, [connection, channel]);
+  const publish = useCallback(
+    (event, data) => {
+      connection?.publish(channel, event, data);
+    },
+    [connection, channel]
+  );
+  const bind = useCallback(
+    (event, handler) => {
+      if (!connection) return () => {
+      };
+      return connection.bind(channel, event, handler);
+    },
+    [connection, channel]
+  );
+  useEffect(() => {
+    if (!connection || !enabled || !channel) return;
+    const unsubSubscribed = connection.on("message", (msg) => {
+      if (msg.type === "subscribed" && msg.channel === channel) {
+        setSubscribed(true);
+      }
+      if (msg.type === "unsubscribed" && msg.channel === channel) {
+        setSubscribed(false);
+      }
+    });
+    const unsubEvent = onEvent ? connection.on("event", (msg) => {
+      if (msg.channel === channel) {
+        onEvent(msg.event, msg.data, msg);
+      }
+    }) : () => {
+    };
+    void subscribe();
+    return () => {
+      unsubSubscribed();
+      unsubEvent();
+      connection.unsubscribe(channel);
+      setSubscribed(false);
+    };
+  }, [connection, channel, enabled, subscribe, onEvent]);
+  return { subscribed, subscribe, unsubscribe, publish, bind };
+}
+function usePresence(connection, channel, options = {}) {
+  const { enabled = true, initialData } = options;
+  const [members, setMembers] = useState([]);
+  useEffect(() => {
+    if (!connection || !enabled || !channel) return;
+    const unsubscribe = connection.on("presence", (msg) => {
+      if (msg.channel !== channel) return;
+      if (msg.action === "sync" && msg.members) {
+        setMembers(msg.members);
+      } else if (msg.action === "enter" && msg.member) {
+        setMembers((prev) => {
+          const filtered = prev.filter((m) => m.clientId !== msg.member.clientId);
+          return [...filtered, msg.member];
+        });
+      } else if (msg.action === "leave" && msg.member) {
+        setMembers((prev) => prev.filter((m) => m.clientId !== msg.member.clientId));
+      } else if (msg.action === "update" && msg.member) {
+        setMembers(
+          (prev) => prev.map((m) => m.clientId === msg.member.clientId ? msg.member : m)
+        );
+      }
+    });
+    if (initialData) {
+      connection.presenceEnter(channel, initialData);
+    }
+    return unsubscribe;
+  }, [connection, channel, enabled, initialData]);
+  const enter = useCallback(
+    (data) => connection?.presenceEnter(channel, data),
+    [connection, channel]
+  );
+  const update = useCallback(
+    (data) => connection?.presenceUpdate(channel, data),
+    [connection, channel]
+  );
+  const leave = useCallback(() => connection?.presenceLeave(channel), [connection, channel]);
+  const sync = useCallback(() => connection?.presenceSync(channel), [connection, channel]);
+  return { members, enter, update, leave, sync };
+}
+function useApplications() {
+  const { client } = useArkNotify();
+  const [apps, setApps] = useState([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const { apps: list } = await client.listApplications();
+      setApps(list);
+    } catch (err) {
+      if (err instanceof ArkNotifyError) setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  const create = useCallback(
+    async (input) => {
+      const { app } = await client.createApplication(input);
+      setApps((prev) => [...prev, app]);
+      return app;
+    },
+    [client]
+  );
+  const update = useCallback(
+    async (id, input) => {
+      const { app } = await client.updateApplication(id, input);
+      setApps((prev) => prev.map((a) => a.id === id ? app : a));
+      return app;
+    },
+    [client]
+  );
+  const remove = useCallback(
+    async (id) => {
+      await client.deleteApplication(id);
+      setApps((prev) => prev.filter((a) => a.id !== id));
+    },
+    [client]
+  );
+  const regenerateSecret = useCallback(
+    async (id) => {
+      const { app } = await client.regenerateSecret(id);
+      setApps((prev) => prev.map((a) => a.id === id ? app : a));
+      return app;
+    },
+    [client]
+  );
+  const getById = useCallback(
+    async (id) => {
+      const { app } = await client.getApplication(id);
+      return app;
+    },
+    [client]
+  );
+  return { apps, loading, error, refresh, create, update, remove, regenerateSecret, getById };
+}
+var TOKEN_STORAGE_KEY = "ark-notify-js-token";
+function usePlatformAuth(options = {}) {
+  const { client } = useArkNotify();
+  const storageKey = options.storageKey ?? TOKEN_STORAGE_KEY;
+  const persist = options.persist ?? true;
+  const [user, setUser] = useState(null);
+  const [token, setToken] = useState(() => {
+    if (!persist || typeof window === "undefined") return null;
+    return localStorage.getItem(storageKey);
+  });
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const saveToken = useCallback(
+    (newToken) => {
+      setToken(newToken);
+      client.setToken(newToken);
+      if (persist && typeof window !== "undefined") {
+        if (newToken) {
+          localStorage.setItem(storageKey, newToken);
+        } else {
+          localStorage.removeItem(storageKey);
+        }
+      }
+    },
+    [client, persist, storageKey]
+  );
+  const refreshUser = useCallback(async () => {
+    if (!token) {
+      setUser(null);
+      return;
+    }
+    setLoading(true);
+    setError(null);
+    try {
+      client.setToken(token);
+      const { user: fetched } = await client.me();
+      setUser(fetched);
+    } catch (err) {
+      setUser(null);
+      if (err instanceof ArkNotifyError) {
+        setError(err);
+        if (err.status === 401) saveToken(null);
+      }
+    } finally {
+      setLoading(false);
+    }
+  }, [client, token, saveToken]);
+  useEffect(() => {
+    if (token) {
+      client.setToken(token);
+      void refreshUser();
+    }
+  }, []);
+  const login = useCallback(
+    async (input) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const res = await client.login(input);
+        saveToken(res.token);
+        setUser(res.user);
+      } catch (err) {
+        if (err instanceof ArkNotifyError) setError(err);
+        throw err;
+      } finally {
+        setLoading(false);
+      }
+    },
+    [client, saveToken]
+  );
+  const logout = useCallback(() => {
+    saveToken(null);
+    setUser(null);
+    setError(null);
+  }, [saveToken]);
+  return {
+    user,
+    token,
+    loading,
+    error,
+    login,
+    logout,
+    refreshUser,
+    isAuthenticated: !!user && !!token
+  };
+}
+function useSSE(options) {
+  const { createSSE } = useArkNotify();
+  const { enabled = true, onEvent, ...sseConfig } = options;
+  const sseRef = useRef(null);
+  const [connected, setConnected] = useState(false);
+  const [connectedMessage, setConnectedMessage] = useState(null);
+  if (!sseRef.current) {
+    sseRef.current = createSSE(sseConfig);
+  }
+  const sse = sseRef.current;
+  useEffect(() => {
+    if (!enabled) return;
+    const unsubs = [
+      sse.on("connected", (msg) => {
+        setConnected(true);
+        setConnectedMessage(msg);
+      }),
+      sse.on("close", () => {
+        setConnected(false);
+        setConnectedMessage(null);
+      }),
+      onEvent ? sse.on("event", (msg) => onEvent(msg.event, msg.data, msg)) : () => {
+      }
+    ];
+    void sse.connect();
+    return () => {
+      unsubs.forEach((u) => u());
+      sse.disconnect();
+      setConnected(false);
+    };
+  }, [sse, enabled, onEvent]);
+  const connect = useCallback(() => void sse.connect(), [sse]);
+  const disconnect = useCallback(() => sse.disconnect(), [sse]);
+  const bind = useCallback(
+    (channel, event, handler) => sse.bind(channel, event, (data) => handler(data)),
+    [sse]
+  );
+  return {
+    sse,
+    connected,
+    connectionId: sse.getConnectionId(),
+    connectedMessage,
+    connect,
+    disconnect,
+    bind
+  };
+}
+function useAdminChannels() {
+  const { client } = useArkNotify();
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState(null);
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      const result = await client.adminChannels();
+      setData(result);
+    } catch (err) {
+      if (err instanceof ArkNotifyError) setError(err);
+    } finally {
+      setLoading(false);
+    }
+  }, [client]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  return { data, loading, error, refresh };
+}
+
+export { ArkNotifyProvider, DEFAULT_BASE_URL, configureArkNotify, useAdminChannels, useApplications, useArkNotify, useChannel, useConnection, usePlatformAuth, usePresence, useSSE };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map