@sparted/shared-library 1.1.8 → 1.2.0

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

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__/is-string-length-within-range.test.ts

@@ -0,0 +1,23 @@
+import { isStringLengthWithinRange } from '../is-string-length-within-range';
+
+describe('isStringLengthWithinRange', () => {
+  it('should return true if the length is within the range', () => {
+    expect(isStringLengthWithinRange({ min: 1, max: 10 }, 'a'.repeat(5))).toBe(true);
+    expect(isStringLengthWithinRange({ min: 1, max: 10 }, 'a'.repeat(1))).toBe(true);
+    expect(isStringLengthWithinRange({ min: 1, max: 10 }, 'a'.repeat(10))).toBe(true);
+  });
+
+  it('should return false if the length is not within the range', () => {
+    expect(isStringLengthWithinRange({ min: 1, max: 10 }, 'a'.repeat(20))).toBe(false);
+  });
+
+  it('should handle undefined string', () => {
+    expect(isStringLengthWithinRange({ min: 1, max: 10 })).toBe(false);
+    expect(isStringLengthWithinRange({ min: 0, max: 10 })).toBe(true);
+    expect(isStringLengthWithinRange({ min: -10, max: -1 })).toBe(false);
+  });
+
+  it('should throw an error if the range is invalid', () => {
+    expect(() => isStringLengthWithinRange({ min: 10, max: 1 })).toThrowError('Invalid range');
+  })
+});

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,2 @@
+export * from './replace-in-template';
+export * from './is-string-length-within-range';

package/src/string/is-string-length-within-range.ts

@@ -0,0 +1,10 @@
+import { Range } from '../types/general';
+
+export const isStringLengthWithinRange = (range: Range, str?: string) => {
+  if (range.min > range.max) {
+    throw new Error('Invalid range');
+  }
+
+  const strLength = str?.length || 0;
+  return strLength >= (range.min || 0) && strLength <= range.max;
+}

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`;
+};