vap1 0.4.4 → 0.4.7

package/utils/crontab/crontabParser.js

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crontabParser = void 0;
+var utils_1 = require("./utils");
+var _global_1 = require("./_global");
+var parseSpecial = function (expression) {
+    var specialExpressions = {
+        '@yearly': '0 0 1 1 *',
+        '@annually': '0 0 1 1 *',
+        '@monthly': '0 0 1 * *',
+        '@weekly': '0 0 * * 0',
+        '@daily': '0 0 * * *',
+        '@midnight': '0 0 * * *',
+        '@hourly': '0 * * * *'
+    };
+    var special = specialExpressions[expression];
+    if (!special) {
+        throw new Error('未知的特殊表达式');
+    }
+    return special;
+};
+var extractParts = function (expression) {
+    // if (!this.expression) {
+    //   throw new Error("cron expression is empty");
+    // }
+    // split on one or more spaces
+    var parsed = expression.trim().split(/[ ]+/);
+    // sort elements with array of numbers
+    for (var i = 0; i < parsed.length; i++) {
+        if (parsed[i].includes(",")) {
+            var arrayElement = parsed[i]
+                .split(",")
+                .map(function (item) { return item.trim(); })
+                .filter(function (item) { return item !== ""; })
+                .map(function (item) { return (!isNaN(Number(item)) ? Number(item) : item); })
+                .filter(function (item) { return item !== null && item !== ""; });
+            if (arrayElement.length === 0) {
+                arrayElement.push("*");
+            }
+            arrayElement.sort(function (a, b) { return (a !== null && b !== null ? a - b : 0); });
+            parsed[i] = arrayElement.map(function (item) { return (item !== null ? item.toString() : ""); }).join(",");
+        }
+    }
+    if (parsed.length < 5) {
+        throw new Error("\u8868\u8FBE\u5F0F\u81F3\u5C11\u9700\u8981\u75315\u4E2A\u90E8\u5206\u7EC4\u6210");
+    }
+    else if (parsed.length == 5) {
+        // 5 part cron so shift array past seconds element
+        parsed.unshift("");
+        parsed.push("");
+    }
+    else if (parsed.length == 6) {
+        /* We will detect if this 6 part expression has a year specified and if so we will shift the parts and treat the
+          first part as a minute part rather than a second part.
+    
+          Ways we detect:
+            1. Last part is a literal year (i.e. 2020)
+            2. 3rd or 5th part is specified as "?" (DOM or DOW)
+        */
+        var isYearWithNoSecondsPart = /\d{4}$/.test(parsed[5]) || parsed[4] == "?" || parsed[2] == "?";
+        if (isYearWithNoSecondsPart) {
+            // year provided; shift parts over by one
+            parsed.unshift("");
+        }
+        else {
+            // seconds provided
+            parsed.push("");
+        }
+    }
+    else if (parsed.length > 7) {
+        throw new Error("\u8868\u8FBE\u5F0F\u6700\u591A\u53EA\u80FD\u75317\u4E2A\u90E8\u5206\u7EC4\u6210");
+    }
+    return parsed;
+};
+var normalize = function (expressionParts) {
+    // Convert ? to * for DOM and DOW
+    expressionParts[3] = expressionParts[3].replace("?", "*");
+    expressionParts[5] = expressionParts[5].replace("?", "*");
+    // Convert ? to * for Hour. ? isn't valid for hour position but we can work around it.
+    expressionParts[2] = expressionParts[2].replace("?", "*");
+    // Convert 0/, 1/ to */
+    if (expressionParts[0].indexOf("0/") == 0) {
+        // Seconds
+        expressionParts[0] = expressionParts[0].replace("0/", "*/");
+    }
+    if (expressionParts[1].indexOf("0/") == 0) {
+        // Minutes
+        expressionParts[1] = expressionParts[1].replace("0/", "*/");
+    }
+    if (expressionParts[2].indexOf("0/") == 0) {
+        // Hours
+        expressionParts[2] = expressionParts[2].replace("0/", "*/");
+    }
+    if (expressionParts[3].indexOf("1/") == 0) {
+        // DOM
+        expressionParts[3] = expressionParts[3].replace("1/", "*/");
+    }
+    if (expressionParts[4].indexOf("1/") == 0) {
+        // Month
+        expressionParts[4] = expressionParts[4].replace("1/", "*/");
+    }
+    if (expressionParts[6].indexOf("1/") == 0) {
+        // Years
+        expressionParts[6] = expressionParts[6].replace("1/", "*/");
+    }
+    // Adjust DOW based on dayOfWeekStartIndexZero option
+    // Normalized DOW: 0=Sunday/6=Saturday
+    expressionParts[5] = expressionParts[5].replace(/(^\d)|([^#/\s]\d)/g, function (t) {
+        // skip anything preceeded by # or /
+        var dowDigits = t.replace(/\D/, ""); // extract digit part (i.e. if "-2" or ",2", just take 2)
+        var dowDigitsAdjusted = dowDigits;
+        if (_global_1.dayOfWeekStartIndexZero) {
+            // "7" also means Sunday so we will convert to "0" to normalize it
+            if (dowDigits == "7") {
+                dowDigitsAdjusted = "0";
+            }
+        }
+        else {
+            // If dayOfWeekStartIndexZero==false, Sunday is specified as 1 and Saturday is specified as 7.
+            // To normalize, we will shift the  DOW number down so that 1 becomes 0, 2 becomes 1, and so on.
+            dowDigitsAdjusted = (parseInt(dowDigits) - 1).toString();
+        }
+        return t.replace(dowDigits, dowDigitsAdjusted);
+    });
+    // Convert DOW 'L' to '6' (Saturday)
+    if (expressionParts[5] == "L") {
+        expressionParts[5] = "6";
+    }
+    // Convert DOM '?' to '*'
+    if (expressionParts[3] == "?") {
+        expressionParts[3] = "*";
+    }
+    if (expressionParts[3].indexOf("W") > -1 &&
+        (expressionParts[3].indexOf(",") > -1 || expressionParts[3].indexOf("-") > -1)) {
+        throw new Error("The 'W' character can be specified only when the day-of-month is a single day, not a range or list of days.");
+    }
+    // Convert DOW SUN-SAT format to 0-6 format
+    var days = {
+        SUN: 0,
+        MON: 1,
+        TUE: 2,
+        WED: 3,
+        THU: 4,
+        FRI: 5,
+        SAT: 6,
+    };
+    for (var day in days) {
+        expressionParts[5] = expressionParts[5].replace(new RegExp(day, "gi"), days[day].toString());
+    }
+    // Adjust month based on monthStartIndexZero option
+    // Normalized Month: 1=JAN/12=DEC
+    expressionParts[4] = expressionParts[4].replace(/(^\d{1,2})|([^#/\s]\d{1,2})/g, function (t) {
+        // skip anything preceeded by # or /
+        var dowDigits = t.replace(/\D/, ""); // extract digit part (i.e. if "-2" or ",2", just take 2)
+        var dowDigitsAdjusted = dowDigits;
+        if (_global_1.monthStartIndexZero) {
+            // if monthStartIndexZero==true, we will shift month number up so that JAN=1 and DEC=12
+            dowDigitsAdjusted = (parseInt(dowDigits) + 1).toString();
+        }
+        return t.replace(dowDigits, dowDigitsAdjusted);
+    });
+    // Convert JAN-DEC format to 1-12 format
+    var months = {
+        JAN: 1,
+        FEB: 2,
+        MAR: 3,
+        APR: 4,
+        MAY: 5,
+        JUN: 6,
+        JUL: 7,
+        AUG: 8,
+        SEP: 9,
+        OCT: 10,
+        NOV: 11,
+        DEC: 12,
+    };
+    for (var month in months) {
+        expressionParts[4] = expressionParts[4].replace(new RegExp(month, "gi"), months[month].toString());
+    }
+    // Convert 0 second to (empty)
+    if (expressionParts[0] == "0") {
+        expressionParts[0] = "";
+    }
+    // If time increment or * (every) is specified for seconds or minutes and hours part is single item, make it a "self-range" so
+    // the expression can be interpreted as an increment / range.  This will allow us to easily interpret an hour part as 'between' a second or minute duration.
+    //     For example:
+    //     0-20/3 9 * * * => 0-20/3 9-9 * * * (9 => 9-9) => Every 3 minutes, minutes 0 through 20 past the hour, between 09:00 AM and 09:59 AM
+    //     */5 3 * * * => */5 3-3 * * * (3 => 3-3) => Every 5 minutes, between 03:00 AM and 03:59 AM
+    if (!/\*|\-|\,|\//.test(expressionParts[2]) &&
+        (/\*|\//.test(expressionParts[1]) || /\*|\//.test(expressionParts[0]))) {
+        expressionParts[2] += "-".concat(expressionParts[2]);
+    }
+    // Loop through all parts and apply global normalization
+    for (var i = 0; i < expressionParts.length; i++) {
+        // ignore empty characters around comma
+        // if nothing left, set it to *
+        if (expressionParts[i].indexOf(",") != -1) {
+            expressionParts[i] =
+                expressionParts[i]
+                    .split(",")
+                    .filter(function (str) { return str !== ""; })
+                    .join(",") || "*";
+        }
+        // convert all '*/1' to '*'
+        if (expressionParts[i] == "*/1") {
+            expressionParts[i] = "*";
+        }
+        /* Convert Month,DOW,Year step values with a starting value (i.e. not '*') to range expressions.
+           This allows us to reuse the range expression handling for step values.
+    
+             For example:
+             - month part '3/2' will be converted to '3-12/2' (every 2 months between March and December)
+             - DOW part '3/2' will be converted to '3-6/2' (every 2 days between Tuesday and Saturday)
+        */
+        if (expressionParts[i].indexOf("/") > -1 && !/^\*|\-|\,/.test(expressionParts[i])) {
+            var stepRangeThrough = null;
+            switch (i) {
+                case 4:
+                    stepRangeThrough = "12";
+                    break;
+                case 5:
+                    stepRangeThrough = "6";
+                    break;
+                case 6:
+                    stepRangeThrough = "9999";
+                    break;
+                default:
+                    stepRangeThrough = null;
+                    break;
+            }
+            if (stepRangeThrough !== null) {
+                var parts = expressionParts[i].split("/");
+                expressionParts[i] = "".concat(parts[0], "-").concat(stepRangeThrough, "/").concat(parts[1]);
+            }
+        }
+    }
+};
+var crontabParser = function (expression) {
+    var parsed;
+    if (expression.startsWith('@')) {
+        var special = parseSpecial(expression);
+        parsed = extractParts(special);
+    }
+    else {
+        parsed = extractParts(expression);
+    }
+    normalize(parsed);
+    (0, utils_1.validate)(parsed);
+    return parsed;
+};
+exports.crontabParser = crontabParser;

package/utils/crontab/crontabRender.d.ts

@@ -0,0 +1,23 @@
+import type { Options } from "./type";
+export declare const crontabRender: (expression: string, options?: Options) => string;
+export declare class ExpressionDescriptor {
+    specialCharacters: string[];
+    expression: string;
+    expressionParts: string[];
+    options: Options;
+    constructor(expression: string, options: Options);
+    getFullDescription(): string;
+    protected getTimeOfDayDescription(): string;
+    protected getSecondsDescription(): string;
+    protected getMinutesDescription(): string;
+    protected getHoursDescription(): string;
+    protected getDayOfWeekDescription(): string;
+    protected getMonthDescription(): string;
+    protected getDayOfMonthDescription(): string | null;
+    protected getYearDescription(): string;
+    protected getSegmentDescription(expression: string, allDescription: string, getSingleItemDescription: (t: string, form?: number) => string, getIncrementDescriptionFormat: (t: string) => string, getRangeDescriptionFormat: (t: string) => string, getDescriptionFormat: (t: string) => string): string | null;
+    protected generateRangeSegmentDescription(rangeExpression: string, getRangeDescriptionFormat: (t: string) => string, getSingleItemDescription: (t: string, form?: number) => string): string;
+    protected formatTime(hourExpression: string, minuteExpression: string, secondExpression: string): string;
+    protected transformVerbosity(description: string, useVerboseFormat: boolean): string;
+    private getPeriod;
+}