@portone/browser-sdk 0.0.2 → 0.0.3

package/dist/{types/v2 → v2}/entity/EasyPayProvider.d.ts

@@ -16,5 +16,6 @@ export declare const EasyPayProvider: {
     readonly NAVERPAY_POINT: "EASY_PAY_PROVIDER_NAVERPAY_POINT";
     readonly SSGPAY_POINT: "EASY_PAY_PROVIDER_SSGPAY_POINT";
     readonly SSGPAY_BANK: "EASY_PAY_PROVIDER_SSGPAY_BANK";
+    readonly TOSS_BRANDPAY: "EASY_PAY_PROVIDER_TOSS_BRANDPAY";
 };
 export type EasyPayProvider = typeof EasyPayProvider[keyof typeof EasyPayProvider];

package/dist/{types/v2/entity/bypass/payment/TosspaymentsBrandpay.d.ts → v2/entity/bypass/payment/TossBrandpay.d.ts}

@@ -2,11 +2,19 @@
  * 정규화가 어려운 토스페이먼츠 브랜드페이 bypass 파라미터
  * 가맹점으로부터 전달 된 값을 PG사로 그대로 전달
  */
-export type TosspaymentsBrandpayPaymentBypass = {
+export type TossBrandpayPaymentBypass = {
+    brandpayOptions?: {
+        ui?: BrandpayUi;
+    };
+    widgetOptions?: {
+        methodType?: '카드' | '계좌';
+        methodId?: string;
+        ui?: BrandpayWidgetUi;
+    };
     discountCode?: string;
-    ui?: Ui;
+    methodId?: string;
 };
-type Ui = {
+type BrandpayUi = {
     highlightColor?: string;
     /**
      * 버튼 스타일
@@ -24,4 +32,15 @@ type NavigationBar = {
     visible?: boolean;
     paddingTop?: number;
 };
+type BrandpayWidgetUi = {
+    promotionSection?: {
+        summary?: {
+            visible?: boolean;
+        };
+        description?: {
+            visible?: boolean;
+            defaultOpen?: boolean;
+        };
+    };
+};
 export {};

package/dist/{types/v2 → v2}/entity/bypass/payment/index.d.ts

@@ -5,7 +5,7 @@ import { KakaopayPaymentBypass } from './Kakaopay.js';
 import { SmartroV2PaymentBypass } from './SmartroV2.js';
 import { NaverpayPaymentBypass } from './Naverpay.js';
 import { NiceV2PaymentBypass } from './NiceV2.js';
-import { TosspaymentsBrandpayPaymentBypass } from './TosspaymentsBrandpay.js';
+import { TossBrandpayPaymentBypass } from './TossBrandpay.js';
 export type PaymentBypass = {
     tosspayments?: TosspaymentsPaymentBypass;
     ksnet?: KsnetPaymentBypass;
@@ -14,5 +14,5 @@ export type PaymentBypass = {
     smartro_v2?: SmartroV2PaymentBypass;
     naverpay?: NaverpayPaymentBypass;
     nice_v2?: NiceV2PaymentBypass;
-    tosspayments_brandpay?: TosspaymentsBrandpayPaymentBypass;
+    toss_brandpay?: TossBrandpayPaymentBypass;
 };

package/dist/v2/exception/CheckoutServiceErrorCode.d.ts

@@ -0,0 +1 @@
+export type CheckoutServiceErrorCode = 'BadRequest' | 'ParseChannelFailed' | 'ParseIdentityVerificationPrepareResponseFailed' | 'ParseIssuePrepareResponseFailed' | 'ParsePgRawIdentityVerificationResponseFailed' | 'ParsePgRawIssueBillingKeyResponseFailed' | 'ParsePgRawResponseFailed' | 'ParsePrepareResponseFailed';

package/dist/v2/exception/ModuleError.d.ts

@@ -0,0 +1,14 @@
+import { CheckoutServiceErrorCode } from './CheckoutServiceErrorCode.js';
+import { GrpcErrorCode } from './GrpcErrorCode.js';
+import { PortOneError } from './index.js';
+export type ModuleErrorCode = CheckoutServiceErrorCode | GrpcErrorCode;
+export declare function isModuleError(error: unknown): error is ModuleError;
+export declare class ModuleError extends Error implements PortOneError {
+    __portOneErrorType: string;
+    code: ModuleErrorCode;
+    message: string;
+    constructor({ code, message }: {
+        code: ModuleErrorCode;
+        message: string;
+    });
+}

package/dist/{types/v2 → v2}/exception/index.d.ts

@@ -4,4 +4,5 @@ export interface PortOneError extends Error {
 export declare function isPortOneError(error: unknown): error is PortOneError;
 export * from './IdentityVerificationError.js';
 export * from './IssueBillingKeyError.js';
+export * from './ModuleError.js';
 export * from './PaymentError.js';

package/dist/v2/index.d.ts

@@ -0,0 +1,15 @@
+import { requestPayment } from './requestPayment.js';
+import { requestIssueBillingKey } from './requestIssueBillingKey.js';
+import { requestIdentityVerification } from './requestIdentityVerification.js';
+declare const PortOne: {
+    requestPayment: typeof requestPayment;
+    requestIssueBillingKey: typeof requestIssueBillingKey;
+    requestIdentityVerification: typeof requestIdentityVerification;
+};
+export { setPortOneJsSdkUrl as __INTERNAL__setPortOneSdkUrl } from './loader.js';
+export { requestPayment, type PaymentRequest, type PaymentResponse, } from './requestPayment.js';
+export { requestIssueBillingKey, type IssueBillingKeyRequest, type IssueBillingKeyResponse, } from './requestIssueBillingKey.js';
+export { requestIdentityVerification, type IdentityVerificationRequest, type IdentityVerificationResponse, } from './requestIdentityVerification.js';
+export * as Entity from './entity/index.js';
+export * from './exception/index.js';
+export default PortOne;

package/dist/v2/loader.d.ts

@@ -0,0 +1,16 @@
+import type { PaymentRequest, PaymentResponse } from './requestPayment.js';
+import type { IssueBillingKeyRequest, IssueBillingKeyResponse } from './requestIssueBillingKey.js';
+import type { IdentityVerificationRequest, IdentityVerificationResponse } from './requestIdentityVerification.js';
+declare global {
+    interface Window {
+        PortOne: PortOne | undefined;
+    }
+}
+interface PortOne {
+    requestPayment(request: PaymentRequest): Promise<PaymentResponse>;
+    requestIssueBillingKey(request: IssueBillingKeyRequest): Promise<IssueBillingKeyResponse>;
+    requestIdentityVerification(request: IdentityVerificationRequest): Promise<IdentityVerificationResponse>;
+}
+export declare function loadScript(): Promise<PortOne>;
+export declare function setPortOneJsSdkUrl(url: string): string;
+export {};

package/dist/v2/requestIdentityVerification.d.ts

@@ -0,0 +1,25 @@
+import { Entity } from './index.js';
+export declare function requestIdentityVerification(request: IdentityVerificationRequest): Promise<IdentityVerificationResponse | undefined>;
+export type IdentityVerificationRequest = {
+    storeId: string;
+    identityVerificationId: string;
+    channelKey?: string;
+    pgProvider?: Entity.PgProvider;
+    isTestChannel?: boolean;
+    customer?: Entity.Customer;
+    windowType?: Entity.WindowTypes;
+    redirectUrl?: string;
+    customData?: string;
+    bypass?: Entity.IdentityVerificationBypass;
+};
+/**
+ * iframe/popup 방식으로 PG사 창이 렌더링 된 경우
+ * 프로세스 종료 후, 콜백 함수로 전달 될 본인인증 정보 데이터
+ */
+export type IdentityVerificationResponse = {
+    transactionType: typeof Entity.TransactionType.IDENTITY_VERIFICATION;
+    identityVerificationId?: string;
+    identityVerificationTxId: string;
+    code?: string;
+    message?: string;
+};

package/dist/{types/v2/request/IssueBillingKey.d.ts → v2/requestIssueBillingKey.d.ts}

@@ -1,11 +1,7 @@
-import { CapsToCamel } from '../../utils.js';
-import { Entity } from '../index.js';
-type BillingKeyMethodOptions<Method extends Entity.BillingKeyMethod, T> = {
-    billingKeyMethod: Method;
-} & {
-    [K in Method as CapsToCamel<K>]?: T;
-};
-type IssueBillingKeyRequest = {
+import { CapsToCamel } from '../utils.js';
+import { Entity } from './index.js';
+export declare function requestIssueBillingKey(request: IssueBillingKeyRequest): Promise<IssueBillingKeyResponse | undefined>;
+export type IssueBillingKeyRequest = {
     displayAmount?: number;
     currency?: Entity.Currency;
     storeId: string;
@@ -25,6 +21,21 @@ type IssueBillingKeyRequest = {
     noticeUrls?: string[];
     bypass?: Entity.IssueBillingKeyBypass;
 } & (BillingKeyMethodOptions<'CARD', Card> | BillingKeyMethodOptions<'MOBILE', Mobile> | BillingKeyMethodOptions<'EASY_PAY', EasyPay> | BillingKeyMethodOptions<'PAYPAL', Paypal>);
+/**
+ * iframe/popup 방식으로 PG사 창이 렌더링 된 경우
+ * 프로세스 종료 후, 콜백 함수로 전달 될 빌링키 발급 정보 데이터
+ */
+export type IssueBillingKeyResponse = {
+    transactionType: typeof Entity.TransactionType.ISSUE_BILLING_KEY;
+    billingKey?: string;
+    code?: string;
+    message?: string;
+};
+type BillingKeyMethodOptions<Method extends Entity.BillingKeyMethod, T> = {
+    billingKeyMethod: Method;
+} & {
+    [K in Method as CapsToCamel<K>]?: T;
+};
 type Card = {
     cardCompany?: Entity.CardCompany;
 };
@@ -35,4 +46,4 @@ type Mobile = {
     carrier?: Entity.Carrier;
 };
 type Paypal = Record<string, never>;
-export default IssueBillingKeyRequest;
+export {};

package/dist/{types/v2/request/Payment.d.ts → v2/requestPayment.d.ts}

@@ -1,11 +1,7 @@
-import { CapsToCamel, OneOfType } from '../../utils.js';
-import { Entity } from '../index.js';
-type PayMethodOptions<Method extends Entity.PayMethod, T> = {
-    payMethod: Method;
-} & {
-    [K in Method as CapsToCamel<K>]?: T;
-};
-type PaymentRequest = {
+import { CapsToCamel, OneOfType } from '../utils.js';
+import { Entity } from './index.js';
+export declare function requestPayment(request: PaymentRequest): Promise<PaymentResponse | undefined>;
+export type PaymentRequest = {
     storeId: string;
     paymentId: string;
     orderName: string;
@@ -34,6 +30,22 @@ type PaymentRequest = {
     country?: Entity.Country;
     shippingAddress?: Entity.Address;
 } & (PayMethodOptions<'CARD', Card> | PayMethodOptions<'VIRTUAL_ACCOUNT', VirtualAccount> | PayMethodOptions<'TRANSFER', Transfer> | PayMethodOptions<'MOBILE', Mobile> | PayMethodOptions<'GIFT_CERTIFICATE', GiftCertificate> | PayMethodOptions<'EASY_PAY', EasyPay> | PayMethodOptions<'PAYPAL', Paypal>);
+/**
+ * iframe/popup 방식으로 PG사 창이 렌더링 된 경우
+ * 프로세스 종료 후, 콜백 함수로 전달 될 결제 정보 데이터
+ */
+export type PaymentResponse = {
+    transactionType: typeof Entity.TransactionType.PAYMENT;
+    txId: string;
+    paymentId?: string;
+    code?: string;
+    message?: string;
+};
+type PayMethodOptions<Method extends Entity.PayMethod, T> = {
+    payMethod: Method;
+} & {
+    [K in Method as CapsToCamel<K>]?: T;
+};
 type Card = {
     cardCompany?: Entity.CardCompany;
     installment?: Entity.Installment;
@@ -76,4 +88,4 @@ type EasyPay = {
     useCardPoint?: boolean;
 };
 type Paypal = Record<string, never>;
-export default PaymentRequest;
+export {};

package/dist/{chunk-f7332846.js → v2.cjs}

@@ -1,4 +1,68 @@
-import { T as TransactionType } from './chunk-ced8f127.js';
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+var _a;
+let promise = null;
+const portone = {
+    jsSdkUrl: (_a = undefined) !== null && _a !== void 0 ? _a : 'https://cdn.portone.io/v2/browser-sdk.js',
+};
+function findScript() {
+    return document.querySelector(`script[src="${portone.jsSdkUrl}"]`);
+}
+function injectScript() {
+    const script = document.createElement('script');
+    script.src = portone.jsSdkUrl;
+    const headOrBody = document.head || document.body;
+    if (!headOrBody)
+        throw new Error('[PortOne] Expected document.body not to be null');
+    return headOrBody.appendChild(script);
+}
+function loadScript() {
+    if (promise != null) {
+        // SDK is already loaded
+        return promise;
+    }
+    return (promise = new Promise((resolve, reject) => {
+        if (window.PortOne) {
+            // window.PortOne is already injected by CDN
+            return resolve(window.PortOne);
+        }
+        try {
+            // window.PortOne will be injected by @portone/browser-sdk
+            const script = findScript() || injectScript();
+            script.addEventListener('load', () => {
+                // script has just loaded
+                if (window.PortOne) {
+                    // window.PortOne is successfully injected @portone/browser-sdk
+                    return resolve(window.PortOne);
+                }
+                reject(new Error('[PortOne] Failed to load window.PortOne'));
+            });
+            script.addEventListener('error', () => {
+                reject(new Error('[PortOne] Failed to load window.PortOne'));
+            });
+        }
+        catch (error) {
+            return reject(error);
+        }
+    }));
+}
+function setPortOneJsSdkUrl(url) {
+    return (portone.jsSdkUrl = url);
+}
+
+function requestPayment(request) {
+    return loadScript().then((sdk) => sdk.requestPayment(request));
+}
+
+function requestIssueBillingKey(request) {
+    return loadScript().then((sdk) => sdk.requestIssueBillingKey(request));
+}
+
+function requestIdentityVerification(request) {
+    return loadScript().then((sdk) => sdk.requestIdentityVerification(request));
+}
 
 // 계좌이체, 가상계좌 발급시 사용되는 은행 코드
 const Bank = {
@@ -590,6 +654,7 @@ const EasyPayProvider = {
     NAVERPAY_POINT: 'EASY_PAY_PROVIDER_NAVERPAY_POINT',
     SSGPAY_POINT: 'EASY_PAY_PROVIDER_SSGPAY_POINT',
     SSGPAY_BANK: 'EASY_PAY_PROVIDER_SSGPAY_BANK',
+    TOSS_BRANDPAY: 'EASY_PAY_PROVIDER_TOSS_BRANDPAY',
 };
 
 // 구매자 성별
@@ -659,6 +724,18 @@ const PgProvider = {
     TOSS_BRANDPAY: 'PG_PROVIDER_TOSS_BRANDPAY',
 };
 
+/**
+ * 트랜잭션 유형
+ * - PAYMENT: 결제
+ * - ISSUE_BILLING_KEY: 빌링키 발급
+ * - IDENTITY_VERIFICATION: 본인 인증
+ */
+const TransactionType = {
+    PAYMENT: 'PAYMENT',
+    ISSUE_BILLING_KEY: 'ISSUE_BILLING_KEY',
+    IDENTITY_VERIFICATION: 'IDENTITY_VERIFICATION',
+};
+
 /**
  * PG사 창 렌더링 방식
  * PG사나 결제 환경에 따라 허용되는 창 종류가 다름
@@ -687,4 +764,88 @@ var index = /*#__PURE__*/Object.freeze({
     WindowType: WindowType
 });
 
-export { Bank as B, CardCompany as C, EasyPayProvider as E, Gender as G, Locale as L, PgProvider as P, WindowType as W, BillingKeyMethod as a, Carrier as b, Country as c, Currency as d, GiftCertificateType as e, index as i };
+function isIdentityVerificationError(error) {
+    return (isPortOneError(error) &&
+        error.__portOneErrorType === 'IdentityVerificationError');
+}
+class IdentityVerificationError extends Error {
+    constructor({ code, message, identityVerificationId, identityVerificationTxId, }) {
+        super(message);
+        this.__portOneErrorType = 'IdentityVerificationError';
+        this.transactionType = TransactionType.IDENTITY_VERIFICATION;
+        this.code = code;
+        this.message = message;
+        this.identityVerificationId = identityVerificationId;
+        this.identityVerificationTxId = identityVerificationTxId;
+    }
+}
+
+function isIssueBillingKeyError(error) {
+    return (isPortOneError(error) && error.__portOneErrorType === 'IssueBillingKeyError');
+}
+class IssueBillingKeyError extends Error {
+    constructor({ code, message, billingKey, }) {
+        super(message);
+        this.__portOneErrorType = 'IssueBillingKeyError';
+        this.transactionType = TransactionType.ISSUE_BILLING_KEY;
+        this.code = code;
+        this.message = message;
+        this.billingKey = billingKey;
+    }
+}
+
+function isModuleError(error) {
+    return isPortOneError(error) && error.__portOneErrorType === 'ModuleError';
+}
+class ModuleError extends Error {
+    constructor({ code, message }) {
+        super(message);
+        this.__portOneErrorType = 'ModuleError';
+        this.code = code;
+        this.message = message;
+    }
+}
+
+function isPaymentError(error) {
+    return isPortOneError(error) && error.__portOneErrorType === 'PaymentError';
+}
+class PaymentError extends Error {
+    constructor({ code, message, txId, paymentId, }) {
+        super(message);
+        this.__portOneErrorType = 'PaymentError';
+        this.transactionType = TransactionType.PAYMENT;
+        this.code = code;
+        this.message = message;
+        this.txId = txId;
+        this.paymentId = paymentId;
+    }
+}
+
+function isPortOneError(error) {
+    return (error != null &&
+        typeof error === 'object' &&
+        '__portOneErrorType' in error &&
+        typeof error.__portOneErrorType === 'string');
+}
+
+const PortOne = {
+    requestPayment,
+    requestIssueBillingKey,
+    requestIdentityVerification,
+};
+
+exports.Entity = index;
+exports.IdentityVerificationError = IdentityVerificationError;
+exports.IssueBillingKeyError = IssueBillingKeyError;
+exports.ModuleError = ModuleError;
+exports.PaymentError = PaymentError;
+exports.__INTERNAL__setPortOneSdkUrl = setPortOneJsSdkUrl;
+exports.default = PortOne;
+exports.isIdentityVerificationError = isIdentityVerificationError;
+exports.isIssueBillingKeyError = isIssueBillingKeyError;
+exports.isModuleError = isModuleError;
+exports.isPaymentError = isPaymentError;
+exports.isPortOneError = isPortOneError;
+exports.requestIdentityVerification = requestIdentityVerification;
+exports.requestIssueBillingKey = requestIssueBillingKey;
+exports.requestPayment = requestPayment;