@sparted/shared-library 1.0.7 → 1.0.8-alpha.0

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,3 @@
+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);
+  });
+});

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

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

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

package/src/promise/delay.ts

@@ -0,0 +1,3 @@
+export const delay = (time: number) => new Promise((resolve) => {
+  setTimeout(resolve, time);
+});

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

@@ -0,0 +1,14 @@
+export type ExecutionConfig<Default> = {
+  execute: boolean,
+  defaultValue: Default,
+};
+
+export const executeOrResolveDefault = <T, Default>(callback: () => Promise<T>, config: ExecutionConfig<Default>): Promise<T | Default> => {
+  const { execute, defaultValue } = config;
+
+  if (execute) {
+    return callback();
+  }
+
+  return Promise.resolve(defaultValue);
+};

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

@@ -0,0 +1,6 @@
+import { delay } from './delay';
+
+export const executeWithDelay = async <T>(callback: () => T, time: number): Promise<T> => {
+  await delay(time);
+  return callback();
+};

package/src/promise/index.ts

@@ -0,0 +1,3 @@
+export * from './execute-or-resolve-default';
+export * from './execute-with-delay';
+export * from './delay';

package/src/string/__tests__/replace-in-template.test.ts

@@ -0,0 +1,52 @@
+import { replaceInTemplate } from '../replace-in-template';
+
+describe('replaceInTemplate', () => {
+  it('should inject the params object into the template with the default config', () => {
+    const template = 'You need to wait {{time}} minutes before ordering on {{deliveryService}} again';
+    const message = replaceInTemplate(template, {
+      time: 5,
+      deliveryService: 'Uber Eat',
+    });
+
+    expect(message).toStrictEqual('You need to wait 5 minutes before ordering on Uber Eat again');
+  });
+
+  it('should handle if there is a primitive array in params', () => {
+    const template = 'Grocery: {{groceries}}';
+    const message = replaceInTemplate(template, {
+      groceries: [
+        'Twix',
+        'Oasis',
+        'm&ms',
+      ],
+    });
+
+    expect(message).toStrictEqual('Grocery: Twix, Oasis, m&ms');
+  });
+
+  it('should ignore non primitive values', () => {
+    const template = 'City: {{city}}, population: {{population}}';
+    const message = replaceInTemplate(template, {
+      city: 'Washington D.C.',
+      population: {
+        value: 12000000,
+      },
+    });
+
+    expect(message).toStrictEqual('City: Washington D.C., population: {{population}}');
+  });
+
+  it('should handle custom delimiter', () => {
+    const template = 'ISO |iso|, |focalLength| mm, f/|aperture|';
+    const params = {
+      iso: 100,
+      focalLength: 50,
+      aperture: '2.8',
+    };
+    const message = replaceInTemplate(template, params, {
+      delimiter: '|',
+    });
+
+    expect(message).toStrictEqual('ISO 100, 50 mm, f/2.8');
+  });
+});

package/src/string/index.ts

@@ -0,0 +1 @@
+export * from './replace-in-template';

package/src/string/replace-in-template.ts

@@ -0,0 +1,45 @@
+import { isArrayOfPrimitive, isPrimitive } from '../predicates';
+
+export type ReplaceConfig = {
+  delimiter: string | {
+    left: string,
+    right: string,
+  },
+};
+
+const defaultConfig: ReplaceConfig = {
+  delimiter: {
+    left: '{{',
+    right: '}}',
+  },
+};
+
+/**
+ * Replace string inside a template. For now, only works with
+ * an object containing promirives or array of primitives. If
+ * it contains other objects, they will be ignored.
+ *
+ * Uses the mustache syntax by default.
+ */
+export const replaceInTemplate = (
+  template: string,
+  params: Record<string, any>,
+  config: ReplaceConfig = defaultConfig,
+) => {
+  const { delimiter } = config;
+  const leftDelimiter = typeof delimiter === 'string' ? delimiter : delimiter.left;
+  const rightDelimiter = typeof delimiter === 'string' ? delimiter : delimiter.right;
+
+  return Object
+    .entries(params)
+    .reduce((acc, [key, value]) => {
+      if (!isPrimitive(value) && !isArrayOfPrimitive(value)) {
+        return acc;
+      }
+
+      const searchValue = `${leftDelimiter}${key}${rightDelimiter}`;
+      const replaceBy = Array.isArray(value) ? value.join(', ') : String(value);
+
+      return acc.replace(searchValue, replaceBy);
+    }, template);
+};

package/src/time/__tests__/convert.test.ts

@@ -0,0 +1,14 @@
+import { msToHour, msToMinute } from '../convert';
+
+describe('msToMinute', () => {
+  it('should correctly convert milliseconds to minutes', () => {
+    expect(msToMinute(2520000)).toStrictEqual(42);
+  });
+});
+
+describe('msToHour', () => {
+  it('should correctly convert milliseconds to hours', () => {
+    expect(msToHour(1.08e+7)).toStrictEqual(3);
+    expect(msToHour(10)).toStrictEqual(0);
+  });
+});

package/src/time/__tests__/format-minutes.test.ts

@@ -0,0 +1,10 @@
+import { formatMinutes } from '../format-minutes';
+
+describe('formatMinutes', () => {
+  it('should format minutes correctly', () => {
+    expect(formatMinutes(48)).toBe('48min');
+    expect(formatMinutes(65)).toBe('1h5min');
+    expect(formatMinutes(150)).toBe('2h30min');
+    expect(formatMinutes(355)).toBe('5h55min');
+  });
+});

package/src/time/__tests__/get-time-diff-as-string.test.ts

@@ -0,0 +1,128 @@
+import { getTimeDiffAsString } from '../get-time-diff-as-string';
+import type { MonthLocaleLabels } from '../get-time-diff-as-string';
+
+describe('getTimeDiffAsString', () => {
+  const recentDate = new Date('2020-10-20 00:00:00.000');
+  const locales: MonthLocaleLabels = [
+    'January',
+    'February',
+    'March',
+    'April',
+    'May',
+    'June',
+    'July',
+    'August',
+    'September',
+    'October',
+    'November',
+    'December',
+  ];
+
+  it('should correctly handle recent date in first param', () => {
+    const shouldBeEmptyString = getTimeDiffAsString(
+      new Date('2020-10-20 00:15:00.000'),
+      recentDate,
+    );
+    expect(shouldBeEmptyString).toStrictEqual('');
+  });
+
+  it('should correctly return formated minutes', () => {
+    const shouldBeFifteenMinAgo = getTimeDiffAsString(
+      new Date('2020-10-19 23:45:00.000'),
+      recentDate,
+    );
+    expect(shouldBeFifteenMinAgo).toStrictEqual('15 min ago');
+
+    const shouldbeFiftyNineMinAgo = getTimeDiffAsString(
+      new Date('2020-10-19 23:01:00.000'),
+      recentDate,
+    );
+    expect(shouldbeFiftyNineMinAgo).toStrictEqual('59 min ago');
+
+    const shouldBeOneMinAgo = getTimeDiffAsString(
+      new Date('2020-10-19 23:59:00.000'),
+      recentDate,
+    );
+    expect(shouldBeOneMinAgo).toStrictEqual('1 min ago');
+  });
+
+  it('should correctly return formated hours', () => {
+    const shouldBeOneHourAgo = getTimeDiffAsString(
+      new Date('2020-10-19 23:00:00.000'),
+      recentDate,
+    );
+    expect(shouldBeOneHourAgo).toStrictEqual('1 hour ago');
+
+    const shouldBeTwelveHoursAgo = getTimeDiffAsString(
+      new Date('2020-10-19 12:00:00.000'),
+      recentDate,
+    );
+    expect(shouldBeTwelveHoursAgo).toStrictEqual('12 hours ago');
+
+    const shouldBeTwentyThreeHoursAgo = getTimeDiffAsString(
+      new Date('2020-10-19 01:00:00.000'),
+      recentDate,
+    );
+    expect(shouldBeTwentyThreeHoursAgo).toStrictEqual('23 hours ago');
+  });
+
+  it('should correctly return formated date', () => {
+    const shouldBeOneDayAgo = getTimeDiffAsString(
+      new Date('2020-10-19 00:00:00.000'),
+      recentDate,
+    );
+    expect(shouldBeOneDayAgo).toStrictEqual('on October 19, 12:00 am');
+
+    const shouldBeTenMonthAgo = getTimeDiffAsString(
+      new Date('2020-01-20 12:30:00.000'),
+      recentDate,
+    );
+    expect(shouldBeTenMonthAgo).toStrictEqual('on January 20, 12:30 pm');
+  });
+
+  it('should correctly return according to template', () => {
+    const template = {
+      fullDateTemplate: 'hello %date% darkness',
+      timeTemplate: '%time% %timeLabel% yeet',
+      monthLocaleLabels: locales,
+      timeLabel: {
+        hour: { plural: 'a', singular: 'b' },
+        minute: { plural: 'c', singular: 'd' },
+      },
+    };
+    const shouldBeEmptyString = getTimeDiffAsString(
+      new Date('2020-10-19 00:00:00.000'),
+      recentDate,
+      template,
+    );
+    expect(shouldBeEmptyString).toStrictEqual('hello October 19, 12:00 am darkness');
+
+    const shouldBeTwoHoursAgo = getTimeDiffAsString(
+      new Date('2020-10-19 22:00:00.000'),
+      recentDate,
+      template,
+    );
+    expect(shouldBeTwoHoursAgo).toStrictEqual('2 a yeet');
+
+    const shouldBeOneHourAgo = getTimeDiffAsString(
+      new Date('2020-10-19 23:00:00.000'),
+      recentDate,
+      template,
+    );
+    expect(shouldBeOneHourAgo).toStrictEqual('1 b yeet');
+
+    const shouldbeFiftyNineMinAgo = getTimeDiffAsString(
+      new Date('2020-10-19 23:01:00.000'),
+      recentDate,
+      template,
+    );
+    expect(shouldbeFiftyNineMinAgo).toStrictEqual('59 c yeet');
+
+    const shouldBeOneMinAgo = getTimeDiffAsString(
+      new Date('2020-10-19 23:59:00.000'),
+      recentDate,
+      template,
+    );
+    expect(shouldBeOneMinAgo).toStrictEqual('1 d yeet');
+  });
+});

package/src/time/constants.ts

@@ -0,0 +1,4 @@
+export const MS_SECOND = 1000;
+export const MS_MINUTE = MS_SECOND * 60;
+export const MS_HOUR = MS_MINUTE * 60;
+export const MS_DAY = MS_HOUR * 24;

package/src/time/convert.ts

@@ -0,0 +1,5 @@
+import { MS_MINUTE, MS_HOUR } from './constants';
+
+export const msToMinute = (ms: number) => Math.floor(ms / MS_MINUTE);
+
+export const msToHour = (ms: number) => Math.floor(ms / MS_HOUR);

package/src/time/format-minutes.ts

@@ -0,0 +1,9 @@
+export const formatMinutes = (timeInMin: number): string => {
+  const hours = Math.floor(timeInMin / 60);
+  const mins = Math.round(timeInMin % 60);
+
+  if (hours === 0) return `${mins}min`;
+  if (mins === 0) return `${hours}h`;
+
+  return `${hours}h${mins}min`;
+};