@ngrdt/utils 0.0.5 → 0.0.6

package/src/lib/utils/date.ts

@@ -0,0 +1,363 @@
+import { Nullable } from '../types/type';
+
+export class RdtDateUtils {
+  static readonly MS = 1;
+  static readonly SECOND = 1000 * RdtDateUtils.MS;
+  static readonly MINUTE = 60 * RdtDateUtils.SECOND;
+  static readonly HOUR = 60 * RdtDateUtils.MINUTE;
+  static readonly DAY = 24 * RdtDateUtils.HOUR;
+
+  /**
+   * Returns number of days between two dates.
+   * Returns zero in case dates are the same. Ignores time.
+   */
+  static getDays(a: Date | string | number, b: Date | string | number) {
+    return (
+      RdtDateUtils.getDayOffset(new Date(a)) -
+      RdtDateUtils.getDayOffset(new Date(b))
+    );
+  }
+
+  static checkDate(year: number, month: number, day: number) {
+    const d = new Date(year, month - 1, day);
+    return (
+      d.getFullYear() === year &&
+      d.getMonth() + 1 === month &&
+      d.getDate() === day
+    );
+  }
+
+  static isValidDate(value: any): value is string | number | Date {
+    if (value == null) {
+      return false;
+    }
+    if (value instanceof Date) {
+      return !isNaN(value.getTime());
+    }
+    return !isNaN(new Date(value).getTime());
+  }
+
+  static startOfDay(input: Date | string) {
+    const date = new Date(input);
+    date.setHours(0, 0, 0, 0);
+    return date;
+  }
+
+  static endOfDay(input: Date | string) {
+    const date = new Date(input);
+    date.setHours(23, 59, 59);
+    return date;
+  }
+
+  static startOfMonth(input: Date | string) {
+    const date = new Date(input);
+    date.setHours(0, 0, 0, 0);
+    date.setDate(1);
+    return date;
+  }
+
+  static endOfMonth(input: Date | string) {
+    const date = new Date(input);
+    date.setHours(23, 59, 59);
+    date.setDate(0);
+    return date;
+  }
+
+  static startOfYear(year: number) {
+    return new Date(year, Month.January, 1);
+  }
+
+  static endOfYear(year: number) {
+    return new Date(year, Month.December, 31);
+  }
+
+  static beginningOfNextMonth() {
+    const today = new Date();
+    if (today.getMonth() === 11) {
+      return new Date(today.getFullYear() + 1, 0, 1);
+    } else {
+      return new Date(today.getFullYear(), today.getMonth() + 1, 1);
+    }
+  }
+
+  static endOfNextMonth() {
+    const today = new Date();
+    if (today.getMonth() === 10) {
+      const firstDayOfInTwoMonths = new Date(today.getFullYear() + 1, 0, 1);
+      return this.minusOneDay(firstDayOfInTwoMonths);
+    } else if (today.getMonth() === 11) {
+      const firstDayOfInTwoMonths = new Date(today.getFullYear() + 1, 1, 1);
+      return this.minusOneDay(firstDayOfInTwoMonths);
+    } else {
+      const firstDayOfInTwoMonths = new Date(
+        today.getFullYear(),
+        today.getMonth() + 2,
+        1
+      );
+      return this.minusOneDay(firstDayOfInTwoMonths);
+    }
+  }
+
+  static beginningOfInThreeMonths() {
+    const today = new Date();
+    if (today.getMonth() === 10) {
+      return new Date(today.getFullYear() + 1, 1, 1);
+    } else if (today.getMonth() === 11) {
+      return new Date(today.getFullYear() + 1, 2, 1);
+    } else {
+      return new Date(today.getFullYear(), today.getMonth() + 3, 1);
+    }
+  }
+
+  static endOfInNextThreeMonths() {
+    const today = new Date();
+    if (today.getMonth() === 9) {
+      const firstDayOfInFourMonths = new Date(today.getFullYear() + 1, 1, 1);
+      return this.minusOneDay(firstDayOfInFourMonths);
+    } else if (today.getMonth() === 10) {
+      const firstDayOfInFourMonths = new Date(today.getFullYear() + 1, 2, 1);
+      return this.minusOneDay(firstDayOfInFourMonths);
+    } else if (today.getMonth() === 11) {
+      const firstDayOfInFourMonths = new Date(today.getFullYear() + 1, 3, 1);
+      return this.minusOneDay(firstDayOfInFourMonths);
+    } else {
+      const firstDayOfInFourMonths = new Date(
+        today.getFullYear(),
+        today.getMonth() + 4,
+        1
+      );
+      return this.minusOneDay(firstDayOfInFourMonths);
+    }
+  }
+
+  static minusOneDay(date: Date) {
+    return new Date(date.getTime() - RdtDateUtils.DAY);
+  }
+
+  static toISOLocal(d: Date) {
+    const year = d.getFullYear();
+    const month = `${d.getMonth() + 1}`.padStart(2, '0');
+    const day = `${d.getDate()}`.padStart(2, '0');
+
+    const hours = `${d.getHours()}`.padStart(2, '0');
+    const minutes = `${d.getMinutes()}`.padStart(2, '0');
+    const seconds = `${d.getSeconds()}`.padStart(2, '0');
+
+    return `${year}-${month}-${day}T${hours}:${minutes}:${seconds}`;
+  }
+
+  static formatDate(date: any) {
+    if (date === null || date === undefined || date === '') {
+      return '';
+    }
+
+    const d = date instanceof Date ? date : new Date(date);
+
+    if (RdtDateUtils.isValidDate(d)) {
+      const year = d.getFullYear();
+      const month = `${d.getMonth() + 1}`.padStart(2, '0');
+      const day = `${d.getDate()}`.padStart(2, '0');
+
+      return `${day}.${month}.${year}`;
+    } else {
+      return '';
+    }
+  }
+
+  static timeToDate(time: string) {
+    const date = new Date(0);
+    if (RdtDateUtils.hhMmSsMsRegex.test(time)) {
+      const matches = time.match(RdtDateUtils.hhMmSsMsRegex);
+      if (matches) {
+        const h = parseInt(matches[1]);
+        const m = parseInt(matches[2]);
+        const s = parseInt(matches[3]);
+        const ms = parseInt(matches[4]);
+        date.setHours(h, m, s, ms);
+        return date;
+      }
+    } else if (RdtDateUtils.hhMmSsRegex.test(time)) {
+      const matches = time.match(RdtDateUtils.hhMmSsRegex);
+      if (matches) {
+        const h = parseInt(matches[1]);
+        const m = parseInt(matches[2]);
+        const s = parseInt(matches[3]);
+        date.setHours(h, m, s);
+        return date;
+      }
+    } else if (RdtDateUtils.hhMmRegex.test(time)) {
+      const matches = time.match(RdtDateUtils.hhMmRegex);
+      if (matches) {
+        const h = parseInt(matches[1]);
+        const m = parseInt(matches[2]);
+        date.setHours(h, m);
+        return date;
+      }
+    }
+    return null;
+  }
+
+  static setTime(date: Date, time: string) {
+    const newDate = new Date(date);
+    const timeDate = RdtDateUtils.timeToDate(time);
+    if (timeDate) {
+      newDate.setHours(
+        timeDate.getHours(),
+        timeDate.getMinutes(),
+        timeDate.getSeconds(),
+        timeDate.getMilliseconds()
+      );
+    }
+    return newDate;
+  }
+
+  static getTime(d: Date, showSeconds = true) {
+    const hh = d.getHours().toString().padStart(2, '0');
+    const mm = d.getMinutes().toString().padStart(2, '0');
+
+    if (showSeconds) {
+      const ss = d.getSeconds().toString().padStart(2, '0');
+      return `${hh}:${mm}:${ss}`;
+    } else {
+      return `${hh}:${mm}`;
+    }
+  }
+
+  static parseToDate(input: Nullable<string | Date>): Date | null {
+    if (input instanceof Date) {
+      return RdtDateUtils.isValidDate(input) ? input : null;
+    }
+    if (typeof input === 'string') {
+      const date = new Date(input);
+      if (RdtDateUtils.isValidDate(date)) {
+        return date;
+      }
+    }
+    return null;
+  }
+
+  static parse(input: Nullable<string | Date>): number | null {
+    if (input instanceof Date) {
+      return RdtDateUtils.isValidDate(input) ? input.getTime() : null;
+    }
+    if (typeof input === 'string') {
+      const date = new Date(input);
+      if (RdtDateUtils.isValidDate(date)) {
+        return date.getTime();
+      }
+    }
+    return null;
+  }
+
+  static isEqual(d1: Date | null, d2: Date | null) {
+    if (d1 === d2) {
+      return true;
+    }
+    if (!d1 || !d2) {
+      return false;
+    }
+    return d1.getTime() === d2.getTime();
+  }
+
+  static isLeapYear(year: number) {
+    return new Date(year, 1, 29).getDate() === 29;
+  }
+
+  static getDaysInYear(year: number) {
+    return RdtDateUtils.isLeapYear(year) ? 366 : 365;
+  }
+
+  private static hhMmRegex =
+    /^\s*([0-9]|0[0-9]|1[0-9]|2[0-3])\s*\W+\s*([0-5]?[0-9])\s*$/;
+  private static hhMmSsRegex =
+    /^\s*([0-9]|0[0-9]|1[0-9]|2[0-3])\s*\W+\s*([0-5]?[0-9])\s*\W+\s*([0-5]?\d)\s*$/;
+  private static hhMmSsMsRegex =
+    /^\s*([0-9]|0[0-9]|1[0-9]|2[0-3])\s*\W+\s*([0-5]?[0-9])\s*\W+\s*([0-5]?\d)\s*[\W|\s]\s*(\d{1,3})\s*$/;
+
+  private static daysUpToMonth = [
+    0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334,
+  ];
+  private static daysUpToMonthLeapYear = [
+    0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335,
+  ];
+
+  private static getDayOffset(date: Date) {
+    const year = date.getFullYear() - 1;
+    const month = date.getMonth() + 1,
+      day = date.getDate();
+    const numOfLeapsYear =
+      Math.trunc(year / 4) - Math.trunc(year / 100) + Math.trunc(year / 400);
+
+    if (RdtDateUtils.isLeapYear(year + 1)) {
+      return (
+        year * 365 +
+        numOfLeapsYear +
+        RdtDateUtils.daysUpToMonthLeapYear[month - 1] +
+        day -
+        1
+      );
+    } else {
+      return (
+        year * 365 +
+        numOfLeapsYear +
+        RdtDateUtils.daysUpToMonth[month - 1] +
+        day -
+        1
+      );
+    }
+  }
+
+  static doubleDigitYearToPast(year2: number) {
+    // If current year is 2024 and input is 24 or less, then result is 2024
+    // If input is 25 or greater, then result is 1925-1999
+    const currentYear = RdtDateUtils.getCurrentYear();
+    const current2 = currentYear % 100;
+    if (year2 <= current2) {
+      return year2 + currentYear - current2;
+    } else {
+      return year2 + currentYear - current2 - 100;
+    }
+  }
+
+  static doubleDigitYearToFuture(year2: number) {
+    // If current year is 2024 and input is 24 or less, then result is 2124
+    // If input is 25 or greater, then result is 2025-2099
+    const currentYear = RdtDateUtils.getCurrentYear();
+    const current2 = currentYear % 100;
+    if (year2 >= current2) {
+      return year2 + currentYear - current2;
+    } else {
+      return year2 + currentYear - current2 + 100;
+    }
+  }
+
+  static getCurrentYear() {
+    return new Date().getFullYear();
+  }
+
+  static calculateAge(birthDateStr: string, referenceDateStr: string): number {
+    const birthDate = new Date(birthDateStr);
+    const referenceDate = new Date(referenceDateStr);
+    let age = referenceDate.getFullYear() - birthDate.getFullYear();
+    const monthDifference = referenceDate.getMonth() - birthDate.getMonth();
+    const dayDifference = referenceDate.getDate() - birthDate.getDate();
+    if (monthDifference < 0 || (monthDifference === 0 && dayDifference < 0)) {
+      age--;
+    }
+    return age;
+  }
+}
+export enum Month {
+  January = 0,
+  February = 1,
+  March = 2,
+  April = 3,
+  May = 4,
+  June = 5,
+  July = 6,
+  August = 7,
+  September = 8,
+  October = 9,
+  November = 10,
+  December = 11,
+}

package/src/lib/utils/file.ts

@@ -0,0 +1,258 @@
+import { HttpResponse } from '@angular/common/http';
+import { RdtEncoding } from '../types/encodings';
+import {
+  EXTENSION_BY_MIME_TYPE,
+  MIME_TYPE_BY_EXTENSION,
+  RdtMimeType,
+} from '../types/mime-types';
+import { Nullable } from '../types/type';
+
+export enum RdtMsOfficeAction {
+  Edit = 'ofe|u|',
+  View = 'ofv|u|',
+}
+
+export enum RdtMsOfficeApp {
+  Word = 'ms-word',
+  Excel = 'ms-excel',
+  PowerPoint = 'ms-powerpoint',
+}
+
+export interface RdtMsOfficeConfig {
+  mimeType?: RdtMimeType;
+  app?: RdtMsOfficeApp;
+  action?: RdtMsOfficeAction;
+}
+
+export interface RdtDocumentFile<T = string> {
+  fileName: string;
+  content?: T;
+  url?: string;
+  mimeType?: RdtMimeType;
+  size?: number;
+  modified?: Date;
+  originalFile?: File;
+}
+
+export interface DokumentProtokol {
+  DokumentProtokol: {
+    filename: string;
+    content_data: string;
+    guid: string;
+    code: string;
+  };
+}
+
+export const Rdt_DEFAULT_MIME_TYPE = RdtMimeType.BIN;
+export const Rdt_DEFAULT_MS_OFFICE_ACTION = RdtMsOfficeAction.View;
+
+export enum FileSizeUnit {
+  B = 'B',
+  KB = 'KB',
+  MB = 'MB',
+  GB = 'GB',
+  TB = 'TB',
+  PB = 'PB',
+  EB = 'EB',
+  ZB = 'ZB',
+  YB = 'YB',
+}
+
+export type RdtFileSize = `${number} ${FileSizeUnit}`;
+
+const SORTED_FILE_SIZE_UNITS = [
+  FileSizeUnit.B,
+  FileSizeUnit.KB,
+  FileSizeUnit.MB,
+  FileSizeUnit.GB,
+  FileSizeUnit.TB,
+  FileSizeUnit.PB,
+  FileSizeUnit.EB,
+  FileSizeUnit.ZB,
+  FileSizeUnit.YB,
+] as const;
+
+export class FileUtils {
+  static getMsOfficeLink(url: string, config: RdtMsOfficeConfig) {
+    const app =
+      config.app ?? FileUtils.getMsOfficeAppByMimeType(config.mimeType);
+    if (app) {
+      const action = config.action ?? Rdt_DEFAULT_MS_OFFICE_ACTION;
+      return `${app}:${action}${url}`;
+    } else {
+      return url;
+    }
+  }
+
+  static openFileFromRemoteUrl(url: string, config: RdtMsOfficeConfig) {
+    window.open(FileUtils.getMsOfficeLink(url, config));
+  }
+
+  static openFileInBrowser(stringData: string, mimeType?: RdtMimeType) {
+    const link = FileUtils.getBase64Link(stringData, mimeType);
+    window.open(link, '_blank');
+  }
+
+  static fileAsArrayBuffer(file: Blob): Promise<ArrayBuffer> {
+    return new Promise((resolve, reject) => {
+      if (!file) {
+        reject(null);
+      }
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result as ArrayBuffer);
+      reader.onerror = reject;
+      reader.readAsArrayBuffer(file);
+    });
+  }
+
+  static fileAsText(file: Blob, encoding?: RdtEncoding): Promise<string> {
+    return new Promise((resolve, reject) => {
+      if (!file) {
+        reject(null);
+      }
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result as string);
+      reader.onerror = reject;
+      reader.readAsText(file, encoding);
+    });
+  }
+
+  static downloadFileFromData(
+    stringData: string,
+    filename: string,
+    mimeType?: RdtMimeType
+  ): void {
+    mimeType =
+      mimeType ??
+      FileUtils.getMimeTypeFromFileName(filename) ??
+      FileUtils.getMimeTypeFromBase64(stringData);
+
+    const url = FileUtils.getBase64Link(stringData, mimeType);
+
+    this.downloadFileFromRemoteUrl(url, filename, mimeType);
+  }
+
+  static downloadFileFromRemoteUrl(
+    url: string,
+    filename: string,
+    mimeType?: RdtMimeType
+  ): void {
+    mimeType = mimeType ?? FileUtils.getMimeTypeFromFileName(filename);
+
+    const link = document.createElement('a');
+    link.href = url;
+    link.download = FileUtils.getFileName(filename, mimeType);
+    link.click();
+  }
+
+  static getMimeTypeFromBase64(base64Data: string) {
+    return base64Data.match(/data:(.*?);base64/)?.[1] as
+      | RdtMimeType
+      | undefined;
+  }
+
+  static getMimeTypeFromFileName(fileName: Nullable<string>): RdtMimeType {
+    const ext = fileName?.split('.').pop();
+    // @ts-ignore
+    return MIME_TYPE_BY_EXTENSION[ext] ?? Rdt_DEFAULT_MIME_TYPE;
+  }
+
+  static getFileName(filename: string, mimeType?: RdtMimeType) {
+    if (mimeType) {
+      const ext = EXTENSION_BY_MIME_TYPE[mimeType];
+      if (filename.endsWith(`.${ext}`)) {
+        return filename;
+      } else {
+        return `${filename}.${ext}`;
+      }
+    } else {
+      return filename;
+    }
+  }
+
+  static getBase64Link(base64Data: string, mimeType?: RdtMimeType) {
+    if (base64Data.startsWith('data:')) {
+      return base64Data;
+    } else if (mimeType) {
+      return `data:${mimeType};base64,${base64Data}`;
+    } else {
+      console.error('Missing mime type for base64 data.');
+      return '';
+    }
+  }
+
+  static getMimeTypeFromResponse(resp: HttpResponse<Blob>) {
+    return resp.body?.type as RdtMimeType;
+  }
+
+  static getFileNameFromResponse(resp: HttpResponse<Blob>): string {
+    return (
+      resp.headers
+        .get('content-disposition')
+        ?.split('filename=')?.[1]
+        ?.split(';')?.[0] ?? ''
+    );
+  }
+
+  static async blobToDataUrl(file: Blob): Promise<string> {
+    return new Promise((resolve, reject) => {
+      if (!file) {
+        reject(null);
+      }
+      const reader = new FileReader();
+      reader.onload = () => resolve(reader.result as string);
+      reader.onerror = reject;
+      reader.readAsDataURL(file);
+    });
+  }
+
+  static convertFromBytes(bytes: number, decimals = 2) {
+    if (bytes === 0) {
+      return '0 ' + FileSizeUnit.B;
+    }
+    const k = 1024;
+    const i = Math.floor(Math.log(bytes) / Math.log(k));
+    return (
+      parseFloat((bytes / Math.pow(k, i)).toFixed(decimals)) +
+      ' ' +
+      SORTED_FILE_SIZE_UNITS[i]
+    );
+  }
+
+  static convertToBytes(amount: number, unit: FileSizeUnit) {
+    const k = 1024;
+    const i = SORTED_FILE_SIZE_UNITS.indexOf(unit);
+    return amount * Math.pow(k, i);
+  }
+
+  static fileSizeToBytes(fileSize: RdtFileSize) {
+    const [amountStr, unitStr] = fileSize.split(' ');
+    const amount = parseFloat(amountStr);
+    const unit = unitStr as FileSizeUnit;
+    if (isNaN(amount) || SORTED_FILE_SIZE_UNITS.indexOf(unit) === -1) {
+      return null;
+    }
+    return FileUtils.convertToBytes(amount, unit);
+  }
+
+  static getMsOfficeAppByMimeType(
+    mimeType: RdtMimeType | undefined
+  ): RdtMsOfficeApp | null {
+    switch (mimeType) {
+      case RdtMimeType.DOC:
+      case RdtMimeType.DOCX:
+      case RdtMimeType.ODT:
+        return RdtMsOfficeApp.Word;
+      case RdtMimeType.XLS:
+      case RdtMimeType.XLSX:
+      case RdtMimeType.ODS:
+        return RdtMsOfficeApp.Excel;
+      case RdtMimeType.PPT:
+      case RdtMimeType.PPTX:
+      case RdtMimeType.ODP:
+        return RdtMsOfficeApp.PowerPoint;
+      default:
+        return null;
+    }
+  }
+}

package/src/lib/utils/html.ts

@@ -0,0 +1,26 @@
+export class RdtHTMLUtils {
+  static scrollIntoViewHorizontallyWithinParent(element: HTMLElement) {
+    const container = element.parentElement;
+    if (!container) {
+      return;
+    }
+    const elOffset = element.offsetLeft;
+    const elWidth = element.offsetWidth;
+    const containerWidth = container.offsetWidth;
+    const currentScroll = container.scrollLeft;
+
+    const alignLeft = elOffset;
+    const alignRight = elOffset - containerWidth + elWidth;
+
+    if (currentScroll > alignLeft) {
+      container.scrollLeft = alignLeft;
+    } else if (currentScroll < alignRight) {
+      container.scrollLeft = alignRight;
+    }
+  }
+
+  static setCaretPosition(element: HTMLInputElement, index: number) {
+    element.focus();
+    element.setSelectionRange(index, index);
+  }
+}

package/src/lib/utils/model.ts

@@ -0,0 +1,73 @@
+import { names } from './names';
+
+const BOOLEAN_KEYWORDS = ['je', 'lze'];
+const ID_KEYWORD = 'id';
+
+export class RdtModelUtils {
+  static inferPropertyInfo(
+    properties: { key: string; type: string }[],
+    interfaceName: string
+  ) {
+    // Lowercase words that interface name consists of
+    const words = names(interfaceName).fileName.split('-');
+    const wordMap: { [key: string]: number } = {};
+    words.forEach((w) => (wordMap[w] = 1));
+    let maxMatches = 0;
+    // Primary key is property that shares the most words with interface name
+    // while containing the word 'id'.
+    // If more such properties exist, the one with shortest name is selected.
+    let primaryKey = '';
+
+    properties.forEach(({ key }) => {
+      const propertyNameWords = names(key).fileName.split('-');
+      let matches = 0;
+      propertyNameWords.forEach((w) => (matches += wordMap[w] ?? 0));
+      const isId = propertyNameWords.includes(ID_KEYWORD);
+
+      if (matches > maxMatches && isId) {
+        maxMatches = matches;
+        primaryKey = key;
+      } else if (matches === maxMatches && isId) {
+        if (key.length < primaryKey.length) {
+          primaryKey = key;
+        }
+      }
+    });
+
+    const res: RdtModelProperty[] = properties.map((pair) => {
+      const propertyNameWords = names(pair.key).fileName.split('-');
+      const isId = propertyNameWords.includes(ID_KEYWORD);
+      return {
+        key: pair.key,
+        type: pair.type as any,
+        required: true,
+        formControlType: pair.type === 'date' ? 'string' : (pair.type as any),
+        primaryKey: pair.key === primaryKey,
+        // Any other property that contains ID, but is not primary key is foreign key.
+        // Foreign keys are to be ignored.
+        foreignKey: isId && pair.key !== primaryKey,
+        // If the property starts with the word 'je' and it's numeric,
+        // then it's probably boolean.
+        probablyBoolean:
+          BOOLEAN_KEYWORDS.includes(propertyNameWords[0]) &&
+          pair.type === 'number',
+      };
+    });
+
+    return res;
+  }
+
+  static names(name: string) {
+    return names(name);
+  }
+}
+
+export interface RdtModelProperty {
+  key: string;
+  type: 'string' | 'number' | 'date' | 'boolean' | 'array' | 'object' | 'any';
+  formControlType: 'string' | 'number' | 'boolean' | 'array' | 'object' | 'any';
+  required: boolean;
+  foreignKey: boolean;
+  primaryKey: boolean;
+  probablyBoolean: boolean;
+}