@sparted/shared-library 1.0.29 → 1.1.0-rc0

package/src/math/__tests__/median.test.ts

@@ -0,0 +1,27 @@
+import { median } from '../median';
+
+describe('median', () => {
+  it('should return the middle value if the array has an odd number of elements', () => {
+    expect(median([1, 2, 3])).toStrictEqual(2);
+  });
+
+  it('should return the average of the middle two values if the array has an even number of elements', () => {
+    expect(median([1, 2, 3, 4])).toStrictEqual(2.5);
+  });
+
+  it('should handle an empty array', () => {
+    expect(median([])).toBeNull();
+  });
+
+  it('should handle array with duplicate values', () => {
+    expect(median([4, 7, 2, 4, 9])).toStrictEqual(4);
+  });
+
+  it('should handle array with negative values', () => {
+    expect(median([-1, -5, -3, -2, -4])).toStrictEqual(-3);
+  });
+
+  it('should overwrite the default value if the array is empty', () => {
+    expect(median([], 0)).toStrictEqual(0);
+  });
+});

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

@@ -0,0 +1,59 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,8 @@
+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

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

package/src/math/interpolate.ts

@@ -0,0 +1,18 @@
+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

@@ -0,0 +1,21 @@
+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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,10 @@
+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

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,65 @@
+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

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

package/src/object/merge-deep.ts

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,26 @@
+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

@@ -0,0 +1,15 @@
+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

@@ -0,0 +1,19 @@
+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

@@ -0,0 +1,20 @@
+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

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

package/src/parsing/parse-boolean.ts

@@ -0,0 +1,10 @@
+/**
+ * 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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,12 @@
+/**
+ * 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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,42 @@
+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

@@ -0,0 +1,11 @@
+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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,5 @@
+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

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

package/src/predicates/is-null.ts

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

package/src/predicates/is-object.ts

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

package/src/predicates/is-primitive.ts

@@ -0,0 +1,19 @@
+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

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

package/src/predicates/is-uuid.ts

@@ -0,0 +1,3 @@
+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

@@ -0,0 +1,13 @@
+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);
+  });
+});