vap1 0.4.5 → 0.4.7

package/utils/crontab/crontabRender.js

@@ -0,0 +1,503 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExpressionDescriptor = exports.crontabRender = void 0;
+var utils_1 = require("./utils");
+var lodash_1 = __importDefault(require("lodash"));
+var crontabParser_1 = require("./crontabParser");
+var _global_1 = require("./_global");
+var crontabRender = function (expression, options) {
+    var option = lodash_1.default.assign({}, _global_1.DEFAULT_OPTION, options);
+    var descripter = new ExpressionDescriptor(expression, option);
+    // console.log(option)
+    return descripter.getFullDescription();
+};
+exports.crontabRender = crontabRender;
+var ExpressionDescriptor = /** @class */ (function () {
+    function ExpressionDescriptor(expression, options) {
+        this.expression = expression;
+        this.options = options;
+        this.expressionParts = new Array(5);
+        if (options.use24HourTimeFormat === undefined) {
+            // if use24HourTimeFormat not specified, set based on locale default
+            options.use24HourTimeFormat = _global_1.i18n.use24HourTimeFormatByDefault();
+        }
+    }
+    ExpressionDescriptor.prototype.getFullDescription = function () {
+        var description = "";
+        try {
+            this.expressionParts = (0, crontabParser_1.crontabParser)(this.expression);
+            var timeSegment = this.getTimeOfDayDescription();
+            var dayOfMonthDesc = this.getDayOfMonthDescription();
+            var monthDesc = this.getMonthDescription();
+            var dayOfWeekDesc = this.getDayOfWeekDescription();
+            var yearDesc = this.getYearDescription();
+            description += timeSegment + dayOfMonthDesc + dayOfWeekDesc + monthDesc + yearDesc;
+            description = this.transformVerbosity(description, !!this.options.verbose);
+            // uppercase first character
+            description = description.charAt(0).toLocaleUpperCase() + description.substr(1);
+        }
+        catch (ex) {
+            if (!this.options.throwExceptionOnParseError) {
+                description = _global_1.i18n.anErrorOccuredWhenGeneratingTheExpressionD();
+            }
+            else {
+                throw "".concat(ex);
+            }
+        }
+        return description;
+    };
+    ExpressionDescriptor.prototype.getTimeOfDayDescription = function () {
+        var secondsExpression = this.expressionParts[0];
+        var minuteExpression = this.expressionParts[1];
+        var hourExpression = this.expressionParts[2];
+        var description = "";
+        if (!(0, utils_1.containsAny)(minuteExpression, _global_1.specialCharacters) &&
+            !(0, utils_1.containsAny)(hourExpression, _global_1.specialCharacters) &&
+            !(0, utils_1.containsAny)(secondsExpression, _global_1.specialCharacters)) {
+            // specific time of day (i.e. 10 14)
+            description += _global_1.i18n.atSpace() + this.formatTime(hourExpression, minuteExpression, secondsExpression);
+        }
+        else if (!secondsExpression &&
+            minuteExpression.indexOf("-") > -1 &&
+            !(minuteExpression.indexOf(",") > -1) &&
+            !(minuteExpression.indexOf("/") > -1) &&
+            !(0, utils_1.containsAny)(hourExpression, _global_1.specialCharacters)) {
+            // minute range in single hour (i.e. 0-10 11)
+            var minuteParts = minuteExpression.split("-");
+            description += (0, utils_1.format)(_global_1.i18n.everyMinuteBetweenX0AndX1(), this.formatTime(hourExpression, minuteParts[0], ""), this.formatTime(hourExpression, minuteParts[1], ""));
+        }
+        else if (!secondsExpression &&
+            hourExpression.indexOf(",") > -1 &&
+            hourExpression.indexOf("-") == -1 &&
+            hourExpression.indexOf("/") == -1 &&
+            !(0, utils_1.containsAny)(minuteExpression, _global_1.specialCharacters)) {
+            // hours list with single minute (i.e. 30 6,14,16)
+            var hourParts = hourExpression.split(",");
+            description += _global_1.i18n.at();
+            for (var i = 0; i < hourParts.length; i++) {
+                description += " ";
+                description += this.formatTime(hourParts[i], minuteExpression, "");
+                if (i < hourParts.length - 2) {
+                    description += ",";
+                }
+                if (i == hourParts.length - 2) {
+                    description += _global_1.i18n.spaceAnd();
+                }
+            }
+        }
+        else {
+            // default time description
+            var secondsDescription = this.getSecondsDescription();
+            var minutesDescription = this.getMinutesDescription();
+            var hoursDescription = this.getHoursDescription();
+            description += secondsDescription;
+            if (description && minutesDescription) {
+                description += ", ";
+            }
+            description += minutesDescription;
+            if (minutesDescription === hoursDescription) {
+                return description;
+            }
+            if (description && hoursDescription) {
+                description += ", ";
+            }
+            description += hoursDescription;
+        }
+        return description;
+    };
+    ExpressionDescriptor.prototype.getSecondsDescription = function () {
+        var description = this.getSegmentDescription(this.expressionParts[0], _global_1.i18n.everySecond(), function (s) {
+            return s;
+        }, function (s) {
+            return (0, utils_1.format)(_global_1.i18n.everyX0Seconds(s), s);
+        }, function (s) {
+            return _global_1.i18n.secondsX0ThroughX1PastTheMinute();
+        }, function (s) {
+            return s == "0"
+                ? ""
+                : parseInt(s) < 20
+                    ? _global_1.i18n.atX0SecondsPastTheMinute(s)
+                    : _global_1.i18n.atX0SecondsPastTheMinuteGt20() || _global_1.i18n.atX0SecondsPastTheMinute(s);
+        });
+        return description;
+    };
+    ExpressionDescriptor.prototype.getMinutesDescription = function () {
+        var secondsExpression = this.expressionParts[0];
+        var hourExpression = this.expressionParts[2];
+        var description = this.getSegmentDescription(this.expressionParts[1], _global_1.i18n.everyMinute(), function (s) {
+            return s;
+        }, function (s) {
+            return (0, utils_1.format)(_global_1.i18n.everyX0Minutes(s), s);
+        }, function (s) {
+            return _global_1.i18n.minutesX0ThroughX1PastTheHour();
+        }, function (s) {
+            try {
+                return s == "0" && hourExpression.indexOf("/") == -1 && secondsExpression == ""
+                    ? _global_1.i18n.everyHour()
+                    : parseInt(s) < 20
+                        ? _global_1.i18n.atX0MinutesPastTheHour(s)
+                        : _global_1.i18n.atX0MinutesPastTheHourGt20() || _global_1.i18n.atX0MinutesPastTheHour(s);
+            }
+            catch (e) {
+                return _global_1.i18n.atX0MinutesPastTheHour(s);
+            }
+        });
+        return description;
+    };
+    ExpressionDescriptor.prototype.getHoursDescription = function () {
+        var _this = this;
+        var expression = this.expressionParts[2];
+        var description = this.getSegmentDescription(expression, _global_1.i18n.everyHour(), function (s) {
+            return _this.formatTime(s, "0", "");
+        }, function (s) {
+            return (0, utils_1.format)(_global_1.i18n.everyX0Hours(s), s);
+        }, function (s) {
+            return _global_1.i18n.betweenX0AndX1();
+        }, function (s) {
+            return _global_1.i18n.atX0();
+        });
+        // If this is an hour range and minute segment is not "on the hour" (0), we'll change the second hour part from :00 to :59
+        if (description && expression.includes("-") && this.expressionParts[1] != "0") {
+            var atTheHourMatches = Array.from(description.matchAll(/:00/g));
+            if (atTheHourMatches.length > 1) {
+                var lastAtTheHourMatchIndex = atTheHourMatches[atTheHourMatches.length - 1].index;
+                description =
+                    description.substring(0, lastAtTheHourMatchIndex) +
+                        ":59" +
+                        description.substring(lastAtTheHourMatchIndex + 3);
+            }
+        }
+        return description;
+    };
+    ExpressionDescriptor.prototype.getDayOfWeekDescription = function () {
+        var _this = this;
+        var daysOfWeekNames = _global_1.i18n.daysOfTheWeek();
+        var description = null;
+        if (this.expressionParts[5] == "*") {
+            // DOW is specified as * so we will not generate a description and defer to DOM part.
+            // Otherwise, we could get a contradiction like "on day 1 of the month, every day"
+            // or a dupe description like "every day, every day".
+            description = "";
+        }
+        else {
+            description = this.getSegmentDescription(this.expressionParts[5], _global_1.i18n.commaEveryDay(), function (s, form) {
+                var exp = s;
+                if (s.indexOf("#") > -1) {
+                    exp = s.substring(0, s.indexOf("#"));
+                }
+                else if (s.indexOf("L") > -1) {
+                    exp = exp.replace("L", "");
+                }
+                var parsedExp = parseInt(exp);
+                if (_this.options.tzOffset) {
+                    var hourExpression = _this.expressionParts[2];
+                    var hour = parseInt(hourExpression) + (_this.options.tzOffset ? _this.options.tzOffset : 0);
+                    if (hour >= 24) {
+                        parsedExp++;
+                    }
+                    else if (hour < 0) {
+                        parsedExp--;
+                    }
+                    if (parsedExp > 6) {
+                        parsedExp = 0;
+                    }
+                    else if (parsedExp < 0) {
+                        parsedExp = 6;
+                    }
+                }
+                var description = _global_1.i18n.daysOfTheWeekInCase
+                    ? _global_1.i18n.daysOfTheWeekInCase(form)[parsedExp]
+                    : daysOfWeekNames[parsedExp];
+                if (s.indexOf("#") > -1) {
+                    var dayOfWeekOfMonthDescription = null;
+                    var dayOfWeekOfMonthNumber = s.substring(s.indexOf("#") + 1);
+                    var dayOfWeekNumber = s.substring(0, s.indexOf("#"));
+                    switch (dayOfWeekOfMonthNumber) {
+                        case "1":
+                            dayOfWeekOfMonthDescription = _global_1.i18n.first(dayOfWeekNumber);
+                            break;
+                        case "2":
+                            dayOfWeekOfMonthDescription = _global_1.i18n.second(dayOfWeekNumber);
+                            break;
+                        case "3":
+                            dayOfWeekOfMonthDescription = _global_1.i18n.third(dayOfWeekNumber);
+                            break;
+                        case "4":
+                            dayOfWeekOfMonthDescription = _global_1.i18n.fourth(dayOfWeekNumber);
+                            break;
+                        case "5":
+                            dayOfWeekOfMonthDescription = _global_1.i18n.fifth(dayOfWeekNumber);
+                            break;
+                    }
+                    description = dayOfWeekOfMonthDescription + " " + description;
+                }
+                return description;
+            }, function (s) {
+                if (parseInt(s) == 1) {
+                    // rather than "every 1 days" just return empty string
+                    return "";
+                }
+                else {
+                    return (0, utils_1.format)(_global_1.i18n.commaEveryX0DaysOfTheWeek(s), s);
+                }
+            }, function (s) {
+                // If both DOM and DOW are specified, the cron will execute at either time.
+                var beginFrom = s.substring(0, s.indexOf("-"));
+                var domSpecified = _this.expressionParts[3] != "*";
+                return domSpecified ? _global_1.i18n.commaAndX0ThroughX1(beginFrom) : _global_1.i18n.commaX0ThroughX1(beginFrom);
+            }, function (s) {
+                var format = null;
+                if (s.indexOf("#") > -1) {
+                    var dayOfWeekOfMonthNumber = s.substring(s.indexOf("#") + 1);
+                    format = _global_1.i18n.commaOnThe(dayOfWeekOfMonthNumber).trim() + _global_1.i18n.spaceX0OfTheMonth();
+                }
+                else if (s.indexOf("L") > -1) {
+                    format = _global_1.i18n.commaOnTheLastX0OfTheMonth(s.replace("L", ""));
+                }
+                else {
+                    // If both DOM and DOW are specified, the cron will execute at either time.
+                    var domSpecified = _this.expressionParts[3] != "*";
+                    format = domSpecified ? _global_1.i18n.commaAndOnX0() : _global_1.i18n.commaOnlyOnX0(s);
+                }
+                return format;
+            });
+        }
+        return description;
+    };
+    ExpressionDescriptor.prototype.getMonthDescription = function () {
+        var monthNames = _global_1.i18n.monthsOfTheYear();
+        var description = this.getSegmentDescription(this.expressionParts[4], "", function (s, form) {
+            return form && _global_1.i18n.monthsOfTheYearInCase
+                ? _global_1.i18n.monthsOfTheYearInCase(form)[parseInt(s) - 1]
+                : monthNames[parseInt(s) - 1];
+        }, function (s) {
+            //
+            if (parseInt(s) == 1) {
+                // rather than "every 1 months" just return empty string
+                return "";
+            }
+            else {
+                return (0, utils_1.format)(_global_1.i18n.commaEveryX0Months(s), s);
+            }
+        }, function (s) {
+            return _global_1.i18n.commaMonthX0ThroughMonthX1() || _global_1.i18n.commaX0ThroughX1();
+        }, function (s) {
+            return _global_1.i18n.commaOnlyInMonthX0 ? _global_1.i18n.commaOnlyInMonthX0() : _global_1.i18n.commaOnlyInX0();
+        });
+        return description;
+    };
+    ExpressionDescriptor.prototype.getDayOfMonthDescription = function () {
+        var description = null;
+        var expression = this.expressionParts[3];
+        switch (expression) {
+            case "L":
+                description = _global_1.i18n.commaOnTheLastDayOfTheMonth();
+                break;
+            case "WL":
+            case "LW":
+                description = _global_1.i18n.commaOnTheLastWeekdayOfTheMonth();
+                break;
+            default: // i.e. 3W or W2
+                var weekDayNumberMatches = expression.match(/(\d{1,2}W)|(W\d{1,2})/);
+                if (weekDayNumberMatches) {
+                    var dayNumber = parseInt(weekDayNumberMatches[0].replace("W", ""));
+                    var dayString = dayNumber == 1
+                        ? _global_1.i18n.firstWeekday()
+                        : (0, utils_1.format)(_global_1.i18n.weekdayNearestDayX0(), dayNumber.toString());
+                    description = (0, utils_1.format)(_global_1.i18n.commaOnTheX0OfTheMonth(), dayString);
+                    break;
+                }
+                else {
+                    // Handle "last day offset" (i.e. L-5:  "5 days before the last day of the month")
+                    var lastDayOffSetMatches = expression.match(/L-(\d{1,2})/);
+                    if (lastDayOffSetMatches) {
+                        var offSetDays = lastDayOffSetMatches[1];
+                        description = (0, utils_1.format)(_global_1.i18n.commaDaysBeforeTheLastDayOfTheMonth(offSetDays), offSetDays);
+                        break;
+                    }
+                    else if (expression == "*" && this.expressionParts[5] != "*") {
+                        // * dayOfMonth and dayOfWeek specified so use dayOfWeek verbiage instead
+                        return "";
+                    }
+                    else {
+                        description = this.getSegmentDescription(expression, _global_1.i18n.commaEveryDay(), function (s) {
+                            return s == "L"
+                                ? _global_1.i18n.lastDay()
+                                : _global_1.i18n.dayX0
+                                    ? (0, utils_1.format)(_global_1.i18n.dayX0(), s)
+                                    : s;
+                        }, function (s) {
+                            return s == "1" ? _global_1.i18n.commaEveryDay() : _global_1.i18n.commaEveryX0Days(s);
+                        }, function (s) {
+                            return _global_1.i18n.commaBetweenDayX0AndX1OfTheMonth(s);
+                        }, function (s) {
+                            return _global_1.i18n.commaOnDayX0OfTheMonth(s);
+                        });
+                    }
+                    break;
+                }
+        }
+        return description;
+    };
+    ExpressionDescriptor.prototype.getYearDescription = function () {
+        var description = this.getSegmentDescription(this.expressionParts[6], "", function (s) {
+            return /^\d+$/.test(s) ? new Date(parseInt(s), 1).getFullYear().toString() : s;
+        }, function (s) {
+            return (0, utils_1.format)(_global_1.i18n.commaEveryX0Years(s), s);
+        }, function (s) {
+            return _global_1.i18n.commaYearX0ThroughYearX1() || _global_1.i18n.commaX0ThroughX1();
+        }, function (s) {
+            return _global_1.i18n.commaOnlyInYearX0 ? _global_1.i18n.commaOnlyInYearX0() : _global_1.i18n.commaOnlyInX0();
+        });
+        return description;
+    };
+    ExpressionDescriptor.prototype.getSegmentDescription = function (expression, allDescription, getSingleItemDescription, getIncrementDescriptionFormat, getRangeDescriptionFormat, getDescriptionFormat) {
+        var description = null;
+        var doesExpressionContainIncrement = expression.indexOf("/") > -1;
+        var doesExpressionContainRange = expression.indexOf("-") > -1;
+        var doesExpressionContainMultipleValues = expression.indexOf(",") > -1;
+        if (!expression) {
+            // Empty
+            description = "";
+        }
+        else if (expression === "*") {
+            // * (All)
+            description = allDescription;
+        }
+        else if (!doesExpressionContainIncrement && !doesExpressionContainRange && !doesExpressionContainMultipleValues) {
+            // Simple
+            description = (0, utils_1.format)(getDescriptionFormat(expression), getSingleItemDescription(expression));
+        }
+        else if (doesExpressionContainMultipleValues) {
+            // Multiple Values
+            var segments = expression.split(",");
+            var descriptionContent = "";
+            for (var i = 0; i < segments.length; i++) {
+                if (i > 0 && segments.length > 2) {
+                    descriptionContent += ",";
+                    if (i < segments.length - 1) {
+                        descriptionContent += " ";
+                    }
+                }
+                if (i > 0 && segments.length > 1 && (i == segments.length - 1 || segments.length == 2)) {
+                    descriptionContent += "".concat(_global_1.i18n.spaceAnd(), " ");
+                }
+                if (segments[i].indexOf("/") > -1 || segments[i].indexOf("-") > -1) {
+                    // Multiple Values with Increment or Range
+                    var isSegmentRangeWithoutIncrement = segments[i].indexOf("-") > -1 && segments[i].indexOf("/") == -1;
+                    var currentDescriptionContent = this.getSegmentDescription(segments[i], allDescription, getSingleItemDescription, getIncrementDescriptionFormat, isSegmentRangeWithoutIncrement ? _global_1.i18n.commaX0ThroughX1 : getRangeDescriptionFormat, getDescriptionFormat);
+                    if (isSegmentRangeWithoutIncrement) {
+                        currentDescriptionContent = currentDescriptionContent.replace(", ", "");
+                    }
+                    descriptionContent += currentDescriptionContent;
+                }
+                else if (!doesExpressionContainIncrement) {
+                    descriptionContent += getSingleItemDescription(segments[i]);
+                }
+                else {
+                    descriptionContent += this.getSegmentDescription(segments[i], allDescription, getSingleItemDescription, getIncrementDescriptionFormat, getRangeDescriptionFormat, getDescriptionFormat);
+                }
+            }
+            if (!doesExpressionContainIncrement) {
+                description = (0, utils_1.format)(getDescriptionFormat(expression), descriptionContent);
+            }
+            else {
+                description = descriptionContent;
+            }
+        }
+        else if (doesExpressionContainIncrement) {
+            // Increment
+            var segments = expression.split("/");
+            description = (0, utils_1.format)(getIncrementDescriptionFormat(segments[1]), segments[1]);
+            if (segments[0].indexOf("-") > -1) {
+                // Range with Increment (ex: 2-59/3 )
+                var rangeSegmentDescription = this.generateRangeSegmentDescription(segments[0], getRangeDescriptionFormat, getSingleItemDescription);
+                if (rangeSegmentDescription.indexOf(", ") != 0) {
+                    description += ", ";
+                }
+                description += rangeSegmentDescription;
+            }
+            else if (segments[0].indexOf("*") == -1) {
+                var rangeItemDescription = (0, utils_1.format)(getDescriptionFormat(segments[0]), getSingleItemDescription(segments[0]));
+                // remove any leading comma
+                rangeItemDescription = rangeItemDescription.replace(", ", "");
+                description += (0, utils_1.format)(_global_1.i18n.commaStartingX0(), rangeItemDescription);
+            }
+        }
+        else if (doesExpressionContainRange) {
+            // Range
+            description = this.generateRangeSegmentDescription(expression, getRangeDescriptionFormat, getSingleItemDescription);
+        }
+        return description;
+    };
+    ExpressionDescriptor.prototype.generateRangeSegmentDescription = function (rangeExpression, getRangeDescriptionFormat, getSingleItemDescription) {
+        var description = "";
+        var rangeSegments = rangeExpression.split("-");
+        var rangeSegment1Description = getSingleItemDescription(rangeSegments[0], 1);
+        var rangeSegment2Description = getSingleItemDescription(rangeSegments[1], 2);
+        var rangeDescriptionFormat = getRangeDescriptionFormat(rangeExpression);
+        description += (0, utils_1.format)(rangeDescriptionFormat, rangeSegment1Description, rangeSegment2Description);
+        return description;
+    };
+    ExpressionDescriptor.prototype.formatTime = function (hourExpression, minuteExpression, secondExpression) {
+        var hourOffset = 0;
+        var minuteOffset = 0;
+        if (this.options.tzOffset) {
+            hourOffset = this.options.tzOffset > 0 ? Math.floor(this.options.tzOffset) : Math.ceil(this.options.tzOffset);
+            minuteOffset = (parseFloat((this.options.tzOffset % 1).toFixed(2)));
+            if (minuteOffset != 0) {
+                minuteOffset *= 60;
+            }
+        }
+        var hour = parseInt(hourExpression) + (hourOffset);
+        var minute = parseInt(minuteExpression) + (minuteOffset);
+        if (minute >= 60) {
+            minute -= 60;
+            hour += 1;
+        }
+        else if (minute < 0) {
+            minute += 60;
+            hour -= 1;
+        }
+        if (hour >= 24) {
+            hour = hour - 24;
+        }
+        else if (hour < 0) {
+            hour = 24 + hour;
+        }
+        var period = "";
+        var setPeriodBeforeTime = false;
+        if (!this.options.use24HourTimeFormat) {
+            setPeriodBeforeTime = !!(_global_1.i18n.setPeriodBeforeTime && _global_1.i18n.setPeriodBeforeTime());
+            period = setPeriodBeforeTime ? "".concat(this.getPeriod(hour), " ") : " ".concat(this.getPeriod(hour));
+            if (hour > 12) {
+                hour -= 12;
+            }
+            if (hour === 0) {
+                hour = 12;
+            }
+        }
+        var second = "";
+        if (secondExpression) {
+            second = ":".concat(("00" + secondExpression).substring(secondExpression.length));
+        }
+        return "".concat(setPeriodBeforeTime ? period : "").concat(("00" + hour.toString()).substring(hour.toString().length), ":").concat(("00" + minute.toString()).substring(minute.toString().length)).concat(second).concat(!setPeriodBeforeTime ? period : "");
+    };
+    ExpressionDescriptor.prototype.transformVerbosity = function (description, useVerboseFormat) {
+        if (!useVerboseFormat) {
+            description = description.replace(new RegExp(", ".concat(_global_1.i18n.everyMinute()), "g"), "");
+            description = description.replace(new RegExp(", ".concat(_global_1.i18n.everyHour()), "g"), "");
+            description = description.replace(new RegExp(_global_1.i18n.commaEveryDay(), "g"), "");
+            description = description.replace(/\, ?$/, "");
+        }
+        return description;
+    };
+    ExpressionDescriptor.prototype.getPeriod = function (hour) {
+        return hour >= 12 ? (_global_1.i18n.pm && _global_1.i18n.pm()) || "PM" : (_global_1.i18n.am && _global_1.i18n.am()) || "AM";
+    };
+    return ExpressionDescriptor;
+}());
+exports.ExpressionDescriptor = ExpressionDescriptor;

package/utils/crontab/index.d.ts

@@ -0,0 +1,3 @@
+export { crontabParser } from './crontabParser';
+export { crontabRender } from './crontabRender';
+export { setLocal } from './_global';

package/utils/crontab/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setLocal = exports.crontabRender = exports.crontabParser = void 0;
+var crontabParser_1 = require("./crontabParser");
+Object.defineProperty(exports, "crontabParser", { enumerable: true, get: function () { return crontabParser_1.crontabParser; } });
+var crontabRender_1 = require("./crontabRender");
+Object.defineProperty(exports, "crontabRender", { enumerable: true, get: function () { return crontabRender_1.crontabRender; } });
+var _global_1 = require("./_global");
+Object.defineProperty(exports, "setLocal", { enumerable: true, get: function () { return _global_1.setLocal; } });

package/utils/crontab/type.d.ts

@@ -0,0 +1,79 @@
+export interface Locale {
+    setPeriodBeforeTime?(): boolean;
+    pm?(): string;
+    am?(): string;
+    use24HourTimeFormatByDefault(): boolean;
+    anErrorOccuredWhenGeneratingTheExpressionD(): string;
+    everyMinute(): string;
+    everyHour(): string;
+    atSpace(): string;
+    everyMinuteBetweenX0AndX1(): string;
+    at(): string;
+    spaceAnd(): string;
+    everySecond(): string;
+    everyX0Seconds(s?: string): string;
+    secondsX0ThroughX1PastTheMinute(): string;
+    atX0SecondsPastTheMinute(s?: string): string;
+    atX0SecondsPastTheMinuteGt20(): string | null;
+    everyX0Minutes(s?: string): string;
+    minutesX0ThroughX1PastTheHour(): string;
+    atX0MinutesPastTheHour(s?: string): string;
+    atX0MinutesPastTheHourGt20(): string | null;
+    everyX0Hours(s?: string): string;
+    betweenX0AndX1(): string;
+    atX0(): string;
+    commaEveryDay(): string;
+    commaEveryX0DaysOfTheWeek(s?: string): string;
+    commaX0ThroughX1(s?: string): string;
+    commaAndX0ThroughX1(s?: string): string;
+    commaMonthX0ThroughMonthX1(): string | null;
+    commaYearX0ThroughYearX1(): string | null;
+    first(s?: string): string;
+    second(s?: string): string;
+    third(s?: string): string;
+    fourth(s?: string): string;
+    fifth(s?: string): string;
+    commaOnThe(s?: string): string;
+    spaceX0OfTheMonth(): string;
+    lastDay(): string;
+    commaOnTheLastX0OfTheMonth(s?: string): string;
+    commaOnlyOnX0(s?: string): string;
+    commaAndOnX0(): string;
+    commaEveryX0Months(s?: string): string;
+    commaOnlyInX0(): string;
+    commaOnlyInMonthX0?(): string;
+    commaOnlyInYearX0?(): string;
+    commaOnTheLastDayOfTheMonth(): string;
+    commaOnTheLastWeekdayOfTheMonth(): string;
+    commaDaysBeforeTheLastDayOfTheMonth(s?: string): string;
+    firstWeekday(): string;
+    weekdayNearestDayX0(): string;
+    commaOnTheX0OfTheMonth(): string;
+    commaEveryX0Days(s?: string): string;
+    commaBetweenDayX0AndX1OfTheMonth(s?: string): string;
+    commaOnDayX0OfTheMonth(s?: string): string;
+    commaEveryX0Years(s?: string): string;
+    commaStartingX0(): string;
+    dayX0?(): string;
+    daysOfTheWeek(): string[];
+    /** If multiple forms are needed in "%s through %s"
+     * @param f 1 for "from", 2 for "through"
+     * @return {string[]} days of week
+     */
+    daysOfTheWeekInCase?(f?: number): string[];
+    monthsOfTheYear(): string[];
+    /** If multiple forms are needed in "%s through %s"
+     * @param f 1 for "from", 2 for "through"
+     * @return {string[]} months of year
+     */
+    monthsOfTheYearInCase?(f?: number): string[];
+}
+export interface Options {
+    throwExceptionOnParseError?: boolean;
+    verbose?: boolean;
+    dayOfWeekStartIndexZero?: boolean;
+    monthStartIndexZero?: boolean;
+    use24HourTimeFormat?: boolean;
+    locale?: string | null;
+    tzOffset?: number;
+}

package/utils/crontab/type.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/utils/crontab/utils.d.ts

@@ -0,0 +1,20 @@
+export declare const validate: (parsed: string[]) => void;
+/**
+ * Takes a string with '%s' placeholders and replaces them with provided values.
+ * Works like sprintf in C or string.Format in C#.
+ * @static
+ * @param {string} template - The string template with enclosed %s replacements
+ * @param {...string[]} values - The ordered replacement text
+ * @returns {string}
+ */
+export declare const format: (template: string, ...values: string[]) => string;
+/**
+ *
+ * Given a string and an array of search strings, determines if the string
+ * contains any value from the array.
+ * @static
+ * @param {string} text - The string to search
+ * @param {string[]} searchStrings - The array of values to search for
+ * @returns {boolean}
+ */
+export declare const containsAny: (text: string, searchStrings: string[]) => boolean;