autumn-js 0.0.108 → 0.0.109

package/dist/libraries/react/hooks/helpers/handleCheck.js

@@ -0,0 +1,813 @@
+"use client";
+
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/libraries/react/hooks/helpers/handleCheck.ts
+var handleCheck_exports = {};
+__export(handleCheck_exports, {
+  handleCheck: () => handleCheck2,
+  openDialog: () => openDialog
+});
+module.exports = __toCommonJS(handleCheck_exports);
+
+// 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/general/genMethods.ts
+var handleCheckout = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/checkout", params);
+};
+var handleAttach = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/attach", params);
+};
+var handleSetupPayment = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/setup_payment", params);
+};
+var handleCancel = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/cancel", params);
+};
+var handleTrack = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/track", params);
+};
+var handleUsage = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/usage", params);
+};
+var handleCheck = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/check", params);
+};
+var handleQuery = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/query", params);
+};
+
+// src/libraries/backend/constants.ts
+var autumnApiUrl = "https://api.useautumn.com/v1";
+
+// src/sdk/utils.ts
+var staticWrapper = (callback, instance, args) => {
+  if (!instance) {
+    instance = new Autumn();
+  }
+  return callback({ instance, ...args });
+};
+
+// src/sdk/customers/cusMethods.ts
+var customerMethods = (instance) => {
+  return {
+    get: (id, params) => staticWrapper(getCustomer, instance, { id, params }),
+    create: (params) => staticWrapper(createCustomer, instance, { params }),
+    update: (id, params) => staticWrapper(updateCustomer, instance, { id, params }),
+    delete: (id) => staticWrapper(deleteCustomer, instance, { id }),
+    billingPortal: (id, params) => staticWrapper(billingPortal, instance, { id, params })
+  };
+};
+var getExpandStr = (expand) => {
+  if (!expand) {
+    return "";
+  }
+  return `expand=${expand.join(",")}`;
+};
+var getCustomer = async ({
+  instance,
+  id,
+  params
+}) => {
+  if (!id) {
+    return {
+      data: null,
+      error: new AutumnError({
+        message: "Customer ID is required",
+        code: "CUSTOMER_ID_REQUIRED"
+      })
+    };
+  }
+  return instance.get(`/customers/${id}?${getExpandStr(params?.expand)}`);
+};
+var createCustomer = async ({
+  instance,
+  params
+}) => {
+  return instance.post(`/customers?${getExpandStr(params?.expand)}`, params);
+};
+var updateCustomer = async ({
+  instance,
+  id,
+  params
+}) => {
+  return instance.post(`/customers/${id}`, params);
+};
+var deleteCustomer = async ({
+  instance,
+  id
+}) => {
+  return instance.delete(`/customers/${id}`);
+};
+var billingPortal = async ({
+  instance,
+  id,
+  params
+}) => {
+  return instance.post(`/customers/${id}/billing_portal`, params);
+};
+
+// src/sdk/customers/entities/entMethods.ts
+var entityMethods = (instance) => {
+  return {
+    get: (customer_id, entity_id, params) => staticWrapper(getEntity, instance, {
+      customer_id,
+      entity_id,
+      params
+    }),
+    create: (customer_id, params) => staticWrapper(createEntity, instance, { customer_id, params }),
+    delete: (customer_id, entity_id) => staticWrapper(deleteEntity, instance, { customer_id, entity_id })
+  };
+};
+var getExpandStr2 = (expand) => {
+  if (!expand) {
+    return "";
+  }
+  return `expand=${expand.join(",")}`;
+};
+var getEntity = async ({
+  instance,
+  customer_id,
+  entity_id,
+  params
+}) => {
+  return instance.get(
+    `/customers/${customer_id}/entities/${entity_id}?${getExpandStr2(
+      params?.expand
+    )}`
+  );
+};
+var createEntity = async ({
+  instance,
+  customer_id,
+  params
+}) => {
+  return instance.post(`/customers/${customer_id}/entities`, params);
+};
+var deleteEntity = async ({
+  instance,
+  customer_id,
+  entity_id
+}) => {
+  return instance.delete(`/customers/${customer_id}/entities/${entity_id}`);
+};
+
+// src/sdk/products/prodMethods.ts
+var productMethods = (instance) => {
+  return {
+    get: (id) => staticWrapper(getProduct, instance, { id }),
+    create: (params) => staticWrapper(createProduct, instance, { params }),
+    list: (params) => staticWrapper(listProducts, instance, { params })
+  };
+};
+var listProducts = async ({
+  instance,
+  params
+}) => {
+  let path = "/products_beta";
+  if (params) {
+    const queryParams = new URLSearchParams();
+    for (const [key, value] of Object.entries(params)) {
+      if (value !== void 0) {
+        queryParams.append(key, String(value));
+      }
+    }
+    const queryString = queryParams.toString();
+    if (queryString) {
+      path += `?${queryString}`;
+    }
+  }
+  return instance.get(path);
+};
+var getProduct = async ({
+  instance,
+  id
+}) => {
+  return instance.get(`/products/${id}`);
+};
+var createProduct = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/products", params);
+};
+
+// src/sdk/referrals/referralMethods.ts
+var referralMethods = (instance) => {
+  return {
+    createCode: (params) => staticWrapper(createReferralCode, instance, { params }),
+    redeemCode: (params) => staticWrapper(redeemReferralCode, instance, { params })
+  };
+};
+var createReferralCode = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/referrals/code", params);
+};
+var redeemReferralCode = async ({
+  instance,
+  params
+}) => {
+  return instance.post("/referrals/redeem", params);
+};
+
+// src/sdk/response.ts
+var toContainerResult = async ({
+  response,
+  logger: logger2,
+  logError = true
+}) => {
+  if (response.status < 200 || response.status >= 300) {
+    let error;
+    try {
+      error = await response.json();
+      if (logError) {
+        logger2.error(`[Autumn] ${error.message}`);
+      }
+    } catch (error2) {
+      throw error2;
+      return {
+        data: null,
+        error: new AutumnError({
+          message: "Failed to parse JSON response from Autumn",
+          code: "internal_error"
+        }),
+        statusCode: response.status
+      };
+    }
+    return {
+      data: null,
+      error: new AutumnError({
+        message: error.message,
+        code: error.code
+      }),
+      statusCode: response.status
+    };
+  }
+  try {
+    let data = await response.json();
+    return {
+      data,
+      error: null,
+      statusCode: response?.status
+    };
+  } catch (error) {
+    throw error;
+    return {
+      data: null,
+      error: new AutumnError({
+        message: "Failed to parse Autumn API response",
+        code: "internal_error"
+      }),
+      statusCode: response?.status
+    };
+  }
+};
+
+// src/utils/logger.ts
+var import_chalk = __toESM(require("chalk"));
+var getTime = () => {
+  let timeString = (/* @__PURE__ */ new Date()).toISOString();
+  return `[${timeString.split("T")[1].split(".")[0]}]`;
+};
+var greaterThanLevel = (level) => {
+  return levels.indexOf(level) >= levels.indexOf(logger.level);
+};
+var levels = ["debug", "info", "warn", "error", "fatal"];
+var logger = {
+  ...console,
+  level: "info",
+  debug: (...args) => {
+    if (greaterThanLevel("debug")) {
+      console.log(getTime(), import_chalk.default.gray("DEBUG"), ...args);
+    }
+  },
+  log: (...args) => {
+    console.log(getTime(), import_chalk.default.blue("INFO"), ...args);
+  },
+  info: (...args) => {
+    if (greaterThanLevel("info")) {
+      console.log(getTime(), import_chalk.default.blue("INFO"), ...args);
+    }
+  },
+  warn: (...args) => {
+    if (greaterThanLevel("warn")) {
+      console.log(getTime(), import_chalk.default.yellow("WARN"), ...args);
+    }
+  },
+  error: (...args) => {
+    if (greaterThanLevel("error")) {
+      console.log(getTime(), import_chalk.default.red("ERROR"), ...args);
+    }
+  }
+};
+
+// src/sdk/client.ts
+var LATEST_API_VERSION = "1.2";
+var Autumn = class {
+  secretKey;
+  publishableKey;
+  headers;
+  url;
+  logger = console;
+  constructor(options) {
+    try {
+      this.secretKey = options?.secretKey || process.env.AUTUMN_SECRET_KEY;
+      this.publishableKey = options?.publishableKey || process.env.AUTUMN_PUBLISHABLE_KEY;
+    } catch (error) {
+    }
+    if (!this.secretKey && !this.publishableKey && !options?.headers) {
+      throw new Error("Autumn secret key or publishable key is required");
+    }
+    this.headers = options?.headers || {
+      Authorization: `Bearer ${this.secretKey || this.publishableKey}`,
+      "Content-Type": "application/json"
+    };
+    let version = options?.version || LATEST_API_VERSION;
+    this.headers["x-api-version"] = version;
+    this.url = options?.url || autumnApiUrl;
+    this.logger = logger;
+    this.logger.level = options?.logLevel || "info";
+  }
+  async get(path) {
+    const response = await fetch(`${this.url}${path}`, {
+      headers: this.headers
+    });
+    return toContainerResult({ response, logger: this.logger });
+  }
+  async post(path, body) {
+    try {
+      const response = await fetch(`${this.url}${path}`, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(body)
+      });
+      return toContainerResult({ response, logger: this.logger });
+    } catch (error) {
+      console.error("Error sending request:", error);
+      throw error;
+    }
+  }
+  async delete(path) {
+    const response = await fetch(`${this.url}${path}`, {
+      method: "DELETE",
+      headers: this.headers
+    });
+    return toContainerResult({ response, logger: this.logger });
+  }
+  static customers = customerMethods();
+  static products = productMethods();
+  static entities = entityMethods();
+  static referrals = referralMethods();
+  customers = customerMethods(this);
+  products = productMethods(this);
+  entities = entityMethods(this);
+  referrals = referralMethods(this);
+  static checkout = (params) => staticWrapper(handleCheckout, void 0, { params });
+  async checkout(params) {
+    return handleCheckout({
+      instance: this,
+      params
+    });
+  }
+  static attach = (params) => staticWrapper(handleAttach, void 0, { params });
+  static usage = (params) => staticWrapper(handleUsage, void 0, { params });
+  async attach(params) {
+    return handleAttach({
+      instance: this,
+      params
+    });
+  }
+  static setupPayment = (params) => staticWrapper(handleSetupPayment, void 0, { params });
+  async setupPayment(params) {
+    return handleSetupPayment({
+      instance: this,
+      params
+    });
+  }
+  static cancel = (params) => staticWrapper(handleCancel, void 0, { params });
+  async cancel(params) {
+    return handleCancel({
+      instance: this,
+      params
+    });
+  }
+  static check = (params) => staticWrapper(handleCheck, void 0, { params });
+  async check(params) {
+    return handleCheck({
+      instance: this,
+      params
+    });
+  }
+  static track = (params) => staticWrapper(handleTrack, void 0, { params });
+  async track(params) {
+    return handleTrack({
+      instance: this,
+      params
+    });
+  }
+  async usage(params) {
+    return handleUsage({
+      instance: this,
+      params
+    });
+  }
+  static query = (params) => staticWrapper(handleQuery, void 0, { params });
+  async query(params) {
+    return handleQuery({
+      instance: this,
+      params
+    });
+  }
+};
+
+// src/sdk/products/prodEnums.ts
+var ProductItemInterval = /* @__PURE__ */ ((ProductItemInterval2) => {
+  ProductItemInterval2["Minute"] = "minute";
+  ProductItemInterval2["Hour"] = "hour";
+  ProductItemInterval2["Day"] = "day";
+  ProductItemInterval2["Week"] = "week";
+  ProductItemInterval2["Month"] = "month";
+  ProductItemInterval2["Quarter"] = "quarter";
+  ProductItemInterval2["SemiAnnual"] = "semi_annual";
+  ProductItemInterval2["Year"] = "year";
+  ProductItemInterval2["Multiple"] = "multiple";
+  return ProductItemInterval2;
+})(ProductItemInterval || {});
+
+// src/sdk/customers/cusEnums.ts
+var import_zod = require("zod");
+var CustomerExpandEnum = import_zod.z.enum([
+  "invoices",
+  "rewards",
+  "trials_used",
+  "entities",
+  "referrals",
+  "payment_method"
+]);
+
+// src/sdk/customers/cusTypes.ts
+var import_zod2 = require("zod");
+var CoreCusFeatureSchema = import_zod2.z.object({
+  unlimited: import_zod2.z.boolean().optional(),
+  interval: import_zod2.z.nativeEnum(ProductItemInterval).optional(),
+  balance: import_zod2.z.number().optional(),
+  usage: import_zod2.z.number().optional(),
+  included_usage: import_zod2.z.number().optional(),
+  next_reset_at: import_zod2.z.number().optional(),
+  overage_allowed: import_zod2.z.boolean().optional(),
+  usage_limit: import_zod2.z.number().optional(),
+  breakdown: import_zod2.z.array(
+    import_zod2.z.object({
+      interval: import_zod2.z.nativeEnum(ProductItemInterval),
+      balance: import_zod2.z.number().optional(),
+      usage: import_zod2.z.number().optional(),
+      included_usage: import_zod2.z.number().optional(),
+      next_reset_at: import_zod2.z.number().optional()
+    })
+  ).optional(),
+  credit_schema: import_zod2.z.array(
+    import_zod2.z.object({
+      feature_id: import_zod2.z.string(),
+      credit_amount: import_zod2.z.number()
+    })
+  ).optional()
+});
+var CustomerDataSchema = import_zod2.z.object({
+  name: import_zod2.z.string().nullish(),
+  email: import_zod2.z.string().nullish(),
+  fingerprint: import_zod2.z.string().nullish()
+});
+var CreateCustomerParamsSchema = import_zod2.z.object({
+  id: import_zod2.z.string().nullish(),
+  email: import_zod2.z.string().nullish(),
+  name: import_zod2.z.string().nullish(),
+  fingerprint: import_zod2.z.string().nullish(),
+  metadata: import_zod2.z.record(import_zod2.z.any()).optional(),
+  expand: import_zod2.z.array(CustomerExpandEnum).optional()
+});
+var BillingPortalParamsSchema = import_zod2.z.object({
+  return_url: import_zod2.z.string().optional()
+});
+
+// src/sdk/general/checkTypes.ts
+var import_zod3 = require("zod");
+var CheckFeatureResultSchema = import_zod3.z.object({
+  allowed: import_zod3.z.boolean(),
+  feature_id: import_zod3.z.string(),
+  customer_id: import_zod3.z.string(),
+  entity_id: import_zod3.z.string().optional(),
+  required_balance: import_zod3.z.number()
+}).extend(CoreCusFeatureSchema.shape);
+
+// src/sdk/customers/entities/entTypes.ts
+var import_zod4 = require("zod");
+var EntityDataSchema = import_zod4.z.object({
+  name: import_zod4.z.string().optional(),
+  feature_id: import_zod4.z.string()
+});
+
+// src/sdk/general/genTypes.ts
+var import_zod5 = require("zod");
+var CancelParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  product_id: import_zod5.z.string(),
+  entity_id: import_zod5.z.string().optional(),
+  cancel_immediately: import_zod5.z.boolean().optional()
+});
+var CancelResultSchema = import_zod5.z.object({
+  success: import_zod5.z.boolean(),
+  customer_id: import_zod5.z.string(),
+  product_id: import_zod5.z.string()
+});
+var TrackParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  value: import_zod5.z.number().optional(),
+  feature_id: import_zod5.z.string().optional(),
+  event_name: import_zod5.z.string().optional(),
+  entity_id: import_zod5.z.string().optional(),
+  customer_data: import_zod5.z.any().optional(),
+  idempotency_key: import_zod5.z.string().optional(),
+  entity_data: import_zod5.z.any().optional()
+});
+var TrackResultSchema = import_zod5.z.object({
+  id: import_zod5.z.string(),
+  code: import_zod5.z.string(),
+  customer_id: import_zod5.z.string(),
+  feature_id: import_zod5.z.string().optional(),
+  event_name: import_zod5.z.string().optional()
+});
+var CheckParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  feature_id: import_zod5.z.string().optional(),
+  product_id: import_zod5.z.string().optional(),
+  entity_id: import_zod5.z.string().optional(),
+  customer_data: import_zod5.z.any().optional(),
+  required_balance: import_zod5.z.number().optional(),
+  send_event: import_zod5.z.boolean().optional(),
+  with_preview: import_zod5.z.boolean().optional(),
+  entity_data: EntityDataSchema.optional()
+});
+var QueryRangeEnum = import_zod5.z.enum(["24h", "7d", "30d", "90d", "last_cycle"]);
+var QueryParamsSchema = import_zod5.z.object({
+  customer_id: import_zod5.z.string(),
+  feature_id: import_zod5.z.string().or(import_zod5.z.array(import_zod5.z.string())),
+  range: QueryRangeEnum.optional()
+});
+
+// src/sdk/referrals/referralTypes.ts
+var import_zod6 = require("zod");
+var CreateReferralCodeParamsSchema = import_zod6.z.object({
+  customer_id: import_zod6.z.string(),
+  program_id: import_zod6.z.string()
+});
+var RedeemReferralCodeParamsSchema = import_zod6.z.object({
+  code: import_zod6.z.string(),
+  customer_id: import_zod6.z.string()
+});
+
+// src/sdk/general/attachTypes.ts
+var import_zod7 = require("zod");
+var AttachFeatureOptionsSchema = import_zod7.z.object({
+  feature_id: import_zod7.z.string(),
+  quantity: import_zod7.z.number()
+});
+var AttachParamsSchema = import_zod7.z.object({
+  customer_id: import_zod7.z.string(),
+  product_id: import_zod7.z.string().optional(),
+  entity_id: import_zod7.z.string().optional(),
+  options: import_zod7.z.array(AttachFeatureOptionsSchema).optional(),
+  product_ids: import_zod7.z.array(import_zod7.z.string()).optional(),
+  free_trial: import_zod7.z.boolean().optional(),
+  success_url: import_zod7.z.string().optional(),
+  metadata: import_zod7.z.record(import_zod7.z.string()).optional(),
+  force_checkout: import_zod7.z.boolean().optional(),
+  customer_data: CustomerDataSchema.optional(),
+  entity_data: import_zod7.z.any().optional(),
+  checkout_session_params: import_zod7.z.record(import_zod7.z.any()).optional(),
+  reward: import_zod7.z.string().optional()
+});
+var AttachResultSchema = import_zod7.z.object({
+  checkout_url: import_zod7.z.string().optional(),
+  customer_id: import_zod7.z.string(),
+  product_ids: import_zod7.z.array(import_zod7.z.string()),
+  code: import_zod7.z.string(),
+  message: import_zod7.z.string(),
+  customer_data: import_zod7.z.any().optional()
+});
+var CheckoutParamsSchema = import_zod7.z.object({
+  customer_id: import_zod7.z.string(),
+  product_id: import_zod7.z.string(),
+  entity_id: import_zod7.z.string().optional(),
+  success_url: import_zod7.z.string().optional(),
+  customer_data: CustomerDataSchema.optional(),
+  options: import_zod7.z.array(AttachFeatureOptionsSchema).optional()
+});
+
+// src/libraries/react/hooks/helpers/handleCheck.ts
+var getCusFeature = ({
+  customer,
+  featureId,
+  requiredBalance = 1
+}) => {
+  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 {
+      feature: 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
+  });
+  let allowed = getFeatureAllowed({ cusFeature, requiredBalance });
+  let result = {
+    allowed,
+    feature_id: params.featureId,
+    customer_id: isEntity ? customer.customer_id : customer.id,
+    required_balance: requiredBalance,
+    ...cusFeature
+  };
+  if (isEntity) {
+    result.entity_id = customer.id;
+  }
+  return CheckFeatureResultSchema.parse(result);
+};
+var handleProductCheck = ({
+  customer,
+  isEntity,
+  params
+}) => {
+  let product = customer.products.find((p) => p.id == params.productId);
+  let allowed = product?.status === "active";
+  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 {
+      allowed: false,
+      feature_id: "",
+      customer_id: "",
+      required_balance: 0
+    };
+  }
+  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 result;
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleCheck,
+  openDialog
+});