@unchainedshop/utils 4.3.3 → 4.4.0

package/src/build-obfuscated-fields-filter.ts

@@ -1,41 +0,0 @@
-const defaultObfuscatedFields = [
-  'password',
-  'newPassword',
-  'oldPassword',
-  'authorization',
-  'secret',
-  'accesskey',
-  'accesstoken',
-  'token',
-];
-
-const buildObfuscatedFieldsFilter = (blacklistedVariables: string[] = []) => {
-  const sensitiveFields = blacklistedVariables || defaultObfuscatedFields;
-
-  const obfuscateSensitiveFields = (data) => {
-    if (!data) return data;
-
-    if (Array.isArray(data)) {
-      return data.map((item) => obfuscateSensitiveFields(item));
-    }
-
-    if (typeof data === 'object') {
-      const temp = data;
-      Object.keys(temp).forEach((key) => {
-        if (sensitiveFields.includes(key)) {
-          temp[key] = '******';
-        } else {
-          temp[key] = obfuscateSensitiveFields(temp[key]);
-        }
-      });
-
-      return temp; // Return the modified copy
-    }
-
-    return data; // Return unchanged data for non-objects
-  };
-
-  return obfuscateSensitiveFields;
-};
-
-export default buildObfuscatedFieldsFilter;

package/src/calculation.test.ts

@@ -1,171 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-
-import {
-  applyRate,
-  roundToNext,
-  resolveAmountAndTax,
-  applyDiscountToMultipleShares,
-  calculateAmountToSplit,
-} from './calculation';
-
-describe('roundToNext', () => {
-  it('rounds to the next multiple of precision correctly when the value is positive', () => {
-    assert.strictEqual(roundToNext(5, 2), 6);
-    assert.strictEqual(roundToNext(10, 5), 10);
-    assert.strictEqual(roundToNext(13, 5), 15);
-  });
-
-  it('rounds to the next multiple of precision correctly when the value is negative', () => {
-    assert.strictEqual(roundToNext(-5, 2), -4);
-    assert.strictEqual(roundToNext(-10, 5), -10);
-    assert.strictEqual(roundToNext(-13, 5), -10);
-  });
-
-  it('returns 0 when the value is 0', () => {
-    assert.strictEqual(roundToNext(0, 5), 0);
-  });
-
-  it('returns the same value when the precision is 1', () => {
-    assert.strictEqual(roundToNext(5, 1), 5);
-  });
-});
-
-describe('resolveAmountAndTax', () => {
-  it('ratio is 0 and taxDivisor is 0', () => {
-    const result = resolveAmountAndTax({ ratio: 0, taxDivisor: 0 }, 100);
-    assert.deepStrictEqual(result, [0, 0]);
-  });
-
-  it('ratio is not 0 and taxDivisor is 0', () => {
-    const result = resolveAmountAndTax({ ratio: 0.5, taxDivisor: 0 }, 100);
-    assert.deepStrictEqual(result, [50, 0]);
-  });
-
-  it('ratio is 0 and taxDivisor is not 0', () => {
-    const result = resolveAmountAndTax({ ratio: 0, taxDivisor: 2 }, 100);
-    assert.deepStrictEqual(result, [0, 0]);
-  });
-
-  it('ratio and taxDivisor are not 0', () => {
-    const result = resolveAmountAndTax({ ratio: 0.5, taxDivisor: 2 }, 100);
-    assert.deepStrictEqual(result, [50, 25]);
-  });
-
-  it('ratio and taxDivisor are not finite number', () => {
-    const result = resolveAmountAndTax({ ratio: Number.NaN, taxDivisor: Number.NaN }, 100);
-    assert.deepStrictEqual(result, [0, 0]);
-  });
-});
-
-describe('applyDiscountToMultipleShares', () => {
-  it('shares are empty', () => {
-    const result = applyDiscountToMultipleShares([], 100);
-    assert.deepStrictEqual(result, [0, 0]);
-  });
-
-  it('shares have one share', () => {
-    const shares = [{ ratio: 0.5, taxDivisor: 2 }];
-    const result = applyDiscountToMultipleShares(shares, 100);
-    assert.deepStrictEqual(result, [50, 25]);
-  });
-
-  it('shares have multiple shares', () => {
-    const shares = [
-      { ratio: 0.5, taxDivisor: 2 },
-      { ratio: 0.2, taxDivisor: 1.5 },
-    ];
-    const result = applyDiscountToMultipleShares(shares, 100);
-    assert.deepStrictEqual(result, [70, 31.666666666666664]);
-  });
-});
-
-describe('applyRate', () => {
-  it('applies the rate correctly when a rate is provided', () => {
-    const configuration = {
-      rate: 0.1,
-    };
-    const amount = 100;
-    assert.strictEqual(applyRate(configuration, amount), 10);
-  });
-
-  it('applies the fixed rate correctly when a fixed rate is provided', () => {
-    const configuration = {
-      fixedRate: 50,
-    };
-    const amount = 100;
-    assert.strictEqual(applyRate(configuration, amount), 50);
-  });
-
-  it('applies the fixed rate correctly when a fixed rate is provided and the amount is less than fixed rate', () => {
-    const configuration = {
-      fixedRate: 150,
-    };
-    const amount = 100;
-    assert.strictEqual(applyRate(configuration, amount), 100);
-  });
-
-  it('applies the rate correctly when rate is less than or equal to 0', () => {
-    const configuration = {
-      rate: -0.1,
-    };
-    const amount = 100;
-    assert.strictEqual(applyRate(configuration, amount), -10);
-  });
-
-  it('applies the rate correctly when only rate is provided and amount is negative', () => {
-    const configuration = {
-      rate: 0.1,
-    };
-    const amount = -100;
-    assert.strictEqual(applyRate(configuration, amount), -10);
-  });
-
-  it('returns 0 when rate and fixed rate are not provided', () => {
-    const configuration = {};
-    const amount = 100;
-    assert.strictEqual(applyRate(configuration, amount), 0);
-  });
-});
-
-describe('calculateAmountToSplit', () => {
-  it('calculates the correct amount to split when using a rate', () => {
-    const configuration = {
-      rate: 0.1,
-    };
-    const amount = 1000;
-    assert.strictEqual(calculateAmountToSplit(configuration, amount), 100);
-  });
-
-  it('calculates the correct amount to split when using a fixed rate', () => {
-    const configuration = {
-      fixedRate: 50,
-    };
-    const amount = 1000;
-    assert.strictEqual(calculateAmountToSplit(configuration, amount), 50);
-  });
-
-  it('returns 0 when the amount is less than or equal to 0', () => {
-    const configuration = {
-      rate: 0.1,
-    };
-    const amount = 0;
-    assert.strictEqual(calculateAmountToSplit(configuration, amount), 0);
-  });
-
-  it('returns 0 when amount is negative', () => {
-    const configuration = {
-      rate: 0.1,
-    };
-    const amount = -1000;
-    assert.strictEqual(calculateAmountToSplit(configuration, amount), 0);
-  });
-
-  it('returns 0 when configuration rate is negative', () => {
-    const configuration = {
-      rate: -0.1,
-    };
-    const amount = 1000;
-    assert.strictEqual(calculateAmountToSplit(configuration, amount), 0);
-  });
-});

package/src/calculation.ts

@@ -1,43 +0,0 @@
-export const roundToNext = (value: number, precision: number) =>
-  Math.ceil(value / precision) * precision;
-
-export const calculateAmountToSplit = (
-  configuration: { rate?: number; fixedRate?: number },
-  amount: number,
-) => {
-  const deductionAmount = configuration.rate
-    ? amount * configuration.rate
-    : Math.min(configuration.fixedRate || 0, amount);
-
-  const leftInDiscount = Math.max(0, deductionAmount);
-  return leftInDiscount;
-};
-
-export const applyRate = (configuration: { fixedRate?: number; rate?: number }, amount) => {
-  const { rate, fixedRate } = configuration;
-  return rate ? amount * rate : Math.min(fixedRate || 0, amount);
-};
-
-export const getTaxAmount = (total: number, rate: number, isNetPrice: boolean) => {
-  return isNetPrice ? total * rate : total - total / (1 + rate);
-};
-
-export const resolveAmountAndTax = (
-  { ratio, taxDivisor }: { ratio?: number; taxDivisor?: number },
-  amount: number,
-) => {
-  const shareAmount = Number.isFinite(ratio) ? amount * ratio! : 0;
-  const shareTaxAmount =
-    Number.isFinite(taxDivisor) && taxDivisor !== 0 ? shareAmount - shareAmount / taxDivisor! : 0;
-  return [shareAmount, shareTaxAmount];
-};
-
-export const applyDiscountToMultipleShares = (shares, amount) => {
-  return shares.reduce(
-    ([currentDiscountAmount, currentTaxAmount], share) => {
-      const [shareAmount, shareTaxAmount] = resolveAmountAndTax(share, amount);
-      return [currentDiscountAmount + shareAmount, currentTaxAmount + shareTaxAmount];
-    },
-    [0, 0],
-  );
-};

package/src/ch/addressToString.ts

@@ -1,25 +0,0 @@
-export const addressToString = (address?: {
-  addressLine?: string;
-  addressLine2?: string;
-  city?: string;
-  company?: string;
-  countryCode?: string;
-  firstName?: string;
-  lastName?: string;
-  postalCode?: string;
-  regionCode?: string;
-}): string => {
-  if (!address) return '';
-
-  return [
-    [address.firstName, address.lastName].filter(Boolean).join(' '),
-    address.company,
-    address.addressLine,
-    address.addressLine2,
-    [address.postalCode, address.city].filter(Boolean).join(' '),
-    address.regionCode,
-    [address.countryCode].filter(Boolean).join(''),
-  ]
-    .filter(Boolean)
-    .join('\n');
-};

package/src/ch/index.ts

@@ -1,3 +0,0 @@
-// This file contains helpers specifically for Swiss projects. It is not intended to be used in other projects.
-export * from './addressToString.js';
-export * from './priceToString.js';

package/src/ch/priceToString.ts

@@ -1,6 +0,0 @@
-export const priceToString = ({ amount, currencyCode }: { amount: number; currencyCode: string }) => {
-  const fixedPrice = amount / 100;
-  return `${currencyCode} ${fixedPrice}`;
-};
-
-export default priceToString;

package/src/director/BaseAdapter.ts

@@ -1,25 +0,0 @@
-import { defaultLogger, LogLevel } from '@unchainedshop/logger';
-
-export interface IBaseAdapter {
-  key: string;
-  label: string;
-  version: string;
-  asString: () => string;
-  log: (
-    message: string,
-    options?: {
-      level?: LogLevel;
-      [x: string]: any;
-    },
-  ) => void;
-}
-
-export const BaseAdapter: Omit<IBaseAdapter, 'key' | 'label' | 'version'> = {
-  log(message: string, { level = LogLevel.Debug, ...options } = {}) {
-    defaultLogger[level](message, options);
-  },
-
-  asString() {
-    return `${this.key}@${this.version}`;
-  },
-};

package/src/director/BaseDirector.ts

@@ -1,40 +0,0 @@
-import { IBaseAdapter } from './BaseAdapter.js';
-
-export interface IBaseDirector<Adapter extends IBaseAdapter> {
-  getAdapters: (options?: { adapterFilter?: (adapter: Adapter) => boolean }) => Adapter[];
-  getAdapter: (key: string) => Adapter | null;
-  registerAdapter: (A: Adapter) => void;
-  unregisterAdapter: (key: string) => boolean;
-}
-
-export const BaseDirector = <AdapterType extends IBaseAdapter>(
-  directorName: string,
-  options?: {
-    adapterSortKey?: string;
-    adapterKeyField?: string; // Set to 'key' per default
-  },
-): IBaseDirector<AdapterType> => {
-  const Adapters = new Map<string, AdapterType>();
-  const keyField = options?.adapterKeyField || 'key';
-
-  return {
-    getAdapter: (key) => {
-      return Adapters.get(key) || null;
-    },
-
-    getAdapters: ({ adapterFilter } = {}) => {
-      const sortKey = options?.adapterSortKey || keyField;
-      return Array.from(Adapters.values())
-        .toSorted((left, right) => left[sortKey] - right[sortKey])
-        .filter(adapterFilter || (() => true));
-    },
-
-    registerAdapter: (Adapter) => {
-      Adapters.set(Adapter[keyField], Adapter);
-    },
-
-    unregisterAdapter: (key) => {
-      return Adapters.delete(key);
-    },
-  };
-};

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

@@ -1,112 +0,0 @@
-import { describe, it, beforeEach } from 'node:test';
-import assert from 'node:assert';
-import { BaseDirector, IBaseDirector } from './BaseDirector.js';
-
-const adapter1 = {
-  key: 'adapter1',
-  label: 'Adapter 1',
-  version: '1',
-  log: () => ({}),
-};
-
-const adapter2 = {
-  key: 'adapter2',
-  label: 'Adapter 2',
-  version: '2',
-  log: () => ({}),
-};
-
-const adapter3 = {
-  key: 'adapter3',
-  label: 'Adapter 3',
-  version: '3',
-  log: () => ({}),
-};
-
-describe('BaseDirector', () => {
-  let director: IBaseDirector<any>;
-
-  beforeEach(() => {
-    director = BaseDirector('TestDirector');
-    director.registerAdapter(adapter1);
-    director.registerAdapter(adapter3);
-    director.registerAdapter(adapter2);
-  });
-
-  describe('registerAdapter', () => {
-    it('should add the adapter to the director', () => {
-      director.registerAdapter(adapter1);
-      assert.strictEqual(director.getAdapter(adapter1.key), adapter1);
-    });
-
-    it('should allow multiple adapters to be registered', () => {
-      assert.strictEqual(director.getAdapter(adapter1.key), adapter1);
-      assert.strictEqual(director.getAdapter(adapter2.key), adapter2);
-    });
-
-    it('should register an adapter and add it to the internal map', () => {
-      assert.deepStrictEqual(director.getAdapter(adapter1.key), adapter1);
-    });
-
-    it('should use the adapterKeyField specified in the options to store the adapter in the internal map', () => {
-      director = BaseDirector('TestDirector', {
-        adapterKeyField: 'label',
-      });
-      director.registerAdapter(adapter1);
-      assert.deepStrictEqual(director.getAdapter(adapter1.label), adapter1);
-    });
-
-    it('should return the correct Adapter object', () => {
-      const directorName = 'TestDirector';
-      const adapterKeyField = 'key';
-      director = BaseDirector(directorName, { adapterKeyField });
-      director.registerAdapter(adapter1);
-
-      assert.deepStrictEqual(director.getAdapter(adapter1.key), adapter1);
-    });
-
-    it('should return undefined if the Adapter does not exist', () => {
-      const directorName = 'TestDirector';
-      const adapterKeyField = 'key';
-      director = BaseDirector(directorName, { adapterKeyField });
-      assert.strictEqual(director.getAdapter(adapter1.key), null);
-    });
-  });
-
-  describe('getAdapter', () => {
-    it('should return the correct Adapter object for a given key', () => {
-      assert.strictEqual(director.getAdapter(adapter1.key), adapter1);
-    });
-
-    it('should return undefined if no Adapter is registered with the given key', () => {
-      assert.strictEqual(director.getAdapter('invalid-key'), null);
-    });
-
-    it('should return the correct Adapter object when the keyField is set to a property other than "key"', () => {
-      director = BaseDirector('TestDirector', { adapterKeyField: 'label' });
-      director.registerAdapter(adapter1);
-      assert.strictEqual(director.getAdapter(adapter1.label), adapter1);
-    });
-  });
-
-  describe('getAdapters', () => {
-    it('should return an array of registered Adapter objects', () => {
-      assert.deepStrictEqual(director.getAdapters(), [adapter1, adapter3, adapter2]);
-    });
-
-    it('should return an empty array if no Adapter objects have been registered', () => {
-      const directorName = 'TestDirector';
-      const adapterKeyField = 'key';
-      const baseDirector = BaseDirector(directorName, { adapterKeyField });
-      assert.deepStrictEqual(baseDirector.getAdapters(), []);
-    });
-
-    it('should return an array of registered Adapter objects sorted by the adapterSortKey provided', () => {
-      director = BaseDirector('TestDirector', { adapterSortKey: 'version' });
-      director.registerAdapter(adapter1);
-      director.registerAdapter(adapter3);
-      director.registerAdapter(adapter2);
-      assert.deepStrictEqual(director.getAdapters(), [adapter1, adapter2, adapter3]);
-    });
-  });
-});

package/src/find-unused-slug.ts

@@ -1,39 +0,0 @@
-const DELIMITER = '-';
-
-const addSuffixToSlug = (slug, index = 1, delimiter = DELIMITER) => {
-  return `${slug}${delimiter}${index}`;
-};
-
-const incrementSuffixedSlug = (slugIncludingSuffix, delimiter = DELIMITER) => {
-  const slugParts = slugIncludingSuffix.split(delimiter);
-  const suffixedIndex = parseInt(slugParts.pop(), 10);
-  const slugWithoutSuffix = slugParts.join(delimiter);
-  return addSuffixToSlug(slugWithoutSuffix, suffixedIndex + 1);
-};
-
-export default (
-  checkSlugIsUniqueFn: (slug: string) => Promise<boolean>,
-  { slugify }: { slugify: (text: string) => string },
-): ((params: { title?: string; existingSlug?: string; newSlug?: string }) => Promise<string>) => {
-  const findUnusedSlug = async ({
-    title,
-    existingSlug,
-    newSlug,
-  }: {
-    title: string;
-    existingSlug?: string;
-    newSlug?: string;
-  }) => {
-    const slug = newSlug || existingSlug || `${slugify(title)}`;
-    if (!(await checkSlugIsUniqueFn(slug))) {
-      const isSlugAlreadySuffixed = !!newSlug;
-      return findUnusedSlug({
-        title,
-        existingSlug,
-        newSlug: isSlugAlreadySuffixed ? incrementSuffixedSlug(slug) : addSuffixToSlug(slug),
-      });
-    }
-    return slug;
-  };
-  return findUnusedSlug;
-};

package/src/generate-random-hash.ts

@@ -1,8 +0,0 @@
-import Hashids from 'hashids';
-
-const hashids = new Hashids('unchained', 6, 'ABCDEFGHIJKLMNPQRSTUVWXYZ23456789');
-
-export default () => {
-  const randomNumber = Math.floor(Math.random() * (999999999 - 1)) + 1;
-  return hashids.encode(randomNumber);
-};

package/src/locale-helpers.ts

@@ -1,79 +0,0 @@
-import { resolveAcceptLanguage } from 'resolve-accept-language';
-
-const { UNCHAINED_LANG = 'de', UNCHAINED_COUNTRY = 'CH', UNCHAINED_CURRENCY = 'CHF' } = process.env;
-
-export const systemLocale = new Intl.Locale(`${UNCHAINED_LANG}-${UNCHAINED_COUNTRY}`);
-
-export const determineFallbackLocale = (
-  countries: { isoCode: string }[],
-  languages: { isoCode: string }[],
-): Intl.Locale => {
-  try {
-    const country =
-      countries.find((country) => country.isoCode === systemLocale.region)?.isoCode ||
-      countries[0]?.isoCode;
-    const language =
-      languages.find((language) => language.isoCode === systemLocale.language)?.isoCode ||
-      languages[0]?.isoCode;
-    return new Intl.Locale(`${language}-${country}`);
-  } catch {
-    return systemLocale;
-  }
-};
-
-export const resolveBestSupported = (
-  acceptLanguage: string,
-  acceptCountry: string,
-  {
-    countries = [],
-    languages = [],
-  }: {
-    countries: { isoCode: string }[];
-    languages: { isoCode: string }[];
-  },
-): Intl.Locale => {
-  const supportedLocales: string[] = languages.reduce<string[]>((accumulator, language) => {
-    const added = countries
-      .filter((country) => {
-        if (acceptCountry) {
-          return country.isoCode === acceptCountry;
-        }
-        return true;
-      })
-      .map((country) => {
-        return `${language.isoCode}-${country.isoCode}`;
-      });
-    return accumulator.concat(added);
-  }, []);
-
-  const fallbackLocale = determineFallbackLocale(countries, languages);
-
-  try {
-    const { match } = resolveAcceptLanguage(
-      acceptLanguage || '',
-      supportedLocales,
-      fallbackLocale.baseName,
-      {
-        returnMatchType: true,
-      },
-    );
-    return new Intl.Locale(match);
-  } catch {
-    return fallbackLocale;
-  }
-};
-
-export const resolveBestCurrency = (currencyCode: string | null, currencies: { isoCode: string }[]) => {
-  if (currencyCode) {
-    const resolvedCurrency = currencies.find(
-      (currency) => currency.isoCode.toUpperCase() === currencyCode.toUpperCase(),
-    );
-    if (resolvedCurrency) {
-      return resolvedCurrency.isoCode;
-    }
-  }
-  return (
-    currencies.find((currency) => currency.isoCode === UNCHAINED_CURRENCY)?.isoCode ||
-    currencies[0]?.isoCode
-  );
-};

package/src/object-invert.ts

@@ -1,8 +0,0 @@
-const invertMapObject = (theMapObject: Record<string, string>): Record<string, string> =>
-  Object.keys(theMapObject).reduce((invertedObj, key) => {
-    const newObj = invertedObj;
-    newObj[theMapObject[key]] = key;
-    return newObj;
-  }, {});
-
-export default invertMapObject;

package/src/pipe-promises.ts

@@ -1,2 +0,0 @@
-export default (fns) => (initialValue) =>
-  fns.reduce((sum, fn) => Promise.resolve(sum).then(fn), initialValue);

package/src/sha1.ts

@@ -1,6 +0,0 @@
-export default async function sha1(message) {
-  const bytes = new TextEncoder().encode(message);
-  const hashBuffer = await crypto.subtle.digest('SHA-1', bytes);
-  // Return Uint8Array instead of Buffer
-  return new Uint8Array(hashBuffer);
-}

package/src/sha256.ts

@@ -1,8 +0,0 @@
-export default async function sha256(message) {
-  const bytes = new TextEncoder().encode(message);
-  const hashBuffer = await crypto.subtle.digest('SHA-256', bytes);
-  // Convert ArrayBuffer to hex string without using Buffer
-  return Array.from(new Uint8Array(hashBuffer))
-    .map((b) => b.toString(16).padStart(2, '0'))
-    .join('');
-}

package/src/slugify.ts

@@ -1,10 +0,0 @@
-export default function slugify(text: string): string {
-  return text
-    .toString()
-    .toLowerCase()
-    .replace(/\s+/g, '-') // Replace spaces with -
-    .replace(/[^\w-]+/g, '') // Remove all non-word chars
-    .replace(/--+/g, '-') // Replace multiple - with single -
-    .replace(/^-+/, '') // Trim - from start of text
-    .replace(/-+$/, ''); // Trim - from end of text
-}