autumn-js 0.1.53 → 0.1.54

package/dist/libraries/react/BaseAutumnProvider.js

@@ -57,30 +57,20 @@ var useDialog = (component) => {
 // src/libraries/react/hooks/useCustomerBase.tsx
 var import_swr2 = __toESM(require("swr"));
 
-// src/sdk/error.ts
-var AutumnError = class _AutumnError extends Error {
-  message;
-  code;
-  constructor(response) {
-    super(response.message);
-    this.message = response.message;
-    this.code = response.code;
-  }
-  static fromError(error) {
-    return new _AutumnError({
-      message: error.message || "Unknown error",
-      code: error.code || "unknown_error"
-    });
-  }
-  toString() {
-    return `${this.message} (code: ${this.code})`;
-  }
-  toJSON() {
-    return {
-      message: this.message,
-      code: this.code
-    };
+// src/libraries/react/errorUtils/logAuthError.ts
+var logAuthError = async (response) => {
+  if (response.status === 401) {
+    let clonedResponse = response.clone();
+    let data = await clonedResponse.json();
+    if (data.message.includes("Missing authorization header")) {
+      console.error(`[Autumn] Missing authorization header.
+
+Use the getBearerToken prop in <AutumnProvider /> to set the authorization header.
+https://docs.useautumn.com/quickstart/quickstart#5-set-up-autumnprovider`);
+      return true;
+    }
   }
+  return false;
 };
 
 // src/sdk/general/genMethods.ts
@@ -168,6 +158,32 @@ var buildPathWithQuery = (basePath, params) => {
   return query ? `${basePath}?${query}` : basePath;
 };
 
+// src/sdk/error.ts
+var AutumnError = class _AutumnError extends Error {
+  message;
+  code;
+  constructor(response) {
+    super(response.message);
+    this.message = response.message;
+    this.code = response.code;
+  }
+  static fromError(error) {
+    return new _AutumnError({
+      message: error.message || "Unknown error",
+      code: error.code || "unknown_error"
+    });
+  }
+  toString() {
+    return `${this.message} (code: ${this.code})`;
+  }
+  toJSON() {
+    return {
+      message: this.message,
+      code: this.code
+    };
+  }
+};
+
 // src/sdk/customers/cusMethods.ts
 var customerMethods = (instance) => {
   return {
@@ -792,6 +808,17 @@ var Autumn = class {
   }
 };
 
+// src/sdk/customers/cusEnums.ts
+var import_v4 = require("zod/v4");
+var CustomerExpandEnum = import_v4.z.enum([
+  "invoices",
+  "rewards",
+  "trials_used",
+  "entities",
+  "referrals",
+  "payment_method"
+]);
+
 // src/sdk/products/prodEnums.ts
 var ProductItemInterval = /* @__PURE__ */ ((ProductItemInterval2) => {
   ProductItemInterval2["Minute"] = "minute";
@@ -806,17 +833,6 @@ var ProductItemInterval = /* @__PURE__ */ ((ProductItemInterval2) => {
   return ProductItemInterval2;
 })(ProductItemInterval || {});
 
-// src/sdk/customers/cusEnums.ts
-var import_v4 = require("zod/v4");
-var CustomerExpandEnum = import_v4.z.enum([
-  "invoices",
-  "rewards",
-  "trials_used",
-  "entities",
-  "referrals",
-  "payment_method"
-]);
-
 // src/sdk/customers/cusTypes.ts
 var import_v42 = require("zod/v4");
 var CoreCusFeatureSchema = import_v42.z.object({
@@ -884,80 +900,103 @@ var ListCustomersParamsSchema = import_v42.z.object({
   offset: import_v42.z.number().optional()
 });
 
-// src/sdk/general/checkTypes.ts
+// src/sdk/customers/entities/entTypes.ts
 var import_v43 = require("zod/v4");
-var CheckFeatureResultSchema = import_v43.z.object({
-  allowed: import_v43.z.boolean(),
-  feature_id: import_v43.z.string(),
-  customer_id: import_v43.z.string(),
-  entity_id: import_v43.z.string().optional(),
-  required_balance: import_v43.z.number()
-}).extend(CoreCusFeatureSchema.shape);
+var EntityDataSchema = import_v43.z.object({
+  name: import_v43.z.string().optional(),
+  feature_id: import_v43.z.string()
+});
+var TransferProductParamsSchema = import_v43.z.object({
+  from_entity_id: import_v43.z.string(),
+  to_entity_id: import_v43.z.string(),
+  product_id: import_v43.z.string()
+});
 
-// src/sdk/customers/entities/entTypes.ts
+// src/sdk/general/pageTypes.ts
 var import_v44 = require("zod/v4");
-var EntityDataSchema = import_v44.z.object({
-  name: import_v44.z.string().optional(),
-  feature_id: import_v44.z.string()
+var PagePaginationDefaults = {
+  Limit: 100,
+  MaxLimit: 1e3
+};
+var PagePaginationQuerySchema = import_v44.z.object({
+  offset: import_v44.z.coerce.number().int().min(0).default(0).describe("Number of items to skip"),
+  limit: import_v44.z.coerce.number().int().min(1).max(PagePaginationDefaults.MaxLimit).default(PagePaginationDefaults.Limit).describe(
+    `Number of items to return. Default ${PagePaginationDefaults.Limit}, max ${PagePaginationDefaults.MaxLimit}.`
+  )
 });
-var TransferProductParamsSchema = import_v44.z.object({
-  from_entity_id: import_v44.z.string(),
-  to_entity_id: import_v44.z.string(),
-  product_id: import_v44.z.string()
+var createPagePaginatedResponseSchema = (itemSchema) => import_v44.z.object({
+  list: import_v44.z.array(itemSchema).describe("Array of items for current page"),
+  has_more: import_v44.z.boolean().describe("Whether more results exist after this page"),
+  offset: import_v44.z.number().describe("Current offset position"),
+  limit: import_v44.z.number().describe("Limit passed in the request"),
+  total: import_v44.z.number().describe("Total number of items returned in the current page")
 });
 
-// src/sdk/general/genTypes.ts
+// src/sdk/events/eventTypes.ts
 var import_v45 = require("zod/v4");
-var CancelParamsSchema = import_v45.z.object({
-  customer_id: import_v45.z.string(),
-  product_id: import_v45.z.string(),
-  entity_id: import_v45.z.string().optional(),
-  cancel_immediately: import_v45.z.boolean().optional()
-});
-var CancelResultSchema = import_v45.z.object({
-  success: import_v45.z.boolean(),
-  customer_id: import_v45.z.string(),
-  product_id: import_v45.z.string()
-});
-var TrackParamsSchema = import_v45.z.object({
+var QueryRangeEnum = import_v45.z.enum([
+  "24h",
+  "7d",
+  "30d",
+  "90d",
+  "last_cycle",
+  "1bc",
+  "3bc"
+]);
+var BinSizeEnum = import_v45.z.enum(["day", "hour"]);
+var QueryParamsSchema = import_v45.z.object({
   customer_id: import_v45.z.string(),
-  value: import_v45.z.number().optional(),
-  feature_id: import_v45.z.string().optional(),
-  event_name: import_v45.z.string().optional(),
-  entity_id: import_v45.z.string().optional(),
-  customer_data: import_v45.z.any().optional(),
-  idempotency_key: import_v45.z.string().optional(),
-  entity_data: import_v45.z.any().optional(),
-  properties: import_v45.z.record(import_v45.z.string(), import_v45.z.any()).optional()
+  feature_id: import_v45.z.string().or(import_v45.z.array(import_v45.z.string())),
+  range: QueryRangeEnum.optional(),
+  group_by: import_v45.z.string().startsWith("properties.").optional(),
+  bin_size: BinSizeEnum.optional(),
+  custom_range: import_v45.z.object({
+    start: import_v45.z.number(),
+    end: import_v45.z.number()
+  }).optional()
 });
-var TrackResultSchema = import_v45.z.object({
-  id: import_v45.z.string(),
-  code: import_v45.z.string(),
+var EventsListParamsSchema = PagePaginationQuerySchema.extend({
   customer_id: import_v45.z.string(),
-  feature_id: import_v45.z.string().optional(),
-  event_name: import_v45.z.string().optional()
+  feature_id: import_v45.z.string().or(import_v45.z.array(import_v45.z.string())),
+  custom_range: import_v45.z.object({
+    start: import_v45.z.coerce.number().optional(),
+    end: import_v45.z.coerce.number().optional()
+  }).optional()
 });
-var CheckParamsSchema = import_v45.z.object({
-  customer_id: import_v45.z.string(),
-  feature_id: import_v45.z.string().optional(),
-  product_id: import_v45.z.string().optional(),
-  entity_id: import_v45.z.string().optional(),
-  customer_data: import_v45.z.any().optional(),
-  required_balance: import_v45.z.number().optional(),
-  send_event: import_v45.z.boolean().optional(),
-  with_preview: import_v45.z.boolean().optional(),
-  entity_data: EntityDataSchema.optional()
+var EventsListItemSchema = import_v45.z.object({
+  id: import_v45.z.string().describe("Event ID (KSUID)"),
+  timestamp: import_v45.z.number().describe("Event timestamp (epoch milliseconds)"),
+  feature_id: import_v45.z.string().describe("Name of the event"),
+  customer_id: import_v45.z.string().describe("Customer identifier"),
+  value: import_v45.z.number().describe("Event value/count"),
+  properties: import_v45.z.object({}).describe("Event properties (JSONB)")
 });
+var EventsListResponseSchema = createPagePaginatedResponseSchema(EventsListItemSchema);
 
-// src/sdk/referrals/referralTypes.ts
+// src/sdk/features/featureTypes.ts
 var import_v46 = require("zod/v4");
-var CreateReferralCodeParamsSchema = import_v46.z.object({
-  customer_id: import_v46.z.string(),
-  program_id: import_v46.z.string()
-});
-var RedeemReferralCodeParamsSchema = import_v46.z.object({
-  code: import_v46.z.string(),
-  customer_id: import_v46.z.string()
+var FeatureType = /* @__PURE__ */ ((FeatureType2) => {
+  FeatureType2["Boolean"] = "boolean";
+  FeatureType2["SingleUse"] = "single_use";
+  FeatureType2["ContinuousUse"] = "continuous_use";
+  FeatureType2["CreditSystem"] = "credit_system";
+  return FeatureType2;
+})(FeatureType || {});
+var FeatureSchema = import_v46.z.object({
+  id: import_v46.z.string(),
+  name: import_v46.z.string(),
+  type: import_v46.z.enum(FeatureType),
+  display: import_v46.z.object({
+    singular: import_v46.z.string(),
+    plural: import_v46.z.string()
+  }).nullish(),
+  credit_schema: import_v46.z.array(
+    import_v46.z.object({
+      metered_feature_id: import_v46.z.string(),
+      credit_cost: import_v46.z.number()
+    })
+  ).nullish(),
+  archived: import_v46.z.boolean()
 });
 
 // src/sdk/general/attachTypes.ts
@@ -1014,251 +1053,69 @@ var CheckoutParamsSchema = import_v47.z.object({
   new_billing_subscription: import_v47.z.boolean().optional()
 });
 
-// src/sdk/general/cursorTypes.ts
+// src/sdk/general/checkTypes.ts
 var import_v48 = require("zod/v4");
-var PaginationDefaults = {
-  Limit: 100,
-  MaxLimit: 1e3
-};
-var CursorPaginationQuerySchema = import_v48.z.object({
-  starting_after: import_v48.z.string().optional(),
-  limit: import_v48.z.coerce.number().int().min(1).max(PaginationDefaults.MaxLimit).default(PaginationDefaults.Limit).optional()
-});
-var createCursorPaginatedResponseSchema = (itemSchema) => import_v48.z.object({
-  list: import_v48.z.array(itemSchema),
-  has_more: import_v48.z.boolean(),
-  next_cursor: import_v48.z.string().nullable()
-});
+var CheckFeatureResultSchema = import_v48.z.object({
+  allowed: import_v48.z.boolean(),
+  feature_id: import_v48.z.string(),
+  customer_id: import_v48.z.string(),
+  entity_id: import_v48.z.string().optional(),
+  required_balance: import_v48.z.number()
+}).extend(CoreCusFeatureSchema.shape);
 
-// src/sdk/events/eventTypes.ts
+// src/sdk/general/genTypes.ts
 var import_v49 = require("zod/v4");
-var QueryRangeEnum = import_v49.z.enum([
-  "24h",
-  "7d",
-  "30d",
-  "90d",
-  "last_cycle",
-  "1bc",
-  "3bc"
-]);
-var BinSizeEnum = import_v49.z.enum(["day", "hour"]);
-var QueryParamsSchema = import_v49.z.object({
+var CancelParamsSchema = import_v49.z.object({
   customer_id: import_v49.z.string(),
-  feature_id: import_v49.z.string().or(import_v49.z.array(import_v49.z.string())),
-  range: QueryRangeEnum.optional(),
-  group_by: import_v49.z.string().startsWith("properties.").optional(),
-  bin_size: BinSizeEnum.optional(),
-  custom_range: import_v49.z.object({
-    start: import_v49.z.number(),
-    end: import_v49.z.number()
-  }).optional()
+  product_id: import_v49.z.string(),
+  entity_id: import_v49.z.string().optional(),
+  cancel_immediately: import_v49.z.boolean().optional()
 });
-var LogParamsSchema = CursorPaginationQuerySchema.extend({
+var CancelResultSchema = import_v49.z.object({
+  success: import_v49.z.boolean(),
   customer_id: import_v49.z.string(),
-  feature_id: import_v49.z.string().or(import_v49.z.array(import_v49.z.string())),
-  time_range: import_v49.z.object({
-    start: import_v49.z.coerce.number().optional(),
-    end: import_v49.z.coerce.number().optional()
-  }).optional()
+  product_id: import_v49.z.string()
 });
-var EventListItemSchema = import_v49.z.object({
-  id: import_v49.z.string().describe("Event ID (KSUID)"),
-  timestamp: import_v49.z.number().describe("Event timestamp (epoch milliseconds)"),
-  feature_id: import_v49.z.string().describe("Name of the event"),
-  customer_id: import_v49.z.string().describe("Customer identifier"),
-  value: import_v49.z.number().describe("Event value/count"),
-  properties: import_v49.z.object({}).describe("Event properties (JSONB)")
+var TrackParamsSchema = import_v49.z.object({
+  customer_id: import_v49.z.string(),
+  value: import_v49.z.number().optional(),
+  feature_id: import_v49.z.string().optional(),
+  event_name: import_v49.z.string().optional(),
+  entity_id: import_v49.z.string().optional(),
+  customer_data: import_v49.z.any().optional(),
+  idempotency_key: import_v49.z.string().optional(),
+  entity_data: import_v49.z.any().optional(),
+  properties: import_v49.z.record(import_v49.z.string(), import_v49.z.any()).optional()
+});
+var TrackResultSchema = import_v49.z.object({
+  id: import_v49.z.string(),
+  code: import_v49.z.string(),
+  customer_id: import_v49.z.string(),
+  feature_id: import_v49.z.string().optional(),
+  event_name: import_v49.z.string().optional()
+});
+var CheckParamsSchema = import_v49.z.object({
+  customer_id: import_v49.z.string(),
+  feature_id: import_v49.z.string().optional(),
+  product_id: import_v49.z.string().optional(),
+  entity_id: import_v49.z.string().optional(),
+  customer_data: import_v49.z.any().optional(),
+  required_balance: import_v49.z.number().optional(),
+  send_event: import_v49.z.boolean().optional(),
+  with_preview: import_v49.z.boolean().optional(),
+  entity_data: EntityDataSchema.optional()
 });
-var EventListResponseSchema = createCursorPaginatedResponseSchema(EventListItemSchema);
 
-// src/sdk/features/featureTypes.ts
+// src/sdk/referrals/referralTypes.ts
 var import_v410 = require("zod/v4");
-var FeatureType = /* @__PURE__ */ ((FeatureType2) => {
-  FeatureType2["Boolean"] = "boolean";
-  FeatureType2["SingleUse"] = "single_use";
-  FeatureType2["ContinuousUse"] = "continuous_use";
-  FeatureType2["CreditSystem"] = "credit_system";
-  return FeatureType2;
-})(FeatureType || {});
-var FeatureSchema = import_v410.z.object({
-  id: import_v410.z.string(),
-  name: import_v410.z.string(),
-  type: import_v410.z.enum(FeatureType),
-  display: import_v410.z.object({
-    singular: import_v410.z.string(),
-    plural: import_v410.z.string()
-  }).nullish(),
-  credit_schema: import_v410.z.array(
-    import_v410.z.object({
-      metered_feature_id: import_v410.z.string(),
-      credit_cost: import_v410.z.number()
-    })
-  ).nullish(),
-  archived: import_v410.z.boolean()
+var CreateReferralCodeParamsSchema = import_v410.z.object({
+  customer_id: import_v410.z.string(),
+  program_id: import_v410.z.string()
+});
+var RedeemReferralCodeParamsSchema = import_v410.z.object({
+  code: import_v410.z.string(),
+  customer_id: import_v410.z.string()
 });
-
-// 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 handleCheck2 = ({
-  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
-  };
-};
-
-// src/libraries/react/errorUtils/logAuthError.ts
-var logAuthError = async (response) => {
-  if (response.status === 401) {
-    let clonedResponse = response.clone();
-    let data = await clonedResponse.json();
-    if (data.message.includes("Missing authorization header")) {
-      console.error(`[Autumn] Missing authorization header.
-
-Use the getBearerToken prop in <AutumnProvider /> to set the authorization header.
-https://docs.useautumn.com/quickstart/quickstart#5-set-up-autumnprovider`);
-      return true;
-    }
-  }
-  return false;
-};
 
 // src/libraries/react/errorUtils/logFetchError.ts
 var logFetchError = ({
@@ -1273,6 +1130,17 @@ var logFetchError = ({
 2. Check that autumnHandler is correctly registered on your backend.`);
 };
 
+// src/libraries/react/client/clientAnalyticsMethods.ts
+async function eventListMethod(params) {
+  const res = await this.post(`${this.prefix}/events/list`, params);
+  console.log("res", res);
+  return res;
+}
+async function eventAggregateMethod(params) {
+  const res = await this.post(`${this.prefix}/events/aggregate`, params);
+  return res;
+}
+
 // src/libraries/react/client/clientCusMethods.ts
 var createCustomerMethod = async ({
   client,
@@ -1375,16 +1243,6 @@ async function redeemCode(params) {
   return res;
 }
 
-// src/libraries/react/client/clientAnalyticsMethods.ts
-async function eventListMethod(params) {
-  const res = await this.post(`${this.prefix}/events/list`, params);
-  return res;
-}
-async function eventAggregateMethod(params) {
-  const res = await this.post(`${this.prefix}/events/aggregate`, params);
-  return res;
-}
-
 // src/libraries/react/client/ReactAutumnClient.tsx
 var AutumnClient = class {
   backendUrl;
@@ -1630,6 +1488,153 @@ var useAutumnContext = ({
   return context;
 };
 
+// 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 handleCheck2 = ({
+  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
+  };
+};
+
 // src/libraries/react/hooks/usePricingTableBase.tsx
 var import_swr = __toESM(require("swr"));
 var mergeProductDetails = (products, productDetails) => {
@@ -2017,7 +2022,8 @@ var useCustomerBase = ({
     swrConfig: {
       shouldRetryOnError: false,
       refreshInterval: 0,
-      ...params?.swrConfig
+      ...params?.swrConfig,
+      dedupingInterval: 2e3
     }
   });
   const autumnFunctions = useAutumnBase({