@xsolla/payment-client-core 0.0.3 → 0.0.5

package/lib/core/payment/status/status.interface.d.ts

@@ -0,0 +1,63 @@
+import { FinanceInfoField } from './finance-info-field.interface';
+import { LineItem } from './line-item.interface';
+import { StatusEnum } from './status.enum';
+import { TitleClass } from './title-class.enum';
+import { WebSocketClientType } from './web-socket-client-type.enum';
+export interface Status {
+    postMessageStatus: string;
+    virtualCurrencyAmount: number;
+    statusState: StatusEnum;
+    email: string;
+    webSocketUrl: string;
+    webSocketChannelName: string;
+    webSocketClientType: WebSocketClientType;
+    financeInfo: {
+        [key: string]: FinanceInfoField;
+    };
+    isCancelUser: boolean;
+    backUrlSettings: {
+        backUrl: string;
+        backUrlAction?: string;
+        backUrlCaption: string;
+        returnRegion: string;
+        showBackButton?: boolean;
+    };
+    additionalBackButton: {
+        link: string;
+        action: string;
+        label: string;
+        region: string;
+        isEnabled: boolean;
+    };
+    group: string;
+    needToCheck: boolean;
+    autoRedirect?: {
+        time: number;
+    };
+    userReturnStatus?: string;
+    statusMessage: string;
+    discount: number | null;
+    userId?: string;
+    invoice?: number;
+    pid?: number;
+    projectAmount?: {
+        amount: string;
+        currency: string;
+    };
+    titleClass: TitleClass;
+    isSuccess?: boolean;
+    isCanceled?: boolean;
+    babkaLink: string;
+    paymentCountryIso: string;
+    order?: {
+        lineitems?: LineItem[];
+        shipping?: {
+            currency: string;
+            amount: number;
+        };
+        contained_taxes?: {
+            sales_tax?: boolean;
+            user_vat?: boolean;
+        };
+    };
+}

package/lib/core/payment/status/title-class.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum TitleClass {
+    done = "done",
+    cancel = "cancel",
+    cancelUser = "canceluser"
+}

package/lib/core/payment/status/web-socket-client-type.enum.d.ts

@@ -0,0 +1,4 @@
+export declare enum WebSocketClientType {
+    nchan = "nchan",
+    centrifugo = "centrifugo"
+}

package/lib/core/payment/submit/request/submit-request.class.d.ts

@@ -0,0 +1,13 @@
+import { Field } from '../../field.interface';
+import { UntypedFormGroup } from '@angular/forms';
+import { XpsApiPartRequest } from '../../xps-api-part-request.abstract';
+export declare class SubmitRequest extends XpsApiPartRequest {
+    readonly access_token: string;
+    readonly xps_dfp_hash?: string;
+    constructor(parameters: {
+        token: string | null;
+        fields: Field[];
+        form: UntypedFormGroup;
+        dfpHash: string | null;
+    });
+}

package/lib/core/payment/submit/request/submit-request.token.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { SubmitRequest } from './submit-request.class';
+export type SubmitRequestParameters = ConstructorParameters<typeof SubmitRequest>;
+export type SubmitRequestFactory = (...args: SubmitRequestParameters) => SubmitRequest;
+export declare const submitRequestFactoryToken: InjectionToken<SubmitRequestFactory>;
+export declare const submitRequestFactoryProvider: ValueProvider;

package/lib/core/payment/submit/response/submit-response.class.d.ts

@@ -0,0 +1,26 @@
+import { XpsResponse } from '../../xps-response.interface';
+import { Field } from '../../field.interface';
+import { Invoice } from '../../invoice.interface';
+import { XpsCommand } from '../../xps-comand.enum';
+export declare class SubmitResponse {
+    readonly responseNumber: number;
+    readonly parameters: XpsResponse;
+    readonly fields: Field[];
+    onlineBanking?: {
+        url: string;
+    };
+    readonly data?: unknown;
+    isNeedRedirect: boolean;
+    buyData: XpsResponse['buyData'];
+    signature?: string;
+    fixInvoice?: string;
+    hasFatalErrors?: boolean;
+    userSession?: Invoice;
+    pid: XpsResponse['pid'];
+    errors: XpsResponse['errors'];
+    summary: XpsResponse['summary'];
+    title: string;
+    currentCommand: XpsCommand | null;
+    messages: XpsResponse['messages'];
+    constructor(parameters: XpsResponse, responseNumber?: number);
+}

package/lib/core/payment/submit/response/submit-response.token.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { SubmitResponse } from './submit-response.class';
+export type SubmitResponseParameters = ConstructorParameters<typeof SubmitResponse>;
+export type SubmitResponseFactory = (...args: SubmitResponseParameters) => SubmitResponse;
+export declare const submitResponseFactoryToken: InjectionToken<SubmitResponseFactory>;
+export declare const submitResponseFactoryProvider: ValueProvider;

package/lib/core/payment/submit/submit.service.d.ts

@@ -0,0 +1,21 @@
+import { Field } from '../field.interface';
+import { SubmitRequestFactory } from './request/submit-request.token';
+import { SubmitResponseFactory } from './response/submit-response.token';
+import { SettingsService } from '../../settings/settings.service';
+import { SubmitResponse } from './response/submit-response.class';
+import { UntypedFormGroup } from '@angular/forms';
+import { DeviceFingerPrintService } from '../../device-finger-print/device-finger-print.service';
+import { SecureApiClient } from '../../http/secure-api/secure-api.service';
+import * as i0 from "@angular/core";
+export declare class SubmitService {
+    private readonly requestFactory;
+    private readonly responseFactory;
+    private readonly settingsService;
+    private readonly deviceFingerPrintService;
+    private readonly secureApi;
+    private readonly directPaymentApiRoute;
+    constructor(requestFactory: SubmitRequestFactory, responseFactory: SubmitResponseFactory, settingsService: SettingsService, deviceFingerPrintService: DeviceFingerPrintService, secureApi: SecureApiClient);
+    request(fields: Field[], form: UntypedFormGroup): Promise<SubmitResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SubmitService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SubmitService>;
+}

package/lib/core/payment/sync/field-sync-state.interface.d.ts

@@ -0,0 +1,5 @@
+import { ValidationErrors } from '@angular/forms';
+export interface FieldSyncState {
+    value: unknown;
+    result: Promise<ValidationErrors | null>;
+}

package/lib/core/payment/sync/sync-request.class.d.ts

@@ -0,0 +1,15 @@
+import { UntypedFormGroup } from '@angular/forms';
+import { Field } from '../field.interface';
+import { XpsRequest } from '../xps-request.abstract';
+export declare class SyncRequest extends XpsRequest {
+    readonly access_token: string;
+    readonly xps_fix_command = "calculate";
+    constructor(parameters: {
+        token: string;
+        changedField: Field;
+        fields: Field[];
+        form: UntypedFormGroup;
+    });
+    private getFieldsValues;
+    private getFieldsMap;
+}

package/lib/core/payment/sync/sync-request.token.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { SyncRequest } from './sync-request.class';
+export type SyncRequestParameters = ConstructorParameters<typeof SyncRequest>;
+export type SyncRequestFactory = (...args: SyncRequestParameters) => SyncRequest;
+export declare const syncRequestFactoryToken: InjectionToken<SyncRequestFactory>;
+export declare const syncRequestFactoryProvider: ValueProvider;

package/lib/core/payment/sync/sync-response.class.d.ts

@@ -0,0 +1,11 @@
+import { Field } from '../field.interface';
+import { XpsResponse } from '../xps-response.interface';
+export declare class SyncResponse {
+    readonly rewritableError?: {
+        code: number;
+        message: string;
+    };
+    readonly fields: Field[];
+    readonly parameters: XpsResponse;
+    constructor(changedField: Field, response: XpsResponse);
+}

package/lib/core/payment/sync/sync-response.token.d.ts

@@ -0,0 +1,6 @@
+import { InjectionToken, ValueProvider } from '@angular/core';
+import { SyncResponse } from './sync-response.class';
+export type SyncResponseParameters = ConstructorParameters<typeof SyncResponse>;
+export type SyncResponseFactory = (...args: SyncResponseParameters) => SyncResponse;
+export declare const syncResponseFactoryToken: InjectionToken<SyncResponseFactory>;
+export declare const syncResponseFactoryProvider: ValueProvider;

package/lib/core/payment/sync/sync.service.d.ts

@@ -0,0 +1,27 @@
+import { UntypedFormGroup, ValidationErrors } from '@angular/forms';
+import { SecureApiClient } from '../../http/secure-api/secure-api.service';
+import { SettingsService } from '../../settings/settings.service';
+import { Field } from '../field.interface';
+import { SyncRequestFactory } from './sync-request.token';
+import { SyncResponseFactory } from './sync-response.token';
+import * as i0 from "@angular/core";
+export declare class SyncService {
+    private readonly requestFactory;
+    private readonly responseFactory;
+    private readonly secureApi;
+    private readonly settingsService;
+    private readonly apiRoute;
+    private prevFieldSyncStates;
+    private form;
+    private fields;
+    constructor(requestFactory: SyncRequestFactory, responseFactory: SyncResponseFactory, secureApi: SecureApiClient, settingsService: SettingsService);
+    setup(form: UntypedFormGroup, fields: Field[]): void;
+    reset(): void;
+    validate(field: Field): Promise<ValidationErrors | null>;
+    private request;
+    private isReadyField;
+    private getPrevFieldSyncState;
+    private setPrevFieldSyncState;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SyncService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SyncService>;
+}

package/lib/core/payment/virtual-currency.interface.d.ts

@@ -0,0 +1,10 @@
+export interface VirtualCurrency {
+    quantity: number;
+    amount: number | null;
+    name: string;
+    image_url: string;
+    description: string;
+    longDescription: string | null;
+    is_bonus: boolean;
+    currency: string;
+}

package/lib/core/payment/xps-api-part-request.abstract.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class XpsApiPartRequest {
+    [fieldName: `xps_${string}`]: unknown;
+    protected addXpsParameters(parameters: {
+        [key: string]: unknown;
+    }): void;
+}

package/lib/core/payment/xps-comand.enum.d.ts

@@ -0,0 +1,8 @@
+export declare enum XpsCommand {
+    form = "form",
+    check = "check",
+    status = "status",
+    checkout = "checkout",
+    account = "account",
+    create = "create"
+}

package/lib/core/payment/xps-error.interface.d.ts

@@ -0,0 +1,7 @@
+import { PaymentMethodApi } from '../payment-methods/payment-method-api.interface';
+export interface XpsError {
+    code: number;
+    message: string;
+    element_name?: string;
+    alternative_instances?: PaymentMethodApi[];
+}

package/lib/core/payment/xps-message.interface.d.ts

@@ -0,0 +1,4 @@
+export interface XpsMessage {
+    code: string;
+    message: string;
+}

package/lib/core/payment/xps-request.abstract.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class XpsRequest {
+    [fieldName: `xps_${string}`]: unknown;
+    protected addXpsParameters(parameters: {
+        [key: string]: unknown;
+    }): void;
+}

package/lib/core/payment/xps-response.interface.d.ts

@@ -0,0 +1,261 @@
+import { XpsBoolean } from '../xps-boolean.enum';
+import { CheckoutItem } from './checkout-item.interface';
+import { Field } from './field.interface';
+import { Invoice } from './invoice.interface';
+import { LineItem } from './status/line-item.interface';
+import { StatusEnum } from './status/status.enum';
+import { TitleClass } from './status/title-class.enum';
+import { WebSocketClientType } from './status/web-socket-client-type.enum';
+import { VirtualCurrency } from './virtual-currency.interface';
+import { XpsCommand } from './xps-comand.enum';
+import { XpsError } from './xps-error.interface';
+import { XpsMessage } from './xps-message.interface';
+import { XpsSubscriptionItem } from './xps-subscription-item.interface';
+export interface XpsResponse {
+    checkout: {
+        action: string;
+        method: string;
+        data: {
+            [key: string]: string;
+        };
+    };
+    summary: {
+        purchase: {
+            virtual_currency?: VirtualCurrency[];
+            checkout_items?: CheckoutItem[];
+            virtual_items?: VirtualCurrency[];
+            subscriptions?: XpsSubscriptionItem[];
+            checkout?: {
+                amount: number;
+                currency: string;
+                description: string;
+                is_bonus?: boolean;
+            };
+        };
+        finance: {
+            payment_country: {
+                iso: string;
+            };
+            sub_total: {
+                amount: number;
+                currency: string;
+                payment_amount: number;
+                payment_currency: string;
+            };
+            discount: {
+                amount: number;
+                currency: string;
+            };
+            vat_user?: {
+                amount: number;
+                percent: number;
+                currency: string;
+                visible: boolean;
+            };
+            sales_tax: {
+                amount: number;
+                percent: number;
+                currency: string;
+            };
+            sales_tax_user?: {
+                amount: number;
+                percent: number;
+                currency: string;
+            };
+            fee: {
+                amount: number;
+                currency: string;
+            };
+            total: {
+                amount: number;
+                currency: string;
+            };
+            xsolla_credits?: {
+                payment_amount: number;
+                payment_currency: string;
+            };
+            vat: {
+                amount: number;
+                percent: number;
+                currency: string;
+                visible: boolean;
+            };
+            user_balance?: {
+                amount: number;
+                currency: string;
+            };
+            grand_total?: {
+                amount: number;
+                currency: string;
+            };
+        };
+    };
+    buyData: {
+        currency: string;
+        enabled: boolean;
+        example: null | unknown;
+        isMandatory: null | boolean;
+        isPakets: null | boolean;
+        isReadonly: null | boolean;
+        isVisible: XpsBoolean;
+        label_hint: null | string;
+        name: string;
+        options: null | unknown[];
+        regex: null | unknown;
+        sum: string;
+        title: null | string;
+        tooltip: null | string;
+        type: 'submit' | string;
+        validation_error_msg: null | string;
+        value: string;
+    };
+    accountXsolla: string;
+    public_id: string;
+    form: {
+        [key: string]: Field;
+    };
+    taxDisclaimer: string | null;
+    number: number;
+    barcode: unknown;
+    offers: unknown;
+    instruction: string;
+    errors: XpsError[] | null;
+    restrictions: unknown;
+    info: string;
+    pid: number;
+    project: {
+        id: number;
+        isMerchant: boolean;
+        isUnknownPrice: number;
+        name: string;
+    };
+    error?: {
+        fields: {
+            [key: string]: string;
+        };
+    };
+    invoiceCreated: XpsBoolean;
+    messages?: XpsMessage[];
+    status?: StatusEnum | XpsStatus | null;
+    final?: boolean;
+    elapsedTime?: number;
+    group?: string;
+    is_payment_account_attached?: boolean;
+    is_partial_pay?: boolean;
+    country?: {
+        iso: string;
+    };
+    userSession?: Invoice;
+    currentCommand: XpsCommand;
+    title: string;
+    onlineBanking?: {
+        value: string;
+    };
+    threeDSForm: {
+        threeDSTrXid: string;
+        threeDSMethod: string;
+        threeDSMethodData: string;
+        webSocketChannelUrl: string;
+        webSocketChannelName: string;
+        webSocketClientType: WebSocketClientType;
+        statusUrl: string;
+        waitCallback: boolean;
+    } | null;
+    skipForm: boolean;
+    skipCheckout: boolean;
+    isMap: boolean;
+    isCheckout: boolean;
+    categories: number[];
+    textAll?: {
+        fatal: boolean;
+    };
+}
+export interface XpsStatus {
+    is_partial_pay: boolean;
+    marketplace: string;
+    autoredirect?: {
+        time: number;
+    };
+    statusData: {
+        project: number;
+        pid: number;
+        out: number;
+        payment_country_iso: string;
+        v1: string;
+        v2: string;
+        v3: string;
+        invoice: number;
+        email: string;
+        state: number;
+        stateText: StatusEnum;
+        statusPs: number;
+        key: string;
+        webSocketChannelUrl: string;
+        webSocketChannelName: string;
+        webSocketClientType: WebSocketClientType;
+        projectAmount: string;
+        recurrentId?: number;
+    };
+    gshare_banner_enabled: boolean;
+    invoice: number;
+    repayment?: null[] | null;
+    email?: null[] | null;
+    group: string;
+    sharing?: unknown;
+    pre_orders: unknown;
+    text: {
+        info: {
+            [key: string]: {
+                key?: string;
+                pref?: string;
+                value?: string;
+            };
+        };
+        state: string;
+        stateFailed: string;
+        is_additional_back_url_enabled?: boolean;
+        additional_back_url_link?: string;
+        additional_back_url_label?: string;
+        additional_back_url_action?: string;
+        backurl: string;
+        backurl_caption: string;
+        backurl_action: string;
+        redeem_instruction_link?: null;
+        order?: {
+            lineitems?: LineItem[];
+            shipping?: {
+                currency: string;
+                amount: number;
+            };
+            contained_taxes?: {
+                sales_tax?: boolean;
+                user_vat?: boolean;
+            };
+        };
+    };
+    country: string;
+    return_region: string;
+    additional_button_return_region?: string;
+    isUserLegal: boolean;
+    isCancelUser: boolean;
+    isPreloader: boolean;
+    alternative?: unknown;
+    showEmailRequest: boolean;
+    autoRecharge: {
+        params?: unknown;
+        packages: unknown;
+        label_error: string;
+        label_continue: string;
+    };
+    title_class: TitleClass;
+    needToCheck: boolean;
+    custom_message: string;
+    custom_header: string;
+    babkaLink: string;
+    discount?: {
+        [key: string]: {
+            key?: string;
+            value?: string;
+        };
+    };
+}

package/lib/core/payment/xps-subscription-item.interface.d.ts

@@ -0,0 +1,20 @@
+export interface XpsSubscriptionItem {
+    amount: number;
+    is_trial: boolean;
+    trial_period: number;
+    period: number;
+    currency: string;
+    description: string;
+    package_info: string;
+    period_type: string;
+    expiration_period_type: string;
+    recurrent_type: string;
+    date_next_charge: string;
+    amount_next_charge: string;
+    setup_fee: number;
+    currency_next_charge: string;
+    promotion_details: unknown;
+    is_allow_user_select_recurrent_type: string;
+    date_start: string;
+    date_end: string;
+}

package/lib/core/saved-methods/saved-methods.service.d.ts

@@ -1,4 +1,3 @@
-import { CountryService } from '../country/country.service';
 import { SecureApiClient } from '../http/secure-api/secure-api.service';
 import { SettingsService } from '../settings/settings.service';
 import { SavedMethodsResponseFactory } from './saved-methods-response.token';
@@ -7,11 +6,10 @@ import * as i0 from "@angular/core";
 export declare class SavedMethodsService {
     private readonly responseFactory;
     private readonly settingsService;
-    private readonly countryService;
     private readonly secureApi;
     private readonly apiRoute;
     private readonly cache;
-    constructor(responseFactory: SavedMethodsResponseFactory, settingsService: SettingsService, countryService: CountryService, secureApi: SecureApiClient);
+    constructor(responseFactory: SavedMethodsResponseFactory, settingsService: SettingsService, secureApi: SecureApiClient);
     getList(): Promise<SavedMethod[]>;
     private request;
     static ɵfac: i0.ɵɵFactoryDeclaration<SavedMethodsService, never>;

package/lib/core/xps-boolean.enum.d.ts

@@ -0,0 +1,4 @@
+export declare const enum XpsBoolean {
+    true = "1",
+    false = "0"
+}

package/lib/core-library.module.d.ts

@@ -1,7 +1,8 @@
 import * as i0 from "@angular/core";
 import * as i1 from "@angular/common/http";
+import * as i2 from "./core/payment/form/form.module";
 export declare class CoreLibraryModule {
     static ɵfac: i0.ɵɵFactoryDeclaration<CoreLibraryModule, never>;
-    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreLibraryModule, never, [typeof i1.HttpClientModule], never>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<CoreLibraryModule, never, [typeof i1.HttpClientModule, typeof i2.FormModule], never>;
     static ɵinj: i0.ɵɵInjectorDeclaration<CoreLibraryModule>;
 }

package/lib/core-library.service.d.ts

@@ -7,6 +7,12 @@ import { SavedMethodsService } from './core/saved-methods/saved-methods.service'
 import { SavedMethod } from './core/saved-methods/saved-method.interface';
 import { UserBalanceResponse } from './core/user-balance/user-balance-response.class';
 import { UserBalanceService } from './core/user-balance/user-balance.service';
+import { PaymentConfig } from './core/payment/payment-config.interface';
+import { PaymentService } from './core/payment/payment.service';
+import { Payment } from './core/payment/payment.interface';
+import { DeviceFingerPrintService } from './core/device-finger-print/device-finger-print.service';
+import { LegalService } from './core/legal/legal.service';
+import { LegalComponentConfig } from './core/legal/legal.component.config';
 import * as i0 from "@angular/core";
 export declare class CoreLibraryService {
     private readonly settingsService;
@@ -14,15 +20,20 @@ export declare class CoreLibraryService {
     private readonly paymentMethodsService;
     private readonly savedMethodsService;
     private readonly userBalanceService;
+    private readonly paymentService;
+    private readonly deviceFingerPrintService;
+    private readonly legalService;
     paymentMethods: {
         getList: () => Promise<PaymentMethod[]>;
         getQuickMethods: () => Promise<PaymentMethod[]>;
         getSavedMethods: () => Promise<SavedMethod[]>;
         getUserBalance: () => Promise<UserBalanceResponse>;
     };
-    constructor(settingsService: SettingsService, countryService: CountryService, paymentMethodsService: PaymentMethodsService, savedMethodsService: SavedMethodsService, userBalanceService: UserBalanceService);
+    constructor(settingsService: SettingsService, countryService: CountryService, paymentMethodsService: PaymentMethodsService, savedMethodsService: SavedMethodsService, userBalanceService: UserBalanceService, paymentService: PaymentService, deviceFingerPrintService: DeviceFingerPrintService, legalService: LegalService);
     init(configuration: InitConfiguration): Promise<void>;
     setCountry(country: string): void;
+    createPayment(config: PaymentConfig): Payment;
+    getLegalComponentConfig(): LegalComponentConfig;
     static ɵfac: i0.ɵɵFactoryDeclaration<CoreLibraryService, never>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CoreLibraryService>;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xsolla/payment-client-core",
-  "version": "0.0.3",
+  "version": "0.0.5",
   "peerDependencies": {
     "@angular/common": "^15.2.6",
     "@angular/core": "^15.2.6",

package/public-api.d.ts

@@ -1,2 +1,3 @@
 export * from './lib/core-library.service';
 export * from './lib/core-library.module';
+export * from './lib/core/legal/legal.component.config';