perimeterx-js-core 0.7.1 → 0.9.0

package/lib/types/http/utils/OutgoingRequestImpl.d.ts

@@ -0,0 +1,14 @@
+import { ReadonlyHeaders, HttpMethod, IOutgoingRequest } from '../index';
+export type OutGoingRequestImplOptions = {
+    url: string;
+    method?: HttpMethod | string;
+    headers?: ReadonlyHeaders;
+    body?: any;
+};
+export declare class OutgoingRequestImpl implements IOutgoingRequest {
+    readonly body: any;
+    readonly url: string;
+    readonly method: HttpMethod;
+    readonly headers: ReadonlyHeaders;
+    constructor(options: OutGoingRequestImplOptions);
+}

package/lib/types/http/utils/URLUtils.d.ts

@@ -0,0 +1,7 @@
+import { IURL, IURLSearchParams } from '../interfaces';
+export declare namespace URLUtils {
+    const parseURL: (rawUrl: string) => IURL;
+    const parseSearchParams: (search: string) => IURLSearchParams;
+    const decodeUriComponent: (input: string) => string;
+    const encodeUriComponent: (input: string) => string;
+}

package/lib/types/http/utils/UrlImpl.d.ts

@@ -0,0 +1,18 @@
+import { IURL, IURLSearchParams } from '../interfaces';
+export declare class UrlImpl implements IURL {
+    protocol: string;
+    hostname: string;
+    pathname: string;
+    search: string;
+    hash: string;
+    protected _port: string;
+    constructor(rawUrl: string);
+    get href(): string;
+    get origin(): string;
+    get host(): string;
+    set host(newHost: string);
+    get port(): string;
+    set port(port: string);
+    get searchParams(): IURLSearchParams;
+    private isDefaultPort;
+}

package/lib/types/http/utils/UrlSearchParamsImpl.d.ts

@@ -0,0 +1,19 @@
+import { IURLSearchParams } from '../interfaces';
+export declare class UrlSearchParamsImpl implements IURLSearchParams {
+    private _searchParamsArray;
+    private _searchParamsMap;
+    constructor(init?: string | Record<string, string | string[]> | [string, string][]);
+    append(name: string, value: any): void;
+    delete(name: string): void;
+    forEach(callback: (value: string, key: string, params?: IURLSearchParams, thisArg?: any) => void): void;
+    get(name: string): string | null;
+    getAll(name: string): string[];
+    has(name: string): boolean;
+    set(name: string, value: any): void;
+    toString(): string;
+    private _constructSearchParamsFromString;
+    private _constructSearchParamsFromArray;
+    private _constructSearchParamsFromObject;
+    private _saveParam;
+    private _storeParamInSearchParamsMap;
+}

package/lib/types/http/utils/index.d.ts

@@ -0,0 +1,11 @@
+export * from './ContentType';
+export * from './constants';
+export * from './HttpMethod';
+export * from './MinimalResponseUtils';
+export * from './MultipartFormDataUtils';
+export * from './FormDataImpl';
+export * from './MinimalResponseImpl';
+export * from './OutgoingRequestImpl';
+export * from './UrlImpl';
+export * from './UrlSearchParamsImpl';
+export * from './URLUtils';

package/lib/types/impl/base64/AtobBase64Utils.d.ts

@@ -0,0 +1,5 @@
+import { IBase64Utils } from '../../utils';
+export declare class AtobBase64Utils implements IBase64Utils {
+    base64Decode(stringToDecode: string): string;
+    base64Encode(stringToEncode: string): string;
+}

package/lib/types/impl/base64/BufferBase64Utils.d.ts

@@ -0,0 +1,6 @@
+import { IBase64Utils } from '../../utils';
+export declare class BufferBase64Utils implements IBase64Utils {
+    static BASE_64_ENCODING: 'base64';
+    base64Decode(stringToDecode: string): string;
+    base64Encode(stringToEncode: string): string;
+}

package/lib/types/impl/base64/JSBase64Base64Utils.d.ts

@@ -0,0 +1,5 @@
+import { IBase64Utils } from '../../utils';
+export declare class JSBase64Base64Utils implements IBase64Utils {
+    base64Encode(stringToEncode: string): string;
+    base64Decode(stringToDecode: string): string;
+}

package/lib/types/impl/cipher/CryptoCipherUtils.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import * as crypto from 'crypto';
+import { ICipherUtils, Pbkdf2DecryptOptions } from '../../utils';
+declare type CryptoModule = typeof crypto;
+export declare class CryptoCipherUtils implements ICipherUtils {
+    private crypto;
+    constructor(cryptoModule?: CryptoModule);
+    pbkdf2Decrypt(secret: string, encryptedString: string, iterations: number, salt: string, options?: Pbkdf2DecryptOptions): Promise<string>;
+}
+export {};

package/lib/types/impl/cipher/SubtleCryptoCipherUtils.d.ts

@@ -0,0 +1,8 @@
+import { ICipherUtils, IBase64Utils, Pbkdf2DecryptOptions } from '../../utils';
+export declare class SubtleCryptoCipherUtils implements ICipherUtils {
+    private base64Utils;
+    private subtleCrypto;
+    constructor(base64Utils: IBase64Utils, subtleCrypto?: SubtleCrypto);
+    pbkdf2Decrypt(secret: string, encryptedString: string, iterations: number, salt: string, options?: Pbkdf2DecryptOptions): Promise<string>;
+    private base64ToArrayBuffer;
+}

package/lib/types/impl/hash/CryptoHashUtils.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import * as crypto from 'crypto';
+import { Algorithm, IHashUtils } from '../../utils';
+declare type CryptoModule = typeof crypto;
+export declare class CryptoHashUtils implements IHashUtils {
+    private readonly crypto;
+    constructor(cryptoModule?: CryptoModule);
+    hashString(text: string, algo: Algorithm): Promise<string>;
+}
+export {};

package/lib/types/impl/hash/CryptoJSHashUtils.d.ts

@@ -0,0 +1,4 @@
+import { Algorithm, IHashUtils } from '../../utils';
+export declare class CryptoJSHashUtils implements IHashUtils {
+    hashString(text: string, algo: Algorithm): string;
+}

package/lib/types/impl/hash/SubtleCryptoHashUtils.d.ts

@@ -0,0 +1,7 @@
+import { Algorithm, IHashUtils } from '../../utils';
+export declare class SubtleCryptoHashUtils implements IHashUtils {
+    private readonly subtle;
+    constructor(subtleCrypto?: SubtleCrypto);
+    hashString(text: string, algo: Algorithm): Promise<string>;
+    private convertAlgo;
+}

package/lib/types/impl/hmac/CryptoHmacUtils.d.ts

@@ -0,0 +1,10 @@
+/// <reference types="node" />
+import * as crypto from 'crypto';
+import { Algorithm, IHmacUtils } from '../../utils';
+declare type CryptoModule = typeof crypto;
+export declare class CryptoHmacUtils implements IHmacUtils {
+    private readonly crypto;
+    constructor(cryptoModule?: CryptoModule);
+    createHmac(algo: Algorithm, payload: string, secret: string): string;
+}
+export {};

package/lib/types/impl/hmac/CryptoJSHmacUtils.d.ts

@@ -0,0 +1,4 @@
+import { Algorithm, IHmacUtils } from '../../utils';
+export declare class CryptoJSHmacUtils implements IHmacUtils {
+    createHmac(algo: Algorithm, payload: string, secret: string): string;
+}

package/lib/types/impl/http/phin/PhinHttpClient.d.ts

@@ -0,0 +1,6 @@
+import { HttpSendOptions, IHttpClient, IIncomingResponse, IOutgoingRequest } from '../../../http/interfaces';
+export declare class PhinHttpClient implements IHttpClient {
+    private readonly httpsKeepAliveAgent;
+    constructor();
+    send(request: IOutgoingRequest, options?: HttpSendOptions): Promise<IIncomingResponse>;
+}

package/lib/types/impl/http/phin/PhinIncomingResponse.d.ts

@@ -0,0 +1,13 @@
+/// <reference types="node" />
+import { IResponse } from 'phin';
+import { IFormData, IIncomingResponse, IURLSearchParams, ReadonlyHeaders } from '../../../http';
+export declare class PhinIncomingResponse implements IIncomingResponse {
+    readonly status: number;
+    readonly headers: ReadonlyHeaders;
+    readonly body: Buffer;
+    constructor(response: IResponse);
+    formData(): Promise<IFormData>;
+    formUrlEncoded(): Promise<IURLSearchParams>;
+    json(): Promise<any>;
+    text(): Promise<string>;
+}

package/lib/types/impl/ip_range_checker/DefaultIpRangeChecker.d.ts

@@ -0,0 +1,4 @@
+import { IIpRangeChecker } from '../../utils';
+export declare class DefaultIpRangeChecker implements IIpRangeChecker {
+    isIpInRange(ip: string, range: string | string[]): boolean;
+}

package/lib/types/impl/request_id_generator/UuidRequestIdGenerator.d.ts

@@ -0,0 +1,4 @@
+import { IRequestIdGenerator } from '../../utils';
+export declare class UuidRequestIdGenerator implements IRequestIdGenerator {
+    generateRequestId(): string;
+}

package/lib/types/impl/url_parser/DefaultUrlParser.d.ts

@@ -0,0 +1,13 @@
+import { IURL } from '../../http';
+import { IURLParser } from '../../utils';
+export type UrlParserOptions = {
+    normalize?: boolean;
+    reverseCharactersEncoding?: boolean;
+};
+export declare class DefaultUrlParser implements IURLParser {
+    protected options: UrlParserOptions;
+    constructor(options?: UrlParserOptions);
+    parse(rawUrl: string): IURL;
+    protected reverseCharactersEncoding(path: string): string;
+    protected normalize(path: string): string;
+}

package/lib/types/products/bot_defender/block/DefaultBotDefenderBlocker.d.ts

@@ -0,0 +1,14 @@
+import { ReadonlyContext } from '../../../context';
+import { IConfiguration } from '../../../config';
+import { IBase64Utils } from '../../../utils';
+import { IBlocker, IConditionalBlocker } from '../../../blocker';
+import { IMinimalResponse } from '../../../http';
+export declare class DefaultBotDefenderBlocker<Req, Res> implements IConditionalBlocker<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res>;
+    protected readonly captchaBlocker: IBlocker<Req, Res>;
+    constructor(config: IConfiguration<Req, Res>, base64Utils: IBase64Utils);
+    shouldBlock({ action, reasons, productData }: ReadonlyContext<Req, Res>): boolean;
+    createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
+    protected createRateLimitResponse(): IMinimalResponse;
+    private createCaptchaResponse;
+}

package/lib/types/products/bot_defender/block/captcha/CaptchaBlocker.d.ts

@@ -0,0 +1,16 @@
+import { IConfiguration } from '../../../../config';
+import { ReadonlyContext } from '../../../../context';
+import { IBase64Utils } from '../../../../utils';
+import { IBlocker } from '../../../../blocker';
+import { IMinimalResponse } from '../../../../http';
+import { JsonCaptchaBlocker } from './JsonCaptchaBlocker';
+import { MobileCaptchaBlocker } from './MobileCaptchaBlocker';
+import { HtmlCaptchaBlocker } from './HtmlCaptchaBlocker';
+export declare class CaptchaBlocker<Req, Res> implements IBlocker<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res>;
+    protected readonly jsonCaptchaBlocker: JsonCaptchaBlocker<Req, Res>;
+    protected readonly mobileCaptchaBlocker: MobileCaptchaBlocker<Req, Res>;
+    protected readonly htmlCaptchaBlocker: HtmlCaptchaBlocker<Req, Res>;
+    constructor(config: IConfiguration<Req, Res>, base64Utils: IBase64Utils);
+    createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
+}

package/lib/types/products/bot_defender/block/captcha/HtmlCaptchaBlocker.d.ts

@@ -0,0 +1,9 @@
+import { IConfiguration } from '../../../../config';
+import { ReadonlyContext } from '../../../../context';
+import { IBlocker } from '../../../../blocker';
+import { IMinimalResponse } from '../../../../http';
+export declare class HtmlCaptchaBlocker<Req, Res> implements IBlocker<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res>;
+    constructor(config: IConfiguration<Req, Res>);
+    createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
+}

package/lib/types/products/bot_defender/block/captcha/JsonCaptchaBlocker.d.ts

@@ -0,0 +1,10 @@
+import { IConfiguration } from '../../../../config';
+import { ReadonlyContext } from '../../../../context';
+import { IConditionalBlocker } from '../../../../blocker';
+import { IMinimalResponse } from '../../../../http';
+export declare class JsonCaptchaBlocker<Req, Res> implements IConditionalBlocker<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res>;
+    constructor(config: IConfiguration<Req, Res>);
+    shouldBlock(context: ReadonlyContext<Req, Res>): boolean;
+    createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
+}

package/lib/types/products/bot_defender/block/captcha/MobileCaptchaBlocker.d.ts

@@ -0,0 +1,12 @@
+import { IConfiguration } from '../../../../config';
+import { ReadonlyContext } from '../../../../context';
+import { IBase64Utils } from '../../../../utils';
+import { IConditionalBlocker } from '../../../../blocker';
+import { IMinimalResponse } from '../../../../http';
+export declare class MobileCaptchaBlocker<Req, Res> implements IConditionalBlocker<Req, Res> {
+    protected readonly config: IConfiguration<Req, Res>;
+    protected readonly base64Utils: IBase64Utils;
+    constructor(config: IConfiguration<Req, Res>, base64Utils: IBase64Utils);
+    shouldBlock(context: ReadonlyContext<Req, Res>): boolean;
+    createBlockResponse(context: ReadonlyContext<Req, Res>): IMinimalResponse;
+}

package/lib/types/products/bot_defender/first_party/constants.d.ts

@@ -0,0 +1,24 @@
+import { ContentType } from '../../../http';
+import { MinimalResponseOptions } from '../../../http';
+export declare const X_PX_ENFORCER_TRUE_IP_HEADER_NAME = "x-px-enforcer-true-ip";
+export declare const FIRST_PARTY_HEADER_NAME = "x-px-first-party";
+export declare const FIRST_PARTY_HEADER_VALUE = "1";
+export declare const DEFAULT_CLIENT_RESPONSE_OPTIONS: MinimalResponseOptions;
+export declare const DEFAULT_XHR_RESPONSE: {
+    content: string;
+    options: {
+        status: number;
+        headers: {
+            "content-type": ContentType[];
+        };
+    };
+};
+export declare const DEFAULT_GIF_RESPONSE: {
+    content: string;
+    options: {
+        status: number;
+        headers: {
+            "content-type": ContentType[];
+        };
+    };
+};

package/lib/types/products/credential_intelligence/endpoint/extractor/BodyCredentialExtractor.d.ts

@@ -0,0 +1,15 @@
+import { DeepReadonly } from 'ts-essentials';
+import { IFormData, IIncomingRequest, IURLSearchParams } from '../../../../http';
+import { Credentials } from '../../model';
+import { ICredentialExtractor } from './ICredentialExtractor';
+export declare class BodyCredentialExtractor<Req> implements ICredentialExtractor<Req> {
+    private readonly userField;
+    private readonly passField;
+    constructor(userField: string, passField: string);
+    extractCredentials(request: DeepReadonly<IIncomingRequest<Req>>): Promise<Credentials | null>;
+    protected extractFromBody(contentType: string, request: DeepReadonly<IIncomingRequest<Req>>): Promise<Credentials>;
+    protected extractFromJson(json: any): Credentials;
+    protected extractFromUrlEncoded(params: IURLSearchParams): Credentials;
+    protected extractFromMultipart(formData: IFormData): Credentials;
+    private formDataEntryValueToString;
+}

package/lib/types/products/credential_intelligence/endpoint/extractor/QueryParamCredentialExtractor.d.ts

@@ -0,0 +1,10 @@
+import { DeepReadonly } from 'ts-essentials';
+import { ICredentialExtractor } from './ICredentialExtractor';
+import { Credentials } from '../../model';
+import { IIncomingRequest } from '../../../../http';
+export declare class QueryParamCredentialExtractor<Req> implements ICredentialExtractor<Req> {
+    protected readonly userField: string;
+    protected readonly passField: string;
+    constructor(userField: string, passField: string);
+    extractCredentials(request: DeepReadonly<IIncomingRequest<Req>>): Promise<Credentials | null>;
+}

package/lib/types/risk_api/client/PostRiskApiClientBase.d.ts

@@ -0,0 +1,39 @@
+import { ReadonlyContext, RiskApiData } from '../../context';
+import { IConfiguration } from '../../config';
+import { IHttpClient, IIncomingResponse, ReadonlyHeaders } from '../../http';
+import { HeaderEntry } from '../../activities';
+import { RiskActivity } from '../model';
+import { IRiskResponse } from '../risk_response';
+import { IRiskApiClient } from './IRiskApiClient';
+export declare abstract class PostRiskApiClientBase<Req, Res> implements IRiskApiClient<Req, Res> {
+    private readonly config;
+    private readonly httpClient;
+    protected constructor(config: IConfiguration<Req, Res>, httpClient: IHttpClient);
+    protected abstract createRiskResponse(response: IIncomingResponse): IRiskResponse;
+    /**
+     * Builds the Risk API activity, sends the request, and returns RiskApiData with the response.
+     * @param context
+     * @returns Promise<RiskApiData>
+     */
+    executeRiskApi(context: ReadonlyContext<Req, Res>): Promise<RiskApiData>;
+    /**
+     * Creates the RiskActivity payload
+     * @param context
+     * @returns RiskActivity
+     * @protected
+     */
+    protected createRiskActivity(context: ReadonlyContext<Req, Res>): RiskActivity;
+    /**
+     * Protected function in case expansions or alterations to the risk activity are needed for certain platforms.
+     * @param riskActivity
+     * @returns RiskActivity
+     * @protected
+     */
+    protected finalizeRiskActivity(riskActivity: RiskActivity): RiskActivity;
+    protected formatRiskHeadersField(headers: ReadonlyHeaders): HeaderEntry[];
+    protected sendRiskActivity(riskActivity: RiskActivity, riskApiData: RiskApiData): Promise<IIncomingResponse>;
+    protected getRiskUrl(): string;
+    protected getRiskHeaders(): ReadonlyHeaders;
+    protected handleS2STimeout(riskApiData: RiskApiData): RiskApiData;
+    protected handleS2SError(riskApiData: RiskApiData, response: IIncomingResponse, error?: Error): Promise<RiskApiData>;
+}

package/lib/types/risk_api/model/RiskActivity.d.ts

@@ -0,0 +1,16 @@
+import { HeaderEntry, CommonActivityDetails } from '../../activities';
+export type RiskRequestData = {
+    socket_ip: string;
+    url: string;
+    headers: HeaderEntry[];
+};
+export type RiskAdditionalData = {
+    s2s_call_reason: string;
+};
+export type RiskActivity = {
+    vid?: string;
+    client_uuid?: string;
+    pxhd?: string;
+    request: RiskRequestData;
+    additional: RiskAdditionalData & CommonActivityDetails;
+};

package/lib/types/risk_api/risk_response/IRiskResponse.d.ts

@@ -0,0 +1,16 @@
+import { AsyncOrSync } from 'ts-essentials';
+import { BlockAction } from '../../blocker';
+import { PXDE } from '../../pxde';
+import { RiskStatus } from '../model';
+export interface IRiskResponse {
+    readonly status: RiskStatus;
+    readonly score: number;
+    readonly action: BlockAction;
+    readonly uuid: string;
+    readonly pxhd?: string;
+    readonly pxhdDomain?: string;
+    readonly message?: string;
+    readonly dataEnrichment?: PXDE;
+    readonly additionalRiskInfo?: string;
+    validate(): AsyncOrSync<boolean>;
+}

package/lib/types/risk_api/risk_response/RiskResponseBase.d.ts

@@ -0,0 +1,23 @@
+import { PXDE } from '../../pxde';
+import { IIncomingResponse } from '../../http';
+import { BlockAction } from '../../blocker';
+import { RiskStatus } from '../model';
+import { IRiskResponse } from './IRiskResponse';
+import { TokenVersion } from '../../risk_token';
+import { RiskResponsePayloadType } from './RiskResponsePayloadType';
+export declare abstract class RiskResponseBase<TokenV extends TokenVersion> implements IRiskResponse {
+    private readonly response;
+    protected riskResponse: RiskResponsePayloadType<TokenV>;
+    abstract score: number;
+    protected abstract validateRiskResponseScore(): boolean;
+    protected constructor(response: IIncomingResponse);
+    validate(): Promise<boolean>;
+    get status(): RiskStatus;
+    get action(): BlockAction;
+    get message(): string;
+    get pxhd(): string;
+    get uuid(): string;
+    get dataEnrichment(): PXDE;
+    get pxhdDomain(): string;
+    get additionalRiskInfo(): string;
+}

package/lib/types/risk_api/risk_response/v2/DefaultRiskResponseV2.d.ts

@@ -0,0 +1,8 @@
+import { IIncomingResponse } from '../../../http';
+import { TokenVersion } from '../../../risk_token';
+import { RiskResponseBase } from '../RiskResponseBase';
+export declare class DefaultRiskResponseV2 extends RiskResponseBase<TokenVersion.V2> {
+    constructor(response: IIncomingResponse);
+    get score(): number;
+    protected validateRiskResponseScore(): boolean;
+}

package/lib/types/risk_api/risk_response/v2/RiskResponseV2Payload.d.ts

@@ -0,0 +1,14 @@
+import { PXDE } from '../../../pxde';
+import { BlockAction } from '../../../blocker';
+import { RiskStatus } from '../../model';
+export type RiskResponseV2Payload = {
+    status: RiskStatus;
+    cookie_cfg_block_result?: '0' | '1';
+    action?: BlockAction;
+    uuid?: string;
+    pxhd?: string;
+    pxhdDomain?: string;
+    message?: string;
+    data_enrichment?: PXDE;
+    additional_risk_info?: string;
+};

package/lib/types/risk_api/risk_response/v3/RiskResponseV3Payload.d.ts

@@ -0,0 +1,14 @@
+import { BlockAction } from '../../../blocker';
+import { PXDE } from '../../../pxde';
+import { RiskStatus } from '../../model';
+export type RiskResponseV3Payload = {
+    status: RiskStatus;
+    score?: number;
+    action?: BlockAction;
+    uuid?: string;
+    pxhd?: string;
+    pxhdDomain?: string;
+    message?: string;
+    data_enrichment?: PXDE;
+    additional_risk_info?: string;
+};

package/lib/types/utils/base64/index.d.ts

@@ -0,0 +1 @@
+export * from './IBase64Utils';

package/lib/types/utils/cipher/index.d.ts

@@ -0,0 +1 @@
+export * from './ICipherUtils';

package/lib/types/utils/constants.d.ts

@@ -0,0 +1,12 @@
+export declare const PXVID_COOKIE_NAME = "_pxvid";
+export declare const PXHD_COOKIE_NAME = "_pxhd";
+export declare const PXDE_COOKIE_NAME = "_pxde";
+export declare const CD_PXVID_COOKIE_NAME = "__pxvid";
+export declare const CTS_COOKIE_NAME = "pxcts";
+export declare const BYPASS_MONITOR_HEADER_VALUE = "1";
+export declare const X_PX_AUTHORIZATION_HEADER_NAME = "x-px-authorization";
+export declare const X_PX_ORIGINAL_TOKEN_HEADER_NAME = "x-px-original-token";
+export declare const X_PX_BYPASS_REASON_HEADER_NAME = "x-px-bypass-reason";
+export declare const EMAIL_ADDRESS_REGEX: RegExp;
+export declare const URL_REGEX: RegExp;
+export declare const CORE_MODULE_VERSION = "JS Core 0.9.0";

package/lib/types/utils/hash/index.d.ts

@@ -0,0 +1 @@
+export * from './IHashUtils';

package/lib/types/utils/hmac/index.d.ts

@@ -0,0 +1 @@
+export * from './IHmacUtils';

package/lib/types/utils/ip_range_checker/index.d.ts

@@ -0,0 +1 @@
+export * from './IIpRangeChecker';

package/lib/types/utils/request_id_generator/index.d.ts

@@ -0,0 +1 @@
+export * from './IRequestIdGenerator';

package/lib/types/utils/url_parser/index.d.ts

@@ -0,0 +1 @@
+export * from './IURLParser';

package/lib/types/utils/utils.d.ts

@@ -0,0 +1,18 @@
+import { ReadonlyHeaders } from '../http';
+export declare const isValidEnumValue: <T>(options: Record<string, T>, selection: T) => boolean;
+export declare const isValidUuid: (uuid: string) => boolean;
+export declare const isEmailAddress: (string: string) => boolean;
+export declare const getScoreApiDomain: (appId: string) => string;
+export declare const getCollectorDomain: (appId: string) => string;
+export declare const getAuthorizationHeader: (authToken: string) => string;
+export declare const getExtension: (route: string) => string;
+export declare const removeSensitiveFields: <T extends Record<string, any>>(object: T, sensitiveFields: (keyof T)[]) => T;
+export declare const removeSensitiveHeaders: (headers: ReadonlyHeaders, sensitiveHeaderNames: string[]) => Record<string, string[]>;
+export declare const isRouteInPatterns: (route: string, patterns: Array<string | RegExp>) => boolean;
+export declare const isRouteMatch: (route: string, pattern: string | RegExp) => boolean;
+/**
+ * @deprecated this method is not typesafe. Copy the fields manually instead.
+ */
+export declare const transferExistingProperties: <FromObj extends Record<string, any>, ToObj extends Record<string, any>>(fromObj: FromObj, toObj: ToObj, propertyMappings: Partial<Record<keyof FromObj, keyof ToObj>>) => void;
+export declare const rejectOnTimeout: <T>(promise: Promise<T>, ms: number) => Promise<T>;
+export declare const getPropertyFromObject: <T>(object: any, ...keys: Array<string | number>) => T;

package/package.json

@@ -1,17 +1,35 @@
 {
   "name": "perimeterx-js-core",
-  "version": "0.7.1",
+  "version": "0.9.0",
   "description": "",
-  "main": "lib/index.js",
   "type": "module",
-  "module": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "typesVersions": {
+    "*": {
+      "*": ["lib/types/*"]
+    }
+  },
   "files": [
     "lib/**/*"
   ],
+  "exports": {
+    ".": {
+      "import": "./lib/esm/index.js",
+      "require": "./lib/cjs/index.js",
+      "default": "./lib/cjs/index.js"
+    },
+    "./impl/*": {
+      "import": "./lib/esm/impl/*.js",
+      "require": "./lib/cjs/impl/*.js",
+      "default": "./lib/cjs/impl/*.js"
+    }
+  },
   "sideEffects": false,
   "scripts": {
-    "build": "tsc",
+    "prebuild": "npm run clean",
+    "build": "npm run build:cjs && npm run build:esm && npm run build:dec",
+    "build:cjs": "tsc -p tsconfig.cjs.json && echo \"{\"type\":\"commonjs\"}\" >> ./lib/cjs/package.json",
+    "build:esm": "tsc -p tsconfig.esm.json",
+    "build:dec": "tsc -p tsconfig.dec.json",
     "clean": "rm -rf lib",
     "lint": "./node_modules/eslint/bin/eslint.js . --ext .ts",
     "lint:fix": "./node_modules/eslint/bin/eslint.js . --ext .ts --fix",
@@ -42,10 +60,10 @@
     "chai-as-promised": "^7.1.1",
     "core-js": "^3.19.1",
     "eslint": "^8.25.0",
-    "eslint-config-prettier": "^8.5.0",
+    "eslint-config-prettier": "^9.0.0",
     "eslint-plugin-prettier": "^4.2.1",
     "husky": "^8.0.3",
-    "lint-staged": "^13.1.0",
+    "lint-staged": "^14.0.1",
     "mocha": "^10.0.0",
     "nyc": "^15.1.0",
     "prettier": "^2.7.1",

package/lib/action/utils.js

@@ -1,34 +0,0 @@
-import { Action } from './Action';
-import { ACTION_PRIORITY_ORDER } from './ActionPriorityOrder';
-export const getDecisionFromContext = (context) => {
-    return getDecisionFromActions(getProductActions(context));
-};
-export const getProductActions = (context) => {
-    return Object.entries(context.productData)
-        .filter(([_, data]) => (data === null || data === void 0 ? void 0 : data.action) != null && (data === null || data === void 0 ? void 0 : data.reason) != null)
-        .map(([productName, data]) => ({
-        action: data.action,
-        reason: data.reason,
-        productName: productName,
-    }));
-};
-export const getDecisionFromActions = (productActions) => {
-    return createDecision(reduce(productActions));
-};
-const reduce = (actions) => {
-    return actions.reduce((tally, { action, reason, productName }) => {
-        if (!tally[action]) {
-            tally[action] = {};
-        }
-        tally[action][productName] = reason;
-        return tally;
-    }, {});
-};
-const createDecision = (tally) => {
-    for (const action of ACTION_PRIORITY_ORDER) {
-        if (tally[action]) {
-            return { action, reasons: tally[action] };
-        }
-    }
-    return { action: Action.PASS_REQUEST };
-};