@payment-kit-js/vanilla 0.1.0-alpha.0

package/dist/cardsetupintent-D2gBMj3e.d.mts

@@ -0,0 +1,35 @@
+//#region ../../packages/sdk/esm/models/cardsetupintent.d.ts
+
+type CardSetupIntent = {
+  /**
+   * Card setup intent identifier
+   */
+  id: string;
+  /**
+   * Whether all card details have been collected
+   */
+  isCardAllSet: boolean;
+  /**
+   * Whether card PAN is set
+   */
+  isCardPanSet: boolean;
+  /**
+   * Whether card expiry is set
+   */
+  isCardExpSet: boolean;
+  /**
+   * Whether card CVC is set
+   */
+  isCardCvcSet: boolean;
+  /**
+   * When the card setup intent was created
+   */
+  createdAt: Date;
+  /**
+   * When the card setup intent was last updated
+   */
+  updatedAt: Date;
+};
+//#endregion
+export { CardSetupIntent as t };
+//# sourceMappingURL=cardsetupintent-D2gBMj3e.d.mts.map

package/dist/cardsetupintent-D2gBMj3e.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cardsetupintent-D2gBMj3e.d.mts","names":["z","Result","SafeParseResult","SDKValidationError","CardSetupIntent","Date","CardSetupIntent$inboundSchema","ZodTypeDef","ZodType","cardSetupIntentFromJSON"],"sources":["../../../packages/sdk/esm/models/cardsetupintent.d.ts"],"sourcesContent":["import * as z from \"zod/v3\";\nimport { Result as SafeParseResult } from \"../types/fp.js\";\nimport { SDKValidationError } from \"./errors/sdkvalidationerror.js\";\nexport type CardSetupIntent = {\n    /**\n     * Card setup intent identifier\n     */\n    id: string;\n    /**\n     * Whether all card details have been collected\n     */\n    isCardAllSet: boolean;\n    /**\n     * Whether card PAN is set\n     */\n    isCardPanSet: boolean;\n    /**\n     * Whether card expiry is set\n     */\n    isCardExpSet: boolean;\n    /**\n     * Whether card CVC is set\n     */\n    isCardCvcSet: boolean;\n    /**\n     * When the card setup intent was created\n     */\n    createdAt: Date;\n    /**\n     * When the card setup intent was last updated\n     */\n    updatedAt: Date;\n};\n/** @internal */\nexport declare const CardSetupIntent$inboundSchema: z.ZodType<CardSetupIntent, z.ZodTypeDef, unknown>;\nexport declare function cardSetupIntentFromJSON(jsonString: string): SafeParseResult<CardSetupIntent, SDKValidationError>;\n//# sourceMappingURL=cardsetupintent.d.ts.map"],"mappings":";;KAGYI,eAAAA;;;;;;;;;;;;;;;;;;;;;;;;aAwBGC;;;;aAIAA"}

package/dist/connect-card-DO2EJxu6.mjs

@@ -0,0 +1,19 @@
+import { t as connectToWindow } from "./penpal-BFKeZTVz.mjs";
+
+//#region src/penpal/connect-card.ts
+const connectToCardIframe = (iframe, methods) => {
+	return connectToWindow({
+		window: iframe.contentWindow,
+		methods
+	});
+};
+const connectToCardParent = (methods) => {
+	return connectToWindow({
+		window: window.parent,
+		methods
+	});
+};
+
+//#endregion
+export { connectToCardParent as n, connectToCardIframe as t };
+//# sourceMappingURL=connect-card-DO2EJxu6.mjs.map

package/dist/connect-card-DO2EJxu6.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-card-DO2EJxu6.mjs","names":[],"sources":["../src/penpal/connect-card.ts"],"sourcesContent":["import type { CardSetupIntent, PublicCardCheckoutResponse } from \"@pkg/sdk/models\";\nimport type { Connection } from \"penpal\";\nimport { connectToWindow } from \".\";\n\ntype CardIFrameMethods = {\n  onSubmit: (cardSetupIntentId: string) => Promise<CardSetupIntent | { error: CardErrorCode }>;\n  onValidate: () => Promise<CardErrorCode | undefined>;\n};\n\ntype CardParentMethods = {\n  onLoaded: () => void;\n  onFocusChange: (isFocused: boolean) => void;\n};\n\nexport type CardInputType = \"card_pan\" | \"card_exp\" | \"card_cvc\";\n\nexport type CardErrorCode =\n  | \"invalid\"\n  | \"required\"\n  | \"unknown_error\"\n  | \"penpal_not_connected\"\n  | \"missing_checkout_token\";\n\nexport type IFrameConnection = Connection<CardIFrameMethods>;\n\nexport type ParentConnection = Connection<CardParentMethods>;\n\nexport type CheckoutResponse = PublicCardCheckoutResponse;\n\nexport const connectToCardIframe = (iframe: HTMLIFrameElement, methods: CardParentMethods) => {\n  return connectToWindow<CardIFrameMethods>({ window: iframe.contentWindow as Window, methods });\n};\n\nexport const connectToCardParent = (methods: CardIFrameMethods) => {\n  return connectToWindow<CardParentMethods>({ window: window.parent, methods });\n};\n"],"mappings":";;;AA6BA,MAAa,uBAAuB,QAA2B,YAA+B;AAC5F,QAAO,gBAAmC;EAAE,QAAQ,OAAO;EAAyB;EAAS,CAAC;;AAGhG,MAAa,uBAAuB,YAA+B;AACjE,QAAO,gBAAmC;EAAE,QAAQ,OAAO;EAAQ;EAAS,CAAC"}

package/dist/connect-card-EaOlRbPS.d.mts

@@ -0,0 +1,25 @@
+import { t as CardSetupIntent } from "./cardsetupintent-D2gBMj3e.mjs";
+import { t as PublicCardCheckoutResponse } from "./publiccardcheckoutresponse-wxFCeVdO.mjs";
+import { Connection } from "penpal";
+
+//#region src/penpal/connect-card.d.ts
+type CardIFrameMethods = {
+  onSubmit: (cardSetupIntentId: string) => Promise<CardSetupIntent | {
+    error: CardErrorCode;
+  }>;
+  onValidate: () => Promise<CardErrorCode | undefined>;
+};
+type CardParentMethods = {
+  onLoaded: () => void;
+  onFocusChange: (isFocused: boolean) => void;
+};
+type CardInputType = "card_pan" | "card_exp" | "card_cvc";
+type CardErrorCode = "invalid" | "required" | "unknown_error" | "penpal_not_connected" | "missing_checkout_token";
+type IFrameConnection = Connection<CardIFrameMethods>;
+type ParentConnection = Connection<CardParentMethods>;
+type CheckoutResponse = PublicCardCheckoutResponse;
+declare const connectToCardIframe: (iframe: HTMLIFrameElement, methods: CardParentMethods) => Connection<CardIFrameMethods>;
+declare const connectToCardParent: (methods: CardIFrameMethods) => Connection<CardParentMethods>;
+//#endregion
+export { ParentConnection as a, IFrameConnection as i, CardInputType as n, connectToCardIframe as o, CheckoutResponse as r, connectToCardParent as s, CardErrorCode as t };
+//# sourceMappingURL=connect-card-EaOlRbPS.d.mts.map

package/dist/connect-card-EaOlRbPS.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-card-EaOlRbPS.d.mts","names":[],"sources":["../src/penpal/connect-card.ts"],"sourcesContent":[],"mappings":";;;;;KAIK,iBAAA;2CACsC,QAAQ;WAA2B;EADzE,CAAA,CAAA;EAC8C,UAAA,EAAA,GAAA,GAC/B,OAD+B,CACvB,aADuB,GAAA,SAAA,CAAA;CAA2B;KAIzE,iBAAA,GAJsC;EACf,QAAA,EAAA,GAAA,GAAA,IAAA;EAAR,aAAA,EAAA,CAAA,SAAA,EAAA,OAAA,EAAA,GAAA,IAAA;CAAO;AAGtB,KAKO,aAAA,GALU,UAAA,GAAA,UAAA,GAAA,UAAA;AAKV,KAEA,aAAA,GAFa,SAAA,GAAA,UAAA,GAAA,eAAA,GAAA,sBAAA,GAAA,wBAAA;AAEb,KAOA,gBAAA,GAAmB,UAPN,CAOiB,iBAPjB,CAAA;AAOb,KAEA,gBAAA,GAAmB,UAFW,CAEA,iBAFX,CAAA;AAEnB,KAEA,gBAAA,GAAmB,0BAFA;AAEnB,cAEC,mBAFkB,EAAA,CAAA,MAAA,EAEa,iBAFa,EAAA,OAAA,EAEe,iBAFf,EAAA,GAEgC,UAFhC,CAEgC,iBAFhC,CAAA;AAE5C,cAIA,mBAFZ,EAAA,CAAA,OAAA,EAE4C,iBAF5C,EAAA,GAE6D,UAF7D,CAE6D,iBAF7D,CAAA"}

package/dist/connect-tunnel-x-BhVAej5Q.mjs

@@ -0,0 +1,44 @@
+import { t as connectToWindow } from "./penpal-BFKeZTVz.mjs";
+
+//#region src/penpal/connect-tunnel-x.ts
+const connectToTunnelXIframe = (iframe, methods) => {
+	return connectToWindow({
+		window: iframe.contentWindow,
+		methods
+	});
+};
+const connectToTunnelXParent = (methods) => {
+	return connectToWindow({
+		window: window.parent,
+		methods
+	});
+};
+var TunnelXManager = class TunnelXManager {
+	penpalConn;
+	_methods;
+	static createFromPenpalConnection = async (penpalConn) => {
+		return new TunnelXManager(penpalConn, await penpalConn.promise);
+	};
+	constructor(penpalConn, penpalMethods) {
+		this.penpalConn = penpalConn;
+		this._methods = penpalMethods;
+	}
+	/**
+	* Makes publicEndpoints act like a real PK client, but actually forwards all calls
+	* through queryPublicEndpoint and sends it through penpal.
+	*/
+	get publicEndpoints() {
+		return new Proxy({}, { get: (_target, prop) => {
+			return async (...args) => {
+				return await this._methods.queryPublicEndpoint(prop, args[0], args[1]);
+			};
+		} });
+	}
+	destroy() {
+		this.penpalConn.destroy();
+	}
+};
+
+//#endregion
+export { connectToTunnelXIframe as n, connectToTunnelXParent as r, TunnelXManager as t };
+//# sourceMappingURL=connect-tunnel-x-BhVAej5Q.mjs.map

package/dist/connect-tunnel-x-BhVAej5Q.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-tunnel-x-BhVAej5Q.mjs","names":[],"sources":["../src/penpal/connect-tunnel-x.ts"],"sourcesContent":["import type { RequestOptions } from \"@pkg/sdk/lib/sdks\";\nimport type { CardSetupIntent, CreateCardSetupIntentRes } from \"@pkg/sdk/models\";\nimport type { Connection } from \"penpal\";\nimport { connectToWindow } from \".\";\n\n// Note: this file is paired with customer-portal/src/routes/embeds/v1/tunnel-x\n// The methods below should also be present in CheckoutTunnelX\n\ntype TunnelXIFrameMethods = {\n  startPayment: () => void;\n  confirmPayment: () => void;\n  submitCheckout: (values: Record<string, string>) => Promise<unknown>;\n  getCheckoutPreview: () => void;\n  getCardSetupIntent: (cardSetupIntentId: string) => Promise<CardSetupIntent>;\n  createCardSetupIntent: (secureToken: string) => Promise<CreateCardSetupIntentRes>;\n  queryPublicEndpoint: (methodName: string, params: unknown, options?: RequestOptions) => Promise<unknown>;\n};\n\ntype TunnelXParentMethods = Record<string, never>;\n\nexport type TunnelXIFrameConnection = Connection<TunnelXIFrameMethods>;\n\nexport type TunnelXParentConnection = Connection<TunnelXParentMethods>;\n\nexport const connectToTunnelXIframe = (iframe: HTMLIFrameElement, methods: TunnelXParentMethods) => {\n  return connectToWindow<TunnelXIFrameMethods>({ window: iframe.contentWindow as Window, methods });\n};\n\nexport const connectToTunnelXParent = (methods: TunnelXIFrameMethods) => {\n  return connectToWindow<TunnelXParentMethods>({ window: window.parent, methods });\n};\n\n/**\n * SDK type for publicEndpoints proxy.\n * This is a simplified version that matches the TunnelX iframe methods.\n */\ntype PublicEndpointsProxy = {\n  [methodName: string]: (params: unknown, options?: RequestOptions) => Promise<unknown>;\n};\n\nexport class TunnelXManager {\n  private penpalConn: TunnelXIFrameConnection;\n  public _methods: TunnelXIFrameMethods;\n\n  static createFromPenpalConnection = async (penpalConn: TunnelXIFrameConnection) => {\n    const methods = await penpalConn.promise;\n    const manager = new TunnelXManager(penpalConn, methods);\n    return manager;\n  };\n\n  private constructor(penpalConn: TunnelXIFrameConnection, penpalMethods: TunnelXIFrameMethods) {\n    this.penpalConn = penpalConn;\n    this._methods = penpalMethods;\n  }\n\n  /**\n   * Makes publicEndpoints act like a real PK client, but actually forwards all calls\n   * through queryPublicEndpoint and sends it through penpal.\n   */\n  get publicEndpoints(): PublicEndpointsProxy {\n    const handler = {\n      get: (_target: Record<string, never>, prop: string) => {\n        return async (...args: unknown[]) => {\n          return await this._methods.queryPublicEndpoint(prop, args[0], args[1] as RequestOptions | undefined);\n        };\n      },\n    };\n    return new Proxy({}, handler) as unknown as PublicEndpointsProxy;\n  }\n\n  destroy() {\n    this.penpalConn.destroy();\n  }\n}\n"],"mappings":";;;AAwBA,MAAa,0BAA0B,QAA2B,YAAkC;AAClG,QAAO,gBAAsC;EAAE,QAAQ,OAAO;EAAyB;EAAS,CAAC;;AAGnG,MAAa,0BAA0B,YAAkC;AACvE,QAAO,gBAAsC;EAAE,QAAQ,OAAO;EAAQ;EAAS,CAAC;;AAWlF,IAAa,iBAAb,MAAa,eAAe;CAC1B,AAAQ;CACR,AAAO;CAEP,OAAO,6BAA6B,OAAO,eAAwC;AAGjF,SADgB,IAAI,eAAe,YADnB,MAAM,WAAW,QACsB;;CAIzD,AAAQ,YAAY,YAAqC,eAAqC;AAC5F,OAAK,aAAa;AAClB,OAAK,WAAW;;;;;;CAOlB,IAAI,kBAAwC;AAQ1C,SAAO,IAAI,MAAM,EAAE,EAPH,EACd,MAAM,SAAgC,SAAiB;AACrD,UAAO,OAAO,GAAG,SAAoB;AACnC,WAAO,MAAM,KAAK,SAAS,oBAAoB,MAAM,KAAK,IAAI,KAAK,GAAiC;;KAGzG,CAC4B;;CAG/B,UAAU;AACR,OAAK,WAAW,SAAS"}

package/dist/connect-tunnel-x-Ce423Pa2.d.mts

@@ -0,0 +1,92 @@
+import { t as CardSetupIntent } from "./cardsetupintent-D2gBMj3e.mjs";
+import { Connection } from "penpal";
+
+//#region ../../packages/sdk/esm/models/createcardsetupintentres.d.ts
+type CreateCardSetupIntentRes = {
+  /**
+   * The ID of the card setup intent
+   */
+  cardSetupIntentId: string;
+};
+//#endregion
+//#region ../../packages/sdk/esm/lib/retries.d.ts
+type BackoffStrategy = {
+  initialInterval: number;
+  maxInterval: number;
+  exponent: number;
+  maxElapsedTime: number;
+};
+type RetryConfig = {
+  strategy: "none";
+} | {
+  strategy: "backoff";
+  backoff?: BackoffStrategy;
+  retryConnectionErrors?: boolean;
+};
+//#endregion
+//#region ../../packages/sdk/esm/lib/sdks.d.ts
+type RequestOptions = {
+  /**
+   * Sets a timeout, in milliseconds, on HTTP requests made by an SDK method. If
+   * `fetchOptions.signal` is set then it will take precedence over this option.
+   */
+  timeoutMs?: number;
+  /**
+   * Set or override a retry policy on HTTP calls.
+   */
+  retries?: RetryConfig;
+  /**
+   * Specifies the status codes which should be retried using the given retry policy.
+   */
+  retryCodes?: string[];
+  /**
+   * Overrides the base server URL that will be used by an operation.
+   */
+  serverURL?: string | URL;
+  /**
+   * @deprecated `fetchOptions` has been flattened into `RequestOptions`.
+   *
+   * Sets various request options on the `fetch` call made by an SDK method.
+   *
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options|Request}
+   */
+  fetchOptions?: Omit<RequestInit, "method" | "body">;
+} & Omit<RequestInit, "method" | "body">;
+//#endregion
+//#region src/penpal/connect-tunnel-x.d.ts
+type TunnelXIFrameMethods = {
+  startPayment: () => void;
+  confirmPayment: () => void;
+  submitCheckout: (values: Record<string, string>) => Promise<unknown>;
+  getCheckoutPreview: () => void;
+  getCardSetupIntent: (cardSetupIntentId: string) => Promise<CardSetupIntent>;
+  createCardSetupIntent: (secureToken: string) => Promise<CreateCardSetupIntentRes>;
+  queryPublicEndpoint: (methodName: string, params: unknown, options?: RequestOptions) => Promise<unknown>;
+};
+type TunnelXParentMethods = Record<string, never>;
+type TunnelXIFrameConnection = Connection<TunnelXIFrameMethods>;
+type TunnelXParentConnection = Connection<TunnelXParentMethods>;
+declare const connectToTunnelXIframe: (iframe: HTMLIFrameElement, methods: TunnelXParentMethods) => Connection<TunnelXIFrameMethods>;
+declare const connectToTunnelXParent: (methods: TunnelXIFrameMethods) => Connection<TunnelXParentMethods>;
+/**
+ * SDK type for publicEndpoints proxy.
+ * This is a simplified version that matches the TunnelX iframe methods.
+ */
+type PublicEndpointsProxy = {
+  [methodName: string]: (params: unknown, options?: RequestOptions) => Promise<unknown>;
+};
+declare class TunnelXManager {
+  private penpalConn;
+  _methods: TunnelXIFrameMethods;
+  static createFromPenpalConnection: (penpalConn: TunnelXIFrameConnection) => Promise<TunnelXManager>;
+  private constructor();
+  /**
+   * Makes publicEndpoints act like a real PK client, but actually forwards all calls
+   * through queryPublicEndpoint and sends it through penpal.
+   */
+  get publicEndpoints(): PublicEndpointsProxy;
+  destroy(): void;
+}
+//#endregion
+export { connectToTunnelXParent as a, connectToTunnelXIframe as i, TunnelXManager as n, TunnelXParentConnection as r, TunnelXIFrameConnection as t };
+//# sourceMappingURL=connect-tunnel-x-Ce423Pa2.d.mts.map

package/dist/connect-tunnel-x-Ce423Pa2.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect-tunnel-x-Ce423Pa2.d.mts","names":["z","Result","SafeParseResult","SDKValidationError","CreateCardSetupIntentRes","CreateCardSetupIntentRes$inboundSchema","ZodTypeDef","ZodType","createCardSetupIntentResFromJSON","BackoffStrategy","RetryConfig","PermanentError","Error","TemporaryError","Response","retry","Promise","SDKHooks","HookContext","ConnectionError","InvalidRequestError","RequestAbortedError","RequestTimeoutError","UnexpectedClientError","Result","SDKOptions","RetryConfig","SecurityState","RequestOptions","URL","RequestInit","Omit","RequestConfig","HeadersInit","ClientSDK","Request","Response","Promise"],"sources":["../../../packages/sdk/esm/models/createcardsetupintentres.d.ts","../../../packages/sdk/esm/lib/retries.d.ts","../../../packages/sdk/esm/lib/sdks.d.ts","../src/penpal/connect-tunnel-x.ts"],"sourcesContent":["import * as z from \"zod/v3\";\nimport { Result as SafeParseResult } from \"../types/fp.js\";\nimport { SDKValidationError } from \"./errors/sdkvalidationerror.js\";\nexport type CreateCardSetupIntentRes = {\n    /**\n     * The ID of the card setup intent\n     */\n    cardSetupIntentId: string;\n};\n/** @internal */\nexport declare const CreateCardSetupIntentRes$inboundSchema: z.ZodType<CreateCardSetupIntentRes, z.ZodTypeDef, unknown>;\nexport declare function createCardSetupIntentResFromJSON(jsonString: string): SafeParseResult<CreateCardSetupIntentRes, SDKValidationError>;\n//# sourceMappingURL=createcardsetupintentres.d.ts.map","export type BackoffStrategy = {\n    initialInterval: number;\n    maxInterval: number;\n    exponent: number;\n    maxElapsedTime: number;\n};\nexport type RetryConfig = {\n    strategy: \"none\";\n} | {\n    strategy: \"backoff\";\n    backoff?: BackoffStrategy;\n    retryConnectionErrors?: boolean;\n};\n/**\n * PermanentError is an error that is not recoverable. Throwing this error will\n * cause a retry loop to terminate.\n */\nexport declare class PermanentError extends Error {\n    /** The underlying cause of the error. */\n    readonly cause: unknown;\n    constructor(message: string, options?: {\n        cause?: unknown;\n    });\n}\n/**\n * TemporaryError is an error is used to signal that an HTTP request can be\n * retried as part of a retry loop. If retry attempts are exhausted and this\n * error is thrown, the response will be returned to the caller.\n */\nexport declare class TemporaryError extends Error {\n    response: Response;\n    constructor(message: string, response: Response);\n}\nexport declare function retry(fetchFn: () => Promise<Response>, options: {\n    config: RetryConfig;\n    statusCodes: string[];\n}): Promise<Response>;\n//# sourceMappingURL=retries.d.ts.map","import { SDKHooks } from \"../hooks/hooks.js\";\nimport { HookContext } from \"../hooks/types.js\";\nimport { ConnectionError, InvalidRequestError, RequestAbortedError, RequestTimeoutError, UnexpectedClientError } from \"../models/errors/httpclienterrors.js\";\nimport { Result } from \"../types/fp.js\";\nimport { SDKOptions } from \"./config.js\";\nimport { RetryConfig } from \"./retries.js\";\nimport { SecurityState } from \"./security.js\";\nexport type RequestOptions = {\n    /**\n     * Sets a timeout, in milliseconds, on HTTP requests made by an SDK method. If\n     * `fetchOptions.signal` is set then it will take precedence over this option.\n     */\n    timeoutMs?: number;\n    /**\n     * Set or override a retry policy on HTTP calls.\n     */\n    retries?: RetryConfig;\n    /**\n     * Specifies the status codes which should be retried using the given retry policy.\n     */\n    retryCodes?: string[];\n    /**\n     * Overrides the base server URL that will be used by an operation.\n     */\n    serverURL?: string | URL;\n    /**\n     * @deprecated `fetchOptions` has been flattened into `RequestOptions`.\n     *\n     * Sets various request options on the `fetch` call made by an SDK method.\n     *\n     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Request/Request#options|Request}\n     */\n    fetchOptions?: Omit<RequestInit, \"method\" | \"body\">;\n} & Omit<RequestInit, \"method\" | \"body\">;\ntype RequestConfig = {\n    method: string;\n    path: string;\n    baseURL?: string | URL | undefined;\n    query?: string;\n    body?: RequestInit[\"body\"];\n    headers?: HeadersInit;\n    security?: SecurityState | null;\n    uaHeader?: string;\n    userAgent?: string | undefined;\n    timeoutMs?: number;\n};\nexport declare class ClientSDK {\n    #private;\n    readonly _baseURL: URL | null;\n    readonly _options: SDKOptions & {\n        hooks?: SDKHooks;\n    };\n    constructor(options: SDKOptions);\n    _createRequest(context: HookContext, conf: RequestConfig, options?: RequestOptions): Result<Request, InvalidRequestError | UnexpectedClientError>;\n    _do(request: Request, options: {\n        context: HookContext;\n        errorCodes: number | string | (number | string)[];\n        retryConfig: RetryConfig;\n        retryCodes: string[];\n    }): Promise<Result<Response, RequestAbortedError | RequestTimeoutError | ConnectionError | UnexpectedClientError>>;\n}\nexport {};\n//# sourceMappingURL=sdks.d.ts.map"],"mappings":";;;;KAGYI,wBAAAA;EAAAA;;;;ACHZ,CAAA;;;KAAYK,eAAAA;;;;EDGAL,cAAAA,EAAAA,MAAAA;;KCGAM,WAAAA;;AANZ,CAAA,GAAYD;EAMAC,QAAAA,EAAAA,SAAW;YAITD;;;;;KCHFmB,cAAAA;EDPAnB;AAMZ;;;;ECCYmB;;;EAyBYE,OAAAA,CAAAA,EAhBVJ,WAgBUI;EAALC;;;EACX,UAAA,CAAA,EAAA,MAAA,EAAA;;;;ECzBH,SAAA,CAAA,EAAA,MAAA,GDgBoBF,GChBA;EAGE;;;;;;;EAI+D,YAAA,CAAA,EDiBvEE,ICjBuE,CDiBlED,WCjBkE,EAAA,QAAA,GAAA,MAAA,CAAA;CAAO,GDkB7FC,IClB6F,CDkBxFD,WClBwF,EAAA,QAAA,GAAA,MAAA,CAAA;;;KAP5F,oBAAA;EHLO1B,YAAAA,EAAAA,GAAAA,GAAAA,IAAAA;;2BGQe,2BAA2B;;EFX1CK,kBAAe,EAAA,CAAA,iBAAA,EAAA,MAAA,EAAA,GEa0B,OFb1B,CEakC,eFblC,CAAA;EAMfC,qBAAW,EAAA,CAAA,WAITD,EAAAA,MAAe,EAAA,GEIqB,OFJrB,CEI6B,wBFJ7B,CAAA;uEEK0C,mBAAmB;;KAGrF,oBAAA,GAAuB;ADXhBmB,KCaA,uBAAA,GAA0B,UDbZ,CCauB,oBDbvB,CAAA;AASZF,KCMF,uBAAA,GAA0B,UDNxBA,CCMmC,oBDNnCA,CAAAA;AAQWG,cCAZ,sBDAYA,EAAAA,CAAAA,MAAAA,ECAsB,iBDAtBA,EAAAA,OAAAA,ECAkD,oBDAlDA,EAAAA,GCAsE,UDAtEA,CCAsE,oBDAtEA,CAAAA;AAQDC,cCJX,sBDIWA,EAAAA,CAAAA,OAAAA,ECJwB,oBDIxBA,EAAAA,GCJ4C,UDI5CA,CCJ4C,oBDI5CA,CAAAA;;;;;KCInB,oBAAA;oDAC+C,mBAAmB;;AA7BlE,cAgCQ,cAAA,CAhCY;EAGE,QAAA,UAAA;EAA2B,QAAA,EA+BnC,oBA/BmC;EAEO,OAAA,0BAAA,EAAA,CAAA,UAAA,EA+BJ,uBA/BI,EAAA,GA+BmB,OA/BnB,CA+BmB,cA/BnB,CAAA;EAAR,QAAA,WAAA,CAAA;EACK;;;;EACuC,IAAA,eAAA,CAAA,CAAA,EA4CxE,oBA5CwE;EAG5F,OAAA,CAAA,CAAA,EAAA,IAAA;AAEL"}

package/dist/index.d.mts

@@ -0,0 +1,11 @@
+import "./cardsetupintent-D2gBMj3e.mjs";
+import "./connect-tunnel-x-Ce423Pa2.mjs";
+import "./publiccardcheckoutresponse-wxFCeVdO.mjs";
+import "./connect-card-EaOlRbPS.mjs";
+import { n as PaymentKitFields, t as PaymentKit$1 } from "./types-6mOKdjCh.mjs";
+
+//#region src/index.d.ts
+declare const PaymentKit: PaymentKit$1;
+//#endregion
+export { type PaymentKitFields, PaymentKit as default };
+//# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/index.ts"],"sourcesContent":[],"mappings":";;;;;;;cAwBM,YAAY"}

package/dist/index.mjs

@@ -0,0 +1,69 @@
+import "./penpal-BFKeZTVz.mjs";
+import { n as connectToTunnelXIframe } from "./connect-tunnel-x-BhVAej5Q.mjs";
+import { r as createCheckoutIFrame } from "./utils-h0dxplHy.mjs";
+
+//#region package.json
+var version = "0.1.0-alpha.0";
+
+//#endregion
+//#region src/index.ts
+const createTunnelXConnection = (baseUrl, apiBaseUrl, token) => {
+	const iframe = createCheckoutIFrame("tunnel-x", baseUrl, {
+		checkout_token: token,
+		api_base_url: apiBaseUrl
+	});
+	document.body.appendChild(iframe);
+	const connection = connectToTunnelXIframe(iframe, {});
+	const unmount = () => {
+		connection.destroy();
+		document.body.removeChild(iframe);
+	};
+	return {
+		unmount,
+		connection
+	};
+};
+const PaymentKit = ({ baseUrl, apiBaseUrl, secureToken, paymentMethods }) => {
+	console.log(`[PaymentKit] v${version} initialized`);
+	const { connection: tunnelXConnection, unmount: unmountTunnelX } = createTunnelXConnection(baseUrl, apiBaseUrl, secureToken);
+	const paymentKitStates = {
+		baseUrl,
+		apiBaseUrl,
+		secureToken,
+		tunnelXConnection
+	};
+	const pmInstances = paymentMethods.map((paymentMethod) => paymentMethod(paymentKitStates));
+	const externalFuncsMapByPm = pmInstances.reduce((acc, { name, externalFuncs }) => {
+		acc[name] = externalFuncs;
+		return acc;
+	}, {});
+	const submit = ({ paymentMethod: paymentMethodName, fields, options, onSuccess, onError }) => {
+		const paymentMethod = pmInstances.find(({ name }) => name === paymentMethodName);
+		if (!paymentMethod) {
+			onError({ root: "payment_method_not_found" });
+			return;
+		}
+		paymentMethod.internalFuncs.submitPayment(fields, options).then(({ data, errors }) => {
+			errors ? onError(errors) : onSuccess(data);
+		}).catch((e) => {
+			console.error("PaymentKit:submit:catch", e);
+			if (e?.response?.data) onError(e.response.data);
+			else if (e?.message) onError({ root: e.message });
+			else onError({ root: "unknown_error" });
+		});
+	};
+	const cleanup = () => {
+		for (const pm of pmInstances) if (pm.internalFuncs.cleanup) pm.internalFuncs.cleanup();
+		unmountTunnelX();
+	};
+	return {
+		submit,
+		cleanup,
+		...externalFuncsMapByPm
+	};
+};
+var src_default = PaymentKit;
+
+//#endregion
+export { src_default as default };
+//# sourceMappingURL=index.mjs.map

package/dist/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","names":["PaymentKit: PaymentKitType","PACKAGE_VERSION","externalFuncsMapByPm: ExternalFuncsMapByPm<PaymentMethods>","submit: PaymentKitReturnType[\"submit\"]"],"sources":["../package.json","../src/index.ts"],"sourcesContent":["{\n  \"name\": \"@payment-kit-js/vanilla\",\n  \"version\": \"0.1.0-alpha.0\",\n  \"main\": \"./dist/index.mjs\",\n  \"types\": \"./dist/index.d.mts\",\n  \"module\": \"./dist/index.mjs\",\n  \"exports\": {\n    \".\": \"./dist/index.mjs\",\n    \"./payment-methods/card\": \"./dist/payment-methods/card.mjs\",\n    \"./payment-methods/google-pay\": \"./dist/payment-methods/google-pay.mjs\",\n    \"./payment-methods/next-action-handlers\": \"./dist/payment-methods/next-action-handlers.mjs\",\n    \"./payment-methods/paypal\": \"./dist/payment-methods/paypal.mjs\",\n    \"./payment-methods/stripe-google-pay-adapter\": \"./dist/payment-methods/stripe-google-pay-adapter.mjs\",\n    \"./penpal/connect-card\": \"./dist/penpal/connect-card.mjs\",\n    \"./penpal/connect-tunnel-x\": \"./dist/penpal/connect-tunnel-x.mjs\",\n    \"./package.json\": \"./package.json\"\n  },\n  \"license\": \"MIT\",\n  \"description\": \"Vanilla JavaScript SDK for PaymentKit\",\n  \"keywords\": [\n    \"payment\",\n    \"payments\",\n    \"paymentkit\",\n    \"checkout\",\n    \"stripe\",\n    \"paypal\",\n    \"googlepay\",\n    \"card\",\n    \"sdk\"\n  ],\n  \"repository\": {\n    \"type\": \"git\",\n    \"url\": \"https://github.com/ProjectPayAdly/core.git\",\n    \"directory\": \"frontend/payment-kit-js/vanilla\"\n  },\n  \"bugs\": {\n    \"url\": \"https://github.com/ProjectPayAdly/core/issues\"\n  },\n  \"homepage\": \"https://github.com/ProjectPayAdly/core#readme\",\n  \"files\": [\n    \"dist\",\n    \"README.md\"\n  ],\n  \"scripts\": {\n    \"dev\": \"yarn tsdown --watch ./src\",\n    \"build\": \"yarn tsdown\"\n  },\n  \"packageManager\": \"yarn@4.10.3\",\n  \"dependencies\": {\n    \"penpal\": \"^7.0.4\",\n    \"valibot\": \"^1.1.0\"\n  },\n  \"devDependencies\": {\n    \"@pkg/sdk\": \"workspace:*\",\n    \"@pkg/tsconfig\": \"workspace:*\",\n    \"tsdown\": \"^0.15.10\",\n    \"typescript\": \"^5.9.3\"\n  },\n  \"stableVersion\": \"0.1.0\"\n}\n","import { version as PACKAGE_VERSION } from \"../package.json\";\nimport { connectToTunnelXIframe } from \"./penpal/connect-tunnel-x\";\nimport type { ExternalFuncsMapByPm, PaymentKitFields, PaymentKit as PaymentKitType } from \"./types\";\nimport { createCheckoutIFrame } from \"./utils\";\n\ntype PaymentKitReturnType = ReturnType<PaymentKitType>;\n\nconst createTunnelXConnection = (baseUrl: string, apiBaseUrl: string, token: string) => {\n  const iframe = createCheckoutIFrame(\"tunnel-x\", baseUrl, {\n    checkout_token: token,\n    api_base_url: apiBaseUrl,\n  });\n  document.body.appendChild(iframe);\n\n  const connection = connectToTunnelXIframe(iframe, {});\n\n  const unmount = () => {\n    connection.destroy();\n    document.body.removeChild(iframe);\n  };\n\n  return { unmount, connection };\n};\n\nconst PaymentKit: PaymentKitType = ({ baseUrl, apiBaseUrl, secureToken, paymentMethods }) => {\n  type PaymentMethods = typeof paymentMethods;\n\n  // Log version for debugging\n  console.log(`[PaymentKit] v${PACKAGE_VERSION} initialized`);\n\n  const { connection: tunnelXConnection, unmount: unmountTunnelX } = createTunnelXConnection(\n    baseUrl,\n    apiBaseUrl,\n    secureToken,\n  );\n\n  const paymentKitStates = {\n    baseUrl,\n    apiBaseUrl,\n    secureToken,\n    tunnelXConnection,\n  };\n\n  const pmInstances = paymentMethods.map((paymentMethod) => paymentMethod(paymentKitStates));\n\n  const externalFuncsMapByPm: ExternalFuncsMapByPm<PaymentMethods> = pmInstances.reduce(\n    (acc, { name, externalFuncs }) => {\n      // @ts-expect-error - typecase this better in future\n      acc[name] = externalFuncs;\n      return acc;\n    },\n    {} as ExternalFuncsMapByPm<PaymentMethods>,\n  );\n\n  const submit: PaymentKitReturnType[\"submit\"] = ({\n    paymentMethod: paymentMethodName,\n    fields,\n    options,\n    onSuccess,\n    onError,\n  }) => {\n    const paymentMethod = pmInstances.find(({ name }) => name === paymentMethodName);\n    if (!paymentMethod) {\n      onError({ root: \"payment_method_not_found\" });\n      return;\n    }\n    paymentMethod.internalFuncs\n      .submitPayment(fields, options)\n      .then(({ data, errors }) => {\n        errors ? onError(errors) : onSuccess(data);\n      })\n      .catch((e) => {\n        console.error(\"PaymentKit:submit:catch\", e);\n\n        // Try to extract error message from response\n        if (e?.response?.data) {\n          onError(e.response.data);\n        } else if (e?.message) {\n          onError({ root: e.message });\n        } else {\n          onError({ root: \"unknown_error\" });\n        }\n      });\n  };\n\n  const cleanup = () => {\n    // Clean up all payment method instances\n    for (const pm of pmInstances) {\n      if (pm.internalFuncs.cleanup) {\n        pm.internalFuncs.cleanup();\n      }\n    }\n    unmountTunnelX();\n  };\n\n  return {\n    submit,\n    cleanup,\n    ...externalFuncsMapByPm,\n  };\n};\n\nexport type { PaymentKitFields };\n\nexport default PaymentKit;\n"],"mappings":";;;;;cAEa;;;;ACKb,MAAM,2BAA2B,SAAiB,YAAoB,UAAkB;CACtF,MAAM,SAAS,qBAAqB,YAAY,SAAS;EACvD,gBAAgB;EAChB,cAAc;EACf,CAAC;AACF,UAAS,KAAK,YAAY,OAAO;CAEjC,MAAM,aAAa,uBAAuB,QAAQ,EAAE,CAAC;CAErD,MAAM,gBAAgB;AACpB,aAAW,SAAS;AACpB,WAAS,KAAK,YAAY,OAAO;;AAGnC,QAAO;EAAE;EAAS;EAAY;;AAGhC,MAAMA,cAA8B,EAAE,SAAS,YAAY,aAAa,qBAAqB;AAI3F,SAAQ,IAAI,iBAAiBC,QAAgB,cAAc;CAE3D,MAAM,EAAE,YAAY,mBAAmB,SAAS,mBAAmB,wBACjE,SACA,YACA,YACD;CAED,MAAM,mBAAmB;EACvB;EACA;EACA;EACA;EACD;CAED,MAAM,cAAc,eAAe,KAAK,kBAAkB,cAAc,iBAAiB,CAAC;CAE1F,MAAMC,uBAA6D,YAAY,QAC5E,KAAK,EAAE,MAAM,oBAAoB;AAEhC,MAAI,QAAQ;AACZ,SAAO;IAET,EAAE,CACH;CAED,MAAMC,UAA0C,EAC9C,eAAe,mBACf,QACA,SACA,WACA,cACI;EACJ,MAAM,gBAAgB,YAAY,MAAM,EAAE,WAAW,SAAS,kBAAkB;AAChF,MAAI,CAAC,eAAe;AAClB,WAAQ,EAAE,MAAM,4BAA4B,CAAC;AAC7C;;AAEF,gBAAc,cACX,cAAc,QAAQ,QAAQ,CAC9B,MAAM,EAAE,MAAM,aAAa;AAC1B,YAAS,QAAQ,OAAO,GAAG,UAAU,KAAK;IAC1C,CACD,OAAO,MAAM;AACZ,WAAQ,MAAM,2BAA2B,EAAE;AAG3C,OAAI,GAAG,UAAU,KACf,SAAQ,EAAE,SAAS,KAAK;YACf,GAAG,QACZ,SAAQ,EAAE,MAAM,EAAE,SAAS,CAAC;OAE5B,SAAQ,EAAE,MAAM,iBAAiB,CAAC;IAEpC;;CAGN,MAAM,gBAAgB;AAEpB,OAAK,MAAM,MAAM,YACf,KAAI,GAAG,cAAc,QACnB,IAAG,cAAc,SAAS;AAG9B,kBAAgB;;AAGlB,QAAO;EACL;EACA;EACA,GAAG;EACJ;;AAKH,kBAAe"}

package/dist/next-action-handlers-DTsWjUIA.mjs

@@ -0,0 +1,53 @@
+//#region src/payment-methods/next-action-handlers.ts
+const sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+const isStripeJsPresent = () => "Stripe" in window;
+/**
+* Get the Stripe instance from the global window object.
+* Expects Stripe.js to be loaded via HTML script tag.
+* Polls for up to 5 seconds waiting for Stripe to be available.
+*/
+const getLoadedStripe = async (publishableKey) => {
+	for (let i = 0; i < 10; i++) {
+		if (isStripeJsPresent()) break;
+		await sleep(500);
+	}
+	if (!isStripeJsPresent()) throw new Error("Stripe.js not loaded. Add this script tag to your HTML <head>:\n<script src=\"https://js.stripe.com/v3/\"><\/script>");
+	return new window.Stripe(publishableKey);
+};
+/**
+* Handle Stripe 3DS authentication.
+*/
+const handleStripe3ds = async (nextAction) => {
+	console.log("3DS authentication required, loading Stripe...");
+	const { clientSecret, stripePk } = nextAction;
+	const { error: stripeError } = await (await getLoadedStripe(stripePk)).confirmCardPayment(clientSecret);
+	if (stripeError) {
+		console.error("3DS authentication failed:", stripeError);
+		return {
+			success: false,
+			error: stripeError.message || "3DS authentication failed"
+		};
+	}
+	console.log("3DS authentication completed");
+	return { success: true };
+};
+/**
+* Handle a next action based on its type.
+* Routes to the appropriate processor-specific handler.
+*
+* @param nextAction - The next action from the checkout response
+* @returns Result indicating success or failure with error message
+*/
+const handleNextAction = async (nextAction) => {
+	switch (nextAction.type) {
+		case "stripe_3ds": return handleStripe3ds(nextAction);
+		default: return {
+			success: false,
+			error: `Unknown next action type: ${nextAction.type}`
+		};
+	}
+};
+
+//#endregion
+export { handleNextAction as t };
+//# sourceMappingURL=next-action-handlers-DTsWjUIA.mjs.map

package/dist/next-action-handlers-DTsWjUIA.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"next-action-handlers-DTsWjUIA.mjs","names":[],"sources":["../src/payment-methods/next-action-handlers.ts"],"sourcesContent":["/**\n * Next action handlers for processor-specific user actions (e.g., 3DS authentication).\n *\n * This module abstracts processor-specific logic away from the generic card payment flow.\n * Each handler implements the logic needed for a specific next action type.\n */\n\nimport type { PublicCardCheckoutResponse } from \"@pkg/sdk/models\";\nimport type { Stripe } from \"@stripe/stripe-js\";\n\n// Helper to wait for a condition\nconst sleep = (ms: number): Promise<void> => new Promise((resolve) => setTimeout(resolve, ms));\n\n// Check if Stripe.js is loaded via script tag\nconst isStripeJsPresent = (): boolean => \"Stripe\" in window;\n\n/**\n * Get the Stripe instance from the global window object.\n * Expects Stripe.js to be loaded via HTML script tag.\n * Polls for up to 5 seconds waiting for Stripe to be available.\n */\nconst getLoadedStripe = async (publishableKey: string): Promise<Stripe> => {\n  // Poll for Stripe.js to be loaded (up to 5 seconds)\n  for (let i = 0; i < 10; i++) {\n    if (isStripeJsPresent()) {\n      break;\n    }\n    await sleep(500);\n  }\n\n  if (!isStripeJsPresent()) {\n    throw new Error(\n      \"Stripe.js not loaded. Add this script tag to your HTML <head>:\\n\" +\n        '<script src=\"https://js.stripe.com/v3/\"></script>',\n    );\n  }\n\n  // @ts-expect-error Stripe is loaded globally via script tag\n  const stripe: Stripe = new window.Stripe(publishableKey);\n  return stripe;\n};\n\n/**\n * Result of handling a next action.\n */\nexport type NextActionResult = { success: true } | { success: false; error: string };\n\n/**\n * Handle Stripe 3DS authentication.\n */\nconst handleStripe3ds = async (\n  nextAction: Extract<PublicCardCheckoutResponse[\"nextAction\"], { type: \"stripe_3ds\" }>,\n): Promise<NextActionResult> => {\n  console.log(\"3DS authentication required, loading Stripe...\");\n  const { clientSecret, stripePk } = nextAction;\n\n  const stripe = await getLoadedStripe(stripePk);\n\n  // Show 3DS modal\n  const { error: stripeError } = await stripe.confirmCardPayment(clientSecret);\n\n  if (stripeError) {\n    console.error(\"3DS authentication failed:\", stripeError);\n    return { success: false, error: stripeError.message || \"3DS authentication failed\" };\n  }\n\n  console.log(\"3DS authentication completed\");\n  return { success: true };\n};\n\n/**\n * Handle a next action based on its type.\n * Routes to the appropriate processor-specific handler.\n *\n * @param nextAction - The next action from the checkout response\n * @returns Result indicating success or failure with error message\n */\nexport const handleNextAction = async (\n  nextAction: NonNullable<PublicCardCheckoutResponse[\"nextAction\"]>,\n): Promise<NextActionResult> => {\n  switch (nextAction.type) {\n    case \"stripe_3ds\":\n      return handleStripe3ds(nextAction);\n    default:\n      // TypeScript will catch if we miss a case when new action types are added\n      return { success: false, error: `Unknown next action type: ${(nextAction as { type: string }).type}` };\n  }\n};\n"],"mappings":";AAWA,MAAM,SAAS,OAA8B,IAAI,SAAS,YAAY,WAAW,SAAS,GAAG,CAAC;AAG9F,MAAM,0BAAmC,YAAY;;;;;;AAOrD,MAAM,kBAAkB,OAAO,mBAA4C;AAEzE,MAAK,IAAI,IAAI,GAAG,IAAI,IAAI,KAAK;AAC3B,MAAI,mBAAmB,CACrB;AAEF,QAAM,MAAM,IAAI;;AAGlB,KAAI,CAAC,mBAAmB,CACtB,OAAM,IAAI,MACR,uHAED;AAKH,QADuB,IAAI,OAAO,OAAO,eAAe;;;;;AAY1D,MAAM,kBAAkB,OACtB,eAC8B;AAC9B,SAAQ,IAAI,iDAAiD;CAC7D,MAAM,EAAE,cAAc,aAAa;CAKnC,MAAM,EAAE,OAAO,gBAAgB,OAHhB,MAAM,gBAAgB,SAAS,EAGF,mBAAmB,aAAa;AAE5E,KAAI,aAAa;AACf,UAAQ,MAAM,8BAA8B,YAAY;AACxD,SAAO;GAAE,SAAS;GAAO,OAAO,YAAY,WAAW;GAA6B;;AAGtF,SAAQ,IAAI,+BAA+B;AAC3C,QAAO,EAAE,SAAS,MAAM;;;;;;;;;AAU1B,MAAa,mBAAmB,OAC9B,eAC8B;AAC9B,SAAQ,WAAW,MAAnB;EACE,KAAK,aACH,QAAO,gBAAgB,WAAW;EACpC,QAEE,QAAO;GAAE,SAAS;GAAO,OAAO,6BAA8B,WAAgC;GAAQ"}

package/dist/payment-methods/card.d.mts

@@ -0,0 +1,22 @@
+import "../cardsetupintent-D2gBMj3e.mjs";
+import "../connect-tunnel-x-Ce423Pa2.mjs";
+import "../publiccardcheckoutresponse-wxFCeVdO.mjs";
+import { n as CardInputType$1, o as connectToCardIframe, r as CheckoutResponse$1 } from "../connect-card-EaOlRbPS.mjs";
+import { r as PaymentMethod } from "../types-6mOKdjCh.mjs";
+
+//#region src/payment-methods/card.d.ts
+type CardInputType = CardInputType$1;
+type CheckoutResponse = CheckoutResponse$1;
+type CreateElementOptions = Partial<Parameters<typeof connectToCardIframe>[1]> & {
+  style?: Record<string, string>;
+};
+declare const CardPaymentMethod: PaymentMethod<{
+  createElement: (type: CardInputType$1, options: CreateElementOptions) => {
+    mount: (parentSelector: string) => {
+      unmount: () => void;
+    };
+  };
+}, "card">;
+//#endregion
+export { CardInputType, CheckoutResponse, CardPaymentMethod as default };
+//# sourceMappingURL=card.d.mts.map

package/dist/payment-methods/card.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"card.d.mts","names":[],"sources":["../../src/payment-methods/card.ts"],"sourcesContent":[],"mappings":";;;;;;;KAQY,aAAA,GAAgB;KAChB,gBAAA,GAAmB;KAgD1B,oBAAA,GAAuB,QAAQ,kBAAkB;UAC5C;;cA+MJ,mBAzM4D;EAxDtD,aAAA,EAAA,CAAa,IAAA,EAwDT,eAxDY,EAAmB,OAAA,EAwDD,oBAxDC,EAAA,GAAA;IACnC,KAAA,EAAA,CAAA,cAAgB,EAAA,MAAG,EAAA,GAAA;MAgD1B,OAAA,EAAA,GAAA,GAAoB,IAAA;IAA6B,CAAA;EAAlB,CAAA;CAAR,EAAA,MAAA,CAAA"}

package/dist/payment-methods/card.mjs

@@ -0,0 +1,183 @@
+import "../penpal-BFKeZTVz.mjs";
+import { t as TunnelXManager } from "../connect-tunnel-x-BhVAej5Q.mjs";
+import { a as validateFormFields, i as definePaymentMethod, n as collectFraudMetadata, r as createCheckoutIFrame, t as $ } from "../utils-h0dxplHy.mjs";
+import { t as connectToCardIframe } from "../connect-card-DO2EJxu6.mjs";
+import { t as handleNextAction } from "../next-action-handlers-DTsWjUIA.mjs";
+
+//#region src/payment-methods/card.ts
+/**
+* Splits a full name into first name and last name.
+* First word becomes firstName, rest becomes lastName.
+*/
+const splitName = (fullName) => {
+	const trimmed = fullName.trim();
+	const spaceIndex = trimmed.indexOf(" ");
+	if (spaceIndex === -1) return { firstName: trimmed };
+	return {
+		firstName: trimmed.substring(0, spaceIndex),
+		lastName: trimmed.substring(spaceIndex + 1).trim() || void 0
+	};
+};
+/**
+* Maps PaymentKitFields to the customerInfo structure expected by the API.
+*/
+const mapFieldsToCustomerInfo = (fields) => {
+	const { firstName, lastName } = splitName(fields.customer_name);
+	return {
+		email: fields.customer_email || void 0,
+		firstName,
+		lastName,
+		billingAddress: fields.customer_country || fields.customer_zip_code ? {
+			country: fields.customer_country || void 0,
+			zipCode: fields.customer_zip_code || void 0
+		} : void 0
+	};
+};
+const defCreateElement = (states) => {
+	const { baseUrl, apiBaseUrl, cardInputConnections, secureToken } = states;
+	return (type, options) => {
+		const { style, onLoaded, onFocusChange } = options;
+		const mountIFrame = (parentSelector) => {
+			const parent = $(parentSelector);
+			const params = {
+				checkout_token: secureToken,
+				api_base_url: apiBaseUrl
+			};
+			if (style) params.style = JSON.stringify(style);
+			const iframe = createCheckoutIFrame(type.replace("_", "-"), baseUrl, params);
+			parent.appendChild(iframe);
+			iframe.onload = () => {
+				const connection = connectToCardIframe(iframe, {
+					onLoaded: onLoaded || (() => {}),
+					onFocusChange: onFocusChange || (() => {})
+				});
+				states.cardInputConnections[type] = connection;
+			};
+			const unmount = () => {
+				cardInputConnections[type]?.destroy();
+				parent.removeChild(iframe);
+				states.cardInputConnections[type] = void 0;
+			};
+			return { unmount };
+		};
+		return { mount: mountIFrame };
+	};
+};
+const defSubmitPayment = (states) => {
+	const submitPayment = async (fields) => {
+		const tunnelX = await TunnelXManager.createFromPenpalConnection(states.tunnelXConnection);
+		const validateCardResult = await validateCardFields(states);
+		const validateFormResult = await validateFormFields(fields);
+		if (!(validateCardResult.isSuccess && validateFormResult.isSuccess)) return { errors: {
+			...validateCardResult.errors,
+			...validateFormResult.errors
+		} };
+		if (!states.cardSetupIntentId) states.cardSetupIntentId = (await tunnelX.publicEndpoints.createCardSetupIntent({ checkoutToken: states.secureToken })).cardSetupIntentId;
+		const submitCardResult = await submitCardFields(states);
+		if (!submitCardResult.isSuccess) return { errors: submitCardResult.errors };
+		const cardSetupIntent = await tunnelX.publicEndpoints.getCardSetupIntent({
+			cardSetupIntentId: states.cardSetupIntentId,
+			checkoutToken: states.secureToken
+		});
+		if (!cardSetupIntent.isCardAllSet) {
+			const errors = {};
+			if (!cardSetupIntent.isCardPanSet) errors.card_pan = "required";
+			if (!cardSetupIntent.isCardExpSet) errors.card_exp = "required";
+			if (!cardSetupIntent.isCardCvcSet) errors.card_cvc = "required";
+			return { errors };
+		}
+		console.log("Card setup intent is set ✅", cardSetupIntent);
+		console.log("Fields", fields);
+		let currentResult = await tunnelX.publicEndpoints.cardCheckout({
+			checkoutToken: states.secureToken,
+			publicCardCheckoutRequest: {
+				cardSetupIntentId: states.cardSetupIntentId,
+				customerInfo: mapFieldsToCustomerInfo(fields),
+				fraudMetadata: collectFraudMetadata()
+			}
+		});
+		console.log("Card checkout result:", currentResult);
+		const MAX_USER_ACTIONS = 5;
+		let userActionCount = 0;
+		while (currentResult.nextAction && userActionCount < MAX_USER_ACTIONS) {
+			userActionCount++;
+			console.log(`Handling user action ${userActionCount}/${MAX_USER_ACTIONS}...`);
+			const actionResult = await handleNextAction(currentResult.nextAction);
+			console.log("User action completed, verifying checkout...");
+			const verifyResult = await tunnelX.publicEndpoints.cardCheckoutVerify({ checkoutToken: states.secureToken });
+			if (verifyResult.nextAction) {
+				if (!actionResult.success) console.log("3DS failed but cascade triggered new action, continuing loop...");
+				else console.log("Another user action required, continuing loop...");
+				currentResult = verifyResult;
+				continue;
+			}
+			if (!actionResult.success) {
+				console.log("3DS authentication failed, checkout concluded:", verifyResult);
+				return { errors: { root: actionResult.error } };
+			}
+			console.log("Card checkout verified ✅", verifyResult);
+			return { data: verifyResult };
+		}
+		if (userActionCount >= MAX_USER_ACTIONS) {
+			console.error("Max user actions exceeded");
+			return { errors: { root: "Too many authentication attempts. Please try again." } };
+		}
+		console.log("Card checkout completed ✅", currentResult);
+		return { data: currentResult };
+	};
+	return submitPayment;
+};
+const submitCardFields = async (states) => {
+	const errors = {};
+	const { cardSetupIntentId, cardInputConnections } = states;
+	const submitPromises = Object.entries(cardInputConnections).map(async ([_type, connection]) => {
+		const type = _type;
+		const result = await (await connection.promise).onSubmit(cardSetupIntentId || "");
+		if ("error" in result) errors[type] = result.error;
+	});
+	await Promise.allSettled(submitPromises);
+	return {
+		errors,
+		isSuccess: Object.keys(errors).length === 0
+	};
+};
+const validateCardFields = async (states) => {
+	const errors = {};
+	const { cardInputConnections } = states;
+	const validatePromises = Object.entries(cardInputConnections).map(async ([_type, connection]) => {
+		const type = _type;
+		if (!connection) {
+			errors[type] = "penpal_not_connected";
+			return;
+		}
+		const errorMsg = await (await connection.promise).onValidate();
+		if (errorMsg) errors[type] = errorMsg;
+	});
+	await Promise.allSettled(validatePromises);
+	return {
+		errors,
+		isSuccess: Object.keys(errors).length === 0
+	};
+};
+const CardPaymentMethod = definePaymentMethod((paymentKitStates) => {
+	const localStates = {
+		...paymentKitStates,
+		cardInputConnections: {}
+	};
+	return {
+		name: "card",
+		externalFuncs: { createElement: defCreateElement(localStates) },
+		internalFuncs: {
+			submitPayment: defSubmitPayment(localStates),
+			cleanup: () => {
+				for (const connection of Object.values(localStates.cardInputConnections)) connection?.destroy();
+				localStates.cardInputConnections = {};
+			}
+		}
+	};
+});
+var card_default = CardPaymentMethod;
+
+//#endregion
+export { card_default as default };
+//# sourceMappingURL=card.mjs.map