3.0.13

.gitignore

@@ -1,5 +1,22 @@
 .nogit/
-node_modules/
+
+# artifacts
 coverage/
 public/
 pages/
+
+# installs
+node_modules/
+
+# caches
+.yarn/
+.cache/
+.rpt2_cache
+
+# builds
+dist/
+dist_web/
+dist_serve/
+dist_ts_web/
+
+# custom

.gitlab-ci.yml

@@ -1,4 +1,4 @@
-# gitzone standard
+# gitzone ci_default
 image: hosttoday/ht-docker-node:npmci
 
 cache:
@@ -37,18 +37,6 @@ snyk:
 # ====================
 # test stage
 # ====================
-testLEGACY:
-  stage: test
-  script:
-  - npmci npm prepare
-  - npmci node install legacy
-  - npmci npm install
-  - npmci npm test
-  coverage: /\d+.?\d+?\%\s*coverage/
-  tags:
-  - docker
-  - notpriv
-  allow_failure: true
 
 testLTS:
   stage: test
@@ -90,19 +78,11 @@ release:
 # ====================
 codequality:
   stage: metadata
-  image: docker:stable
   allow_failure: true
-  services:
-    - docker:stable-dind
   script:
-    - export SP_VERSION=$(echo "$CI_SERVER_VERSION" | sed 's/^\([0-9]*\)\.\([0-9]*\).*/\1-\2-stable/')
-    - docker run
-        --env SOURCE_CODE="$PWD"
-        --volume "$PWD":/code
-        --volume /var/run/docker.sock:/var/run/docker.sock
-        "registry.gitlab.com/gitlab-org/security-products/codequality:$SP_VERSION" /code
-  artifacts:
-    paths: [codeclimate.json]
+    - npmci command npm install -g tslint typescript
+    - npmci npm install
+    - npmci command "tslint -c tslint.json ./ts/**/*.ts"
   tags:
   - docker
   - priv
@@ -121,10 +101,10 @@ pages:
   image: hosttoday/ht-docker-node:npmci
   stage: metadata
   script:
-    - npmci command npm install -g typedoc typescript
+    - npmci command npm install -g @gitzone/tsdoc
     - npmci npm prepare
     - npmci npm install
-    - npmci command typedoc --module "commonjs" --target "ES2016" --out public/ ts/
+    - npmci command tsdoc
   tags:
     - docker
     - notpriv

dist_ts/index.d.ts

@@ -0,0 +1,7 @@
+export * from './smarttime.classes.cronmanager';
+export * from './smarttime.classes.extendeddate';
+export * from './smarttime.classes.hrtmeasurement';
+export * from './smarttime.classes.timer';
+export * from './smarttime.classes.timestamp';
+export * from './smarttime.units';
+export { luxon } from './smarttime.plugins';

dist_ts/index.js

@@ -0,0 +1,21 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !exports.hasOwnProperty(p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./smarttime.classes.cronmanager"), exports);
+__exportStar(require("./smarttime.classes.extendeddate"), exports);
+__exportStar(require("./smarttime.classes.hrtmeasurement"), exports);
+__exportStar(require("./smarttime.classes.timer"), exports);
+__exportStar(require("./smarttime.classes.timestamp"), exports);
+__exportStar(require("./smarttime.units"), exports);
+var smarttime_plugins_1 = require("./smarttime.plugins");
+Object.defineProperty(exports, "luxon", { enumerable: true, get: function () { return smarttime_plugins_1.luxon; } });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7QUFFQSxrRUFBZ0Q7QUFDaEQsbUVBQWlEO0FBQ2pELHFFQUFtRDtBQUNuRCw0REFBMEM7QUFDMUMsZ0VBQThDO0FBQzlDLG9EQUFrQztBQUVsQyx5REFBNEM7QUFBbkMsMEdBQUEsS0FBSyxPQUFBIn0=

dist_ts/smarttime.classes.cronjob.d.ts

@@ -0,0 +1,17 @@
+import { CronManager } from './smarttime.classes.cronmanager';
+export declare type TJobFunction = (() => void) | (() => Promise<any>);
+export declare class CronJob {
+    status: 'started' | 'stopped' | 'initial';
+    cronExpression: string;
+    jobFunction: TJobFunction;
+    private cronInterval;
+    private nextExecutionUnix;
+    constructor(cronManager: CronManager, cronExpressionArg: string, jobFunction: TJobFunction);
+    /**
+     * checks wether the cronjob needs to be executed
+     */
+    checkExecution(): void;
+    start(): void;
+    stop(): void;
+    private getCronInterval;
+}

dist_ts/smarttime.classes.cronjob.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronJob = void 0;
+const plugins = __importStar(require("./smarttime.plugins"));
+class CronJob {
+    constructor(cronManager, cronExpressionArg, jobFunction) {
+        this.status = 'initial';
+        this.cronInterval = plugins.cronParser.parseExpression('* * * * * *');
+        this.nextExecutionUnix = 0;
+        this.cronExpression = cronExpressionArg;
+        this.jobFunction = jobFunction;
+    }
+    /**
+     * checks wether the cronjob needs to be executed
+     */
+    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();
+        }
+    }
+    start() {
+        this.cronInterval = this.getCronInterval();
+        this.status = 'started';
+    }
+    stop() {
+        this.status = 'stopped';
+    }
+    getCronInterval() {
+        return plugins.cronParser.parseExpression(this.cronExpression);
+    }
+}
+exports.CronJob = CronJob;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLmNsYXNzZXMuY3JvbmpvYi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0dGltZS5jbGFzc2VzLmNyb25qb2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQUFBLDZEQUErQztBQUsvQyxNQUFhLE9BQU87SUFRbEIsWUFBWSxXQUF3QixFQUFFLGlCQUF5QixFQUFFLFdBQXlCO1FBUG5GLFdBQU0sR0FBc0MsU0FBUyxDQUFDO1FBSXJELGlCQUFZLEdBQUUsT0FBTyxDQUFDLFVBQVUsQ0FBQyxlQUFlLENBQUMsYUFBYSxDQUFDLENBQUM7UUFDaEUsc0JBQWlCLEdBQVcsQ0FBQyxDQUFDO1FBR3BDLElBQUksQ0FBQyxjQUFjLEdBQUcsaUJBQWlCLENBQUM7UUFDeEMsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7SUFDakMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksY0FBYztRQUNuQixJQUFJLElBQUksQ0FBQyxpQkFBaUIsS0FBSyxDQUFDLEVBQUU7WUFDaEMsSUFBSSxDQUFDLGlCQUFpQixHQUFHLElBQUksQ0FBQyxZQUFZLENBQUMsSUFBSSxFQUFFLENBQUMsTUFBTSxFQUFFLENBQUMsT0FBTyxFQUFFLENBQUM7WUFDckUsT0FBTztTQUNSO1FBQ0QsSUFBSSxJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLGlCQUFpQixFQUFFO1lBQ3ZDLElBQUksQ0FBQyxXQUFXLEVBQUUsQ0FBQztZQUNuQixJQUFJLENBQUMsaUJBQWlCLEdBQUcsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLEVBQUUsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxPQUFPLEVBQUUsQ0FBQztTQUN0RTtJQUNILENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUMsZUFBZSxFQUFFLENBQUM7UUFDM0MsSUFBSSxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFDMUIsQ0FBQztJQUVNLElBQUk7UUFDVCxJQUFJLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUMxQixDQUFDO0lBRU8sZUFBZTtRQUNyQixPQUFPLE9BQU8sQ0FBQyxVQUFVLENBQUMsZUFBZSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztJQUNqRSxDQUFDO0NBQ0Y7QUF2Q0QsMEJBdUNDIn0=

dist_ts/smarttime.classes.cronmanager.d.ts

@@ -0,0 +1,17 @@
+import { CronJob } from './smarttime.classes.cronjob';
+import { Interval } from './smarttime.classes.interval';
+export declare class CronManager {
+    cronInterval: Interval;
+    status: 'started' | 'stopped';
+    cronjobs: CronJob[];
+    constructor();
+    addCronjob(cronIdentifierArg: string, cronFunctionArg: () => any): void;
+    /**
+     * starts the cronjob
+     */
+    start(): void;
+    /**
+     * stops all cronjobs
+     */
+    stop(): void;
+}

dist_ts/smarttime.classes.cronmanager.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CronManager = void 0;
+const smarttime_classes_cronjob_1 = require("./smarttime.classes.cronjob");
+const smarttime_classes_interval_1 = require("./smarttime.classes.interval");
+class CronManager {
+    constructor() {
+        this.cronInterval = new smarttime_classes_interval_1.Interval(1000);
+        this.status = 'stopped';
+        this.cronjobs = [];
+        this.cronInterval.addIntervalJob(() => {
+            for (const cronJob of this.cronjobs) {
+                cronJob.checkExecution();
+            }
+        });
+    }
+    addCronjob(cronIdentifierArg, cronFunctionArg) {
+        const newCronJob = new smarttime_classes_cronjob_1.CronJob(this, cronIdentifierArg, cronFunctionArg);
+        this.cronjobs.push(newCronJob);
+        if (this.status === 'started') {
+            newCronJob.start();
+        }
+    }
+    /**
+     * starts the cronjob
+     */
+    start() {
+        this.status = 'started';
+        for (const cron of this.cronjobs) {
+            cron.start();
+        }
+        this.cronInterval.start();
+    }
+    /**
+     * stops all cronjobs
+     */
+    stop() {
+        this.status = 'stopped';
+        for (const cron of this.cronjobs) {
+            cron.stop();
+        }
+        this.cronInterval.stop();
+    }
+}
+exports.CronManager = CronManager;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLmNsYXNzZXMuY3Jvbm1hbmFnZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHRpbWUuY2xhc3Nlcy5jcm9ubWFuYWdlci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFDQSwyRUFBc0Q7QUFFdEQsNkVBQXdEO0FBRXhELE1BQWEsV0FBVztJQU10QjtRQUxPLGlCQUFZLEdBQUcsSUFBSSxxQ0FBUSxDQUFDLElBQUksQ0FBQyxDQUFDO1FBRWxDLFdBQU0sR0FBMEIsU0FBUyxDQUFDO1FBQzFDLGFBQVEsR0FBYyxFQUFFLENBQUM7UUFHOUIsSUFBSSxDQUFDLFlBQVksQ0FBQyxjQUFjLENBQUMsR0FBRyxFQUFFO1lBQ3BDLEtBQUssTUFBTSxPQUFPLElBQUksSUFBSSxDQUFDLFFBQVEsRUFBRTtnQkFDbkMsT0FBTyxDQUFDLGNBQWMsRUFBRSxDQUFDO2FBQzFCO1FBQ0gsQ0FBQyxDQUFDLENBQUM7SUFDTCxDQUFDO0lBRU0sVUFBVSxDQUFDLGlCQUF5QixFQUFFLGVBQTBCO1FBQ3JFLE1BQU0sVUFBVSxHQUFHLElBQUksbUNBQU8sQ0FBQyxJQUFJLEVBQUUsaUJBQWlCLEVBQUUsZUFBZSxDQUFDLENBQUM7UUFDekUsSUFBSSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7UUFDL0IsSUFBSSxJQUFJLENBQUMsTUFBTSxLQUFLLFNBQVMsRUFBRTtZQUM3QixVQUFVLENBQUMsS0FBSyxFQUFFLENBQUM7U0FDcEI7SUFDSCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLO1FBQ1YsSUFBSSxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUM7UUFDeEIsS0FBSyxNQUFNLElBQUksSUFBSSxJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ2hDLElBQUksQ0FBQyxLQUFLLEVBQUUsQ0FBQztTQUNkO1FBQ0QsSUFBSSxDQUFDLFlBQVksQ0FBQyxLQUFLLEVBQUUsQ0FBQztJQUM1QixDQUFDO0lBRUQ7O09BRUc7SUFDSSxJQUFJO1FBQ1QsSUFBSSxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUM7UUFDeEIsS0FBSyxNQUFNLElBQUksSUFBSSxJQUFJLENBQUMsUUFBUSxFQUFFO1lBQ2hDLElBQUksQ0FBQyxJQUFJLEVBQUUsQ0FBQztTQUNiO1FBQ0QsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUMzQixDQUFDO0NBQ0Y7QUEzQ0Qsa0NBMkNDIn0=

dist_ts/smarttime.classes.extendeddate.d.ts

@@ -0,0 +1,33 @@
+export declare 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 declare class ExtendedDate extends Date {
+    static fromMillis(milliSeconds: number): ExtendedDate;
+    static fromDate(dateArg: Date): ExtendedDate;
+    static fromEuropeanDate(europeanDate: string): ExtendedDate;
+    /**
+     * creates an Extended date from a hypedDate like "2018-03-28"
+     * @param dateString
+     */
+    static fromHyphedDate(dateString: string): ExtendedDate;
+    /**
+     * Same as .fromEuropeanDate(), but accepts additional timeArg and zoneArg
+     */
+    static fromEuropeanDateAndTime(europeanDateArg: string, timeArg?: string, zoneArg?: TAvailableZone): ExtendedDate;
+    timezone: TAvailableZone;
+    constructor(unixMilli: number);
+    exportToEuropeanDate(): string;
+    /**
+     * exports units
+     */
+    exportToUnits(): IDateUnits;
+}

dist_ts/smarttime.classes.extendeddate.js

@@ -0,0 +1,117 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExtendedDate = void 0;
+const plugins = __importStar(require("./smarttime.plugins"));
+class ExtendedDate extends Date {
+    constructor(unixMilli) {
+        super(unixMilli);
+    }
+    // STATIC factories
+    static fromMillis(milliSeconds) {
+        return new ExtendedDate(milliSeconds);
+    }
+    static fromDate(dateArg) {
+        return new ExtendedDate(dateArg.getTime());
+    }
+    static fromEuropeanDate(europeanDate) {
+        const dateArray = /(.*)\.(.*)\.(.*)/.exec(europeanDate);
+        const luxonDate = plugins.luxon.DateTime.utc(parseFloat(dateArray[3]), // year
+        parseFloat(dateArray[2]), // month
+        parseFloat(dateArray[1]) // day
+        );
+        const unixMilli = luxonDate.toMillis();
+        return new ExtendedDate(unixMilli);
+    }
+    /**
+     * creates an Extended date from a hypedDate like "2018-03-28"
+     * @param dateString
+     */
+    static fromHyphedDate(dateString) {
+        // guards
+        // implementation
+        const dateMillis = new Date(dateString).getTime();
+        return new ExtendedDate(dateMillis);
+    }
+    /**
+     * Same as .fromEuropeanDate(), but accepts additional timeArg and zoneArg
+     */
+    static fromEuropeanDateAndTime(europeanDateArg, timeArg = '12:00:00', zoneArg = 'Europe/Berlin') {
+        // guards
+        // implementation
+        const dateArray = /(.*)\.(.*)\.(.*)/.exec(europeanDateArg);
+        const sliceDate = (dateString) => {
+            return `0${dateString}`.slice(-2);
+        };
+        const dateTimeString = `${dateArray[3]}-${sliceDate(dateArray[2])}-${sliceDate(dateArray[1])}T${timeArg}`;
+        const luxonDate = plugins.luxon.DateTime.fromISO(dateTimeString, {
+            zone: zoneArg
+        });
+        const unixMilli = luxonDate.toMillis();
+        return new ExtendedDate(unixMilli);
+    }
+    //
+    exportToEuropeanDate() {
+        const units = this.exportToUnits();
+        return `${units.dayString}.${units.monthString}.${units.yearString}`;
+    }
+    /**
+     * exports units
+     */
+    exportToUnits() {
+        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()]
+        };
+    }
+}
+exports.ExtendedDate = ExtendedDate;
+//# sourceMappingURL=data:application/json;base64,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

dist_ts/smarttime.classes.hrtmeasurement.d.ts

@@ -0,0 +1,22 @@
+/**
+ * easy high resolution time measurement
+ */
+export declare class HrtMeasurement {
+    nanoSeconds: number;
+    milliSeconds: number;
+    private _hrTimeStart;
+    private _hrTimeStopDiff;
+    private _started;
+    /**
+     * start the measurement
+     */
+    start(): void;
+    /**
+     * stop the measurement
+     */
+    stop(): this;
+    /**
+     * reset the measurement
+     */
+    reset(): void;
+}

dist_ts/smarttime.classes.hrtmeasurement.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HrtMeasurement = void 0;
+/**
+ * easy high resolution time measurement
+ */
+class HrtMeasurement {
+    constructor() {
+        this.nanoSeconds = null;
+        this.milliSeconds = null;
+        this._hrTimeStart = null;
+        this._hrTimeStopDiff = null;
+        this._started = false;
+    }
+    /**
+     * start the measurement
+     */
+    start() {
+        this._started = true;
+        this._hrTimeStart = process.hrtime();
+    }
+    /**
+     * stop the measurement
+     */
+    stop() {
+        if (this._started === false) {
+            console.log("Hasn't started yet");
+            return;
+        }
+        this._hrTimeStopDiff = process.hrtime(this._hrTimeStart);
+        this.nanoSeconds = this._hrTimeStopDiff[0] * 1e9 + this._hrTimeStopDiff[1];
+        this.milliSeconds = this.nanoSeconds / 1000000;
+        return this;
+    }
+    /**
+     * reset the measurement
+     */
+    reset() {
+        this.nanoSeconds = null;
+        this.milliSeconds = null;
+        this._hrTimeStart = null;
+        this._hrTimeStopDiff = null;
+        this._started = false;
+    }
+}
+exports.HrtMeasurement = HrtMeasurement;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLmNsYXNzZXMuaHJ0bWVhc3VyZW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHRpbWUuY2xhc3Nlcy5ocnRtZWFzdXJlbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7QUFBQTs7R0FFRztBQUNILE1BQWEsY0FBYztJQUEzQjtRQUNTLGdCQUFXLEdBQVcsSUFBSSxDQUFDO1FBQzNCLGlCQUFZLEdBQVcsSUFBSSxDQUFDO1FBQzNCLGlCQUFZLEdBQUcsSUFBSSxDQUFDO1FBQ3BCLG9CQUFlLEdBQUcsSUFBSSxDQUFDO1FBQ3ZCLGFBQVEsR0FBWSxLQUFLLENBQUM7SUFrQ3BDLENBQUM7SUFoQ0M7O09BRUc7SUFDSSxLQUFLO1FBQ1YsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUM7UUFDckIsSUFBSSxDQUFDLFlBQVksR0FBRyxPQUFPLENBQUMsTUFBTSxFQUFFLENBQUM7SUFDdkMsQ0FBQztJQUVEOztPQUVHO0lBQ0ksSUFBSTtRQUNULElBQUksSUFBSSxDQUFDLFFBQVEsS0FBSyxLQUFLLEVBQUU7WUFDM0IsT0FBTyxDQUFDLEdBQUcsQ0FBQyxvQkFBb0IsQ0FBQyxDQUFDO1lBQ2xDLE9BQU87U0FDUjtRQUNELElBQUksQ0FBQyxlQUFlLEdBQUcsT0FBTyxDQUFDLE1BQU0sQ0FBQyxJQUFJLENBQUMsWUFBWSxDQUFDLENBQUM7UUFDekQsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxHQUFHLEdBQUcsR0FBRyxJQUFJLENBQUMsZUFBZSxDQUFDLENBQUMsQ0FBQyxDQUFDO1FBQzNFLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLFdBQVcsR0FBRyxPQUFPLENBQUM7UUFDL0MsT0FBTyxJQUFJLENBQUM7SUFDZCxDQUFDO0lBRUQ7O09BRUc7SUFDSSxLQUFLO1FBQ1YsSUFBSSxDQUFDLFdBQVcsR0FBRyxJQUFJLENBQUM7UUFDeEIsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUM7UUFDekIsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUM7UUFDekIsSUFBSSxDQUFDLGVBQWUsR0FBRyxJQUFJLENBQUM7UUFDNUIsSUFBSSxDQUFDLFFBQVEsR0FBRyxLQUFLLENBQUM7SUFDeEIsQ0FBQztDQUNGO0FBdkNELHdDQXVDQyJ9

dist_ts/smarttime.classes.interval.d.ts

@@ -0,0 +1,11 @@
+export declare class Interval {
+    status: 'started' | 'stopped' | 'initial';
+    private statusAuthorization;
+    intervalMilliseconds: number;
+    intervalJobs: Array<() => any>;
+    constructor(intervalMillisencondsArg: number);
+    start(): void;
+    stop(): void;
+    addIntervalJob(funcArg: () => any): void;
+    private executeIntervalJobs;
+}

dist_ts/smarttime.classes.interval.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Interval = void 0;
+const plugins = __importStar(require("./smarttime.plugins"));
+class Interval {
+    constructor(intervalMillisencondsArg) {
+        this.status = 'initial';
+        this.statusAuthorization = null;
+        this.intervalJobs = [];
+        this.intervalMilliseconds = intervalMillisencondsArg;
+    }
+    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();
+    }
+    stop() {
+        this.status = 'stopped';
+        this.statusAuthorization = null;
+    }
+    addIntervalJob(funcArg) {
+        this.intervalJobs.push(funcArg);
+    }
+    executeIntervalJobs() {
+        for (const funcArg of this.intervalJobs) {
+            funcArg();
+        }
+    }
+}
+exports.Interval = Interval;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLmNsYXNzZXMuaW50ZXJ2YWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHRpbWUuY2xhc3Nlcy5pbnRlcnZhbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNkRBQStDO0FBRS9DLE1BQWEsUUFBUTtJQU1uQixZQUFZLHdCQUFnQztRQUxyQyxXQUFNLEdBQXNDLFNBQVMsQ0FBQztRQUNyRCx3QkFBbUIsR0FBUSxJQUFJLENBQUM7UUFHakMsaUJBQVksR0FBcUIsRUFBRSxDQUFDO1FBRXpDLElBQUksQ0FBQyxvQkFBb0IsR0FBRyx3QkFBd0IsQ0FBQztJQUN2RCxDQUFDO0lBRU0sS0FBSztRQUNWLElBQUksQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDO1FBQ3hCLE1BQU0sVUFBVSxHQUFHLElBQUksSUFBSSxFQUFFLENBQUM7UUFDOUIsSUFBSSxDQUFDLG1CQUFtQixHQUFHLFVBQVUsQ0FBQztRQUN0QyxNQUFNLFdBQVcsR0FBRyxLQUFLLElBQUksRUFBRTtZQUM3QixPQUFPLElBQUksQ0FBQyxNQUFNLEtBQUssU0FBUyxJQUFJLElBQUksQ0FBQyxtQkFBbUIsS0FBSyxVQUFVLEVBQUU7Z0JBQzNFLE1BQU0sT0FBTyxDQUFDLFVBQVUsQ0FBQyxRQUFRLENBQUMsSUFBSSxDQUFDLG9CQUFvQixDQUFDLENBQUM7Z0JBQzdELElBQUksQ0FBQyxtQkFBbUIsRUFBRSxDQUFDO2FBQzVCO1FBQ0gsQ0FBQyxDQUFDO1FBQ0YsV0FBVyxFQUFFLENBQUM7SUFDaEIsQ0FBQztJQUVNLElBQUk7UUFDVCxJQUFJLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQztRQUN4QixJQUFJLENBQUMsbUJBQW1CLEdBQUcsSUFBSSxDQUFDO0lBQ2xDLENBQUM7SUFFTSxjQUFjLENBQUMsT0FBa0I7UUFDdEMsSUFBSSxDQUFDLFlBQVksQ0FBQyxJQUFJLENBQUMsT0FBTyxDQUFDLENBQUM7SUFDbEMsQ0FBQztJQUVPLG1CQUFtQjtRQUN6QixLQUFLLE1BQU0sT0FBTyxJQUFJLElBQUksQ0FBQyxZQUFZLEVBQUU7WUFDdkMsT0FBTyxFQUFFLENBQUM7U0FDWDtJQUNILENBQUM7Q0FDRjtBQXJDRCw0QkFxQ0MifQ==

dist_ts/smarttime.classes.timer.d.ts

@@ -0,0 +1,38 @@
+import { TimeStamp } from './smarttime.classes.timestamp';
+export declare type TimerState = 'initiated' | 'started' | 'paused' | 'completed';
+export declare class Timer {
+    /**
+     * the original amount of milliseconds for this Timer
+     */
+    timeInMilliseconds: number;
+    /**
+     * the state of the timer
+     */
+    state: TimerState;
+    /**
+     * completed Promise
+     */
+    completed: Promise<void>;
+    /**
+     * a reference to when the Timeout started
+     */
+    startedAt: TimeStamp;
+    /**
+     * a reference to when a Timer has been potentially paused
+     */
+    pausedAt: TimeStamp;
+    get timeLeft(): number;
+    /**
+     * the current timeout the needs to be canceled when this Timer is stopped
+     */
+    private currentTimeout;
+    private completedDeferred;
+    constructor(timeInMillisecondsArg: number);
+    /**
+     * starts the timer
+     */
+    start(): void;
+    pause(): void;
+    resume(): void;
+    reset(): void;
+}

dist_ts/smarttime.classes.timer.js

@@ -0,0 +1,77 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Timer = void 0;
+const plugins = __importStar(require("./smarttime.plugins"));
+const smarttime_classes_timestamp_1 = require("./smarttime.classes.timestamp");
+class Timer {
+    constructor(timeInMillisecondsArg) {
+        /**
+         * the state of the timer
+         */
+        this.state = 'initiated';
+        // a deferred triggeted when Timer has completed
+        this.completedDeferred = plugins.smartpromise.defer();
+        this.timeInMilliseconds = timeInMillisecondsArg;
+        this.completed = this.completedDeferred.promise;
+    }
+    get timeLeft() {
+        return this.timeInMilliseconds - this.pausedAt.change;
+    }
+    /**
+     * starts the timer
+     */
+    start() {
+        if (!this.startedAt) {
+            this.currentTimeout = setTimeout(() => {
+                this.completedDeferred.resolve();
+            }, this.timeInMilliseconds);
+            this.startedAt = new smarttime_classes_timestamp_1.TimeStamp();
+        }
+        else {
+            throw new Error('timer has been started before. Please use resume instead');
+        }
+    }
+    pause() {
+        if (this.startedAt) {
+            clearTimeout(this.currentTimeout);
+            this.currentTimeout = null;
+            this.pausedAt = smarttime_classes_timestamp_1.TimeStamp.fromTimeStamp(this.startedAt);
+        }
+    }
+    resume() {
+        if (this.startedAt) {
+            this.currentTimeout = setTimeout(() => {
+                this.completedDeferred.resolve();
+            }, this.timeLeft);
+        }
+        else {
+            throw new Error('timer has NOT been started before. Please use .start() instead');
+        }
+    }
+    reset() {
+        this.pause();
+        this.startedAt = null;
+        this.pausedAt = null;
+    }
+}
+exports.Timer = Timer;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLmNsYXNzZXMudGltZXIuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHRpbWUuY2xhc3Nlcy50aW1lci50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsNkRBQStDO0FBRS9DLCtFQUEwRDtBQUkxRCxNQUFhLEtBQUs7SUFxQ2hCLFlBQVkscUJBQTZCO1FBL0J6Qzs7V0FFRztRQUNJLFVBQUssR0FBZSxXQUFXLENBQUM7UUF5QnZDLGdEQUFnRDtRQUN4QyxzQkFBaUIsR0FBRyxPQUFPLENBQUMsWUFBWSxDQUFDLEtBQUssRUFBUSxDQUFDO1FBRzdELElBQUksQ0FBQyxrQkFBa0IsR0FBRyxxQkFBcUIsQ0FBQztRQUNoRCxJQUFJLENBQUMsU0FBUyxHQUFHLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxPQUFPLENBQUM7SUFDbEQsQ0FBQztJQWRELElBQUksUUFBUTtRQUNWLE9BQU8sSUFBSSxDQUFDLGtCQUFrQixHQUFHLElBQUksQ0FBQyxRQUFRLENBQUMsTUFBTSxDQUFDO0lBQ3hELENBQUM7SUFjRDs7T0FFRztJQUNJLEtBQUs7UUFDVixJQUFJLENBQUMsSUFBSSxDQUFDLFNBQVMsRUFBRTtZQUNuQixJQUFJLENBQUMsY0FBYyxHQUFHLFVBQVUsQ0FBQyxHQUFHLEVBQUU7Z0JBQ3BDLElBQUksQ0FBQyxpQkFBaUIsQ0FBQyxPQUFPLEVBQUUsQ0FBQztZQUNuQyxDQUFDLEVBQUUsSUFBSSxDQUFDLGtCQUFrQixDQUFDLENBQUM7WUFDNUIsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLHVDQUFTLEVBQUUsQ0FBQztTQUNsQzthQUFNO1lBQ0wsTUFBTSxJQUFJLEtBQUssQ0FBQywwREFBMEQsQ0FBQyxDQUFDO1NBQzdFO0lBQ0gsQ0FBQztJQUVNLEtBQUs7UUFDVixJQUFJLElBQUksQ0FBQyxTQUFTLEVBQUU7WUFDbEIsWUFBWSxDQUFDLElBQUksQ0FBQyxjQUFjLENBQUMsQ0FBQztZQUNsQyxJQUFJLENBQUMsY0FBYyxHQUFHLElBQUksQ0FBQztZQUMzQixJQUFJLENBQUMsUUFBUSxHQUFHLHVDQUFTLENBQUMsYUFBYSxDQUFDLElBQUksQ0FBQyxTQUFTLENBQUMsQ0FBQztTQUN6RDtJQUNILENBQUM7SUFFTSxNQUFNO1FBQ1gsSUFBSSxJQUFJLENBQUMsU0FBUyxFQUFFO1lBQ2xCLElBQUksQ0FBQyxjQUFjLEdBQUcsVUFBVSxDQUFDLEdBQUcsRUFBRTtnQkFDcEMsSUFBSSxDQUFDLGlCQUFpQixDQUFDLE9BQU8sRUFBRSxDQUFDO1lBQ25DLENBQUMsRUFBRSxJQUFJLENBQUMsUUFBUSxDQUFDLENBQUM7U0FDbkI7YUFBTTtZQUNMLE1BQU0sSUFBSSxLQUFLLENBQUMsZ0VBQWdFLENBQUMsQ0FBQztTQUNuRjtJQUNILENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxDQUFDLEtBQUssRUFBRSxDQUFDO1FBQ2IsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUM7UUFDdEIsSUFBSSxDQUFDLFFBQVEsR0FBRyxJQUFJLENBQUM7SUFDdkIsQ0FBQztDQUNGO0FBL0VELHNCQStFQyJ9

dist_ts/smarttime.classes.timestamp.d.ts

@@ -0,0 +1,45 @@
+/**
+ * TimeStamp
+ * smart timestamp
+ */
+export declare class TimeStamp {
+    /**
+     * returns new TimeStamp from milliseconds
+     */
+    static fromMilliSeconds(milliSecondsArg: any): TimeStamp;
+    /**
+     * returns new TimeStamp for now with change set
+     * @param timeStampArg
+     */
+    static fromTimeStamp(timeStampArg: TimeStamp): TimeStamp;
+    /**
+     * The standard JavaScript Date
+     */
+    date: Date;
+    /**
+     * The time as linux time (milliseconds, not seconds though)
+     * good for comparison
+     */
+    milliSeconds: number;
+    /**
+     * The standard epoch time in seconds
+     */
+    epochtime: number;
+    /**
+     * if derived from another TimeStamp points out the change in milliseconds
+     */
+    change: number;
+    constructor(creatorArg?: number);
+    /**
+     * Is the current instance older than the argument
+     * @param TimeStampArg
+     */
+    isOlderThan(TimeStampArg: TimeStamp, tresholdTimeArg?: number): boolean;
+    /**
+     * returns a boolean for wether a timestamp is younger
+     * @param TimeStampArg
+     * @param tresholdTimeArg
+     */
+    isYoungerThanOtherTimeStamp(TimeStampArg: TimeStamp, tresholdTimeArg?: number): boolean;
+    isYoungerThanMilliSeconds(millisecondArg: number): boolean;
+}

dist_ts/smarttime.classes.timestamp.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeStamp = void 0;
+/**
+ * TimeStamp
+ * smart timestamp
+ */
+class TimeStamp {
+    constructor(creatorArg) {
+        /**
+         * if derived from another TimeStamp points out the change in milliseconds
+         */
+        this.change = null;
+        if (!creatorArg) {
+            this.date = new Date();
+        }
+        else if (typeof creatorArg === 'number') {
+            this.date = new Date(creatorArg);
+        }
+        this.milliSeconds = this.date.getTime();
+        this.epochtime = Math.floor(this.milliSeconds / 1000);
+    }
+    /**
+     * returns new TimeStamp from milliseconds
+     */
+    static fromMilliSeconds(milliSecondsArg) {
+        return new TimeStamp(milliSecondsArg);
+    }
+    /**
+     * returns new TimeStamp for now with change set
+     * @param timeStampArg
+     */
+    static fromTimeStamp(timeStampArg) {
+        const localTimeStamp = new TimeStamp();
+        localTimeStamp.change = localTimeStamp.milliSeconds - timeStampArg.milliSeconds;
+        return localTimeStamp;
+    }
+    /**
+     * Is the current instance older than the argument
+     * @param TimeStampArg
+     */
+    isOlderThan(TimeStampArg, tresholdTimeArg = 0) {
+        if (this.milliSeconds + tresholdTimeArg < TimeStampArg.milliSeconds) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    /**
+     * returns a boolean for wether a timestamp is younger
+     * @param TimeStampArg
+     * @param tresholdTimeArg
+     */
+    isYoungerThanOtherTimeStamp(TimeStampArg, tresholdTimeArg = 0) {
+        if (this.milliSeconds > TimeStampArg.milliSeconds + tresholdTimeArg) {
+            return true;
+        }
+        else {
+            return false;
+        }
+    }
+    isYoungerThanMilliSeconds(millisecondArg) {
+        const nowTimeStamp = new TimeStamp();
+        const compareEpochTime = nowTimeStamp.epochtime - millisecondArg;
+        const compareTimeStamp = new TimeStamp(compareEpochTime);
+        return this.isYoungerThanOtherTimeStamp(compareTimeStamp);
+    }
+}
+exports.TimeStamp = TimeStamp;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLmNsYXNzZXMudGltZXN0YW1wLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnR0aW1lLmNsYXNzZXMudGltZXN0YW1wLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUVBOzs7R0FHRztBQUNILE1BQWEsU0FBUztJQXVDcEIsWUFBWSxVQUFtQjtRQUwvQjs7V0FFRztRQUNJLFdBQU0sR0FBVyxJQUFJLENBQUM7UUFHM0IsSUFBSSxDQUFDLFVBQVUsRUFBRTtZQUNmLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQztTQUN4QjthQUFNLElBQUksT0FBTyxVQUFVLEtBQUssUUFBUSxFQUFFO1lBQ3pDLElBQUksQ0FBQyxJQUFJLEdBQUcsSUFBSSxJQUFJLENBQUMsVUFBVSxDQUFDLENBQUM7U0FDbEM7UUFDRCxJQUFJLENBQUMsWUFBWSxHQUFHLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDeEMsSUFBSSxDQUFDLFNBQVMsR0FBRyxJQUFJLENBQUMsS0FBSyxDQUFDLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDLENBQUM7SUFDeEQsQ0FBQztJQTlDRDs7T0FFRztJQUNJLE1BQU0sQ0FBQyxnQkFBZ0IsQ0FBQyxlQUFlO1FBQzVDLE9BQU8sSUFBSSxTQUFTLENBQUMsZUFBZSxDQUFDLENBQUM7SUFDeEMsQ0FBQztJQUVEOzs7T0FHRztJQUNJLE1BQU0sQ0FBQyxhQUFhLENBQUMsWUFBdUI7UUFDakQsTUFBTSxjQUFjLEdBQUcsSUFBSSxTQUFTLEVBQUUsQ0FBQztRQUN2QyxjQUFjLENBQUMsTUFBTSxHQUFHLGNBQWMsQ0FBQyxZQUFZLEdBQUcsWUFBWSxDQUFDLFlBQVksQ0FBQztRQUNoRixPQUFPLGNBQWMsQ0FBQztJQUN4QixDQUFDO0lBaUNEOzs7T0FHRztJQUNJLFdBQVcsQ0FBQyxZQUF1QixFQUFFLGtCQUEwQixDQUFDO1FBQ3JFLElBQUksSUFBSSxDQUFDLFlBQVksR0FBRyxlQUFlLEdBQUcsWUFBWSxDQUFDLFlBQVksRUFBRTtZQUNuRSxPQUFPLElBQUksQ0FBQztTQUNiO2FBQU07WUFDTCxPQUFPLEtBQUssQ0FBQztTQUNkO0lBQ0gsQ0FBQztJQUVEOzs7O09BSUc7SUFDSSwyQkFBMkIsQ0FBQyxZQUF1QixFQUFFLGtCQUEwQixDQUFDO1FBQ3JGLElBQUksSUFBSSxDQUFDLFlBQVksR0FBRyxZQUFZLENBQUMsWUFBWSxHQUFHLGVBQWUsRUFBRTtZQUNuRSxPQUFPLElBQUksQ0FBQztTQUNiO2FBQU07WUFDTCxPQUFPLEtBQUssQ0FBQztTQUNkO0lBQ0gsQ0FBQztJQUVNLHlCQUF5QixDQUFDLGNBQXNCO1FBQ3JELE1BQU0sWUFBWSxHQUFHLElBQUksU0FBUyxFQUFFLENBQUM7UUFDckMsTUFBTSxnQkFBZ0IsR0FBRyxZQUFZLENBQUMsU0FBUyxHQUFHLGNBQWMsQ0FBQztRQUNqRSxNQUFNLGdCQUFnQixHQUFHLElBQUksU0FBUyxDQUFDLGdCQUFnQixDQUFDLENBQUM7UUFDekQsT0FBTyxJQUFJLENBQUMsMkJBQTJCLENBQUMsZ0JBQWdCLENBQUMsQ0FBQztJQUM1RCxDQUFDO0NBQ0Y7QUFoRkQsOEJBZ0ZDIn0=

dist_ts/smarttime.plugins.d.ts

@@ -0,0 +1,6 @@
+import * as smartdelay from '@pushrocks/smartdelay';
+import * as smartpromise from '@pushrocks/smartpromise';
+export { smartdelay, smartpromise };
+import cronParser from 'cron-parser';
+import * as luxon from 'luxon';
+export { cronParser, luxon };

dist_ts/smarttime.plugins.js

@@ -0,0 +1,36 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.luxon = exports.cronParser = exports.smartpromise = exports.smartdelay = void 0;
+// @pushrocks scope
+const smartdelay = __importStar(require("@pushrocks/smartdelay"));
+exports.smartdelay = smartdelay;
+const smartpromise = __importStar(require("@pushrocks/smartpromise"));
+exports.smartpromise = smartpromise;
+// third parties
+const cron_parser_1 = __importDefault(require("cron-parser"));
+exports.cronParser = cron_parser_1.default;
+const luxon = __importStar(require("luxon"));
+exports.luxon = luxon;
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLnBsdWdpbnMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHRpbWUucGx1Z2lucy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUEsbUJBQW1CO0FBQ25CLGtFQUFvRDtBQUczQyxnQ0FBVTtBQUZuQixzRUFBd0Q7QUFFbkMsb0NBQVk7QUFFakMsZ0JBQWdCO0FBQ2hCLDhEQUFxQztBQUc1QixxQkFIRixxQkFBVSxDQUdFO0FBRm5CLDZDQUErQjtBQUVWLHNCQUFLIn0=

dist_ts/smarttime.units.d.ts

@@ -0,0 +1,17 @@
+export declare let units: {
+    years: (timesArg?: number) => number;
+    months: (timesArg?: number) => number;
+    weeks: (timesArg?: number) => number;
+    days: (timesArg?: number) => number;
+    hours: (timesArg?: number) => number;
+    minutes: (timesArg?: number) => number;
+};
+export interface IUnitCombinationArg {
+    years?: number;
+    months?: number;
+    weeks?: number;
+    days?: number;
+    hours?: number;
+    minutes?: number;
+}
+export declare let getMilliSecondsFromUnits: (combinationArg: IUnitCombinationArg) => number;

dist_ts/smarttime.units.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMilliSecondsFromUnits = exports.units = void 0;
+exports.units = {
+    years: (timesArg = 1) => {
+        return timesArg * 3.154e10;
+    },
+    months: (timesArg = 1) => {
+        return timesArg * 2.628e9;
+    },
+    weeks: (timesArg = 1) => {
+        return timesArg * 6.048e8;
+    },
+    days: (timesArg = 1) => {
+        return timesArg * 8.64e7;
+    },
+    hours: (timesArg = 1) => {
+        return timesArg * 3.6e6;
+    },
+    minutes: (timesArg = 1) => {
+        return timesArg * 60000;
+    }
+};
+exports.getMilliSecondsFromUnits = (combinationArg) => {
+    let timeInMilliseconds = 0;
+    let addMilliSeconds = milliSecondsArg => {
+        timeInMilliseconds = timeInMilliseconds + milliSecondsArg;
+    };
+    if (combinationArg.years) {
+        addMilliSeconds(exports.units.years(combinationArg.years));
+    }
+    if (combinationArg.months) {
+        addMilliSeconds(exports.units.months(combinationArg.months));
+    }
+    if (combinationArg.weeks) {
+        addMilliSeconds(exports.units.weeks(combinationArg.weeks));
+    }
+    if (combinationArg.days) {
+        addMilliSeconds(exports.units.days(combinationArg.days));
+    }
+    if (combinationArg.hours) {
+        addMilliSeconds(exports.units.hours(combinationArg.hours));
+    }
+    if (combinationArg.minutes) {
+        addMilliSeconds(exports.units.minutes(combinationArg.minutes));
+    }
+    return timeInMilliseconds;
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLnVuaXRzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvc21hcnR0aW1lLnVuaXRzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFXLFFBQUEsS0FBSyxHQUFHO0lBQ2pCLEtBQUssRUFBRSxDQUFDLFFBQVEsR0FBRyxDQUFDLEVBQVUsRUFBRTtRQUM5QixPQUFPLFFBQVEsR0FBRyxRQUFRLENBQUM7SUFDN0IsQ0FBQztJQUNELE1BQU0sRUFBRSxDQUFDLFFBQVEsR0FBRyxDQUFDLEVBQVUsRUFBRTtRQUMvQixPQUFPLFFBQVEsR0FBRyxPQUFPLENBQUM7SUFDNUIsQ0FBQztJQUNELEtBQUssRUFBRSxDQUFDLFFBQVEsR0FBRyxDQUFDLEVBQUUsRUFBRTtRQUN0QixPQUFPLFFBQVEsR0FBRyxPQUFPLENBQUM7SUFDNUIsQ0FBQztJQUNELElBQUksRUFBRSxDQUFDLFFBQVEsR0FBRyxDQUFDLEVBQUUsRUFBRTtRQUNyQixPQUFPLFFBQVEsR0FBRyxNQUFNLENBQUM7SUFDM0IsQ0FBQztJQUNELEtBQUssRUFBRSxDQUFDLFFBQVEsR0FBRyxDQUFDLEVBQUUsRUFBRTtRQUN0QixPQUFPLFFBQVEsR0FBRyxLQUFLLENBQUM7SUFDMUIsQ0FBQztJQUNELE9BQU8sRUFBRSxDQUFDLFFBQVEsR0FBRyxDQUFDLEVBQUUsRUFBRTtRQUN4QixPQUFPLFFBQVEsR0FBRyxLQUFLLENBQUM7SUFDMUIsQ0FBQztDQUNGLENBQUM7QUFXUyxRQUFBLHdCQUF3QixHQUFHLENBQUMsY0FBbUMsRUFBRSxFQUFFO0lBQzVFLElBQUksa0JBQWtCLEdBQUcsQ0FBQyxDQUFDO0lBQzNCLElBQUksZUFBZSxHQUFHLGVBQWUsQ0FBQyxFQUFFO1FBQ3RDLGtCQUFrQixHQUFHLGtCQUFrQixHQUFHLGVBQWUsQ0FBQztJQUM1RCxDQUFDLENBQUM7SUFDRixJQUFJLGNBQWMsQ0FBQyxLQUFLLEVBQUU7UUFDeEIsZUFBZSxDQUFDLGFBQUssQ0FBQyxLQUFLLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7S0FDcEQ7SUFDRCxJQUFJLGNBQWMsQ0FBQyxNQUFNLEVBQUU7UUFDekIsZUFBZSxDQUFDLGFBQUssQ0FBQyxNQUFNLENBQUMsY0FBYyxDQUFDLE1BQU0sQ0FBQyxDQUFDLENBQUM7S0FDdEQ7SUFDRCxJQUFJLGNBQWMsQ0FBQyxLQUFLLEVBQUU7UUFDeEIsZUFBZSxDQUFDLGFBQUssQ0FBQyxLQUFLLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7S0FDcEQ7SUFDRCxJQUFJLGNBQWMsQ0FBQyxJQUFJLEVBQUU7UUFDdkIsZUFBZSxDQUFDLGFBQUssQ0FBQyxJQUFJLENBQUMsY0FBYyxDQUFDLElBQUksQ0FBQyxDQUFDLENBQUM7S0FDbEQ7SUFDRCxJQUFJLGNBQWMsQ0FBQyxLQUFLLEVBQUU7UUFDeEIsZUFBZSxDQUFDLGFBQUssQ0FBQyxLQUFLLENBQUMsY0FBYyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7S0FDcEQ7SUFDRCxJQUFJLGNBQWMsQ0FBQyxPQUFPLEVBQUU7UUFDMUIsZUFBZSxDQUFDLGFBQUssQ0FBQyxPQUFPLENBQUMsY0FBYyxDQUFDLE9BQU8sQ0FBQyxDQUFDLENBQUM7S0FDeEQ7SUFFRCxPQUFPLGtCQUFrQixDQUFDO0FBQzVCLENBQUMsQ0FBQyJ9

npmextra.json

@@ -2,5 +2,15 @@
   "npmci": {
     "npmGlobalTools": [],
     "npmAccessLevel": "public"
+  },
+  "gitzone": {
+    "module": {
+      "githost": "gitlab.com",
+      "gitscope": "pushrocks",
+      "gitrepo": "smarttime",
+      "shortDescription": "handle time in smart ways",
+      "npmPackagename": "@pushrocks/smarttime",
+      "license": "MIT"
+    }
   }
 }

package.json

@@ -1,28 +1,42 @@
 {
   "name": "@pushrocks/smarttime",
   "private": false,
-  "version": "3.0.4",
-  "description": "handle timeformats in smart ways",
+  "version": "3.0.13",
+  "description": "handle time in smart ways",
   "main": "dist/index.js",
   "typings": "dist/index.d.ts",
   "author": "Lossless GmbH",
   "license": "MIT",
   "scripts": {
     "test": "(tstest ./test/)",
-    "build": "(tsbuild)"
+    "build": "(tsbuild && tsbundle npm)"
   },
   "devDependencies": {
-    "@gitzone/tsbuild": "^2.0.22",
-    "@gitzone/tsrun": "^1.1.13",
-    "@gitzone/tstest": "^1.0.15",
-    "@pushrocks/tapbundle": "^3.0.7",
-    "@types/node": "^10.12.10",
-    "tslint": "^5.11.0",
-    "tslint-config-prettier": "^1.16.0"
+    "@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": "^14.0.5",
+    "tslint": "^6.1.2",
+    "tslint-config-prettier": "^1.18.0"
   },
   "dependencies": {
-    "@pushrocks/smartpromise": "^2.0.5",
-    "@types/luxon": "^1.4.1",
-    "luxon": "^1.8.0"
-  }
+    "@pushrocks/smartdelay": "^2.0.6",
+    "@pushrocks/smartpromise": "^3.0.2",
+    "@types/cron": "^1.7.1",
+    "@types/luxon": "^1.15.1",
+    "cron-parser": "^2.14.0",
+    "luxon": "^1.16.0"
+  },
+  "files": [
+    "ts/*",
+    "ts_web/*",
+    "dist/*",
+    "dist_web/*",
+    "assets/*",
+    "cli.js",
+    "npmextra.json",
+    "readme.md"
+  ]
 }

readme.md

@@ -1,24 +1,20 @@
 # @pushrocks/smarttime
+handle time in smart ways
 
-handle timeformats in smart ways
-
-## Availabililty
-
-[![npm](https://pushrocks.gitlab.io/assets/repo-button-npm.svg)](https://www.npmjs.com/package/smarttime)
-[![git](https://pushrocks.gitlab.io/assets/repo-button-git.svg)](https://GitLab.com/pushrocks/smarttime)
-[![git](https://pushrocks.gitlab.io/assets/repo-button-mirror.svg)](https://github.com/pushrocks/smarttime)
-[![docs](https://pushrocks.gitlab.io/assets/repo-button-docs.svg)](https://pushrocks.gitlab.io/smarttime/)
+## Availabililty and Links
+* [npmjs.org (npm package)](https://www.npmjs.com/package/@pushrocks/smarttime)
+* [gitlab.com (source)](https://gitlab.com/pushrocks/smarttime)
+* [github.com (source mirror)](https://github.com/pushrocks/smarttime)
+* [docs (typedoc)](https://pushrocks.gitlab.io/smarttime/)
 
 ## Status for master
-
-[![build status](https://GitLab.com/pushrocks/smarttime/badges/master/build.svg)](https://GitLab.com/pushrocks/smarttime/commits/master)
-[![coverage report](https://GitLab.com/pushrocks/smarttime/badges/master/coverage.svg)](https://GitLab.com/pushrocks/smarttime/commits/master)
-[![npm downloads per month](https://img.shields.io/npm/dm/smarttime.svg)](https://www.npmjs.com/package/smarttime)
-[![Dependency Status](https://david-dm.org/pushrocks/smarttime.svg)](https://david-dm.org/pushrocks/smarttime)
-[![bitHound Dependencies](https://www.bithound.io/github/pushrocks/smarttime/badges/dependencies.svg)](https://www.bithound.io/github/pushrocks/smarttime/master/dependencies/npm)
-[![bitHound Code](https://www.bithound.io/github/pushrocks/smarttime/badges/code.svg)](https://www.bithound.io/github/pushrocks/smarttime)
-[![TypeScript](https://img.shields.io/badge/TypeScript-2.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
-[![node](https://img.shields.io/badge/node->=%206.x.x-blue.svg)](https://nodejs.org/dist/latest-v6.x/docs/api/)
+[![build status](https://gitlab.com/pushrocks/smarttime/badges/master/build.svg)](https://gitlab.com/pushrocks/smarttime/commits/master)
+[![coverage report](https://gitlab.com/pushrocks/smarttime/badges/master/coverage.svg)](https://gitlab.com/pushrocks/smarttime/commits/master)
+[![npm downloads per month](https://img.shields.io/npm/dm/@pushrocks/smarttime.svg)](https://www.npmjs.com/package/@pushrocks/smarttime)
+[![Known Vulnerabilities](https://snyk.io/test/npm/@pushrocks/smarttime/badge.svg)](https://snyk.io/test/npm/@pushrocks/smarttime)
+[![TypeScript](https://img.shields.io/badge/TypeScript->=%203.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+[![node](https://img.shields.io/badge/node->=%2010.x.x-blue.svg)](https://nodejs.org/dist/latest-v10.x/docs/api/)
+[![JavaScript Style Guide](https://img.shields.io/badge/code%20style-prettier-ff69b4.svg)](https://prettier.io/)
 
 ## Usage
 
@@ -26,18 +22,29 @@ Use TypeScript for best in class instellisense.
 
 Smarttime offers smart ways to deal with time.
 
-### class ExtendedDate
+### class CronManager
+This class provides scheduling of functions with a cron syntax
 
-This class offers static functions to create zone speicific JavaScript dates from European formated time strings.
+```typescript
+import { CronManager } from '@pushrocks/smarrtime';
+const cronManagerInstance = new CronManager();
+cronManagerInstance.addConrjob('* * * * * *', async () => {
+  console.log('hello'); // will log 'hello' to console once every second;
+})
+cronManagerInstance.start();
+```
+
+### class ExtendedDate
+This class offers static functions to create zone specific JavaScript dates from European formated time strings.
 
 ```TypeScript
 import { ExtendedDate } from '@pushrocks/smarttime'
 const myDate: Date = ExtendedDate.fromEuropeanDate('8.6.2018')
 ```
 
-For further information read the linked docs at the top of this README.
+For further information read the linked docs at the top of this readme.
 
 > MIT licensed | **©** [Lossless GmbH](https://lossless.gmbh)
-> | By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
+| By using this npm module you agree to our [privacy policy](https://lossless.gmbH/privacy.html)
 
-[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://push.rocks)
+[![repo-footer](https://pushrocks.gitlab.io/assets/repo-footer.svg)](https://maintainedby.lossless.com)

test/test.cronmanager.ts

@@ -0,0 +1,27 @@
+import { tap, expect } from '@pushrocks/tapbundle';
+
+import * as smarttime from '../ts/index';
+
+let testCronManager: smarttime.CronManager;
+
+tap.test('should create a valid instance of cronmanager', async () => {
+  testCronManager = new smarttime.CronManager();
+  expect(testCronManager).to.be.instanceOf(smarttime.CronManager);
+});
+
+tap.test('should create a valid cronJon', async tools => {
+  const done = tools.defer();
+  let counter = 0;
+  testCronManager.addCronjob('* * * * * *', () => {
+    if (counter === 10) {
+      done.resolve();
+    }
+    counter++;
+    console.log(`hey ${counter}`);
+  });
+  testCronManager.start();
+  await done.promise;
+  testCronManager.stop();
+});
+
+tap.start();

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/index.ts

@@ -1,6 +1,7 @@
 import * as plugins from './smarttime.plugins';
 
-export * from './smarttime.classes.date';
+export * from './smarttime.classes.cronmanager';
+export * from './smarttime.classes.extendeddate';
 export * from './smarttime.classes.hrtmeasurement';
 export * from './smarttime.classes.timer';
 export * from './smarttime.classes.timestamp';

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

@@ -0,0 +1,49 @@
+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[] = [];
+
+  constructor() {
+    this.cronInterval.addIntervalJob(() => {
+      for (const cronJob of this.cronjobs) {
+        cronJob.checkExecution();
+      }
+    });
+  }
+
+  public addCronjob(cronIdentifierArg: string, cronFunctionArg: () => any) {
+    const newCronJob = new CronJob(this, cronIdentifierArg, cronFunctionArg);
+    this.cronjobs.push(newCronJob);
+    if (this.status === 'started') {
+      newCronJob.start();
+    }
+  }
+
+  /**
+   * starts the cronjob
+   */
+  public start() {
+    this.status = 'started';
+    for (const cron of this.cronjobs) {
+      cron.start();
+    }
+    this.cronInterval.start();
+  }
+
+  /**
+   * stops all cronjobs
+   */
+  public stop() {
+    this.status = 'stopped';
+    for (const cron of this.cronjobs) {
+      cron.stop();
+    }
+    this.cronInterval.stop();
+  }
+}

ts/smarttime.classes.date.ts

@@ -1,40 +0,0 @@
-import * as plugins from './smarttime.plugins';
-
-export type TAvailableZone = 'Europe/Berlin';
-
-export class ExtendedDate extends Date {
-  public static fromEuropeanDate(europeanDate: string) {
-    const dateArray = /(.*)\.(.*)\.(.*)/.exec(europeanDate);
-    const luxonDate = plugins.luxon.DateTime.utc(
-      parseFloat(dateArray[3]), // year
-      parseFloat(dateArray[2]), // month
-      parseFloat(dateArray[1]) // day
-    );
-    const unixMilli = luxonDate.toMillis();
-    return new ExtendedDate(unixMilli);
-  }
-
-  /** */
-  public static fromEuropeanDateAndTime(
-    europeanDateArg: string,
-    timeArg: string,
-    zoneArg: TAvailableZone
-  ) {
-    const dateArray = /(.*)\.(.*)\.(.*)/.exec(europeanDateArg);
-    const sliceDate = (dateString: string) => {
-      return `0${dateString}`.slice(-2);
-    };
-    const dateTimeString = `${dateArray[3]}-${sliceDate(dateArray[2])}-${sliceDate(
-      dateArray[1]
-    )}T${timeArg}`;
-    const luxonDate = plugins.luxon.DateTime.fromISO(dateTimeString, {
-      zone: zoneArg
-    });
-    const unixMilli = luxonDate.toMillis();
-    return new ExtendedDate(unixMilli);
-  }
-
-  constructor(unixMilli: number) {
-    super(unixMilli);
-  }
-}

ts/smarttime.classes.extendeddate.ts

@@ -0,0 +1,127 @@
+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(
+      parseFloat(dateArray[3]), // year
+      parseFloat(dateArray[2]), // month
+      parseFloat(dateArray[1]) // day
+    );
+    const unixMilli = luxonDate.toMillis();
+    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 = '12:00:00',
+    zoneArg: TAvailableZone = 'Europe/Berlin'
+  ) {
+    // guards
+
+    // implementation
+    const dateArray = /(.*)\.(.*)\.(.*)/.exec(europeanDateArg);
+    const sliceDate = (dateString: string) => {
+      return `0${dateString}`.slice(-2);
+    };
+    const dateTimeString = `${dateArray[3]}-${sliceDate(dateArray[2])}-${sliceDate(
+      dateArray[1]
+    )}T${timeArg}`;
+    const luxonDate = plugins.luxon.DateTime.fromISO(dateTimeString, {
+      zone: zoneArg
+    });
+    const unixMilli = luxonDate.toMillis();
+    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,11 +1,9 @@
-import * as process from 'process';
-
 /**
  * easy high resolution time measurement
  */
 export class HrtMeasurement {
-  nanoSeconds: number = null;
-  milliSeconds: number = null;
+  public nanoSeconds: number = null;
+  public milliSeconds: number = null;
   private _hrTimeStart = null;
   private _hrTimeStopDiff = null;
   private _started: boolean = false;
@@ -13,7 +11,7 @@ export class HrtMeasurement {
   /**
    * start the measurement
    */
-  start() {
+  public start() {
     this._started = true;
     this._hrTimeStart = process.hrtime();
   }
@@ -21,7 +19,7 @@ export class HrtMeasurement {
   /**
    * stop the measurement
    */
-  stop() {
+  public stop() {
     if (this._started === false) {
       console.log("Hasn't started yet");
       return;
@@ -35,7 +33,7 @@ export class HrtMeasurement {
   /**
    * reset the measurement
    */
-  reset() {
+  public reset() {
     this.nanoSeconds = null;
     this.milliSeconds = null;
     this._hrTimeStart = null;

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.classes.timer.ts

@@ -61,9 +61,11 @@ export class Timer {
   }
 
   public pause() {
-    clearTimeout(this.currentTimeout);
-    this.currentTimeout = null;
-    this.pausedAt = TimeStamp.fromTimeStamp(this.startedAt);
+    if (this.startedAt) {
+      clearTimeout(this.currentTimeout);
+      this.currentTimeout = null;
+      this.pausedAt = TimeStamp.fromTimeStamp(this.startedAt);
+    }
   }
 
   public resume() {

ts/smarttime.classes.timestamp.ts

@@ -65,6 +65,11 @@ export class TimeStamp {
     }
   }
 
+  /**
+   * returns a boolean for wether a timestamp is younger
+   * @param TimeStampArg
+   * @param tresholdTimeArg
+   */
   public isYoungerThanOtherTimeStamp(TimeStampArg: TimeStamp, tresholdTimeArg: number = 0) {
     if (this.milliSeconds > TimeStampArg.milliSeconds + tresholdTimeArg) {
       return true;

ts/smarttime.plugins.ts

@@ -1,9 +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';
 
-export { luxon };
+export { cronParser, luxon };