@stardeckai/autumn-js 0.1.85

package/dist/libraries/react/chunk-BVK3DYFG.mjs

@@ -0,0 +1,157 @@
+"use client";
+
+import {
+  CheckFeatureResultSchema
+} from "./chunk-ZJPIZX24.mjs";
+
+// src/libraries/react/hooks/helpers/handleCheck.ts
+var getCusFeature = ({
+  customer,
+  featureId,
+  requiredBalance = 1
+}) => {
+  let cusFeature = customer.features[featureId];
+  if (cusFeature && typeof cusFeature.balance === "number" && cusFeature.balance >= requiredBalance) {
+    return {
+      cusFeature,
+      requiredBalance
+    };
+  }
+  let creditSchema = Object.values(customer.features).find(
+    (f) => f.credit_schema && f.credit_schema.some((c) => c.feature_id === featureId)
+  );
+  if (creditSchema) {
+    let schemaItem = creditSchema.credit_schema?.find(
+      (c) => c.feature_id === featureId
+    );
+    return {
+      cusFeature: creditSchema,
+      requiredBalance: schemaItem.credit_amount * requiredBalance
+    };
+  }
+  return {
+    cusFeature: customer.features[featureId],
+    requiredBalance
+  };
+};
+var getFeatureAllowed = ({
+  cusFeature,
+  requiredBalance
+}) => {
+  if (!cusFeature) return false;
+  if (cusFeature.type == "static") return true;
+  if (cusFeature.unlimited || cusFeature.overage_allowed) return true;
+  if (cusFeature.usage_limit) {
+    let extraUsage = (cusFeature.usage_limit || 0) - (cusFeature.included_usage || 0);
+    return (cusFeature.balance || 0) + extraUsage >= requiredBalance;
+  }
+  return (cusFeature.balance || 0) >= requiredBalance;
+};
+var handleFeatureCheck = ({
+  customer,
+  isEntity,
+  params
+}) => {
+  let { cusFeature, requiredBalance } = getCusFeature({
+    customer,
+    featureId: params.featureId,
+    ...params.requiredBalance ? { requiredBalance: params.requiredBalance } : {}
+  });
+  let allowed = getFeatureAllowed({
+    cusFeature,
+    requiredBalance: requiredBalance ?? 1
+  });
+  let result = {
+    allowed,
+    feature_id: cusFeature?.id ?? params.featureId,
+    customer_id: isEntity ? customer.customer_id : customer.id,
+    required_balance: requiredBalance,
+    ...cusFeature
+  };
+  if (isEntity) {
+    result.entity_id = customer.id;
+  }
+  try {
+    return CheckFeatureResultSchema.parse(result);
+  } catch (error) {
+    return result;
+  }
+};
+var handleProductCheck = ({
+  customer,
+  isEntity,
+  params
+}) => {
+  let product = customer.products.find((p) => p.id == params.productId);
+  let allowed = product?.status === "active" || product?.status === "trialing";
+  let result = {
+    allowed,
+    customer_id: isEntity ? customer.customer_id : customer.id,
+    product_id: params.productId
+  };
+  if (product) {
+    result.status = product.status;
+  }
+  if (isEntity) {
+    result.entity_id = customer.id;
+  }
+  return result;
+};
+var openDialog = ({
+  result,
+  params,
+  context
+}) => {
+  let open = result?.allowed === false && params.dialog && context;
+  if (!open) return;
+  const isInRenderCycle = (() => {
+    const stack = new Error().stack || "";
+    return stack.includes("renderWithHooks") || stack.includes("updateFunctionComponent") || stack.includes("beginWork") || stack.includes("performUnitOfWork") || stack.includes("workLoop") || stack.includes("Component.render") || stack.includes("FunctionComponent");
+  })();
+  if (isInRenderCycle) {
+    context.paywallRef.current = {
+      component: params.dialog,
+      open: true,
+      props: params
+    };
+  } else {
+    context.paywallDialog.setComponent(params.dialog);
+    context.paywallDialog.setProps(params);
+    context.paywallDialog.setOpen(true);
+  }
+};
+var handleCheck = ({
+  customer,
+  isEntity,
+  params,
+  context
+}) => {
+  if (!customer) {
+    return {
+      data: {
+        allowed: false,
+        feature_id: "",
+        customer_id: "",
+        required_balance: 0
+      },
+      error: null
+    };
+  }
+  if (!params.featureId && !params.productId) {
+    throw new Error("allowed() requires either featureId or productId");
+  }
+  let result;
+  if (params.featureId)
+    result = handleFeatureCheck({ customer, params, isEntity });
+  if (params.productId)
+    result = handleProductCheck({ customer, params, isEntity });
+  return {
+    data: result,
+    error: null
+  };
+};
+
+export {
+  openDialog,
+  handleCheck
+};

package/dist/libraries/react/chunk-CIBQ4BJU.mjs

@@ -0,0 +1,19 @@
+"use client";
+
+
+// src/libraries/react/errorUtils/logFetchError.ts
+var logFetchError = ({
+  method,
+  backendUrl,
+  path,
+  error
+}) => {
+  console.error(`[Autumn] Fetch failed: ${method} ${backendUrl}${path}
+
+1. Check that backendUrl in <AutumnProvider/> is correctly set.
+2. Check that autumnHandler is correctly registered on your backend.`);
+};
+
+export {
+  logFetchError
+};

package/dist/libraries/react/chunk-CSHDMTUY.mjs

@@ -0,0 +1,52 @@
+"use client";
+
+import {
+  AutumnContext,
+  useAutumnContext
+} from "./chunk-D2TXVOAD.mjs";
+import {
+  AutumnError
+} from "./chunk-ZJPIZX24.mjs";
+
+// src/libraries/react/hooks/useAnalytics.tsx
+import useSWR from "swr";
+var useAnalytics = (params) => {
+  const context = useAutumnContext({
+    AutumnContext,
+    name: "useAnalytics"
+  });
+  const client = context.client;
+  const fetcher = async () => {
+    const res = await client.query(params);
+    if (res.error) {
+      const err = new AutumnError({
+        message: res.error.message,
+        code: res.error.code
+      });
+      err.statusCode = res.statusCode;
+      throw err;
+    }
+    return res.data;
+  };
+  const { data, error, mutate } = useSWR(
+    ["analytics", client.backendUrl, JSON.stringify(client.customerData), params.featureId, params.range],
+    fetcher,
+    {
+      refreshInterval: 0,
+      revalidateOnFocus: false,
+      revalidateOnReconnect: false,
+      shouldRetryOnError: (error2) => error2.statusCode === 429,
+      errorRetryCount: 3
+    }
+  );
+  return {
+    data: data?.list,
+    isLoading: !error && !data,
+    error,
+    refetch: mutate
+  };
+};
+
+export {
+  useAnalytics
+};

package/dist/libraries/react/chunk-D2TXVOAD.mjs

@@ -0,0 +1,50 @@
+"use client";
+
+import {
+  AutumnClient
+} from "./chunk-TI73WOTR.mjs";
+
+// src/libraries/react/AutumnContext.tsx
+import { createContext, useContext } from "react";
+var AutumnContext = createContext({
+  initialized: false,
+  disableDialogs: false,
+  client: new AutumnClient({ backendUrl: "" }),
+  paywallDialog: {
+    props: null,
+    setProps: () => {
+    },
+    open: false,
+    setOpen: () => {
+    },
+    setComponent: () => {
+    }
+  },
+  attachDialog: {
+    props: null,
+    setProps: () => {
+    },
+    open: false,
+    setOpen: () => {
+    },
+    setComponent: () => {
+    }
+  },
+  paywallRef: { current: null }
+});
+var useAutumnContext = ({
+  AutumnContext: AutumnContext2,
+  name,
+  errorIfNotInitialized = true
+}) => {
+  const context = useContext(AutumnContext2);
+  if (!context.initialized && errorIfNotInitialized) {
+    throw new Error(`${name} must be used within <AutumnProvider />`);
+  }
+  return context;
+};
+
+export {
+  AutumnContext,
+  useAutumnContext
+};

package/dist/libraries/react/chunk-EAZME3W6.mjs

@@ -0,0 +1,89 @@
+"use client";
+
+import {
+  AutumnContext,
+  useAutumnContext
+} from "./chunk-D2TXVOAD.mjs";
+import {
+  AutumnError
+} from "./chunk-ZJPIZX24.mjs";
+
+// src/libraries/react/hooks/useListEvents.tsx
+import { useCallback, useState } from "react";
+import useSWR from "swr";
+var useListEvents = (params) => {
+  const context = useAutumnContext({
+    AutumnContext,
+    name: "useListEvents"
+  });
+  const client = context.client;
+  const limit = params.limit ?? 100;
+  const [page, setPage] = useState(0);
+  const startDate = params.customRange?.start ? new Date(params.customRange.start).toISOString().slice(0, 13) : void 0;
+  const endDate = params.customRange?.end ? new Date(params.customRange.end).toISOString().slice(0, 13) : void 0;
+  const offset = page * limit;
+  const fetcher = async () => {
+    const res = await client.events.list({
+      ...params,
+      offset,
+      limit
+    });
+    if (res.error) {
+      const err = new AutumnError({
+        message: res.error.message,
+        code: res.error.code
+      });
+      err.statusCode = res.statusCode;
+      throw err;
+    }
+    return res.data;
+  };
+  const { data, error, mutate, isLoading } = useSWR(
+    ["eventList", client.backendUrl, JSON.stringify(client.customerData), params.featureId, startDate, endDate, offset, limit],
+    fetcher,
+    {
+      dedupingInterval: 2e3,
+      revalidateOnFocus: false,
+      revalidateOnReconnect: false,
+      shouldRetryOnError: (error2) => error2.statusCode === 429,
+      errorRetryCount: 3,
+      refreshInterval: 0,
+      ...params.swrConfig
+    }
+  );
+  const hasMore = data?.has_more ?? false;
+  const hasPrevious = page > 0;
+  const nextPage = useCallback(() => {
+    if (hasMore) {
+      setPage((p) => p + 1);
+    }
+  }, [hasMore]);
+  const prevPage = useCallback(() => {
+    if (hasPrevious) {
+      setPage((p) => p - 1);
+    }
+  }, [hasPrevious]);
+  const goToPage = useCallback((pageNum) => {
+    setPage(Math.max(0, pageNum));
+  }, []);
+  const resetPagination = useCallback(() => {
+    setPage(0);
+  }, []);
+  return {
+    list: data?.list,
+    hasMore,
+    hasPrevious,
+    page,
+    isLoading,
+    error,
+    refetch: mutate,
+    nextPage,
+    prevPage,
+    goToPage,
+    resetPagination
+  };
+};
+
+export {
+  useListEvents
+};