@sparted/shared-library 1.9.5 → 1.9.6

package/src/math/__tests__/number-range.test.ts

@@ -1,59 +0,0 @@
-import { assertNumberRange, isNumberInRange } from '../number-range';
-
-describe('assertNumberRange', () => {
-  it('should throw an error if min is above max', () => {
-    expect(
-      () => assertNumberRange({
-        min: 5,
-        max: 0,
-      }),
-    ).toThrowError('Invalid number range: min must be lower than or equal to max');
-  });
-
-  it('should not throw an error if the number range is valid', () => {
-    expect(
-      () => assertNumberRange({
-        min: 0,
-        max: 5,
-      }),
-    ).not.toThrowError();
-  });
-});
-
-describe('isNumberInRange', () => {
-  it('should throw an error if range is incorrect', () => {
-    expect(
-      () => isNumberInRange(2, {
-        min: 5,
-        max: 0,
-      }),
-    ).toThrowError('Invalid number range: min must be lower than or equal to max');
-  });
-
-  it('should return true if number is in range', () => {
-    const set = [
-      { num: 1, range: { min: 0, max: 1 } },
-      { num: 0, range: { min: 0, max: 1 } },
-      { num: 0.5, range: { min: 0, max: 1 } },
-      { num: -30, range: { min: -1000, max: 1000 } },
-    ];
-
-    set.forEach(({ num, range }) => {
-      expect(isNumberInRange(num, range)).toBeTrue();
-    });
-  });
-
-  it('should return false if number is not in range', () => {
-    const set = [
-      { num: -5, range: { min: 0, max: 1 } },
-      { num: 1.01, range: { min: 0, max: 1 } },
-      { num: 10, range: { min: 0, max: 1 } },
-      { num: -2000, range: { min: -1000, max: 1000 } },
-      { num: 2000, range: { min: -1000, max: 1000 } },
-    ];
-
-    set.forEach(({ num, range }) => {
-      expect(isNumberInRange(num, range)).toBeFalse();
-    });
-  });
-});

package/src/math/__tests__/random-number.test.ts

@@ -1,11 +0,0 @@
-import { randomNumber } from '../random-number';
-
-describe('randomNumber', () => {
-  const satisfyInRange = (min: number, max: number) => (value: number) => value >= min && value <= max;
-
-  it('should return a random number between the range', () => {
-    expect(randomNumber({ min: 98, max: 110 })).toSatisfy(satisfyInRange(98, 110));
-    expect(randomNumber({ min: -5, max: 0 })).toSatisfy(satisfyInRange(-5, 0));
-    expect(randomNumber({ min: 0, max: 10 })).toSatisfy(satisfyInRange(0, 10));
-  });
-});

package/src/math/clamp-number.ts

@@ -1,8 +0,0 @@
-import { assertNumberRange } from './number-range';
-import type { NumberRange } from './number-range';
-
-export const clampNumber = (num: number, { min, max }: NumberRange) => {
-  assertNumberRange({ min, max });
-
-  return Math.min(Math.max(num, min), max);
-};

package/src/math/index.ts

@@ -1,5 +0,0 @@
-export * from './clamp-number';
-export * from './interpolate';
-export * from './number-range';
-export * from './random-number';
-export * from './median';

package/src/math/interpolate.ts

@@ -1,18 +0,0 @@
-import { isNumberInRange } from './number-range';
-
-export type RangeArray = [number, number];
-
-export const interpolate = (num: number, inputRange: RangeArray, outputRange: RangeArray) => {
-  const [x1, x2] = inputRange;
-  const [y1, y2] = outputRange;
-
-  if (x1 > x2) {
-    throw new Error('interpolate: inputRange[0] should not be superior to inputRange[1]');
-  }
-
-  if (!isNumberInRange(num, { min: x1, max: x2 })) {
-    throw new Error(`interpolate: input number {${num}} is not in range of {${x1}}-{${x2}}`);
-  }
-
-  return y1 + ((num - x1) / (x2 - x1)) * (y2 - y1);
-};

package/src/math/median.ts

@@ -1,21 +0,0 @@
-export function median(arr: number[]): number | null;
-export function median(arr: number[], defaultValueIfEmpty: number): number;
-export function median(arr: number[], defaultValueIfEmpty?: number) {
-  if (arr.length === 0) {
-    if (typeof defaultValueIfEmpty === 'number') {
-      return defaultValueIfEmpty;
-    }
-    return null;
-  }
-
-  const sorted = [...arr].sort((a, b) => a - b);
-  const mid = Math.floor(sorted.length / 2);
-
-  // If the length of the array is odd, return the middle element
-  if (sorted.length % 2 === 1) {
-    return sorted[mid];
-  }
-
-  // If the length of the array is even, return the average of the middle two elements
-  return (sorted[mid - 1] + sorted[mid]) / 2;
-}

package/src/math/number-range.ts

@@ -1,16 +0,0 @@
-export type NumberRange = {
-  min: number,
-  max: number,
-};
-
-export const assertNumberRange = (range: NumberRange) => {
-  if (range.min > range.max) {
-    throw new Error('Invalid number range: min must be lower than or equal to max');
-  }
-};
-
-export const isNumberInRange = (num: number, { min, max }: NumberRange) => {
-  assertNumberRange({ min, max });
-
-  return num >= min && num <= max;
-};

package/src/math/random-number.ts

@@ -1,10 +0,0 @@
-import { assertNumberRange } from './number-range';
-import type { NumberRange } from './number-range';
-
-export const randomNumber = ({ min, max }: NumberRange) => {
-  assertNumberRange({ min, max });
-
-  return Math.floor(
-    Math.random() * (max - min) + min,
-  );
-};

package/src/object/__tests__/merge-deep.test.ts

@@ -1,56 +0,0 @@
-import { mergeDeep } from '../merge-deep';
-
-type A = {
-  a: number,
-  b: {
-    c: {
-      c1: string,
-      c2: number,
-    },
-  },
-  d:ReadonlyArray<number>,
-  e: boolean,
-};
-
-describe('mergeDeep', () => {
-  it('should return same object if no update', () => {
-    const a: A = {
-      a: 0, b: { c: { c1: 'yo', c2: 0 } }, d: [], e: false,
-    };
-    const b = {};
-
-    expect(mergeDeep(a, b)).toBe(a);
-  });
-
-  it('should leave object unchanged if update does nothing', () => {
-    const a: A = {
-      a: 0, b: { c: { c1: 'yo', c2: 0 } }, d: [], e: false,
-    };
-    const b = { a: 0 };
-
-    expect(mergeDeep(a, b)).toBe(a);
-  });
-
-  it('should do an update', () => {
-    const a: A = {
-      a: 0, b: { c: { c1: 'yo', c2: 0 } }, d: [], e: false,
-    };
-    const b = { a: 1, b: { c: { c1: 'hey' } }, d: [1, 2], e: true };
-
-    expect(mergeDeep(a, b)).toStrictEqual({ a: 1, b: { c: { c1: 'hey', c2: 0 } }, d: [1, 2], e: true });
-  });
-
-  it('should overwrite arrays', () => {
-    const a = { a: [1, 2] };
-    const b = { a: [3, 4] };
-
-    expect(mergeDeep(a, b)).toStrictEqual(b);
-  });
-
-  it('should not add new keys', () => {
-    const a = { a: 0, c: 0 };
-    const b: any = { a: 0, b: 0, c: 0 };
-
-    expect(mergeDeep(a, b)).toBe(a);
-  });
-});

package/src/object/__tests__/strip-properties-from-object.test.ts

@@ -1,65 +0,0 @@
-import { stripPropertiesFromObject } from '../strip-properties-from-object';
-
-describe('stripPropertiesFromObject', () => {
-  const obj = {
-    a: 1,
-    b: {
-      b1: 1,
-      b2: 2,
-      b3: 3,
-      b4: {
-        b41: 1,
-        b42: 2,
-        b43: 3,
-      },
-    },
-    c: 3,
-  };
-
-  it('should remove the properties from the object', () => {
-    const result = stripPropertiesFromObject(obj, ['c', 'b.b1', 'b.b4.b41']);
-
-    expect(result).toMatchObject({
-      a: 1,
-      b: {
-        b2: 2,
-        b3: 3,
-        b4: {
-          b42: 2,
-          b43: 3,
-        },
-      },
-    });
-
-    // Check if no mutation on the orignal object
-    expect(obj).toEqual({
-      a: 1,
-      b: {
-        b1: 1,
-        b2: 2,
-        b3: 3,
-        b4: {
-          b41: 1,
-          b42: 2,
-          b43: 3,
-        },
-      },
-      c: 3,
-    });
-  });
-
-  it('should ignore properties that do not exist', () => {
-    const result = stripPropertiesFromObject(obj, ['d', 'a.b', 'b.b1.b11']);
-    expect(result).toEqual(obj);
-  });
-
-  it('should not fail with empty array', () => {
-    const result = stripPropertiesFromObject(obj, []);
-    expect(result).toEqual(obj);
-  });
-
-  it('should handle empty property', () => {
-    const result = stripPropertiesFromObject(obj, ['']);
-    expect(result).toEqual(obj);
-  });
-});

package/src/object/index.ts

@@ -1,2 +0,0 @@
-export * from './merge-deep';
-export * from './strip-properties-from-object';

package/src/object/merge-deep.ts

@@ -1,26 +0,0 @@
-import type { DeepPartial, ValueType } from '../types';
-
-// https://stackoverflow.com/questions/8511281/check-if-a-value-is-an-object-in-javascript/8511350#8511350
-const isObject = (a: any) => typeof a === 'object' && a !== null;
-const isValueType = (a: any): a is ValueType => !isObject(a) || Array.isArray(a);
-
-export const mergeDeep = <T>(a: T, b: DeepPartial<T>): T => {
-  if (isValueType(a) || isValueType(b)) {
-    return b as T;
-  }
-
-  return (Object.keys(b) as (keyof T)[]).reduce((acc, key) => {
-    // @ts-ignore
-    if (!(key in a)) {
-      return acc;
-    }
-
-    if (b[key] === a[key]) {
-      return acc;
-    }
-
-    const merged = mergeDeep(a[key], b[key] as DeepPartial<T[keyof T]>);
-
-    return { ...acc, [key]: merged };
-  }, a);
-};

package/src/object/strip-properties-from-object.ts

@@ -1,26 +0,0 @@
-import structuredClone from '@ungap/structured-clone';
-
-export const stripPropertiesFromObject = <Output extends Record<any, any>, Input extends Record<any, any>>(
-  obj: Input,
-  properties: string[],
-): Output => {
-  const copy = structuredClone(obj);
-
-  properties.forEach((nestedPropertyStr) => {
-    const nestedProperties = nestedPropertyStr.split('.');
-    const propertyToRemove = nestedProperties[nestedProperties.length - 1];
-
-    const nestedObject =
-      nestedProperties.length === 1
-        ? copy
-        : nestedProperties
-            .slice(0, nestedProperties.length - 1)
-            .reduce((acc, property) => acc[property], copy);
-
-    if (nestedObject) {
-      delete nestedObject[propertyToRemove];
-    }
-  });
-
-  return copy;
-};

package/src/parsing/__tests__/parse-boolean.test.ts

@@ -1,15 +0,0 @@
-import { parseBoolean } from '../parse-boolean';
-
-describe('parseBoolean', () => {
-  it('should return true if value is "true"', () => {
-    expect(parseBoolean('true')).toStrictEqual(true);
-  });
-
-  it('should return false if value is "false"', () => {
-    expect(parseBoolean('false')).toStrictEqual(false);
-  });
-
-  it('should throw an exception if value is neither "true" nor "false"', () => {
-    expect(() => parseBoolean('value')).toThrow();
-  });
-});

package/src/parsing/__tests__/parse-enum.test.ts

@@ -1,19 +0,0 @@
-import { createEnumParser } from '../parse-enum';
-
-enum TestEnum {
-  FirstValue = 'first',
-  SecondValue = 'second',
-  ThirdValue = 'third',
-}
-
-describe('createEnumParser', () => {
-  const parseTestEnum = createEnumParser(TestEnum);
-
-  it('should return a valid enum parser', () => {
-    expect(parseTestEnum('second')).toStrictEqual(TestEnum.SecondValue);
-  });
-
-  it('should throw an error if the parsing did not work', () => {
-    expect(() => parseTestEnum('fourth')).toThrowError();
-  });
-});

package/src/parsing/__tests__/parse-number.test.ts

@@ -1,20 +0,0 @@
-import { parseNumber } from '../parse-number';
-
-describe('parseNumber', () => {
-  it('should return number 10 if value is "10', () => {
-    expect(parseNumber('10')).toStrictEqual(10);
-  });
-
-  it('should return -10 if value is "-10"', () => {
-    expect(parseNumber('-10')).toStrictEqual(-10);
-  });
-
-  it('should return 0 if value is "0"', () => {
-    expect(parseNumber('0')).toStrictEqual(0);
-  });
-
-  it('should throw an exception if value is not a number', () => {
-    expect(() => parseNumber('number')).toThrow();
-    expect(() => parseNumber('false')).toThrow();
-  });
-});

package/src/parsing/index.ts

@@ -1,3 +0,0 @@
-export * from './parse-boolean';
-export * from './parse-enum';
-export * from './parse-number';

package/src/parsing/parse-boolean.ts

@@ -1,10 +0,0 @@
-/**
- * Parse a string to a boolean. Throw error if string is neither "true" nor "false"
- */
-export const parseBoolean = (value: string): boolean => {
-  if (value !== 'true' && value !== 'false') {
-    throw new Error('Cannot parse value');
-  }
-
-  return value === 'true';
-};

package/src/parsing/parse-enum.ts

@@ -1,16 +0,0 @@
-import type { Primitive } from '../types';
-
-/**
- * Factory to build enum to parse a string to an enum. Throw error if string is not an enum value
- */
-export const createEnumParser = <E extends Record<string, Primitive>>(enumType: E) => (
-  (value: string) => {
-    const enumValues = Object.values(enumType);
-
-    if (!enumValues.includes(value as any)) {
-      throw new Error('Can\'t parse this value');
-    }
-
-    return value as unknown as E;
-  }
-);

package/src/parsing/parse-number.ts

@@ -1,12 +0,0 @@
-/**
- * Parse a string to a number. Throw error if string is NaN
- */
-export const parseNumber = (value: string): number => {
-  const number = parseInt(value, 10);
-
-  if (Number.isNaN(number)) {
-    throw new Error('Cannot parse value');
-  }
-
-  return number;
-};

package/src/predicates/__tests__/is-function.test.ts

@@ -1,11 +0,0 @@
-import { isFunction } from '../is-function';
-
-describe('isFunction', () => {
-  it('should return true if value is a function', () => {
-    expect(isFunction(() => {})).toBeTrue();
-  });
-
-  it('should return false if value is not a function', () => {
-    expect(isFunction('')).toBeFalse();
-  });
-});

package/src/predicates/__tests__/is-null.test.ts

@@ -1,11 +0,0 @@
-import { isNull } from '../is-null';
-
-describe('isNull', () => {
-  it('should return true if value is null', () => {
-    expect(isNull(null)).toBeTrue();
-  });
-
-  it('should return false if value is not null', () => {
-    expect(isNull('')).toBeFalse();
-  });
-});

package/src/predicates/__tests__/is-object.test.ts

@@ -1,11 +0,0 @@
-import { isObject } from '../is-object';
-
-describe('isObject', () => {
-  it('should return true if value is an object', () => {
-    expect(isObject({})).toBeTrue();
-  });
-
-  it('should return false if value is not an object', () => {
-    expect(isObject('')).toBeFalse();
-  });
-});

package/src/predicates/__tests__/is-primitive.test.ts

@@ -1,42 +0,0 @@
-import { isPrimitive, isArrayOfPrimitive } from '../is-primitive';
-
-describe('isPrimitive', () => {
-  it('should return true if value is a primitive', () => {
-    expect(isPrimitive('a value')).toBeTrue();
-    expect(isPrimitive(6)).toBeTrue();
-    expect(isPrimitive(true)).toBeTrue();
-  });
-
-  it('should return false if value is not a primitive', () => {
-    expect(isPrimitive({})).toBeFalse();
-    expect(isPrimitive(new Date())).toBeFalse();
-    expect(isPrimitive([])).toBeFalse();
-  });
-});
-
-describe('isArrayOfPrimitive', () => {
-  it('should return false if value not an array', () => {
-    expect(isArrayOfPrimitive({})).toBeFalse();
-    expect(isArrayOfPrimitive(1)).toBeFalse();
-  });
-
-  it('should return false if not every value in the array is primitive', () => {
-    expect(isArrayOfPrimitive([
-      1,
-      'test',
-      true,
-      false,
-      [],
-      {},
-    ])).toBeFalse();
-  });
-
-  it('should return true if every value in the array is a primitive', () => {
-    expect(isArrayOfPrimitive([
-      1,
-      'test',
-      true,
-      false,
-    ])).toBeTrue();
-  });
-});

package/src/predicates/__tests__/is-undefined.test.ts

@@ -1,11 +0,0 @@
-import { isUndefined } from '../is-undefined';
-
-describe('isUndefined', () => {
-  it('should return true if value is undefined', () => {
-    expect(isUndefined(undefined)).toBeTrue();
-  });
-
-  it('should return false if value is not undefined', () => {
-    expect(isUndefined('')).toBeFalse();
-  });
-});

package/src/predicates/__tests__/is-uuid.test.ts

@@ -1,13 +0,0 @@
-import { isUuidV4 } from '../is-uuid';
-
-describe('isUuidV4', () => {
-  it('returns true if the string is uuid v4', () => {
-    expect(isUuidV4('dd819894-70f3-4629-8712-430445f93c5d')).toBeTrue();
-  });
-  it('returns false if argument is not a string', () => {
-    expect(isUuidV4(4)).toBeFalse();
-  });
-  it('returns false if argument is uuid V1', () => {
-    expect(isUuidV4('4dfde9e2-3988-11ed-a261-0242ac120002')).toBeFalse();
-  });
-});

package/src/predicates/index.ts

@@ -1,5 +0,0 @@
-export * from './is-function';
-export * from './is-null';
-export * from './is-object';
-export * from './is-primitive';
-export * from './is-undefined';

package/src/predicates/is-function.ts

@@ -1,3 +0,0 @@
-export const isFunction = (value: any): value is Function => (
-  typeof value === 'function'
-);

package/src/predicates/is-null.ts

@@ -1 +0,0 @@
-export const isNull = (value: any): value is null => value === null;

package/src/predicates/is-object.ts

@@ -1,3 +0,0 @@
-export const isObject = (value: any): value is Object => (
-  typeof value === 'object'
-);

package/src/predicates/is-primitive.ts

@@ -1,19 +0,0 @@
-import { Primitive } from '../types/general';
-
-const PRIMITIVE_TYPES = [
-  'string',
-  'boolean',
-  'number',
-];
-
-export const isPrimitive = (value: any): value is Primitive => (
-  PRIMITIVE_TYPES.includes(typeof value)
-);
-
-export const isArrayOfPrimitive = (value: any): value is Array<Primitive> => {
-  if (!Array.isArray(value)) {
-    return false;
-  }
-
-  return value.every((arrayValue) => isPrimitive(arrayValue));
-};

package/src/predicates/is-undefined.ts

@@ -1,3 +0,0 @@
-export const isUndefined = (value: any): value is undefined => (
-  value === undefined
-);

package/src/predicates/is-uuid.ts

@@ -1,3 +0,0 @@
-const UUID_REGEX = /^[0-9A-F]{8}-[0-9A-F]{4}-[4][0-9A-F]{3}-[89AB][0-9A-F]{3}-[0-9A-F]{12}$/i;
-
-export const isUuidV4 = (arg: any): arg is string => UUID_REGEX.test(arg);

package/src/promise/__tests__/delay.test.ts

@@ -1,13 +0,0 @@
-import { delay } from '../delay';
-
-jest.useFakeTimers();
-jest.spyOn(global, 'setTimeout');
-
-describe('delay.ts', () => {
-  it('waits ', () => {
-    delay(500);
-
-    expect(setTimeout).toHaveBeenCalledOnce();
-    expect(setTimeout).toHaveBeenCalledWith(expect.any(Function), 500);
-  });
-});

package/src/promise/__tests__/execute-or-resolve-default.test.ts

@@ -1,25 +0,0 @@
-import { executeOrResolveDefault } from '../execute-or-resolve-default';
-
-describe('executeOrResolveDefault', () => {
-  it('should execute the function', async () => {
-    const cb = jest.fn().mockResolvedValue(8);
-    const res = await executeOrResolveDefault(cb, {
-      execute: true,
-      defaultValue: undefined,
-    });
-
-    expect(res).toStrictEqual(8);
-    expect(cb).toHaveBeenCalledTimes(1);
-  });
-
-  it('should not execute the function', async () => {
-    const cb = jest.fn().mockResolvedValue(8);
-    const res = await executeOrResolveDefault(cb, {
-      execute: false,
-      defaultValue: 'sup m8',
-    });
-
-    expect(res).toStrictEqual('sup m8');
-    expect(cb).toHaveBeenCalledTimes(0);
-  });
-});

package/src/promise/__tests__/execute-with-delay.test.ts

@@ -1,24 +0,0 @@
-import { executeWithDelay } from '../execute-with-delay';
-
-describe('executeWithDelay', () => {
-  beforeAll(() => {
-    jest.useFakeTimers();
-  });
-
-  afterAll(() => {
-    jest.useRealTimers();
-  });
-
-  it('should execute the promise with a delay', async () => {
-    const setTimeoutSpy = jest.spyOn(global, 'setTimeout');
-    const res = executeWithDelay(() => Promise.resolve(1), 500);
-
-    expect(setTimeoutSpy).toHaveBeenCalledWith(expect.toBeFunction(), 500);
-
-    jest.advanceTimersByTime(501);
-
-    expect(await res).toStrictEqual(1);
-
-    setTimeoutSpy.mockRestore();
-  });
-});