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

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,8 @@
+export type Primitive = string | number | boolean;
+export type Nullable<T> = T | null;
+export type ValueType =
+  | Primitive
+  | null
+  | void
+  | Array<any>
+  | ReadonlyArray<any>;

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",
+  ]
+}