@smartsoft001/paypal 2.76.0 → 2.81.0

package/index.js

@@ -0,0 +1,230 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result)
+    __defProp(target, key, result);
+  return result;
+};
+
+// packages/shared/paypal/src/lib/paypal.config.ts
+var PaypalConfig = class {
+  constructor(clientId, clientSecret, currencyCode, returnUrl, apiUrl, cancelUrl, test) {
+    this.clientId = clientId;
+    this.clientSecret = clientSecret;
+    this.currencyCode = currencyCode;
+    this.returnUrl = returnUrl;
+    this.apiUrl = apiUrl;
+    this.cancelUrl = cancelUrl;
+    this.test = test;
+  }
+};
+var PAYPAL_CONFIG_PROVIDER = "PAYPAL_CONFIG_PROVIDER";
+var IPaypalConfigProvider = class {
+};
+
+// packages/shared/paypal/src/lib/paypal.service.ts
+import { Injectable, Logger } from "@nestjs/common";
+import * as paypal from "paypal-rest-sdk";
+var PaypalService = class {
+  constructor(httpService, config, moduleRef) {
+    this.httpService = httpService;
+    this.config = config;
+    this.moduleRef = moduleRef;
+  }
+  async create(obj) {
+    const config = await this.getConfig(obj.data);
+    const data = {
+      intent: "sale",
+      payer: {
+        payment_method: "paypal"
+      },
+      redirect_urls: {
+        return_url: config.apiUrl + "paypal/" + obj.id + "/confirm",
+        cancel_url: config.cancelUrl
+      },
+      transactions: [
+        {
+          item_list: {
+            items: [
+              {
+                name: obj.name,
+                sku: obj.id,
+                price: obj.amount / 100,
+                currency: config.currencyCode,
+                quantity: 1
+              }
+            ]
+          },
+          amount: {
+            currency: config.currencyCode,
+            total: obj.amount / 100
+          },
+          description: obj.name
+        }
+      ]
+    };
+    const result = await new Promise((res, rej) => {
+      paypal.payment.create(
+        data,
+        this.getEnv(config),
+        (error, payment2) => {
+          if (error) {
+            rej(error);
+          } else {
+            res(payment2);
+          }
+        }
+      );
+    });
+    return {
+      redirectUrl: result.links.find(
+        (l) => l.rel === "approval_url"
+      ).href,
+      orderId: result.id
+    };
+  }
+  async confirm(payerId, paymentId, amount, externalData) {
+    const config = await this.getConfig(externalData);
+    const data = {
+      payer_id: payerId,
+      transactions: [
+        {
+          amount: {
+            currency: config.currencyCode,
+            total: amount
+          }
+        }
+      ]
+    };
+    return await new Promise((res, rej) => {
+      paypal.payment.execute(
+        paymentId,
+        data,
+        this.getEnv(config),
+        (error, payment2) => {
+          if (error) {
+            rej(error);
+          } else {
+            res(payment2);
+          }
+        }
+      );
+    });
+  }
+  async getStatus(trans) {
+    const orderId = this.getOrderId(trans) ?? "";
+    const config = await this.getConfig(trans.data);
+    const payment2 = await new Promise((res, rej) => {
+      paypal.payment.get(
+        orderId,
+        this.getEnv(config),
+        (error, result) => {
+          if (error) {
+            rej(error);
+          } else {
+            res(result);
+          }
+        }
+      );
+    });
+    return {
+      status: this.getStatusFromExternal(payment2.state),
+      data: payment2
+    };
+  }
+  async refund(trans, comment) {
+    const orderId = this.getOrderId(trans);
+    const config = await this.getConfig(trans.data);
+    const transactionId = this.getTransactionId(trans);
+    if (!transactionId) {
+      throw new Error("Paypal transaction ID not found for refund");
+    }
+    const refundData = {
+      amount: {
+        total: (trans.amount / 100).toString(),
+        currency: config.currencyCode
+      },
+      description: comment
+    };
+    return new Promise((resolve, reject) => {
+      paypal.sale.refund(
+        transactionId,
+        refundData,
+        this.getEnv(config),
+        (error, refund) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(refund);
+          }
+        }
+      );
+    });
+  }
+  getOrderId(trans) {
+    const historyItem = trans.history.find((x) => x.status === "started");
+    if (!historyItem) {
+      console.warn("Transaction without start status");
+      return null;
+    }
+    return historyItem.data.orderId;
+  }
+  getStatusFromExternal(status) {
+    status = status.toUpperCase();
+    switch (status) {
+      case "COMPLETED":
+        return "completed";
+      case "VOIDED":
+        return "canceled";
+      case "CREATED":
+        return "pending";
+      case "SAVED":
+        return "pending";
+      case "APPROVED":
+        return "completed";
+      default:
+        return status;
+    }
+  }
+  async getConfig(data) {
+    try {
+      const provider = this.moduleRef.get(
+        PAYPAL_CONFIG_PROVIDER,
+        { strict: false }
+      );
+      return await provider.get(data);
+    } catch (e) {
+      Logger.warn("PayPal config provider not found", PaypalService.name);
+    }
+    return this.config;
+  }
+  getEnv(config) {
+    return {
+      mode: config.test ? "sandbox" : "live",
+      client_id: config.clientId,
+      client_secret: config.clientSecret
+    };
+  }
+  getApiUrl(config) {
+    return config.test ? "https://api-m.sandbox.paypal.com/" : "https://api-m.paypal.com/";
+  }
+  getTransactionId(trans) {
+    const historyItem = trans.history.find(
+      (i) => i.status === "completed" && i.data && i.data.customData && i.data.customData.transactions && i.data.customData.transactions.length && i.data.customData.transactions[0].related_resources && i.data.customData.transactions[0].related_resources.length && i.data.customData.transactions[0].related_resources[0].sale
+    );
+    return historyItem ? historyItem.data.customData.transactions[0].related_resources[0].sale.id : null;
+  }
+};
+PaypalService = __decorateClass([
+  Injectable()
+], PaypalService);
+export {
+  IPaypalConfigProvider,
+  PAYPAL_CONFIG_PROVIDER,
+  PaypalConfig,
+  PaypalService
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartsoft001/paypal",
-  "version": "2.76.0",
+  "version": "2.81.0",
   "description": "Utils for paypal",
   "repository": {
     "type": "git",

package/src/lib/paypal.config.d.ts

@@ -0,0 +1,14 @@
+export declare class PaypalConfig {
+    clientId: string;
+    clientSecret: string;
+    currencyCode: string;
+    returnUrl: string;
+    apiUrl: string;
+    cancelUrl: string;
+    test?: boolean;
+    constructor(clientId: string, clientSecret: string, currencyCode: string, returnUrl: string, apiUrl: string, cancelUrl: string, test?: boolean);
+}
+export declare const PAYPAL_CONFIG_PROVIDER = "PAYPAL_CONFIG_PROVIDER";
+export declare abstract class IPaypalConfigProvider {
+    abstract get(data: any): Promise<PaypalConfig>;
+}

package/src/lib/paypal.service.d.ts

@@ -0,0 +1,36 @@
+import { HttpService } from '@nestjs/axios';
+import { ModuleRef } from '@nestjs/core';
+import { ITransPaymentSingleService, Trans, TransStatus } from '@smartsoft001/trans-domain';
+import { PaypalConfig } from './paypal.config';
+export declare class PaypalService implements ITransPaymentSingleService {
+    private readonly httpService;
+    private config;
+    private moduleRef;
+    constructor(httpService: HttpService, config: PaypalConfig, moduleRef: ModuleRef);
+    create(obj: {
+        id: string;
+        name: string;
+        amount: number;
+        firstName?: string;
+        lastName?: string;
+        email?: string;
+        contactPhone?: string;
+        clientIp: string;
+        data: any;
+    }): Promise<{
+        orderId: string;
+        redirectUrl: string;
+    }>;
+    confirm(payerId: any, paymentId: any, amount: number, externalData: any): Promise<any>;
+    getStatus<T>(trans: Trans<T>): Promise<{
+        status: TransStatus;
+        data: any;
+    }>;
+    refund(trans: Trans<any>, comment: string): Promise<any>;
+    private getOrderId;
+    private getStatusFromExternal;
+    private getConfig;
+    private getEnv;
+    private getApiUrl;
+    private getTransactionId;
+}

package/.eslintrc

@@ -1,13 +0,0 @@
-{
-  "extends": "../../../.eslintrc.json",
-  "ignorePatterns": ["!**/*"],
-  "rules": {
-
-  },
-  "overrides": [
-    {
-      "files": ["*.json"],
-      "parser": "jsonc-eslint-parser"
-    }
-  ]
-}

package/jest.config.ts

@@ -1,27 +0,0 @@
-/* eslint-disable */
-export default {
-  displayName: 'shared-paypal',
-  globals: {},
-  testEnvironment: 'node',
-  transform: {
-    '^.+\\.[tj]sx?$': [
-      'ts-jest',
-      {
-        tsConfig: '<rootDir>/tsconfig.spec.json',
-      },
-    ],
-  },
-  moduleFileExtensions: ['ts', 'tsx', 'js', 'jsx'],
-  coverageDirectory: '../../../coverage/libs/shared/paypal',
-  preset: '../../../jest.preset.js',
-  /* TODO: Update to latest Jest snapshotFormat
-   * By default Nx has kept the older style of Jest Snapshot formats
-   * to prevent breaking of any existing tests with snapshots.
-   * It's recommend you update to the latest format.
-   * You can do this by removing snapshotFormat property
-   * and running tests with --update-snapshot flag.
-   * Example: From within the project directory, run "nx test --update-snapshot"
-   * More info: https://jestjs.io/docs/upgrading-to-jest29#snapshot-format
-   */
-  snapshotFormat: { escapeString: true, printBasicPrototype: true },
-};

package/project.json

@@ -1,46 +0,0 @@
-{
-  "name": "shared-paypal",
-  "$schema": "../../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "packages/shared/paypal/src",
-  "projectType": "library",
-  "tags": ["scope:shared", "type:util"],
-  "generators": {},
-  "targets": {
-    "lint": {
-      "executor": "@nx/eslint:lint",
-      "outputs": ["{options.outputFile}"],
-      "options": {
-        "lintFilePatterns": [
-          "packages/shared/paypal/**/*.{ts,tsx,js,jsx}",
-          "packages/shared/paypal/package.json"
-        ]
-      }
-    },
-    "test": {
-      "executor": "@nx/jest:jest",
-      "options": {
-        "jestConfig": "packages/shared/paypal/jest.config.ts"
-      },
-      "outputs": ["{workspaceRoot}/coverage/packages/shared/paypal"]
-    },
-    "build": {
-      "executor": "@nx/esbuild:esbuild",
-      "outputs": ["{options.outputPath}"],
-      "options": {
-        "outputPath": "dist/packages/shared/paypal",
-        "tsConfig": "packages/shared/paypal/tsconfig.lib.json",
-        "packageJson": "packages/shared/paypal/package.json",
-        "main": "packages/shared/paypal/src/index.ts",
-        "assets": ["packages/shared/paypal/*.md"]
-      }
-    },
-    "deploy": {
-      "executor": "ngx-deploy-npm:deploy",
-      "options": {
-        "access": "public",
-        "distFolderPath": "dist/packages/shared/paypal"
-      },
-      "dependsOn": ["build"]
-    }
-  }
-}

package/src/lib/paypal.config.ts

@@ -1,17 +0,0 @@
-export class PaypalConfig {
-  constructor(
-    public clientId: string,
-    public clientSecret: string,
-    public currencyCode: string,
-    public returnUrl: string,
-    public apiUrl: string,
-    public cancelUrl: string,
-    public test?: boolean,
-  ) {}
-}
-
-export const PAYPAL_CONFIG_PROVIDER = 'PAYPAL_CONFIG_PROVIDER';
-
-export abstract class IPaypalConfigProvider {
-  abstract get(data: any): Promise<PaypalConfig>;
-}

package/src/lib/paypal.service.spec.ts

@@ -1,192 +0,0 @@
-import { HttpService } from '@nestjs/axios';
-import { ModuleRef } from '@nestjs/core';
-import { Test, TestingModule } from '@nestjs/testing';
-
-import { Trans } from '@smartsoft001/trans-domain';
-
-import { PaypalConfig } from './paypal.config';
-import { PaypalService } from './paypal.service';
-
-// Mock the module before importing it
-jest.mock('paypal-rest-sdk', () => ({
-  payment: {
-    create: jest.fn(),
-    execute: jest.fn(),
-    get: jest.fn(),
-  },
-  sale: {
-    refund: jest.fn(),
-  },
-  configure: jest.fn(),
-  sdkVersion: '1.8.1',
-  userAgent: 'PayPalSDK/PayPal-node-SDK 1.8.1',
-}));
-
-//eslint-disable-next-line
-import * as paypal from 'paypal-rest-sdk'; // Needs to be mocked first
-
-const mockHttpService = {
-  post: jest.fn(),
-  get: jest.fn(),
-};
-
-const mockModuleRef = {
-  get: jest.fn(),
-};
-
-const mockPaypalConfig = {
-  clientId: 'mock-client-id',
-  clientSecret: 'mock-client-secret',
-  currencyCode: 'USD',
-  apiUrl: 'https://mock.api.url',
-  cancelUrl: 'https://mock.cancel.url',
-  test: true,
-};
-
-describe('paypal: PaypalService', () => {
-  let service: PaypalService;
-
-  beforeEach(async () => {
-    const module: TestingModule = await Test.createTestingModule({
-      providers: [
-        PaypalService,
-        { provide: PaypalConfig, useValue: mockPaypalConfig },
-        { provide: HttpService, useValue: mockHttpService },
-        { provide: ModuleRef, useValue: mockModuleRef },
-      ],
-    }).compile();
-
-    service = module.get<PaypalService>(PaypalService);
-  });
-
-  afterEach(() => {
-    jest.clearAllMocks();
-  });
-
-  describe('create', () => {
-    it('should create a payment and return orderId and redirectUrl', async () => {
-      const mockPayment = {
-        id: 'test-payment-id',
-        links: [{ rel: 'approval_url', href: 'https://approval.url' }],
-      };
-
-      (paypal.payment.create as jest.Mock).mockImplementation(
-        (data, config, callback) => {
-          callback(null, mockPayment);
-        },
-      );
-
-      const result = await service.create({
-        id: 'test-id',
-        name: 'test-name',
-        amount: 1000,
-        email: 'test@example.com',
-        clientIp: '127.0.0.1',
-        data: {},
-      });
-
-      expect(result).toEqual({
-        orderId: 'test-payment-id',
-        redirectUrl: 'https://approval.url',
-      });
-    });
-  });
-
-  describe('confirm', () => {
-    it('should execute a payment and return the result', async () => {
-      const mockPayment = { id: 'test-payment-id', state: 'approved' };
-
-      (paypal.payment.execute as jest.Mock).mockImplementation(
-        (paymentId, data, config, callback) => {
-          callback(null, mockPayment);
-        },
-      );
-
-      const result = await service.confirm(
-        'test-payer-id',
-        'test-payment-id',
-        10,
-        {},
-      );
-
-      expect(result).toEqual(mockPayment);
-    });
-  });
-
-  describe('getStatus', () => {
-    it('should return the status and data of a payment', async () => {
-      const mockPayment = { state: 'COMPLETED' };
-
-      (paypal.payment.get as jest.Mock).mockImplementation(
-        (paymentId, config, callback) => {
-          callback(null, mockPayment);
-        },
-      );
-
-      const result = await service.getStatus({
-        data: {},
-        history: [
-          {
-            status: 'started',
-            data: { orderId: 'test-order-id' },
-          },
-        ],
-      } as Trans<any>);
-
-      expect(result).toEqual({ status: 'completed', data: mockPayment });
-    });
-  });
-
-  describe('refund', () => {
-    it('should process a refund and return the result', async () => {
-      const mockRefund = { id: 'test-refund-id', state: 'completed' };
-
-      (paypal.sale.refund as jest.Mock).mockImplementation(
-        (saleId, data, config, callback) => {
-          callback(null, mockRefund);
-        },
-      );
-
-      const result = await service.refund(
-        {
-          amount: 1000,
-          data: {},
-          history: [
-            {
-              status: 'completed',
-              data: {
-                customData: {
-                  transactions: [
-                    {
-                      related_resources: [
-                        {
-                          sale: { id: 'test-sale-id' },
-                        },
-                      ],
-                    },
-                  ],
-                },
-              },
-            },
-          ],
-        } as Trans<any>,
-        'test comment',
-      );
-
-      expect(result).toEqual(mockRefund);
-    });
-
-    it('should throw an error when transaction ID is not found', async () => {
-      await expect(
-        service.refund(
-          {
-            amount: 1000,
-            data: {},
-            history: [],
-          } as unknown as Trans<any>,
-          'test comment',
-        ),
-      ).rejects.toThrow('Paypal transaction ID not found for refund');
-    });
-  });
-});

package/src/lib/paypal.service.ts

@@ -1,266 +0,0 @@
-import { HttpService } from '@nestjs/axios';
-import { Injectable, Logger } from '@nestjs/common';
-import { ModuleRef } from '@nestjs/core';
-import * as paypal from 'paypal-rest-sdk';
-
-import {
-  ITransPaymentSingleService,
-  Trans,
-  TransStatus,
-} from '@smartsoft001/trans-domain';
-
-import {
-  IPaypalConfigProvider,
-  PAYPAL_CONFIG_PROVIDER,
-  PaypalConfig,
-} from './paypal.config';
-
-@Injectable()
-export class PaypalService implements ITransPaymentSingleService {
-  constructor(
-    private readonly httpService: HttpService,
-    private config: PaypalConfig,
-    private moduleRef: ModuleRef,
-  ) {}
-
-  async create(obj: {
-    id: string;
-    name: string;
-    amount: number;
-    firstName?: string;
-    lastName?: string;
-    email?: string;
-    contactPhone?: string;
-    clientIp: string;
-    data: any;
-  }): Promise<{ orderId: string; redirectUrl: string }> {
-    const config = await this.getConfig(obj.data);
-
-    const data = {
-      intent: 'sale',
-      payer: {
-        payment_method: 'paypal',
-      },
-      redirect_urls: {
-        return_url: config.apiUrl + 'paypal/' + obj.id + '/confirm',
-        cancel_url: config.cancelUrl,
-      },
-      transactions: [
-        {
-          item_list: {
-            items: [
-              {
-                name: obj.name,
-                sku: obj.id,
-                price: obj.amount / 100,
-                currency: config.currencyCode,
-                quantity: 1,
-              },
-            ],
-          },
-          amount: {
-            currency: config.currencyCode,
-            total: obj.amount / 100,
-          },
-          description: obj.name,
-        },
-      ],
-    };
-
-    const result: { id: any; links: any[] } = await new Promise((res, rej) => {
-      paypal.payment.create(
-        data as any,
-        this.getEnv(config) as any,
-        (error: any, payment: any) => {
-          if (error) {
-            rej(error);
-          } else {
-            res(payment);
-          }
-        },
-      );
-    });
-
-    return {
-      redirectUrl: result.links.find(
-        (l: { rel: string }) => l.rel === 'approval_url',
-      ).href,
-      orderId: result.id,
-    };
-  }
-
-  async confirm(
-    payerId: any,
-    paymentId: any,
-    amount: number,
-    externalData: any,
-  ): Promise<any> {
-    const config = await this.getConfig(externalData);
-
-    const data = {
-      payer_id: payerId,
-      transactions: [
-        {
-          amount: {
-            currency: config.currencyCode,
-            total: amount,
-          },
-        },
-      ],
-    };
-
-    return await new Promise<void>((res, rej) => {
-      paypal.payment.execute(
-        paymentId,
-        data,
-        this.getEnv(config) as any,
-        (error: any, payment: any) => {
-          if (error) {
-            rej(error);
-          } else {
-            res(payment);
-          }
-        },
-      );
-    });
-  }
-
-  async getStatus<T>(
-    trans: Trans<T>,
-  ): Promise<{ status: TransStatus; data: any }> {
-    const orderId = this.getOrderId(trans) ?? '';
-    const config = await this.getConfig(trans.data);
-
-    const payment: { state: string } = await new Promise((res, rej) => {
-      paypal.payment.get(
-        orderId,
-        this.getEnv(config) as any,
-        (error: any, result: any) => {
-          if (error) {
-            rej(error);
-          } else {
-            res(result);
-          }
-        },
-      );
-    });
-
-    return {
-      status: this.getStatusFromExternal(payment.state),
-      data: payment,
-    };
-  }
-
-  async refund(trans: Trans<any>, comment: string): Promise<any> {
-    const orderId = this.getOrderId(trans);
-    const config = await this.getConfig(trans.data);
-    const transactionId = this.getTransactionId(trans);
-
-    if (!transactionId) {
-      throw new Error('Paypal transaction ID not found for refund');
-    }
-
-    const refundData = {
-      amount: {
-        total: (trans.amount / 100).toString(),
-        currency: config.currencyCode,
-      },
-      description: comment,
-    };
-
-    return new Promise((resolve, reject) => {
-      paypal.sale.refund(
-        transactionId,
-        refundData,
-        this.getEnv(config) as any,
-        (error: any, refund: any) => {
-          if (error) {
-            reject(error);
-          } else {
-            resolve(refund);
-          }
-        },
-      );
-    });
-  }
-
-  private getOrderId(trans: Trans<any>): string | null {
-    const historyItem = trans.history.find((x) => x.status === 'started');
-
-    if (!historyItem) {
-      console.warn('Transaction without start status');
-      return null;
-    }
-
-    return historyItem.data.orderId;
-  }
-
-  private getStatusFromExternal(status: string): any {
-    status = status.toUpperCase();
-
-    switch (status) {
-      case 'COMPLETED':
-        return 'completed';
-      case 'VOIDED':
-        return 'canceled';
-      case 'CREATED':
-        return 'pending';
-      case 'SAVED':
-        return 'pending';
-      case 'APPROVED':
-        return 'completed';
-      default:
-        return status;
-    }
-  }
-
-  private async getConfig(data: any): Promise<PaypalConfig> {
-    try {
-      const provider: IPaypalConfigProvider = this.moduleRef.get(
-        PAYPAL_CONFIG_PROVIDER,
-        { strict: false },
-      );
-      return await provider.get(data);
-    } catch (e) {
-      Logger.warn('PayPal config provider not found', PaypalService.name);
-    }
-
-    return this.config;
-  }
-
-  private getEnv(config: PaypalConfig): {
-    mode: any;
-    client_id: any;
-    client_secret: any;
-  } {
-    return {
-      mode: config.test ? 'sandbox' : 'live',
-      client_id: config.clientId,
-      client_secret: config.clientSecret,
-    };
-  }
-
-  private getApiUrl(config: PaypalConfig): string {
-    return config.test
-      ? 'https://api-m.sandbox.paypal.com/'
-      : 'https://api-m.paypal.com/';
-  }
-
-  private getTransactionId(trans: Trans<any>): string {
-    const historyItem = trans.history.find(
-      (i) =>
-        i.status === 'completed' &&
-        i.data &&
-        i.data.customData &&
-        i.data.customData.transactions &&
-        i.data.customData.transactions.length &&
-        i.data.customData.transactions[0].related_resources &&
-        i.data.customData.transactions[0].related_resources.length &&
-        i.data.customData.transactions[0].related_resources[0].sale,
-    );
-
-    return historyItem
-      ? historyItem.data.customData.transactions[0].related_resources[0].sale.id
-      : null;
-  }
-}

package/tsconfig.json

@@ -1,13 +0,0 @@
-{
-  "extends": "../../../tsconfig.base.json",
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node"]
-  },
-  "exclude": ["jest.config.ts", "src/**/*.spec.ts", "src/**/*.test.ts"],
-  "include": ["src/**/*.ts"]
-}

package/tsconfig.spec.json

@@ -1,20 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../../dist/out-tsc",
-    "module": "commonjs",
-    "types": ["jest", "node"]
-  },
-  "include": [
-    "**/*.spec.ts",
-    "**/*.test.ts",
-    "**/*.spec.tsx",
-    "**/*.test.tsx",
-    "**/*.spec.js",
-    "**/*.test.js",
-    "**/*.spec.jsx",
-    "**/*.test.jsx",
-    "**/*.d.ts",
-    "jest.config.ts"
-  ]
-}