@push.rocks/smarttime 4.0.1

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @pushrocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@pushrocks/smarttime',
+    version: '4.0.1',
+    description: 'handle time in smart ways'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSxzQkFBc0I7SUFDNUIsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLDJCQUEyQjtDQUN6QyxDQUFBIn0=

package/dist_ts/index.d.ts

@@ -0,0 +1,8 @@
+export * from './smarttime.classes.cronmanager.js';
+export * from './smarttime.classes.cronjob.js';
+export * from './smarttime.classes.extendeddate.js';
+export * from './smarttime.classes.hrtmeasurement.js';
+export * from './smarttime.classes.interval.js';
+export * from './smarttime.classes.timer.js';
+export * from './smarttime.classes.timestamp.js';
+export * from './smarttime.units.js';

package/dist_ts/index.js

@@ -0,0 +1,9 @@
+export * from './smarttime.classes.cronmanager.js';
+export * from './smarttime.classes.cronjob.js';
+export * from './smarttime.classes.extendeddate.js';
+export * from './smarttime.classes.hrtmeasurement.js';
+export * from './smarttime.classes.interval.js';
+export * from './smarttime.classes.timer.js';
+export * from './smarttime.classes.timestamp.js';
+export * from './smarttime.units.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLG9DQUFvQyxDQUFDO0FBQ25ELGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxxQ0FBcUMsQ0FBQztBQUNwRCxjQUFjLHVDQUF1QyxDQUFDO0FBQ3RELGNBQWMsaUNBQWlDLENBQUM7QUFDaEQsY0FBYyw4QkFBOEIsQ0FBQztBQUM3QyxjQUFjLGtDQUFrQyxDQUFDO0FBQ2pELGNBQWMsc0JBQXNCLENBQUMifQ==

package/dist_ts/smarttime.classes.cronjob.d.ts

@@ -0,0 +1,22 @@
+import * as plugins from './smarttime.plugins.js';
+import { CronManager } from './smarttime.classes.cronmanager.js';
+export type TJobFunction = ((triggerTimeArg?: number) => void) | ((triggerTimeArg?: number) => Promise<any>);
+export declare class CronJob {
+    cronParser: plugins.croner;
+    status: 'started' | 'stopped' | 'initial';
+    cronExpression: string;
+    jobFunction: TJobFunction;
+    private nextExecutionUnix;
+    constructor(cronManager: CronManager, cronExpressionArg: string, jobFunction: TJobFunction);
+    /**
+     * checks wether the cronjob needs to be executed
+     */
+    checkExecution(): number;
+    getNextExecutionTime(): number;
+    /**
+     * gets the time to next execution
+     */
+    getTimeToNextExecution(): number;
+    start(): void;
+    stop(): void;
+}

package/dist_ts/smarttime.classes.cronjob.js

@@ -0,0 +1,44 @@
+import * as plugins from './smarttime.plugins.js';
+import './smarttime.classes.cronmanager.js';
+import './smarttime.classes.cronparser.js';
+export class CronJob {
+    constructor(cronManager, cronExpressionArg, jobFunction) {
+        this.status = 'initial';
+        this.nextExecutionUnix = 0;
+        this.cronExpression = cronExpressionArg;
+        this.jobFunction = jobFunction;
+        this.cronParser = plugins.croner(cronExpressionArg);
+    }
+    /**
+     * checks wether the cronjob needs to be executed
+     */
+    checkExecution() {
+        if (this.nextExecutionUnix === 0) {
+            this.getNextExecutionTime();
+        }
+        if (Date.now() > this.nextExecutionUnix) {
+            const maybePromise = this.jobFunction(this.nextExecutionUnix);
+            if (maybePromise instanceof Promise) {
+                maybePromise.catch((e) => console.log(e));
+            }
+            this.nextExecutionUnix = this.getNextExecutionTime();
+        }
+        return this.nextExecutionUnix;
+    }
+    getNextExecutionTime() {
+        return (this.nextExecutionUnix = Date.now() + this.getTimeToNextExecution());
+    }
+    /**
+     * gets the time to next execution
+     */
+    getTimeToNextExecution() {
+        return this.cronParser.msToNext();
+    }
+    start() {
+        this.status = 'started';
+    }
+    stop() {
+        this.status = 'stopped';
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLmNsYXNzZXMuY3JvbmpvYi5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uL3RzL3NtYXJ0dGltZS5jbGFzc2VzLmNyb25qb2IudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsT0FBTyxLQUFLLE9BQU8sTUFBTSx3QkFBd0IsQ0FBQztBQUNsRCxPQUE0QixvQ0FBb0MsQ0FBQztBQUVqRSxPQUEyQixtQ0FBbUMsQ0FBQztBQU0vRCxNQUFNLE9BQU8sT0FBTztJQU9sQixZQUFZLFdBQXdCLEVBQUUsaUJBQXlCLEVBQUUsV0FBeUI7UUFMbkYsV0FBTSxHQUFzQyxTQUFTLENBQUM7UUFHckQsc0JBQWlCLEdBQVcsQ0FBQyxDQUFDO1FBR3BDLElBQUksQ0FBQyxjQUFjLEdBQUcsaUJBQWlCLENBQUM7UUFDeEMsSUFBSSxDQUFDLFdBQVcsR0FBRyxXQUFXLENBQUM7UUFDL0IsSUFBSSxDQUFDLFVBQVUsR0FBRyxPQUFPLENBQUMsTUFBTSxDQUFDLGlCQUFpQixDQUFDLENBQUM7SUFDdEQsQ0FBQztJQUVEOztPQUVHO0lBQ0ksY0FBYztRQUNuQixJQUFJLElBQUksQ0FBQyxpQkFBaUIsS0FBSyxDQUFDLEVBQUU7WUFDaEMsSUFBSSxDQUFDLG9CQUFvQixFQUFFLENBQUM7U0FDN0I7UUFDRCxJQUFJLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUMsaUJBQWlCLEVBQUU7WUFDdkMsTUFBTSxZQUFZLEdBQUcsSUFBSSxDQUFDLFdBQVcsQ0FBQyxJQUFJLENBQUMsaUJBQWlCLENBQUMsQ0FBQztZQUM5RCxJQUFJLFlBQVksWUFBWSxPQUFPLEVBQUU7Z0JBQ25DLFlBQVksQ0FBQyxLQUFLLENBQUMsQ0FBQyxDQUFDLEVBQUUsRUFBRSxDQUFDLE9BQU8sQ0FBQyxHQUFHLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQzthQUMzQztZQUNELElBQUksQ0FBQyxpQkFBaUIsR0FBRyxJQUFJLENBQUMsb0JBQW9CLEVBQUUsQ0FBQztTQUN0RDtRQUNELE9BQU8sSUFBSSxDQUFDLGlCQUFpQixDQUFDO0lBQ2hDLENBQUM7SUFFTSxvQkFBb0I7UUFDekIsT0FBTyxDQUFDLElBQUksQ0FBQyxpQkFBaUIsR0FBRyxJQUFJLENBQUMsR0FBRyxFQUFFLEdBQUcsSUFBSSxDQUFDLHNCQUFzQixFQUFFLENBQUMsQ0FBQztJQUMvRSxDQUFDO0lBRUQ7O09BRUc7SUFDSSxzQkFBc0I7UUFDM0IsT0FBTyxJQUFJLENBQUMsVUFBVSxDQUFDLFFBQVEsRUFBRSxDQUFDO0lBQ3BDLENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUM7SUFDMUIsQ0FBQztJQUVNLElBQUk7UUFDVCxJQUFJLENBQUMsTUFBTSxHQUFHLFNBQVMsQ0FBQztJQUMxQixDQUFDO0NBQ0YifQ==

package/dist_ts/smarttime.classes.cronmanager.d.ts

@@ -0,0 +1,18 @@
+import * as plugins from './smarttime.plugins.js';
+import { CronJob, TJobFunction } from './smarttime.classes.cronjob.js';
+export declare class CronManager {
+    executionTimeout: plugins.smartdelay.Timeout<void>;
+    status: 'started' | 'stopped';
+    cronjobs: plugins.lik.ObjectMap<CronJob>;
+    constructor();
+    addCronjob(cronIdentifierArg: string, cronFunctionArg: TJobFunction): CronJob;
+    removeCronjob(cronjobArg: CronJob): void;
+    /**
+     * starts the cronjob
+     */
+    start(): void;
+    /**
+     * stops all cronjobs
+     */
+    stop(): void;
+}

package/dist_ts/smarttime.classes.cronmanager.js

@@ -0,0 +1,71 @@
+import * as plugins from './smarttime.plugins.js';
+import { CronJob } from './smarttime.classes.cronjob.js';
+import { getMilliSecondsAsHumanReadableString } from './smarttime.units.js';
+export class CronManager {
+    constructor() {
+        this.status = 'stopped';
+        this.cronjobs = new plugins.lik.ObjectMap();
+    }
+    addCronjob(cronIdentifierArg, cronFunctionArg) {
+        const newCronJob = new CronJob(this, cronIdentifierArg, cronFunctionArg);
+        this.cronjobs.add(newCronJob);
+        if (this.status === 'started') {
+            newCronJob.start();
+        }
+        return newCronJob;
+    }
+    removeCronjob(cronjobArg) {
+        cronjobArg.stop();
+        this.cronjobs.remove(cronjobArg);
+    }
+    /**
+     * starts the cronjob
+     */
+    start() {
+        if (this.status !== 'started') {
+            this.status = 'started';
+            for (const cronJob of this.cronjobs.getArray()) {
+                cronJob.start();
+            }
+            const runCronCycle = async () => {
+                this.executionTimeout = new plugins.smartdelay.Timeout(0);
+                do {
+                    let nextRunningCronjob;
+                    for (const cronJob of this.cronjobs.getArray()) {
+                        cronJob.checkExecution();
+                        if (!nextRunningCronjob ||
+                            cronJob.getTimeToNextExecution() < nextRunningCronjob.getTimeToNextExecution()) {
+                            nextRunningCronjob = cronJob;
+                        }
+                    }
+                    if (nextRunningCronjob) {
+                        this.executionTimeout = new plugins.smartdelay.Timeout(nextRunningCronjob.getTimeToNextExecution());
+                        console.log(`Next CronJob scheduled in ${getMilliSecondsAsHumanReadableString(this.executionTimeout.getTimeLeft())}`);
+                    }
+                    else {
+                        this.executionTimeout = new plugins.smartdelay.Timeout(1000);
+                        console.log('no cronjobs specified! Checking again in 1 second');
+                    }
+                    await this.executionTimeout.promise;
+                } while (this.status === 'started');
+            };
+            runCronCycle();
+        }
+    }
+    /**
+     * stops all cronjobs
+     */
+    stop() {
+        if (this.status === 'started') {
+            this.status = 'stopped';
+            this.executionTimeout.cancel();
+        }
+        else {
+            console.log(`You tried to stop a CronManager that was not actually started.`);
+        }
+        for (const cron of this.cronjobs.getArray()) {
+            cron.stop();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smarttime.classes.cronparser.d.ts

@@ -0,0 +1,7 @@
+export declare class CronParser {
+    cronExpression: string;
+    get cronArray(): string[];
+    constructor(cronExpressionArg: string);
+    private getNextPartMatch;
+    msToNext(): number;
+}

package/dist_ts/smarttime.classes.cronparser.js

@@ -0,0 +1,74 @@
+import './smarttime.plugins.js';
+export class CronParser {
+    get cronArray() {
+        return this.cronExpression.split(' ');
+    }
+    constructor(cronExpressionArg) {
+        this.cronExpression = cronExpressionArg;
+        if (this.cronArray.length < 6) {
+            throw new Error('CronParser needs second level accuracy');
+        }
+    }
+    getNextPartMatch(cronPart, startValue, moduloArg) {
+        if (cronPart === '*') {
+            return startValue;
+        }
+        if (cronPart.includes('/')) {
+            const every = parseInt(cronPart.split('/')[1], 10);
+            const findEvenMatch = (recursionStartArg) => {
+                if (recursionStartArg % every === 0) {
+                    return recursionStartArg;
+                }
+                else {
+                    return findEvenMatch(recursionStartArg + 1);
+                }
+            };
+            return findEvenMatch(startValue);
+        }
+        if (parseInt(cronPart, 10) || cronPart === '0') {
+            const match = parseInt(cronPart, 10);
+            return match;
+        }
+    }
+    msToNext() {
+        const cronArray = this.cronArray;
+        const secondExpression = cronArray[0];
+        const minuteExpression = cronArray[1];
+        const hourExpression = cronArray[2];
+        const dayExpression = cronArray[3];
+        const monthExpression = cronArray[4];
+        const yearExpression = cronArray[5];
+        let currentDate = new Date();
+        let currentSecond = currentDate.getSeconds() + 1;
+        let currentMinute = currentDate.getMinutes();
+        let currentHour = currentDate.getHours();
+        let currentDay = currentDate.getDate();
+        let currentMonth = currentDate.getMonth();
+        let currentYear = currentDate.getFullYear();
+        const targetSecond = this.getNextPartMatch(secondExpression, currentSecond, 59);
+        if (targetSecond < currentSecond) {
+            currentMinute = (currentMinute + 1) % 59;
+        }
+        const targetMinute = this.getNextPartMatch(minuteExpression, currentMinute, 59);
+        if (targetMinute < currentMinute) {
+            currentHour = (currentHour + 1) % 23;
+        }
+        const targetHour = this.getNextPartMatch(hourExpression, currentHour, 23);
+        if (targetHour < currentHour) {
+            currentDay = (currentDay + 1) % 30;
+        }
+        const targetDay = currentDay;
+        if (targetDay < currentDay) {
+            currentMonth = (currentMonth + 1) % 11;
+        }
+        const targetMonth = currentMonth;
+        if (targetMonth < currentMonth) {
+            currentYear = currentYear + 1;
+        }
+        const targetYear = currentYear;
+        const targetDate = new Date(targetYear, targetMonth, targetDay, targetHour, targetMinute, targetSecond);
+        const targetTime = targetDate.getTime();
+        return targetTime - Date.now();
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/smarttime.classes.extendeddate.d.ts

@@ -0,0 +1,42 @@
+import * as units from './smarttime.units.js';
+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 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;
+    exportToHyphedSortableDate(): string;
+    /**
+     * exports units
+     */
+    exportToUnits(): IDateUnits;
+    format(formatArg: string): string;
+    /**
+     * boolean checks
+     */
+    isToday(): boolean;
+    lessTimePassedToNow(unitArgs: units.IUnitCombinationArg): boolean;
+    moreTimePassedToNow(unitArgs: units.IUnitCombinationArg): boolean;
+}

package/dist_ts/smarttime.classes.extendeddate.js

@@ -0,0 +1,114 @@
+import * as plugins from './smarttime.plugins.js';
+import * as units from './smarttime.units.js';
+export class ExtendedDate extends Date {
+    // 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 date = new Date(parseFloat(dateArray[3]), // year
+        parseFloat(dateArray[2]) - 1, // month
+        parseFloat(dateArray[1]) // day
+        );
+        const unixMilli = date.getTime();
+        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 date = plugins.dayjs(dateTimeString);
+        const unixMilli = date.toDate().getTime();
+        return new ExtendedDate(unixMilli);
+    }
+    constructor(unixMilli = Date.now()) {
+        super(unixMilli);
+    }
+    //
+    exportToEuropeanDate() {
+        const units = this.exportToUnits();
+        return `${units.dayString}.${units.monthString}.${units.yearString}`;
+    }
+    exportToHyphedSortableDate() {
+        const units = this.exportToUnits();
+        return `${units.yearString}-${units.monthString}-${units.dayString}`;
+    }
+    /**
+     * 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()],
+        };
+    }
+    format(formatArg) {
+        return plugins.dayjs(this.getTime()).format(formatArg);
+    }
+    /**
+     * boolean checks
+     */
+    isToday() {
+        return plugins.dayjs(this.getTime()).isToday();
+    }
+    lessTimePassedToNow(unitArgs) {
+        const maxPassedUnixTime = units.getMilliSecondsFromUnits(unitArgs);
+        const actualPassedUnixTime = Date.now() - this.getTime();
+        return actualPassedUnixTime < maxPassedUnixTime;
+    }
+    moreTimePassedToNow(unitArgs) {
+        return !this.lessTimePassedToNow(unitArgs);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/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 _milliStart;
+    private _milliDiff;
+    private _started;
+    /**
+     * start the measurement
+     */
+    start(): void;
+    /**
+     * stop the measurement
+     */
+    stop(): this;
+    /**
+     * reset the measurement
+     */
+    reset(): void;
+}

package/dist_ts/smarttime.classes.hrtmeasurement.js

@@ -0,0 +1,43 @@
+/**
+ * easy high resolution time measurement
+ */
+export class HrtMeasurement {
+    constructor() {
+        this.nanoSeconds = null;
+        this.milliSeconds = null;
+        this._milliStart = null;
+        this._milliDiff = null;
+        this._started = false;
+    }
+    /**
+     * start the measurement
+     */
+    start() {
+        this._started = true;
+        this._milliStart = Date.now();
+    }
+    /**
+     * stop the measurement
+     */
+    stop() {
+        if (this._started === false) {
+            console.log("Hasn't started yet");
+            return;
+        }
+        this._milliDiff = Date.now() - this._milliStart;
+        this.nanoSeconds = this._milliDiff * 1000;
+        this.milliSeconds = this._milliDiff;
+        return this;
+    }
+    /**
+     * reset the measurement
+     */
+    reset() {
+        this.nanoSeconds = null;
+        this.milliSeconds = null;
+        this._milliStart = null;
+        this._milliDiff = null;
+        this._started = false;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLmNsYXNzZXMuaHJ0bWVhc3VyZW1lbnQuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHRpbWUuY2xhc3Nlcy5ocnRtZWFzdXJlbWVudC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQTs7R0FFRztBQUNILE1BQU0sT0FBTyxjQUFjO0lBQTNCO1FBQ1MsZ0JBQVcsR0FBVyxJQUFJLENBQUM7UUFDM0IsaUJBQVksR0FBVyxJQUFJLENBQUM7UUFDM0IsZ0JBQVcsR0FBVyxJQUFJLENBQUM7UUFDM0IsZUFBVSxHQUFXLElBQUksQ0FBQztRQUMxQixhQUFRLEdBQVksS0FBSyxDQUFDO0lBa0NwQyxDQUFDO0lBaENDOztPQUVHO0lBQ0ksS0FBSztRQUNWLElBQUksQ0FBQyxRQUFRLEdBQUcsSUFBSSxDQUFDO1FBQ3JCLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDLEdBQUcsRUFBRSxDQUFDO0lBQ2hDLENBQUM7SUFFRDs7T0FFRztJQUNJLElBQUk7UUFDVCxJQUFJLElBQUksQ0FBQyxRQUFRLEtBQUssS0FBSyxFQUFFO1lBQzNCLE9BQU8sQ0FBQyxHQUFHLENBQUMsb0JBQW9CLENBQUMsQ0FBQztZQUNsQyxPQUFPO1NBQ1I7UUFDRCxJQUFJLENBQUMsVUFBVSxHQUFHLElBQUksQ0FBQyxHQUFHLEVBQUUsR0FBRyxJQUFJLENBQUMsV0FBVyxDQUFDO1FBQ2hELElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDLFVBQVUsR0FBRyxJQUFJLENBQUM7UUFDMUMsSUFBSSxDQUFDLFlBQVksR0FBRyxJQUFJLENBQUMsVUFBVSxDQUFDO1FBQ3BDLE9BQU8sSUFBSSxDQUFDO0lBQ2QsQ0FBQztJQUVEOztPQUVHO0lBQ0ksS0FBSztRQUNWLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDO1FBQ3hCLElBQUksQ0FBQyxZQUFZLEdBQUcsSUFBSSxDQUFDO1FBQ3pCLElBQUksQ0FBQyxXQUFXLEdBQUcsSUFBSSxDQUFDO1FBQ3hCLElBQUksQ0FBQyxVQUFVLEdBQUcsSUFBSSxDQUFDO1FBQ3ZCLElBQUksQ0FBQyxRQUFRLEdBQUcsS0FBSyxDQUFDO0lBQ3hCLENBQUM7Q0FDRiJ9

package/dist_ts/smarttime.classes.interval.d.ts

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

package/dist_ts/smarttime.classes.interval.js

@@ -0,0 +1,34 @@
+import * as plugins from './smarttime.plugins.js';
+export 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();
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic21hcnR0aW1lLmNsYXNzZXMuaW50ZXJ2YWwuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi90cy9zbWFydHRpbWUuY2xhc3Nlcy5pbnRlcnZhbC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEtBQUssT0FBTyxNQUFNLHdCQUF3QixDQUFDO0FBRWxELE1BQU0sT0FBTyxRQUFRO0lBU25CLFlBQVksd0JBQWdDO1FBUnJDLFdBQU0sR0FBc0MsU0FBUyxDQUFDO1FBQ3JELHdCQUFtQixHQUFRLElBQUksQ0FBQztRQU1qQyxpQkFBWSxHQUFxQixFQUFFLENBQUM7UUFFekMsSUFBSSxDQUFDLG9CQUFvQixHQUFHLHdCQUF3QixDQUFDO0lBQ3ZELENBQUM7SUFFTSxLQUFLO1FBQ1YsSUFBSSxDQUFDLE1BQU0sR0FBRyxTQUFTLENBQUM7UUFDeEIsTUFBTSxVQUFVLEdBQUcsSUFBSSxJQUFJLEVBQUUsQ0FBQztRQUM5QixJQUFJLENBQUMsbUJBQW1CLEdBQUcsVUFBVSxDQUFDO1FBQ3RDLE1BQU0sV0FBVyxHQUFHLEtBQUssSUFBSSxFQUFFO1lBQzdCLE9BQU8sSUFBSSxDQUFDLE1BQU0sS0FBSyxTQUFTLElBQUksSUFBSSxDQUFDLG1CQUFtQixLQUFLLFVBQVUsRUFBRTtnQkFDM0UsTUFBTSxPQUFPLENBQUMsVUFBVSxDQUFDLFFBQVEsQ0FBQyxJQUFJLENBQUMsb0JBQW9CLENBQUMsQ0FBQztnQkFDN0QsSUFBSSxDQUFDLG1CQUFtQixFQUFFLENBQUM7YUFDNUI7UUFDSCxDQUFDLENBQUM7UUFDRixXQUFXLEVBQUUsQ0FBQztJQUNoQixDQUFDO0lBRU0sSUFBSTtRQUNULElBQUksQ0FBQyxNQUFNLEdBQUcsU0FBUyxDQUFDO1FBQ3hCLElBQUksQ0FBQyxtQkFBbUIsR0FBRyxJQUFJLENBQUM7SUFDbEMsQ0FBQztJQUVNLGNBQWMsQ0FBQyxPQUFrQjtRQUN0QyxJQUFJLENBQUMsWUFBWSxDQUFDLElBQUksQ0FBQyxPQUFPLENBQUMsQ0FBQztJQUNsQyxDQUFDO0lBRU8sbUJBQW1CO1FBQ3pCLEtBQUssTUFBTSxPQUFPLElBQUksSUFBSSxDQUFDLFlBQVksRUFBRTtZQUN2QyxPQUFPLEVBQUUsQ0FBQztTQUNYO0lBQ0gsQ0FBQztDQUNGIn0=

package/dist_ts/smarttime.classes.timer.d.ts

@@ -0,0 +1,38 @@
+import { TimeStamp } from './smarttime.classes.timestamp.js';
+export 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;
+}