@sparted/shared-library 0.0.18 → 1.0.1-O

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

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

@@ -0,0 +1,196 @@
+import { ReplaceConfig, replaceInTemplate } from '../string';
+import { MS_HOUR, MS_DAY } from './constants';
+import { msToMinute, msToHour } from './convert';
+
+export type MonthLocaleLabels = [
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+  string,
+];
+
+export type DiffTemplate = {
+  /**
+   * e.g.: ("%time% %timelabel% blabla")
+   */
+  timeTemplate: string,
+  /**
+   * e.g.: "%date% blabla"
+   */
+  monthLocaleLabels: MonthLocaleLabels,
+  fullDateTemplate: string,
+  timeLabel: {
+    minute: {
+      singular: string,
+      plural: string,
+    },
+    hour: {
+      singular: string,
+      plural: string,
+    },
+  }
+};
+
+const defaultLocaleLabels: MonthLocaleLabels = [
+  'January',
+  'February',
+  'March',
+  'April',
+  'May',
+  'June',
+  'July',
+  'August',
+  'September',
+  'October',
+  'November',
+  'December',
+];
+
+const defaultEnglishTemplate: DiffTemplate = {
+  timeTemplate: '%time% %timeLabel% ago',
+  fullDateTemplate: 'on %date%',
+  monthLocaleLabels: defaultLocaleLabels,
+  timeLabel: {
+    minute: {
+      singular: 'min',
+      plural: 'min',
+    },
+    hour: {
+      singular: 'hour',
+      plural: 'hours',
+    },
+  },
+};
+
+const TEMPLATE_CONFIG: ReplaceConfig = {
+  delimiter: {
+    left: '%',
+    right: '%',
+  },
+};
+
+type HourFormat = {
+  time: string,
+  period: 'am' | 'pm';
+};
+
+type MinuteFormat = {
+  time: string,
+};
+
+type DateForTemplate = {
+  old: Date,
+  recent: Date,
+};
+
+type ParamForTemplateConfig = {
+  templateConfig: DiffTemplate,
+  dates: DateForTemplate,
+};
+
+const formatMinuteString = (minute: number): MinuteFormat => {
+  const str = minute.toString();
+
+  return {
+    time: str.length === 2 ? str : `0${str}`,
+  };
+};
+
+const formatHourString = (hour: number): HourFormat => {
+  const period = hour < 12 ? 'am' : 'pm';
+  const twelveHourTime = hour > 12 ? hour - 12 : hour;
+
+  return {
+    time: twelveHourTime === 0 ? '12' : twelveHourTime.toString(),
+    period,
+  };
+};
+
+const getTemplatingParameters = (msDiff: number, config: ParamForTemplateConfig) => {
+  const { dates, templateConfig } = config;
+  const { timeLabel, monthLocaleLabels, timeTemplate, fullDateTemplate } = templateConfig;
+
+  if (msDiff < MS_HOUR) {
+    const minuteDiff = msToMinute(msDiff);
+    const minuteUnit = minuteDiff > 1
+      ? timeLabel.minute.plural
+      : timeLabel.minute.singular;
+
+    return {
+      template: timeTemplate,
+      params: {
+        time: String(minuteDiff || 1),
+        timeLabel: minuteUnit,
+      },
+    };
+  }
+
+  if (msDiff < MS_DAY) {
+    const hourDiff = msToHour(msDiff);
+    const hourUnit = hourDiff > 1
+      ? timeLabel.hour.plural
+      : timeLabel.hour.singular;
+
+    return {
+      template: timeTemplate,
+      params: {
+        time: String(hourDiff),
+        timeLabel: hourUnit,
+      },
+    };
+  }
+
+  const monthLabel = monthLocaleLabels[dates.old.getMonth()];
+
+  const minute = formatMinuteString(dates.old.getMinutes());
+  const hour = formatHourString(dates.old.getHours());
+
+  const dayFormat = `${monthLabel} ${dates.old.getDate()}`;
+  const timeFormat = `${hour.time}:${minute.time} ${hour.period}`;
+
+  return {
+    template: fullDateTemplate,
+    params: {
+      date: `${dayFormat}, ${timeFormat}`,
+    },
+  };
+};
+
+/**
+ * The returned string follows the following rules:
+ *  - If diff < 60 minutes: '29 min ago'
+ *  - If diff >= 60 minutes & < 24 hours: '12 hours ago' | '1 hour ago'
+ *  - If diff > 24 hours: 'on March 15, 14:45 pm'
+ *
+ * @param olderDate - Date
+ * @param recentDate - Date
+ * @param template - DiffTemplate
+ * @returns a preformated string to be inserted in a phrase.
+ */
+export const getTimeDiffAsString = (olderDate: Date, recentDate = new Date(), templateConfig = defaultEnglishTemplate): string => {
+  const oldDateTime = olderDate.getTime();
+  const recentDateTime = recentDate.getTime();
+
+  if (oldDateTime > recentDateTime) {
+    return '';
+  }
+
+  const msDiff = recentDateTime - oldDateTime;
+  const { template, params } = getTemplatingParameters(msDiff, {
+    dates: {
+      old: olderDate,
+      recent: recentDate,
+    },
+    templateConfig,
+  });
+
+  return replaceInTemplate(template, params, TEMPLATE_CONFIG);
+};

package/src/time/index.ts

@@ -0,0 +1,4 @@
+export * from './constants';
+export * from './convert';
+export * from './format-minutes';
+export * from './get-time-diff-as-string';

package/src/types/function.ts

@@ -0,0 +1 @@
+export type GenericFunction<TS extends any[], R> = (...args: TS) => R;

package/src/types/general.ts

@@ -0,0 +1,10 @@
+export type Primitive = string | number | boolean;
+export type Nullable<T> = T | null;
+export type ValueType =
+  | Primitive
+  | null
+  | void
+  | Array<any>
+  | ReadonlyArray<any>;
+
+export type ValueOf<T> = T[keyof T];

package/src/types/index.ts

@@ -0,0 +1,4 @@
+export * from './function';
+export * from './general';
+export * from './object';
+export * from './search';

package/src/types/object.ts

@@ -0,0 +1,33 @@
+import { ValueType } from './general';
+
+// Used to extract non function attributes from a class or object
+export type NonMethodKeys<T> = { [P in keyof T]: T[P] extends Function ? never : P }[keyof T];
+export type Attributes<T> = { [K in NonMethodKeys<T>]: T[K] };
+export type PartialAttributes<T> = { [K in NonMethodKeys<T>]?: T[K] };
+
+// Used to extract functions attributes from a class or object
+export type MethodKeys<T> = { [P in keyof T]: T[P] extends Function ? P : never }[keyof T];
+export type Methods<T> = { [K in MethodKeys<T>]: T[K] };
+export type PartialMethods<T> = { [K in MethodKeys<T>]?: T[K] };
+
+export type ClassType<T> = {
+  new(...args: any[]): T;
+};
+
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
+
+export type DeepPartial<T> = T extends ValueType
+  ? T
+  : { [P in keyof T]?: DeepPartial<T[P]> };
+
+// Return intersecting properties of A & B
+export type Intersection<A, B> = {
+  [P in keyof A & keyof B]: A[P] | B[P];
+};
+
+/**
+ * Helper type. Passes T out again, but boxes it in a way that it cannot
+ * "widen" the type by accident if it is a generic that should be inferred
+ * from elsewhere.
+ */
+export type NoInfer<T> = [T][T extends any ? 0 : never];

package/src/types/search.ts

@@ -0,0 +1,29 @@
+export type SearchSortBy = string;
+export type SearchSortOrder = 'asc' | 'desc';
+
+export type SearchSort = {
+  [by: SearchSortBy]: SearchSortOrder
+};
+
+export type SearchQueryProperty = string;
+export type SearchQueryValue = string;
+
+export type SearchQuery = {
+  [property: SearchQueryProperty]: SearchQueryValue,
+};
+
+export type SearchObject = {
+  offset: number,
+  limit: number,
+  sort?: Record<string, SearchSortOrder>,
+  query?: SearchQuery,
+};
+
+export type SearchResponse<T> = {
+  items: ReadonlyArray<T>,
+  offset: number,
+  limit: number,
+  total: number,
+  next: string | null,
+  previous: string | null,
+};

package/tsconfig.eslint.json

@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "include": [
+    "src/",
+    ".eslintrc.*",
+    "rollup.config.ts",
+  ],
+}

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "allowJs": false,
+    "allowSyntheticDefaultImports": true,
+    "moduleResolution": "node",
+    "strict": true,    
+    "noImplicitAny": true,
+    "strictNullChecks": true,
+    "sourceMap": true,
+    "module": "ESNext",
+    "target": "ES6",
+    "isolatedModules": true, 
+    "forceConsistentCasingInFileNames": true,
+    "declaration": true,
+    "outDir": "dist",
+    "lib": ["es2015", "es2017.object"]
+  },
+  "files": ["global.d.ts"],
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "**/node_modules",
+  ]
+}