@unchainedshop/utils 3.0.0-alpha7 → 3.0.0-rc2

package/src/director/BasePricingSheet.ts

@@ -1,121 +0,0 @@
-export interface PricingCalculation {
-  category: string;
-  amount: number;
-  baseCategory?: string;
-  meta?: any;
-}
-export interface PricingDiscount {
-  discountId: string;
-  amount: number;
-  currency: string;
-}
-
-export interface IPricingSheet<Calculation extends PricingCalculation>
-  extends IBasePricingSheet<Calculation> {
-  discountPrices: (discountId?: string) => Array<PricingDiscount>;
-  addDiscount: (params: { amount: number; discountId: string; meta?: any }) => void;
-}
-
-export interface IBasePricingSheet<Calculation extends PricingCalculation> {
-  calculation: Array<Calculation>;
-  currency?: string;
-  quantity?: number;
-
-  getRawPricingSheet: () => Array<Calculation>;
-  filterBy: (filter?: Partial<Calculation>) => Array<Calculation>;
-  isValid: () => boolean;
-
-  gross: () => number;
-  net: () => number;
-  sum: (filter?: Partial<Calculation>) => number;
-  total: (params?: { category?: string; discountId?: string; useNetPrice?: boolean }) => {
-    amount: number;
-    currency: string;
-  };
-
-  taxSum: (filter?: Partial<Calculation>) => number;
-
-  resetCalculation: (sheetToInvert: IBasePricingSheet<Calculation>) => Array<Calculation>;
-}
-
-export interface PricingSheetParams<Calculation extends PricingCalculation> {
-  calculation?: Array<Calculation>;
-  currency?: string;
-  quantity?: number;
-}
-
-export const BasePricingSheet = <Calculation extends PricingCalculation>(
-  params: PricingSheetParams<Calculation>,
-): IBasePricingSheet<Calculation> => {
-  const pricingSheet: IBasePricingSheet<Calculation> = {
-    calculation: params.calculation || [],
-    currency: params.currency,
-    quantity: params.quantity,
-
-    getRawPricingSheet() {
-      return this.calculation;
-    },
-
-    isValid() {
-      return this.calculation.length > 0;
-    },
-
-    sum(filter) {
-      return this.filterBy(filter)
-        .filter(Boolean)
-        .reduce((sum: number, calculationRow: Calculation) => sum + calculationRow.amount, 0);
-    },
-
-    taxSum() {
-      return 0;
-    },
-
-    gross() {
-      // Sum contains taxes, thus it's gross when just suming everything
-      return this.sum();
-    },
-
-    net() {
-      // Remove all taxes from gross to get net
-      return this.sum() - this.taxSum();
-    },
-
-    total({ category, useNetPrice, discountId } = { useNetPrice: false }) {
-      const amount = this.sum({ category, discountId });
-      const taxAmountForCategory = this.taxSum({ baseCategory: category, discountId });
-
-      // Sum does not contain taxes when filtering by category, it's net in that case and gross if there is no category
-      const netAmount = !category ? amount - taxAmountForCategory : amount;
-
-      return {
-        amount: Math.round(useNetPrice ? netAmount : netAmount + taxAmountForCategory),
-        currency: this.currency,
-      };
-    },
-
-    filterBy(filter) {
-      const filteredCalculation = Object.keys(filter || {}).reduce(
-        (oldCalculation, filterKey) =>
-          oldCalculation.filter(
-            (row: Calculation) =>
-              !!row && (filter[filterKey] === undefined || row[filterKey] === filter[filterKey]),
-          ),
-        this.calculation,
-      );
-
-      return filteredCalculation;
-    },
-
-    resetCalculation(calculationSheet) {
-      calculationSheet.filterBy().forEach(({ amount, ...row }: Calculation) => {
-        this.calculation.push({
-          ...row,
-          amount: amount * -1,
-        } as Calculation);
-      });
-      return this.calculation;
-    },
-  };
-
-  return pricingSheet;
-};

package/src/director/base-discount-adapter.test.ts

@@ -1,49 +0,0 @@
-import { BaseDiscountAdapter } from './BaseDiscountAdapter.js';
-
-describe('BaseDiscountAdapter instantiation', () => {
-  const adapter = BaseDiscountAdapter;
-  const context = null as any;
-  it('should initialize with default values', async () => {
-    expect(adapter.orderIndex).toEqual(0);
-    expect(adapter.log).toEqual(expect.any(Function));
-    expect(await adapter.isManualAdditionAllowed('')).toEqual(false);
-    expect(await adapter.isManualRemovalAllowed()).toEqual(false);
-    expect(await adapter.actions(context)).toEqual({
-      isValidForSystemTriggering: expect.any(Function),
-      reserve: expect.any(Function),
-      release: expect.any(Function),
-      isValidForCodeTriggering: expect.any(Function),
-      discountForPricingAdapterKey: expect.any(Function),
-    });
-  });
-
-  describe('actions', () => {
-    it('isValidForSystemTriggering', async () => {
-      const result = await adapter.actions(context);
-      expect(await result.isValidForSystemTriggering()).toEqual(false);
-    });
-
-    it('reserve', async () => {
-      const result = await adapter.actions(context);
-      expect(await result.reserve({ code: '' })).toEqual({});
-    });
-
-    it('release', async () => {
-      const result = await adapter.actions(context);
-      expect(await result.release()).toEqual(null);
-    });
-
-    it('isValidForCodeTriggering', async () => {
-      const result = await adapter.actions(context);
-      expect(await result.isValidForCodeTriggering({ code: '' })).toEqual(false);
-    });
-
-    it('discountForPricingAdapterKey', async () => {
-      const result = await adapter.actions(context);
-      const calculationSheet = {};
-      expect(
-        await result.discountForPricingAdapterKey({ calculationSheet, pricingAdapterKey: 'key' } as any),
-      ).toEqual(null);
-    });
-  });
-});

package/src/director/base-price-sheet.test.ts

@@ -1,100 +0,0 @@
-import { BasePricingSheet } from './BasePricingSheet.js';
-
-describe('BasePricingSheet', () => {
-  let pricingSheet;
-  const TAX = { category: 'tax', amount: 100 };
-  const DISCOUNT = { category: 'discount', amount: 50 };
-  const ITEM1 = { category: 'item', amount: 200 };
-  const ITEM2 = { category: 'item', amount: 200 };
-  const calculations = [TAX, DISCOUNT, ITEM1, ITEM2];
-
-  beforeEach(() => {
-    pricingSheet = BasePricingSheet({
-      calculation: calculations,
-    });
-  });
-
-  it('gross() calculates the sum of the amounts in the calculations', () => {
-    expect(pricingSheet.gross()).toEqual(550);
-  });
-
-  it('gross() returns 0 if the calculation is empty', () => {
-    expect(BasePricingSheet({ calculation: [] }).gross()).toEqual(0);
-  });
-
-  it('total() calculates the sum of the amounts in the calculations by default', () => {
-    expect(pricingSheet.total()).toEqual({ amount: 550, currency: undefined });
-  });
-
-  it('total() calculates the sum of the amounts in the calculations for a given category', () => {
-    expect(pricingSheet.total({ category: 'item' })).toEqual({ amount: 400, currency: undefined });
-  });
-
-  it('total() calculates the net sum of the amounts in the calculations if useNetPrice is true', () => {
-    expect(pricingSheet.total({ useNetPrice: true })).toEqual({ amount: 550, currency: undefined });
-  });
-
-  it('total() returns 0 if the calculation is empty', () => {
-    expect(BasePricingSheet({ calculation: [] }).total()).toEqual({ amount: 0, currency: undefined });
-  });
-
-  it('calculates the correct net amount', () => {
-    expect(pricingSheet.net()).toEqual(550);
-  });
-
-  it('calculates the correct sum for a given category', () => {
-    expect(pricingSheet.sum({ category: 'item' })).toEqual(400);
-  });
-
-  it('calculates the correct tax amount', () => {
-    expect(pricingSheet.taxSum()).toEqual(0);
-  });
-
-  describe('getRawPricingSheet', () => {
-    it('returns the correct list of calculations', () => {
-      expect(pricingSheet.getRawPricingSheet()).toEqual(calculations);
-    });
-
-    it('returns an empty list of calculations if none are provided', () => {
-      expect(BasePricingSheet({}).getRawPricingSheet()).toEqual([]);
-    });
-  });
-
-  describe('isValid', () => {
-    it('returns true if the sheet has calculations', () => {
-      expect(pricingSheet.isValid()).toEqual(true);
-    });
-
-    it('returns false if the sheet does not have calculations', () => {
-      expect(BasePricingSheet({}).isValid()).toEqual(false);
-    });
-  });
-
-  describe('filterBy', () => {
-    it('filters the list of calculations correctly', () => {
-      expect(pricingSheet.filterBy({ category: 'item' })).toEqual([ITEM1, ITEM2]);
-    });
-
-    it('returns the full list of calculations if no filter is provided', () => {
-      expect(pricingSheet.filterBy()).toEqual(calculations);
-    });
-  });
-
-  describe('resetCalculation', () => {
-    it('resets the list of calculations correctly', () => {
-      const expectedCalculations = calculations.reduce(
-        (prev, { amount, ...row }) => {
-          return [
-            ...prev,
-            {
-              ...row,
-              amount: -amount,
-            },
-          ];
-        },
-        [...calculations],
-      );
-      expect(pricingSheet.resetCalculation(pricingSheet)).toEqual(expectedCalculations);
-    });
-  });
-});

package/src/random-value-hex.ts

@@ -1,8 +0,0 @@
-import crypto from 'crypto';
-
-export default function randomValueHex(len: number): string {
-  return crypto
-    .randomBytes(Math.ceil(len / 2))
-    .toString('hex') // convert to hexadecimal format
-    .slice(0, len); // return required number of characters
-}