3.0.14

npmextra.json

@@ -4,6 +4,7 @@
     "npmAccessLevel": "public"
   },
   "gitzone": {
+    "projectType": "npm",
     "module": {
       "githost": "gitlab.com",
       "gitscope": "pushrocks",

package.json

@@ -1,30 +1,32 @@
 {
   "name": "@pushrocks/smarttime",
   "private": false,
-  "version": "3.0.8",
+  "version": "3.0.14",
   "description": "handle time in smart ways",
-  "main": "dist/index.js",
-  "typings": "dist/index.d.ts",
+  "main": "dist_ts/index.js",
+  "typings": "dist_ts/index.d.ts",
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
     "test": "(tstest ./test/)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild && tsbundle npm)"
   },
   "devDependencies": {
     "@gitzone/tsbuild": "^2.1.11",
+    "@gitzone/tsbundle": "^1.0.69",
     "@gitzone/tsrun": "^1.2.6",
     "@gitzone/tstest": "^1.0.24",
     "@pushrocks/tapbundle": "^3.0.9",
-    "@types/node": "^12.0.8",
-    "tslint": "^5.17.0",
+    "@types/node": "^14.0.5",
+    "tslint": "^6.1.2",
     "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
+    "@pushrocks/smartdelay": "^2.0.6",
     "@pushrocks/smartpromise": "^3.0.2",
     "@types/cron": "^1.7.1",
     "@types/luxon": "^1.15.1",
-    "cron": "^1.7.1",
+    "cron-parser": "^2.14.0",
     "luxon": "^1.16.0"
   },
   "files": [

test/test.extendeddate.ts

@@ -16,4 +16,9 @@ tap.test('should create a date and time with European Format', async () => {
   console.log(extendedDate);
 });
 
+tap.test('should create a European date string', async () => {
+  const extendedDate = smarttime.ExtendedDate.fromHyphedDate('2018-02-13');
+  expect(extendedDate.exportToEuropeanDate()).to.equal('13.02.2018');
+});
+
 tap.start();

ts/smarttime.classes.cronjob.ts

@@ -0,0 +1,45 @@
+import * as plugins from './smarttime.plugins';
+import { CronManager } from './smarttime.classes.cronmanager';
+
+export type TJobFunction = (() => void) | (() => Promise<any>);
+
+export class CronJob {
+  public status: 'started' | 'stopped' | 'initial' = 'initial';
+  public cronExpression: string;
+  public jobFunction: TJobFunction;
+  
+  private cronInterval= plugins.cronParser.parseExpression('* * * * * *');
+  private nextExecutionUnix: number = 0;
+
+  constructor(cronManager: CronManager, cronExpressionArg: string, jobFunction: TJobFunction ) {
+    this.cronExpression = cronExpressionArg;
+    this.jobFunction = jobFunction;
+  }
+
+  /**
+   * checks wether the cronjob needs to be executed
+   */
+  public checkExecution() {
+    if (this.nextExecutionUnix === 0) {
+      this.nextExecutionUnix = this.cronInterval.next().toDate().getTime();
+      return;
+    }
+    if (Date.now() > this.nextExecutionUnix) {
+      this.jobFunction();
+      this.nextExecutionUnix = this.cronInterval.next().toDate().getTime();
+    }
+  }
+
+  public start() {
+    this.cronInterval = this.getCronInterval();
+    this.status = 'started';
+  }
+
+  public stop() {
+    this.status = 'stopped';
+  }
+
+  private getCronInterval () {
+    return plugins.cronParser.parseExpression(this.cronExpression);
+  }
+}

ts/smarttime.classes.cronmanager.ts

@@ -1,16 +1,28 @@
 import * as plugins from './smarttime.plugins';
+import { CronJob } from './smarttime.classes.cronjob';
+import { Timer } from './smarttime.classes.timer';
+import { Interval } from './smarttime.classes.interval';
 
 export class CronManager {
+  public cronInterval = new Interval(1000);
+
   public status: 'started' | 'stopped' = 'stopped';
+  public cronjobs: CronJob[] = [];
 
-  public cronjobs: plugins.cron.CronJob[] = [];
+  constructor() {
+    this.cronInterval.addIntervalJob(() => {
+      for (const cronJob of this.cronjobs) {
+        cronJob.checkExecution();
+      }
+    });
+  }
 
-  public addCronjob(cronIdentifierArg: string, cronFunctionArg: plugins.cron.CronCommand) {
-    const newCronJob = new plugins.cron.CronJob(cronIdentifierArg, cronFunctionArg);
+  public addCronjob(cronIdentifierArg: string, cronFunctionArg: () => any) {
+    const newCronJob = new CronJob(this, cronIdentifierArg, cronFunctionArg);
+    this.cronjobs.push(newCronJob);
     if (this.status === 'started') {
       newCronJob.start();
     }
-    this.cronjobs.push(newCronJob);
   }
 
   /**
@@ -21,6 +33,7 @@ export class CronManager {
     for (const cron of this.cronjobs) {
       cron.start();
     }
+    this.cronInterval.start();
   }
 
   /**
@@ -31,5 +44,6 @@ export class CronManager {
     for (const cron of this.cronjobs) {
       cron.stop();
     }
+    this.cronInterval.stop();
   }
 }

ts/smarttime.classes.extendeddate.ts

@@ -2,7 +2,28 @@ import * as plugins from './smarttime.plugins';
 
 export type TAvailableZone = 'Europe/Berlin';
 
+export interface IDateUnits {
+  year: number;
+  yearString: string;
+  month: number;
+  monthString: string;
+  monthName: string;
+  day: number;
+  dayString: string;
+  dayOfTheWeek: number;
+  dayOfTheWeekName: string;
+}
+
 export class ExtendedDate extends Date {
+  // STATIC factories
+  public static fromMillis(milliSeconds: number) {
+    return new ExtendedDate(milliSeconds);
+  }
+
+  public static fromDate(dateArg: Date) {
+    return new ExtendedDate(dateArg.getTime());
+  }
+
   public static fromEuropeanDate(europeanDate: string) {
     const dateArray = /(.*)\.(.*)\.(.*)/.exec(europeanDate);
     const luxonDate = plugins.luxon.DateTime.utc(
@@ -14,12 +35,28 @@ export class ExtendedDate extends Date {
     return new ExtendedDate(unixMilli);
   }
 
-  /** */
+  /**
+   * creates an Extended date from a hypedDate like "2018-03-28"
+   * @param dateString
+   */
+  public static fromHyphedDate(dateString: string) {
+    // guards
+    // implementation
+    const dateMillis = new Date(dateString).getTime();
+    return new ExtendedDate(dateMillis);
+  }
+
+  /**
+   * Same as .fromEuropeanDate(), but accepts additional timeArg and zoneArg
+   */
   public static fromEuropeanDateAndTime(
     europeanDateArg: string,
-    timeArg: string,
-    zoneArg: TAvailableZone
+    timeArg: string = '12:00:00',
+    zoneArg: TAvailableZone = 'Europe/Berlin'
   ) {
+    // guards
+
+    // implementation
     const dateArray = /(.*)\.(.*)\.(.*)/.exec(europeanDateArg);
     const sliceDate = (dateString: string) => {
       return `0${dateString}`.slice(-2);
@@ -34,7 +71,57 @@ export class ExtendedDate extends Date {
     return new ExtendedDate(unixMilli);
   }
 
+  // INSTANCE
+  public timezone: TAvailableZone;
+
+
   constructor(unixMilli: number) {
     super(unixMilli);
   }
+
+  //
+  public exportToEuropeanDate() {
+    const units = this.exportToUnits();
+    return `${units.dayString}.${units.monthString}.${units.yearString}`;
+  }
+
+  /**
+   * exports units
+   */
+  public exportToUnits(): IDateUnits {
+    const monthsArray = [
+      'January',
+      'February',
+      'March',
+      'April',
+      'May',
+      'June',
+      'July',
+      'August',
+      'September',
+      'October',
+      'November',
+      'December'
+    ];
+    const daysArray = [
+      'Monday',
+      'Tuesday',
+      'Wednesday',
+      'Thursday',
+      'Friday',
+      'Saturday',
+      'Sunday'
+    ];
+    return {
+      year: this.getFullYear(),
+      yearString: `${this.getFullYear()}`,
+      month: this.getMonth() + 1,
+      monthString: ("0" + (this.getMonth() + 1)).slice(-2),
+      monthName: monthsArray[this.getMonth()],
+      day: this.getDate(),
+      dayString: ("0" + this.getDate()).slice(-2),
+      dayOfTheWeek: this.getDay(),
+      dayOfTheWeekName: daysArray[this.getDay()]
+    };
+  }
 }

ts/smarttime.classes.hrtmeasurement.ts

@@ -1,5 +1,3 @@
-import * as process from 'process';
-
 /**
  * easy high resolution time measurement
  */

ts/smarttime.classes.interval.ts

@@ -0,0 +1,40 @@
+import * as plugins from './smarttime.plugins';
+
+export class Interval {
+  public status: 'started' | 'stopped' | 'initial' = 'initial';
+  private statusAuthorization: any = null;
+  
+  public intervalMilliseconds: number;
+  public intervalJobs: Array<() => any> = [];
+  constructor(intervalMillisencondsArg: number) {
+    this.intervalMilliseconds = intervalMillisencondsArg;
+  }
+
+  public start() {
+    this.status = 'started';
+    const statusAuth = new Date();
+    this.statusAuthorization = statusAuth;
+    const runInterval = async () => {
+      while (this.status === 'started' && this.statusAuthorization === statusAuth) {
+        await plugins.smartdelay.delayFor(this.intervalMilliseconds);
+        this.executeIntervalJobs();
+      }
+    };
+    runInterval();
+  }
+
+  public stop () {
+    this.status = 'stopped';
+    this.statusAuthorization = null;
+  }
+
+  public addIntervalJob(funcArg: () => any) {
+    this.intervalJobs.push(funcArg);
+  }
+
+  private executeIntervalJobs () {
+    for (const funcArg of this.intervalJobs) {
+      funcArg();
+    }
+  }
+}

ts/smarttime.plugins.ts

@@ -1,10 +1,11 @@
 // @pushrocks scope
+import * as smartdelay from '@pushrocks/smartdelay';
 import * as smartpromise from '@pushrocks/smartpromise';
 
-export { smartpromise };
+export { smartdelay, smartpromise };
 
 // third parties
+import cronParser from 'cron-parser';
 import * as luxon from 'luxon';
-import * as cron from 'cron';
 
-export { luxon, cron };
+export { cronParser, luxon };