@whatalo/plugin-sdk 1.0.0

package/dist/index.cjs

@@ -0,0 +1,843 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AuthenticationError: () => AuthenticationError,
+  AuthorizationError: () => AuthorizationError,
+  BILLING_OPERATION: () => BILLING_OPERATION,
+  InternalError: () => InternalError,
+  ManifestValidationError: () => ManifestValidationError,
+  NotFoundError: () => NotFoundError,
+  RateLimitError: () => RateLimitError,
+  SDK_VERSION: () => SDK_VERSION,
+  ValidationError: () => ValidationError,
+  WhataloAPIError: () => WhataloAPIError,
+  WhataloClient: () => WhataloClient,
+  defineApp: () => defineApp,
+  useAppBridge: () => useAppBridge,
+  useWhataloAction: () => useWhataloAction,
+  useWhataloContext: () => useWhataloContext,
+  verifyWebhook: () => verifyWebhook
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/client/errors.ts
+var WhataloAPIError = class extends Error {
+  statusCode;
+  code;
+  requestId;
+  constructor(message, statusCode, code, requestId) {
+    super(message);
+    this.name = "WhataloAPIError";
+    this.statusCode = statusCode;
+    this.code = code;
+    this.requestId = requestId;
+  }
+};
+var AuthenticationError = class extends WhataloAPIError {
+  constructor(message = "Invalid or missing API key", requestId) {
+    super(message, 401, "authentication_error", requestId);
+    this.name = "AuthenticationError";
+  }
+};
+var AuthorizationError = class extends WhataloAPIError {
+  requiredScope;
+  constructor(message, requiredScope, requestId) {
+    super(message, 403, "authorization_error", requestId);
+    this.name = "AuthorizationError";
+    this.requiredScope = requiredScope;
+  }
+};
+var InsufficientScopeError = class extends WhataloAPIError {
+  /** The exact scope string missing from the installation's granted_scopes */
+  requiredScope;
+  /** The scopes currently granted to this installation */
+  grantedScopes;
+  constructor(message, requiredScope, grantedScopes, requestId) {
+    super(message, 403, "insufficient_scope", requestId);
+    this.name = "InsufficientScopeError";
+    this.requiredScope = requiredScope;
+    this.grantedScopes = grantedScopes;
+  }
+};
+var NotFoundError = class extends WhataloAPIError {
+  resourceType;
+  resourceId;
+  constructor(resourceType, resourceId, requestId) {
+    super(
+      `${resourceType} '${resourceId}' not found`,
+      404,
+      "not_found",
+      requestId
+    );
+    this.name = "NotFoundError";
+    this.resourceType = resourceType;
+    this.resourceId = resourceId;
+  }
+};
+var ValidationError = class extends WhataloAPIError {
+  fieldErrors;
+  constructor(fieldErrors, requestId) {
+    const message = `Validation failed: ${fieldErrors.map((e) => `${e.field} \u2014 ${e.message}`).join(", ")}`;
+    super(message, 422, "validation_error", requestId);
+    this.name = "ValidationError";
+    this.fieldErrors = fieldErrors;
+  }
+};
+var RateLimitError = class extends WhataloAPIError {
+  /** Seconds until the rate limit resets */
+  retryAfter;
+  constructor(retryAfter, requestId) {
+    super(
+      `Rate limit exceeded. Retry after ${retryAfter} seconds.`,
+      429,
+      "rate_limit_exceeded",
+      requestId
+    );
+    this.name = "RateLimitError";
+    this.retryAfter = retryAfter;
+  }
+};
+var InternalError = class extends WhataloAPIError {
+  constructor(message = "An internal error occurred", requestId) {
+    super(message, 500, "internal_error", requestId);
+    this.name = "InternalError";
+  }
+};
+
+// src/client/whatalo-client.ts
+var DEFAULT_BASE_URL = "https://api.whatalo.com/v1";
+var DEFAULT_TIMEOUT = 3e4;
+var WhataloClient = class {
+  apiKey;
+  baseUrl;
+  timeout;
+  maxRetries;
+  fetchFn;
+  onRequest;
+  onResponse;
+  /** Rate limit info from the most recent API response */
+  rateLimit = { limit: 0, remaining: 0, reset: 0 };
+  /** Product resource methods */
+  products;
+  /** Order resource methods */
+  orders;
+  /** Customer resource methods */
+  customers;
+  /** Category resource methods */
+  categories;
+  /** Discount resource methods */
+  discounts;
+  /** Store resource methods */
+  store;
+  /** Inventory resource methods */
+  inventory;
+  /** Webhook resource methods */
+  webhooks;
+  constructor(options) {
+    this.apiKey = options.apiKey;
+    this.baseUrl = (options.baseUrl ?? DEFAULT_BASE_URL).replace(/\/$/, "");
+    this.timeout = options.timeout ?? DEFAULT_TIMEOUT;
+    this.maxRetries = Math.min(options.retries ?? 0, 3);
+    this.fetchFn = options.fetch ?? globalThis.fetch;
+    this.onRequest = options.onRequest;
+    this.onResponse = options.onResponse;
+    this.products = new ProductResource(this);
+    this.orders = new OrderResource(this);
+    this.customers = new CustomerResource(this);
+    this.categories = new CategoryResource(this);
+    this.discounts = new DiscountResource(this);
+    this.store = new StoreResource(this);
+    this.inventory = new InventoryResource(this);
+    this.webhooks = new WebhookResource(this);
+  }
+  /**
+   * Internal request method shared by all resource namespaces.
+   * Handles headers, timeout, error parsing, and rate limit extraction.
+   */
+  async request(method, path, options) {
+    let url = `${this.baseUrl}${path}`;
+    if (options?.params) {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(options.params)) {
+        if (value !== void 0) {
+          searchParams.set(key, String(value));
+        }
+      }
+      const qs = searchParams.toString();
+      if (qs) url += `?${qs}`;
+    }
+    const headers = {
+      "X-API-Key": this.apiKey,
+      "Content-Type": "application/json"
+    };
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+      const requestInit = {
+        method,
+        headers,
+        body: options?.body ? JSON.stringify(options.body) : void 0,
+        signal: controller.signal
+      };
+      const startedAt = Date.now();
+      this.onRequest?.(url, requestInit);
+      try {
+        const response = await this.fetchFn(url, requestInit);
+        clearTimeout(timeoutId);
+        this.onResponse?.(response, Date.now() - startedAt);
+        this.rateLimit = {
+          limit: Number(response.headers.get("X-RateLimit-Limit") ?? 0),
+          remaining: Number(
+            response.headers.get("X-RateLimit-Remaining") ?? 0
+          ),
+          reset: Number(response.headers.get("X-RateLimit-Reset") ?? 0)
+        };
+        const requestId = response.headers.get("X-Request-Id") ?? void 0;
+        if (response.ok) {
+          return await response.json();
+        }
+        const errorBody = await response.json().catch(() => ({
+          error: { code: "unknown", message: response.statusText }
+        }));
+        const errData = errorBody.error;
+        switch (response.status) {
+          case 401:
+            throw new AuthenticationError(errData?.message, requestId);
+          case 403:
+            if (errData?.code === "insufficient_scope") {
+              const details = errorBody;
+              throw new InsufficientScopeError(
+                errData.message ?? "Insufficient scope",
+                details.error?.required ?? "",
+                details.error?.granted ?? [],
+                requestId
+              );
+            }
+            throw new AuthorizationError(
+              errData?.message ?? "Forbidden",
+              errData?.code ?? "unknown_scope",
+              requestId
+            );
+          case 404:
+            throw new NotFoundError("Resource", path, requestId);
+          case 422:
+            throw new ValidationError(
+              errData?.details ?? [
+                { field: "unknown", message: errData?.message ?? "Validation failed" }
+              ],
+              requestId
+            );
+          case 429: {
+            const retryAfter = Number(
+              response.headers.get("Retry-After") ?? 60
+            );
+            throw new RateLimitError(retryAfter, requestId);
+          }
+          default:
+            if (response.status >= 500 && attempt < this.maxRetries) {
+              lastError = new InternalError(errData?.message, requestId);
+              await this.sleep(Math.pow(2, attempt) * 1e3);
+              continue;
+            }
+            throw new WhataloAPIError(
+              errData?.message ?? "API error",
+              response.status,
+              errData?.code ?? "unknown",
+              requestId
+            );
+        }
+      } catch (err) {
+        clearTimeout(timeoutId);
+        if (err instanceof WhataloAPIError) throw err;
+        if (err.name === "AbortError") {
+          throw new WhataloAPIError(
+            "Request timed out",
+            408,
+            "timeout"
+          );
+        }
+        throw err;
+      }
+    }
+    throw lastError ?? new InternalError("Request failed after retries");
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+};
+var ProductResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.request("GET", "/products", {
+      params
+    });
+  }
+  async get(id) {
+    return this.client.request("GET", `/products/${id}`);
+  }
+  async create(data) {
+    return this.client.request("POST", "/products", { body: data });
+  }
+  async update(id, data) {
+    return this.client.request("PATCH", `/products/${id}`, { body: data });
+  }
+  async delete(id) {
+    return this.client.request("DELETE", `/products/${id}`);
+  }
+  async count(status) {
+    return this.client.request("GET", "/products/count", {
+      params: status ? { status } : void 0
+    });
+  }
+};
+var OrderResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.request("GET", "/orders", {
+      params
+    });
+  }
+  async get(id) {
+    return this.client.request("GET", `/orders/${id}`);
+  }
+  async updateStatus(id, data) {
+    return this.client.request("PATCH", `/orders/${id}`, { body: data });
+  }
+  async count(status) {
+    return this.client.request("GET", "/orders/count", {
+      params: status ? { status } : void 0
+    });
+  }
+};
+var CustomerResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.request("GET", "/customers", {
+      params
+    });
+  }
+  async get(id) {
+    return this.client.request("GET", `/customers/${id}`);
+  }
+};
+var CategoryResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.request("GET", "/categories", {
+      params
+    });
+  }
+  async get(id) {
+    return this.client.request("GET", `/categories/${id}`);
+  }
+  async create(data) {
+    return this.client.request("POST", "/categories", { body: data });
+  }
+  async update(id, data) {
+    return this.client.request("PATCH", `/categories/${id}`, { body: data });
+  }
+  async delete(id) {
+    return this.client.request("DELETE", `/categories/${id}`);
+  }
+  async count() {
+    return this.client.request("GET", "/categories/count");
+  }
+};
+var DiscountResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list(params) {
+    return this.client.request("GET", "/discounts", {
+      params
+    });
+  }
+  async get(id) {
+    return this.client.request("GET", `/discounts/${id}`);
+  }
+  async create(data) {
+    return this.client.request("POST", "/discounts", { body: data });
+  }
+  async update(id, data) {
+    return this.client.request("PATCH", `/discounts/${id}`, { body: data });
+  }
+  async delete(id) {
+    return this.client.request("DELETE", `/discounts/${id}`);
+  }
+};
+var StoreResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get() {
+    return this.client.request("GET", "/store");
+  }
+};
+var InventoryResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async get(productId) {
+    return this.client.request("GET", `/products/${productId}/inventory`);
+  }
+  async adjust(productId, data) {
+    return this.client.request("PATCH", `/products/${productId}/inventory`, {
+      body: data
+    });
+  }
+};
+var WebhookResource = class {
+  constructor(client) {
+    this.client = client;
+  }
+  async list() {
+    return this.client.request("GET", "/webhooks");
+  }
+  async create(data) {
+    return this.client.request("POST", "/webhooks", { body: data });
+  }
+  async update(id, data) {
+    return this.client.request("PATCH", `/webhooks/${id}`, { body: data });
+  }
+  async delete(id) {
+    return this.client.request("DELETE", `/webhooks/${id}`);
+  }
+};
+
+// src/webhooks/verify.ts
+var import_node_crypto = require("crypto");
+function verifyWebhook({
+  payload,
+  signature,
+  secret
+}) {
+  if (!payload || !signature || !secret) return false;
+  const expected = (0, import_node_crypto.createHmac)("sha256", secret).update(payload, "utf8").digest("hex");
+  if (expected.length !== signature.length) return false;
+  try {
+    return (0, import_node_crypto.timingSafeEqual)(
+      Buffer.from(expected, "hex"),
+      Buffer.from(signature, "hex")
+    );
+  } catch {
+    return false;
+  }
+}
+
+// src/manifest/validate.ts
+var ManifestValidationError = class extends Error {
+  errors;
+  constructor(errors) {
+    const message = `Invalid app manifest: ${errors.map((e) => `${e.field}: ${e.message}`).join("; ")}`;
+    super(message);
+    this.name = "ManifestValidationError";
+    this.errors = errors;
+  }
+};
+var ID_REGEX = /^[a-z0-9][a-z0-9-]*[a-z0-9]$/;
+var SEMVER_REGEX = /^\d+\.\d+\.\d+$/;
+var EMAIL_REGEX = /^[^\s@]+@[^\s@]+\.[^\s@]+$/;
+var VALID_PERMISSIONS = /* @__PURE__ */ new Set([
+  "read:products",
+  "write:products",
+  "read:orders",
+  "write:orders",
+  "read:customers",
+  "write:customers",
+  "read:inventory",
+  "write:inventory",
+  "read:store",
+  "write:store",
+  "read:webhooks",
+  "write:webhooks",
+  "read:discounts",
+  "write:discounts",
+  "read:analytics"
+]);
+var VALID_CATEGORIES = /* @__PURE__ */ new Set([
+  "analytics",
+  "marketing",
+  "shipping",
+  "payments",
+  "payment",
+  "inventory",
+  "communication",
+  "productivity",
+  "accounting",
+  "developer",
+  "other"
+]);
+function defineApp(manifest) {
+  const errors = [];
+  if (!manifest.id || manifest.id.length < 3 || manifest.id.length > 50) {
+    errors.push({ field: "id", message: "Must be 3-50 characters" });
+  } else if (!ID_REGEX.test(manifest.id)) {
+    errors.push({
+      field: "id",
+      message: "Must be lowercase alphanumeric with hyphens"
+    });
+  }
+  if (!manifest.name || manifest.name.length < 3 || manifest.name.length > 50) {
+    errors.push({ field: "name", message: "Must be 3-50 characters" });
+  }
+  if (!manifest.description || manifest.description.length < 10 || manifest.description.length > 200) {
+    errors.push({
+      field: "description",
+      message: "Must be 10-200 characters"
+    });
+  }
+  if (!manifest.version || !SEMVER_REGEX.test(manifest.version)) {
+    errors.push({
+      field: "version",
+      message: "Must be valid semver (e.g., 1.0.0)"
+    });
+  }
+  if (!manifest.author?.name) {
+    errors.push({ field: "author.name", message: "Required" });
+  }
+  if (!manifest.author?.email || !EMAIL_REGEX.test(manifest.author.email)) {
+    errors.push({
+      field: "author.email",
+      message: "Must be a valid email address"
+    });
+  }
+  if (!manifest.permissions || manifest.permissions.length === 0) {
+    errors.push({
+      field: "permissions",
+      message: "At least one permission is required"
+    });
+  } else {
+    for (const perm of manifest.permissions) {
+      if (!VALID_PERMISSIONS.has(perm)) {
+        errors.push({
+          field: "permissions",
+          message: `Invalid permission: ${perm}`
+        });
+      }
+    }
+  }
+  if (!manifest.appUrl) {
+    errors.push({ field: "appUrl", message: "Required" });
+  }
+  if (manifest.pricing !== "free" && manifest.pricing !== "paid") {
+    errors.push({
+      field: "pricing",
+      message: 'Must be "free" or "paid"'
+    });
+  }
+  if (!VALID_CATEGORIES.has(manifest.category)) {
+    errors.push({
+      field: "category",
+      message: `Invalid category: ${manifest.category}`
+    });
+  }
+  if (errors.length > 0) {
+    throw new ManifestValidationError(errors);
+  }
+  return manifest;
+}
+
+// src/bridge/use-whatalo-context.ts
+var import_react2 = require("react");
+
+// src/bridge/use-whatalo-action.ts
+var import_react = require("react");
+
+// src/bridge/types.ts
+var BILLING_OPERATION = {
+  GET_PLANS: "getPlans",
+  GET_SUBSCRIPTION: "getSubscription",
+  REQUEST_SUBSCRIPTION: "requestSubscription",
+  CANCEL_SUBSCRIPTION: "cancelSubscription",
+  REACTIVATE_SUBSCRIPTION: "reactivateSubscription",
+  SWITCH_PLAN: "switchPlan",
+  CREATE_USAGE_RECORD: "createUsageRecord"
+};
+
+// src/bridge/use-whatalo-action.ts
+var ACK_TIMEOUT_MS = 5e3;
+var parentOrigin = null;
+var originResolvers = [];
+function waitForParentOrigin() {
+  if (parentOrigin !== null) {
+    return Promise.resolve(parentOrigin);
+  }
+  return new Promise((resolve) => {
+    originResolvers.push(resolve);
+  });
+}
+var initListenerAttached = false;
+function attachInitListener() {
+  if (initListenerAttached) return;
+  initListenerAttached = true;
+  window.addEventListener("message", (event) => {
+    if (event.source !== window.parent) return;
+    if (!event.data || typeof event.data !== "object") return;
+    if (event.data.type !== "whatalo:init") return;
+    const origin = event.data.origin;
+    if (typeof origin !== "string" || !origin) return;
+    parentOrigin = origin;
+    for (const resolve of originResolvers) {
+      resolve(origin);
+    }
+    originResolvers.length = 0;
+  });
+}
+function useWhataloAction() {
+  const pendingAcks = (0, import_react.useRef)(
+    /* @__PURE__ */ new Map()
+  );
+  (0, import_react.useEffect)(() => {
+    attachInitListener();
+    const handleMessage = (event) => {
+      if (!event.data || typeof event.data !== "object") return;
+      const msg = event.data;
+      if (msg.type !== "whatalo:ack") return;
+      const resolve = pendingAcks.current.get(msg.actionId);
+      if (resolve) {
+        resolve(msg);
+        pendingAcks.current.delete(msg.actionId);
+      }
+    };
+    window.addEventListener("message", handleMessage);
+    return () => window.removeEventListener("message", handleMessage);
+  }, []);
+  const sendAction = (0, import_react.useCallback)(
+    (action, payload) => {
+      return new Promise((resolve) => {
+        const actionId = crypto.randomUUID();
+        const timeout = setTimeout(() => {
+          pendingAcks.current.delete(actionId);
+          resolve({
+            type: "whatalo:ack",
+            actionId,
+            success: false,
+            error: "timeout"
+          });
+        }, ACK_TIMEOUT_MS);
+        pendingAcks.current.set(actionId, (ack) => {
+          clearTimeout(timeout);
+          resolve(ack);
+        });
+        waitForParentOrigin().then((origin) => {
+          window.parent.postMessage(
+            { type: "whatalo:action", actionId, action, payload },
+            origin
+          );
+        });
+      });
+    },
+    []
+  );
+  const showToast = (0, import_react.useCallback)(
+    (options) => sendAction("toast", options),
+    [sendAction]
+  );
+  const navigate = (0, import_react.useCallback)(
+    (path) => sendAction("navigate", { path }),
+    [sendAction]
+  );
+  const openModal = (0, import_react.useCallback)(
+    (options) => sendAction("modal", {
+      operation: "open",
+      ...options
+    }),
+    [sendAction]
+  );
+  const closeModal = (0, import_react.useCallback)(
+    () => sendAction("modal", { operation: "close" }),
+    [sendAction]
+  );
+  const resize = (0, import_react.useCallback)(
+    (height) => sendAction("resize", { height }),
+    [sendAction]
+  );
+  const sendBillingAction = (0, import_react.useCallback)(
+    (operation, extra) => sendAction("billing", {
+      operation,
+      ...extra
+    }),
+    [sendAction]
+  );
+  const billingGetPlans = (0, import_react.useCallback)(async () => {
+    const ack = await sendBillingAction(BILLING_OPERATION.GET_PLANS);
+    if (!ack.success) {
+      throw new Error(ack.error ?? "billing.getPlans failed");
+    }
+    return ack.data ?? [];
+  }, [sendBillingAction]);
+  const billingGetSubscription = (0, import_react.useCallback)(
+    async () => {
+      const ack = await sendBillingAction(BILLING_OPERATION.GET_SUBSCRIPTION);
+      if (!ack.success) {
+        throw new Error(ack.error ?? "billing.getSubscription failed");
+      }
+      return ack.data ?? null;
+    },
+    [sendBillingAction]
+  );
+  const billingRequestSubscription = (0, import_react.useCallback)(
+    async (planSlug) => {
+      const ack = await sendBillingAction(BILLING_OPERATION.REQUEST_SUBSCRIPTION, {
+        planSlug
+      });
+      if (!ack.success) {
+        throw new Error(ack.error ?? "billing.requestSubscription failed");
+      }
+    },
+    [sendBillingAction]
+  );
+  const billingCancelSubscription = (0, import_react.useCallback)(async () => {
+    const ack = await sendBillingAction(BILLING_OPERATION.CANCEL_SUBSCRIPTION);
+    if (!ack.success) {
+      throw new Error(ack.error ?? "billing.cancelSubscription failed");
+    }
+  }, [sendBillingAction]);
+  const billingReactivateSubscription = (0, import_react.useCallback)(async () => {
+    const ack = await sendBillingAction(BILLING_OPERATION.REACTIVATE_SUBSCRIPTION);
+    if (!ack.success) {
+      throw new Error(ack.error ?? "billing.reactivateSubscription failed");
+    }
+  }, [sendBillingAction]);
+  const billingSwitchPlan = (0, import_react.useCallback)(
+    async (newPlanSlug) => {
+      const ack = await sendBillingAction(BILLING_OPERATION.SWITCH_PLAN, {
+        planSlug: newPlanSlug
+      });
+      if (!ack.success) {
+        throw new Error(ack.error ?? "billing.switchPlan failed");
+      }
+    },
+    [sendBillingAction]
+  );
+  const billing = {
+    getPlans: billingGetPlans,
+    getSubscription: billingGetSubscription,
+    requestSubscription: billingRequestSubscription,
+    cancelSubscription: billingCancelSubscription,
+    reactivateSubscription: billingReactivateSubscription,
+    switchPlan: billingSwitchPlan
+  };
+  return { sendAction, showToast, navigate, openModal, closeModal, resize, billing };
+}
+
+// src/bridge/use-whatalo-context.ts
+var DEFAULT_CONTEXT = {
+  storeId: "",
+  storeName: "",
+  user: { id: "", name: "", email: "", role: "owner" },
+  appId: "",
+  currentPage: "",
+  locale: "es",
+  theme: "light",
+  initialHeight: 200
+};
+function useWhataloContext() {
+  const [context, setContext] = (0, import_react2.useState)(DEFAULT_CONTEXT);
+  const [isReady, setIsReady] = (0, import_react2.useState)(false);
+  const handleMessage = (0, import_react2.useCallback)((event) => {
+    if (!event.data || typeof event.data !== "object") return;
+    const msg = event.data;
+    if (msg.type !== "whatalo:context") return;
+    const payload = msg.data ?? msg.context;
+    if (!payload || typeof payload.storeId !== "string") return;
+    setContext(payload);
+    setIsReady(true);
+    if (payload.theme) {
+      document.documentElement.setAttribute("data-theme", payload.theme);
+    }
+  }, []);
+  (0, import_react2.useEffect)(() => {
+    attachInitListener();
+    window.addEventListener("message", handleMessage);
+    waitForParentOrigin().then((origin) => {
+      window.parent.postMessage(
+        {
+          type: "whatalo:action",
+          actionId: crypto.randomUUID(),
+          action: "ready",
+          payload: {}
+        },
+        origin
+      );
+    });
+    return () => window.removeEventListener("message", handleMessage);
+  }, [handleMessage]);
+  return { ...context, isReady };
+}
+
+// src/bridge/use-app-bridge.ts
+function useAppBridge() {
+  const ctx = useWhataloContext();
+  const actions = useWhataloAction();
+  return {
+    storeId: ctx.storeId,
+    storeName: ctx.storeName,
+    locale: ctx.locale,
+    theme: ctx.theme,
+    user: ctx.user,
+    appId: ctx.appId,
+    isReady: ctx.isReady,
+    toast: {
+      show: (title, options) => actions.showToast({ title, ...options })
+    },
+    navigate: actions.navigate,
+    modal: {
+      open: actions.openModal,
+      close: actions.closeModal
+    },
+    resize: actions.resize,
+    billing: actions.billing
+  };
+}
+
+// src/index.ts
+var SDK_VERSION = "0.0.1";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AuthenticationError,
+  AuthorizationError,
+  BILLING_OPERATION,
+  InternalError,
+  ManifestValidationError,
+  NotFoundError,
+  RateLimitError,
+  SDK_VERSION,
+  ValidationError,
+  WhataloAPIError,
+  WhataloClient,
+  defineApp,
+  useAppBridge,
+  useWhataloAction,
+  useWhataloContext,
+  verifyWebhook
+});
+//# sourceMappingURL=index.cjs.map