@elderbyte/ngx-starter 14.12.0-beta6 → 14.12.1

package/src/lib/pipes/iso-interval-parse.pipe.ts

@@ -1,61 +0,0 @@
-import {Inject, LOCALE_ID, Pipe, PipeTransform} from '@angular/core';
-import {Interval, IsoIntervalStr} from '../common/time/interval';
-import {LoggerFactory} from '@elderbyte/ts-logger';
-import {Instant, ZoneId} from '@js-joda/core';
-import {TimeUtil} from '../common/time/time-util';
-import {DatePipe} from '@angular/common';
-
-@Pipe({
-  name: 'isoIntervalParse'
-})
-export class IsoIntervalParsePipe implements PipeTransform {
-
-  /***************************************************************************
-   *                                                                         *
-   * Fields                                                                  *
-   *                                                                         *
-   **************************************************************************/
-
-  private static log = LoggerFactory.getLogger('IsoIntervalParsePipe');
-
-  /***************************************************************************
-   *                                                                         *
-   * Constructor                                                             *
-   *                                                                         *
-   **************************************************************************/
-
-  constructor(
-
-  ) {
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Public API                                                              *
-   *                                                                         *
-   **************************************************************************/
-
-  /**
-   * Parses an iso interval string to an interval object
-   * @param value The interval as iso string
-   * @return The parsed interval object
-   */
-  public transform(
-    value: IsoIntervalStr | Interval
-  ): Interval {
-    if (value) {
-      try {
-        return (value instanceof Interval) ? value : Interval.parse(value);
-      } catch (err) {
-        IsoIntervalParsePipe.log.warn('Failed to parse iso interval: ' + value, err);
-      }
-    }
-    return null;
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Private methods                                                         *
-   *                                                                         *
-   **************************************************************************/
-}

package/src/lib/pipes/iso-interval.pipe.ts

@@ -1,146 +0,0 @@
-import {Inject, LOCALE_ID, Pipe, PipeTransform} from '@angular/core';
-import {Interval, IsoIntervalStr} from '../common/time/interval';
-import {LoggerFactory} from '@elderbyte/ts-logger';
-import {Instant, ZoneId} from '@js-joda/core';
-import {TimeUtil} from '../common/time/time-util';
-import {DatePipe} from '@angular/common';
-
-@Pipe({
-  name: 'isoInterval'
-})
-export class IsoIntervalPipe implements PipeTransform {
-
-  /***************************************************************************
-   *                                                                         *
-   * Fields                                                                  *
-   *                                                                         *
-   **************************************************************************/
-
-  private static log = LoggerFactory.getLogger('IsoIntervalPipe');
-
-  private readonly datePipe: DatePipe;
-
-  /***************************************************************************
-   *                                                                         *
-   * Constructor                                                             *
-   *                                                                         *
-   **************************************************************************/
-
-  constructor(
-    @Inject(LOCALE_ID) private readonly localeId: string
-  ) {
-    this.datePipe = new DatePipe(localeId);
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Public API                                                              *
-   *                                                                         *
-   **************************************************************************/
-
-  /**
-   *
-   * @param value The interval value, either as iso string or interval object
-   * @param format The format of the start (and if not specified otherwise, the end)
-   * @param formatEnd The format of the end
-   * @param timezone
-   * @param locale
-   */
-  public transform(
-    value: IsoIntervalStr | Interval,
-    format?: string,
-    formatEnd?: string,
-    timezone?: string,
-    locale?: string
-  ): string {
-    if (value) {
-      try {
-        const interval = (value instanceof Interval) ? value : Interval.parse(value);
-
-        const zone = timezone ? ZoneId.of(timezone) : ZoneId.SYSTEM;
-
-        const duration = interval.toDuration();
-        const period = interval.toPeriodDuration(zone);
-
-        const zonedStart = interval.start.atZone(zone);
-        const zonedEndExc = interval.end.atZone(zone);
-
-        const localStart = zonedStart.toLocalDate();
-        const localEndExc = zonedEndExc.toLocalDate();
-
-        if (period.period.days() === 0
-          && (localStart.equals(localEndExc) || TimeUtil.isStartOfDay(zonedEndExc))) {
-          // If the period is less than a day, and the interval falls in the same local date
-          // We can improve the generated display text by omitting the redundant date information.
-          return this.formatSubDay(interval, format, zone, locale);
-
-        } else if (TimeUtil.isStartOfDay(zonedStart) && TimeUtil.isFullDays(duration)) {
-          // We dont have to care about time since we are in days
-          const startDay = this.formatInstant(interval.start, format || 'mediumDate', zone, locale);
-
-          if (period.period.days() === 1) {
-            // Display a single, full day
-            return startDay;
-          } else {
-            // Display a range of multiple 'full' days
-            const endDayInstant =  zonedEndExc.minusDays(1).toInstant();
-            const endDay = this.formatInstant(endDayInstant,  formatEnd || format || 'mediumDate', zone, locale);
-
-            return startDay + ' - ' + endDay;
-          }
-        } else {
-          // No special handling, we render both instants
-          const start = this.formatInstant(interval.start, format || 'short', zone, locale);
-          const end = this.formatInstant(interval.end, formatEnd || format || 'short', zone, locale);
-          return start + ' - ' + end;
-        }
-
-      } catch (err) {
-        IsoIntervalPipe.log.warn('Failed to parse iso interval: ' + value, err);
-      }
-    }
-    return null;
-  }
-
-  /***************************************************************************
-   *                                                                         *
-   * Private methods                                                         *
-   *                                                                         *
-   **************************************************************************/
-
-
-  private formatSubDay(
-    interval: Interval,
-    format: string,
-    timezone: ZoneId,
-    locale: string
-  ): string {
-    const startDay = this.formatInstant(interval.start, format || 'short', timezone, locale);
-    const endTime = interval.end.atZone(timezone).toLocalTime().toString();
-    return startDay + ' - ' + endTime;
-  }
-
-  private formatInstant(
-    instant: Instant,
-    format: string,
-    timezone: ZoneId,
-    locale?: string
-  ): string {
-    return this.format(
-      instant.toEpochMilli(),
-      format,
-      timezone,
-      locale
-    );
-  }
-
-  private format(
-    value: string | Date | number,
-    format: string,
-    timezone: ZoneId,
-    locale?: string
-  ): string {
-    return this.datePipe.transform(value, format, timezone.id(), locale);
-  }
-
-}

package/src/lib/pipes/public_api.ts

@@ -1,3 +0,0 @@
-
-
-export * from './elder-pipes.module';

package/src/lib/pipes/time-ago.pipe.ts

@@ -1,88 +0,0 @@
-
-import {Pipe, PipeTransform, NgZone, ChangeDetectorRef, OnDestroy} from '@angular/core';
-
-
-/**
- * Source code from
- * https://github.com/AndrewPoyntz/time-ago-pipe
- */
-@Pipe({
-  name: 'timeAgo',
-  pure: false
-})
-export class TimeAgoPipe implements PipeTransform, OnDestroy {
-
-  private timer: number | null;
-
-  constructor(private changeDetectorRef: ChangeDetectorRef, private ngZone: NgZone) {}
-
-  public transform(value: string | number | Date) {
-    this.removeTimer();
-
-    if (!value) { return 'unknown time'; }
-
-    const d = new Date(value);
-    const now = new Date();
-    const seconds = Math.round(Math.abs((now.getTime() - d.getTime()) / 1000));
-    const timeToUpdate = this.getSecondsUntilUpdate(seconds) * 1000;
-    this.timer = this.ngZone.runOutsideAngular(() => {
-      if (typeof window !== 'undefined') {
-        return window.setTimeout(() => {
-          this.ngZone.run(() => this.changeDetectorRef.markForCheck());
-        }, timeToUpdate);
-      }
-      return null;
-    });
-    const minutes = Math.round(Math.abs(seconds / 60));
-    const hours = Math.round(Math.abs(minutes / 60));
-    const days = Math.round(Math.abs(hours / 24));
-    const months = Math.round(Math.abs(days / 30.416));
-    const years = Math.round(Math.abs(days / 365));
-    if (seconds <= 45) {
-      return 'a few seconds ago';
-    } else if (seconds <= 90) {
-      return 'a minute ago';
-    } else if (minutes <= 45) {
-      return minutes + ' minutes ago';
-    } else if (minutes <= 90) {
-      return 'an hour ago';
-    } else if (hours <= 22) {
-      return hours + ' hours ago';
-    } else if (hours <= 36) {
-      return 'a day ago';
-    } else if (days <= 25) {
-      return days + ' days ago';
-    } else if (days <= 45) {
-      return 'a month ago';
-    } else if (days <= 345) {
-      return months + ' months ago';
-    } else if (days <= 545) {
-      return 'a year ago';
-    } else { // (days > 545)
-      return years + ' years ago';
-    }
-  }
-  ngOnDestroy(): void {
-    this.removeTimer();
-  }
-  private removeTimer() {
-    if (this.timer) {
-      window.clearTimeout(this.timer);
-      this.timer = null;
-    }
-  }
-  private getSecondsUntilUpdate(seconds: number) {
-    const min = 60;
-    const hr = min * 60;
-    const day = hr * 24;
-    if (seconds < min) { // less than 1 min, update ever 2 secs
-      return 2;
-    } else if (seconds < hr) { // less than an hour, update every 30 secs
-      return 30;
-    } else if (seconds < day) { // less then a day, update every 5 mins
-      return 300;
-    } else { // update every hour
-      return 3600;
-    }
-  }
-}

package/src/lib/pipes/time-duration.pipe.ts

@@ -1,81 +0,0 @@
-
-import {Pipe, PipeTransform} from '@angular/core';
-
-
-/**
- * Shows a duration in an approximated, human friendly way.
- * Based on time-ago pipe.
- */
-@Pipe({
-  name: 'caTimeDuration',
-  pure: false
-})
-export class TimeDurationPipe implements PipeTransform {
-
-  constructor() {}
-
-
-  transform(value = 0, unit = 's', precision: number = null) {
-
-    if (isNaN(parseFloat(String(value))) || !isFinite(value)) { return '?'; }
-
-    // 10−3 s	ms	millisecond	103 s	ks	kilosecond
-    // 10−6 s	µs	microsecond	106 s	Ms	megasecond
-    // 10−9 s	ns	nanosecond
-
-    let ns = 0;
-    switch (unit) {
-      case 'ns': ns = value; break;
-      case 'micro':
-      case 'µs' : ns = value * 1000; break;
-      case 'ms': ns = value * 1000 * 1000; break;
-      case 's' : ns = value * 1000 * 1000 * 1000; break;
-      default: throw new Error(`Unknown input unit in weight pipe: '${unit}'`);
-    }
-
-    const nanoseconds = ns;
-    const microseconds = nanoseconds / 1000.0;
-    const milliseconds = microseconds / 1000.0;
-    const seconds = milliseconds / 1000.0;
-    const minutes = seconds / 60.0;
-    const hours = minutes / 60.0;
-    const days = hours / 24.0;
-    const months = days / 30.416;
-    const years = days / 365;
-
-    if (nanoseconds <= 999) {
-      return this.format(nanoseconds, precision || 0) + ' ns';
-    } else if (microseconds <= 999) {
-      return this.format(microseconds, precision  || 0) + ' µs';
-    } else if (milliseconds <= 999) {
-      return this.format(milliseconds, precision || 0) + ' ms';
-    } else if (seconds <= 59) {
-      return this.format(seconds, precision || 0) + ' seconds';
-    } else if (seconds <= 90) {
-      return 'a minute';
-    } else if (minutes <= 45) {
-      return this.format(minutes, precision || 0) + ' minutes';
-    } else if (minutes <= 90) {
-      return 'an hour';
-    } else if (hours <= 22) {
-      return this.format(hours, precision || 1) + ' hours';
-    } else if (hours <= 36) {
-      return 'a day';
-    } else if (days <= 25) {
-      return this.format(days, precision || 1) + ' days';
-    } else if (days <= 45) {
-      return 'a month';
-    } else if (days <= 345) {
-      return this.format(months, precision || 1) + ' months';
-    } else if (days <= 545) {
-      return 'a year';
-    } else { // (days > 545)
-      return this.format(years, precision || 1) + ' years';
-    }
-  }
-
-
-  private format(value: number, precision: number): number {
-    return +value.toFixed(precision);
-  }
-}

package/src/lib/pipes/weight.pipe.ts

@@ -1,45 +0,0 @@
-import { Pipe, PipeTransform } from '@angular/core';
-
-
-/*
- * Convert milligrams into largest possible unit.
- * Takes an precision argument that defaults to 2.
- * Usage:
- *   weight | weight:unit:precision
- * Example:
- *   {{ 1024 |  weight:'g':2}}
- *   formats to: 1.02kg
- */
-@Pipe({name: 'weight'})
-export class WeightPipe implements PipeTransform {
-
-    transform(value = 0, unit = 'kg', precision = 2): string {
-
-        if (isNaN(parseFloat(String(value))) || !isFinite(value)) { return '?'; }
-
-        let mg = 0;
-        switch (unit) {
-            case 'mg': mg = value; break;
-            case 'g' : mg = value * 1000; break;
-            case 'kg': mg = value * 1000 * 1000; break;
-            case 't' : mg = value * 1000 * 1000 * 1000; break;
-            default: throw new Error(`Unknown input unit in weight pipe: '${unit}'`);
-        }
-
-        const g = mg / 1000.0;
-        const kg = g / 1000.0;
-        const t = kg / 1000.0;
-
-        if (t > 1) {
-            return t.toFixed(+precision) + 't';
-        } else if (kg > 1) {
-            return kg.toFixed(+precision) + 'kg';
-        } else if (g > 1) {
-            return kg.toFixed(+precision) + 'g';
-        } else {
-            return mg.toFixed(+precision) + 'mg';
-        }
-    }
-}
-
-

package/src/public_api.ts

@@ -1,8 +0,0 @@
-/*
- * Public API Surface of ngx-starter
- */
-
-export * from './lib/pipes/public_api';
-export * from './lib/common/public_api';
-export * from './lib/components/public_api';
-export * from './lib/features/public_api';

package/src/test.ts

@@ -1,28 +0,0 @@
-// This file is required by karma.conf.js and loads recursively all the .spec and framework files
-
-import 'zone.js';
-import 'zone.js/testing';
-import { getTestBed } from '@angular/core/testing';
-import {
-  BrowserDynamicTestingModule,
-  platformBrowserDynamicTesting
-} from '@angular/platform-browser-dynamic/testing';
-
-declare const require: {
-  context(path: string, deep?: boolean, filter?: RegExp): {
-    keys(): string[];
-    <T>(id: string): T;
-  };
-};
-
-// First, initialize the Angular testing environment.
-getTestBed().initTestEnvironment(
-  BrowserDynamicTestingModule,
-  platformBrowserDynamicTesting(), {
-    teardown: { destroyAfterEach: false }
-}
-);
-// Then we find all the tests.
-const context = require.context('./', true, /\.spec\.ts$/);
-// And load the modules.
-context.keys().map(context);

package/tsconfig.lib.json

@@ -1,33 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../../out-tsc/lib",
-    "declarationMap": true,
-    "target": "es2020",
-    "module": "es2020",
-    "moduleResolution": "node",
-    "declaration": true,
-    "sourceMap": true,
-    "inlineSources": true,
-    "experimentalDecorators": true,
-    "importHelpers": true,
-    "types": [],
-    "lib": [
-      "dom",
-      "es2020"
-    ]
-  },
-  "angularCompilerOptions": {
-    "skipTemplateCodegen": true,
-    "strictMetadataEmit": true,
-    "fullTemplateTypeCheck": true,
-    "strictInjectionParameters": true,
-    "flatModuleId": "AUTOGENERATED",
-    "flatModuleOutFile": "AUTOGENERATED",
-    "strictTemplates": true,
-  },
-  "exclude": [
-    "src/test.ts",
-    "**/*.spec.ts"
-  ]
-}

package/tsconfig.lib.prod.json

@@ -1,10 +0,0 @@
-{
-  "extends": "./tsconfig.lib.json",
-  "compilerOptions": {
-    "declarationMap": false
-  },
-  "angularCompilerOptions": {
-    "compilationMode": "partial",
-    "strictTemplates": true,
-  }
-}

package/tsconfig.spec.json

@@ -1,17 +0,0 @@
-{
-  "extends": "../../../tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../../out-tsc/spec",
-    "types": [
-      "jasmine",
-      "node"
-    ]
-  },
-  "files": [
-    "src/test.ts"
-  ],
-  "include": [
-    "**/*.spec.ts",
-    "**/*.d.ts"
-  ]
-}