@kerne/react 0.1.0 → 0.1.2

package/dist/index.js

@@ -1,208 +1,186 @@
-// src/index.tsx
-import { createContext, useContext, useEffect, useState, useMemo } from "react";
-import { Kerne } from "@kerne/server";
+"use client";
+import {
+  KerneClient,
+  KerneContext,
+  KerneProvider,
+  defaultLocalization,
+  useAccess,
+  useAuth,
+  useAuthConfig,
+  useCheckout,
+  useClient,
+  useEntitlements,
+  useInvitation,
+  usePlans,
+  usePortal,
+  useSubscription,
+  useUsage,
+  useUser,
+  useWaitlist
+} from "./chunk-AIUIBAYB.js";
+
+// src/components.tsx
+import React from "react";
 import { jsx } from "react/jsx-runtime";
-var DEFAULT_STORAGE_KEY = "kerne_auth";
-var KerneClient = class {
-  kerne;
-  storage;
-  storageKey;
-  onAuthChange;
-  currentUser = null;
-  currentToken = null;
-  constructor(config) {
-    this.storage = config.storage ?? (typeof window !== "undefined" ? localStorage : null);
-    this.storageKey = config.storageKey ?? DEFAULT_STORAGE_KEY;
-    this.onAuthChange = config.onAuthChange;
-    this.kerne = new Kerne({
-      baseUrl: config.baseUrl,
-      appId: config.appId,
-      timeout: config.timeout
-    });
-    this.loadSession();
-  }
-  loadSession() {
-    if (!this.storage) return;
-    try {
-      const data = this.storage.getItem(this.storageKey);
-      if (data) {
-        const { user, token, expires_at } = JSON.parse(data);
-        if (new Date(expires_at) > /* @__PURE__ */ new Date()) {
-          this.currentUser = user;
-          this.currentToken = token;
-          this.kerne = this.kerne.withToken(token);
-        } else {
-          this.storage.removeItem(this.storageKey);
-        }
-      }
-    } catch {
-      this.storage.removeItem(this.storageKey);
-    }
-  }
-  saveSession(response) {
-    this.currentUser = response.user;
-    this.currentToken = response.token;
-    this.kerne = this.kerne.withToken(response.token);
-    if (this.storage) {
-      this.storage.setItem(this.storageKey, JSON.stringify(response));
-    }
-    this.onAuthChange?.(response.user);
-  }
-  clearSession() {
-    this.currentUser = null;
-    this.currentToken = null;
-    if (this.storage) {
-      this.storage.removeItem(this.storageKey);
-    }
-    this.onAuthChange?.(null);
-  }
-  get user() {
-    return this.currentUser;
-  }
-  get token() {
-    return this.currentToken;
-  }
-  get isAuthenticated() {
-    return this.currentToken !== null;
-  }
-  get client() {
-    return this.kerne;
-  }
-  get projects() {
-    return this.kerne.projects;
-  }
-  async register(params) {
-    const [firstName, ...lastNameParts] = (params.name || "").split(" ");
-    const lastName = lastNameParts.join(" ");
-    const response = await this.kerne.auth.signup({
-      email: params.email,
-      password: params.password,
-      first_name: firstName,
-      last_name: lastName || void 0
-    });
-    this.saveSession(response);
-    return response;
-  }
-  async login(params) {
-    const response = await this.kerne.auth.login({
-      email: params.email,
-      password: params.password
-    });
-    this.saveSession(response);
-    return response;
-  }
-  async refreshToken() {
-    if (!this.currentToken) return null;
-    const response = await this.kerne.auth.refreshToken({
-      refresh_token: this.currentToken
+function Authenticated({ children, fallback = null }) {
+  const { isAuthenticated } = useAuth();
+  return isAuthenticated ? children : fallback;
+}
+function Unauthenticated({ children, fallback = null }) {
+  const { isAuthenticated } = useAuth();
+  return !isAuthenticated ? children : fallback;
+}
+function AuthLoading({ children }) {
+  const client = useClient();
+  return client.isLoading ? children : null;
+}
+function HasSubscription({ children, fallback = null }) {
+  const client = useClient();
+  const [hasSubscription, setHasSubscription] = React.useState(null);
+  React.useEffect(() => {
+    client.getSubscription().then((sub) => {
+      setHasSubscription(sub !== null && ["ACTIVE", "TRIALING"].includes(sub.status));
+    }).catch(() => {
+      setHasSubscription(false);
     });
-    this.saveSession(response);
-    return response;
-  }
-  logout() {
-    this.clearSession();
-  }
-  async refreshUser() {
-    if (!this.currentToken) return null;
-    try {
-      const user = await this.kerne.users.me();
-      this.currentUser = user;
-      this.onAuthChange?.(user);
-      return user;
-    } catch {
-      this.clearSession();
-      return null;
-    }
-  }
-  async checkEntitlement(featureKey, requested) {
-    try {
-      const check = await this.kerne.billing.checkEntitlement(featureKey, requested);
-      return check.has_access;
-    } catch {
-      return false;
-    }
-  }
-  async createCheckout(planId, options) {
-    const { url } = await this.kerne.billing.createCheckout(planId, {
-      success_url: options?.successUrl,
-      cancel_url: options?.cancelUrl
+  }, [client]);
+  if (hasSubscription === null) return null;
+  return hasSubscription ? children : fallback;
+}
+function Allows({
+  children,
+  featureKey,
+  minimum,
+  fallback = null
+}) {
+  const client = useClient();
+  const [allowed, setAllowed] = React.useState(null);
+  React.useEffect(() => {
+    client.allows(featureKey, minimum).then((result) => {
+      setAllowed(result);
+    }).catch(() => {
+      setAllowed(false);
     });
-    return url;
-  }
-  async openCheckout(planId, options) {
-    const url = await this.createCheckout(planId, options);
-    if (typeof window !== "undefined") {
-      window.location.href = url;
+  }, [client, featureKey, minimum]);
+  if (allowed === null) return null;
+  return allowed ? children : fallback;
+}
+function Protected({
+  children,
+  auth = true,
+  featureKey,
+  authFallback = null,
+  billingFallback = null
+}) {
+  const { isAuthenticated } = useAuth();
+  if (auth && !isAuthenticated) {
+    return authFallback;
+  }
+  if (featureKey) {
+    return /* @__PURE__ */ jsx(Allows, { featureKey, fallback: billingFallback, children });
+  }
+  return children;
+}
+
+// src/error-boundary.tsx
+import React2, { Component } from "react";
+import { jsx as jsx2, jsxs } from "react/jsx-runtime";
+var KerneErrorBoundary = class extends Component {
+  constructor(props) {
+    super(props);
+    this.state = { error: null, hasError: false };
+  }
+  static getDerivedStateFromError(error) {
+    return { error, hasError: true };
+  }
+  componentDidCatch(error, errorInfo) {
+    const kerneError = error;
+    this.props.onError?.(kerneError, errorInfo);
+    if (process.env.NODE_ENV === "development") {
+      console.error("[KerneSDK] Error caught by boundary:", kerneError);
+      console.error("[KerneSDK] Component stack:", errorInfo.componentStack);
     }
   }
-  async createPortal(returnUrl) {
-    const { url } = await this.kerne.billing.createPortal({ return_url: returnUrl });
-    return url;
-  }
-  async openPortal(returnUrl) {
-    const url = await this.createPortal(returnUrl);
-    if (typeof window !== "undefined") {
-      window.location.href = url;
+  reset = () => {
+    this.props.onReset?.();
+    this.setState({ error: null, hasError: false });
+  };
+  render() {
+    if (this.state.hasError && this.state.error) {
+      const { fallback } = this.props;
+      const { error } = this.state;
+      if (fallback) {
+        if (typeof fallback === "function") {
+          return fallback(error, this.reset);
+        }
+        return fallback;
+      }
+      return /* @__PURE__ */ jsxs("div", { style: { padding: "20px", textAlign: "center" }, children: [
+        /* @__PURE__ */ jsx2("h2", { style: { color: "#dc2626", marginBottom: "10px" }, children: "Something went wrong" }),
+        /* @__PURE__ */ jsx2("p", { style: { color: "#6b7280", marginBottom: "20px" }, children: error.message || "An unexpected error occurred" }),
+        error.code && /* @__PURE__ */ jsxs("p", { style: { color: "#9ca3af", fontSize: "12px", marginBottom: "20px" }, children: [
+          "Error code: ",
+          error.code
+        ] }),
+        /* @__PURE__ */ jsx2(
+          "button",
+          {
+            onClick: this.reset,
+            style: {
+              padding: "10px 20px",
+              backgroundColor: "#3b82f6",
+              color: "white",
+              border: "none",
+              borderRadius: "6px",
+              cursor: "pointer"
+            },
+            children: "Try again"
+          }
+        )
+      ] });
     }
+    return this.props.children;
   }
 };
-function createKerneClient(config) {
-  return new KerneClient(config);
-}
-var KerneContext = createContext(null);
-function KerneProvider({ children, ...config }) {
-  const [user, setUser] = useState(null);
-  const client = useMemo(() => {
-    return new KerneClient({
-      ...config,
-      onAuthChange: (u) => {
-        setUser(u);
-        config.onAuthChange?.(u);
-      }
-    });
-  }, [config.appId, config.baseUrl]);
-  useEffect(() => {
-    setUser(client.user);
-  }, [client]);
-  return /* @__PURE__ */ jsx(KerneContext.Provider, { value: client, children });
-}
-function useKerne() {
-  const context = useContext(KerneContext);
-  if (!context) {
-    throw new Error("useKerne must be used within a KerneProvider");
-  }
-  return context;
-}
-function useAuth() {
-  const client = useKerne();
-  const [user, setUser] = useState(client.user);
-  useEffect(() => {
-    setUser(client.user);
-  }, [client.user]);
-  return {
-    user,
-    isAuthenticated: client.isAuthenticated,
-    login: client.login.bind(client),
-    register: client.register.bind(client),
-    logout: client.logout.bind(client),
-    refreshUser: client.refreshUser.bind(client)
-  };
-}
-function useBilling() {
-  const client = useKerne();
+function useKerneError() {
+  const [error, setError] = React2.useState(null);
+  const handleError = React2.useCallback((err) => {
+    setError(err);
+  }, []);
+  const clearError = React2.useCallback(() => {
+    setError(null);
+  }, []);
   return {
-    checkEntitlement: client.checkEntitlement.bind(client),
-    createCheckout: client.createCheckout.bind(client),
-    openCheckout: client.openCheckout.bind(client),
-    createPortal: client.createPortal.bind(client),
-    openPortal: client.openPortal.bind(client)
+    error,
+    hasError: error !== null,
+    handleError,
+    clearError
   };
 }
 export {
+  Allows,
+  AuthLoading,
+  Authenticated,
+  HasSubscription,
   KerneClient,
+  KerneContext,
+  KerneErrorBoundary,
   KerneProvider,
-  createKerneClient,
+  Protected,
+  Unauthenticated,
+  defaultLocalization,
+  useAccess,
   useAuth,
-  useBilling,
-  useKerne
+  useAuthConfig,
+  useCheckout,
+  useClient,
+  useEntitlements,
+  useInvitation,
+  useKerneError,
+  usePlans,
+  usePortal,
+  useSubscription,
+  useUsage,
+  useUser,
+  useWaitlist
 };