@vope/utils 1.6.1 → 1.6.2

package/dist/cron.js

@@ -0,0 +1,674 @@
+import { isNumber, isString } from "lodash-es";
+import { hash8json } from "./convert/json";
+const {
+  parseInt,
+  isInteger,
+  MAX_SAFE_INTEGER
+} = Number;
+class Dic {
+  constructor(dics) {
+    this.dics = dics;
+    this.keys = hash8json(dics, "key");
+    this.values = hash8json(dics, "value");
+  }
+  keys;
+  values;
+  item(key) {
+    return this.keys[key]?.value;
+  }
+  at(value) {
+    return this.values[value]?.key;
+  }
+  reduce(callbackfn, initialValue) {
+    return this.dics.reduce(callbackfn, initialValue);
+  }
+}
+const weekDic = new Dic([
+  {
+    key: "SUN",
+    value: 0
+  },
+  {
+    key: "MON",
+    value: 1
+  },
+  {
+    key: "TUE",
+    value: 2
+  },
+  {
+    key: "WED",
+    value: 3
+  },
+  {
+    key: "THU",
+    value: 4
+  },
+  {
+    key: "FRI",
+    value: 5
+  },
+  {
+    key: "SAT",
+    value: 6
+  }
+]);
+const place_value = 0;
+const default_max_second = 59;
+const default_min_second = 0;
+const default_max_minute = default_max_second;
+const default_min_minute = default_min_second;
+const default_max_hour = 23;
+const default_min_hour = 0;
+const default_max_day = 31;
+const default_min_day = 1;
+const default_max_month = 12;
+const default_min_month = 1;
+const default_max_week = 6;
+const default_min_week = 0;
+const re_single_number_text = "\\d";
+const createCronRegexText = (options = {}) => {
+  const {
+    enableSlot = true,
+    enableSecond = true,
+    enableYear = true,
+    enableMax = true,
+    enableInvalid = true,
+    enableDayLast = true,
+    enableWeekLast = true,
+    enableWeekSupport7 = true,
+    enableWeekSupportDic = true,
+    enableDicEnumSupportMixin = true,
+    enablePrefixZero
+  } = options;
+  const enableMaxSplit = enableMax && (options.enableIncrementMax ?? true);
+  const singleNumberMatch = (end, fromZero) => {
+    const start = fromZero ? 0 : 1;
+    if (end === start) {
+      return `${end}`;
+    } else if (end < 3 + start) {
+      let text = "";
+      for (let i = start; i <= end; i++) {
+        text += i;
+      }
+      return `[${text}]`;
+    } else if (start === 0 && end === 9) {
+      return re_single_number_text;
+    } else {
+      return `[${start}-${end}]`;
+    }
+  };
+  const numberMatch = (max, fromZero) => {
+    if (max === place_value) return `[1-9]${re_single_number_text}*`;
+    if (max < 10) return singleNumberMatch(max, fromZero);
+    const mod = max % 10;
+    const quot = (max - mod) / 10;
+    let text = "";
+    if (fromZero) {
+      text = re_single_number_text;
+    } else {
+      text = singleNumberMatch(9);
+    }
+    text += "|";
+    if (mod === 9) {
+      text += singleNumberMatch(quot) + re_single_number_text;
+    } else {
+      if (quot > 1) {
+        text += singleNumberMatch(quot - 1) + re_single_number_text + "|";
+      }
+      text += `${quot}${singleNumberMatch(mod, true)}`;
+    }
+    return `(?:${text})`;
+  };
+  const numberMatchByPrefix = (max, fromZero) => {
+    const text = numberMatch(max, fromZero);
+    return enablePrefixZero ? "0*" + text : text;
+  };
+  const mixin = (text) => {
+    let tmp = "";
+    for (const char of text) {
+      const code = char.charCodeAt(0);
+      if (code > 64 && code < 91) {
+        tmp += `[${char.toLocaleLowerCase()}${char}]`;
+      } else if (code > 96 && code < 123) {
+        tmp += `[${char}${char.toLocaleUpperCase()}]`;
+      } else {
+        tmp += char;
+      }
+    }
+    return tmp;
+  };
+  const generate = ({
+    type,
+    max,
+    split,
+    dic,
+    invalid,
+    last,
+    fromZero
+  }) => {
+    const list = [];
+    invalid && list.push("\\?");
+    const template = [numberMatchByPrefix(max, fromZero)];
+    let lastTemplate;
+    if (last) {
+      if (type === "D") {
+        lastTemplate = `L(?:-${numberMatchByPrefix(max - 1)})?`;
+      } else if (type === "w") {
+        lastTemplate = `${numberMatchByPrefix(max, true)}L`;
+      }
+    }
+    if (type === "w" && dic) {
+      template.push(
+        dic.reduce((tmp2, { key }) => {
+          const text = enableDicEnumSupportMixin ? mixin(key) : key;
+          return tmp2 ? tmp2 + "|" + text : text;
+        }, "")
+      );
+    }
+    let tmp = template.length > 1 ? `(?:${template.join("|")})` : template[0];
+    if (lastTemplate) {
+      tmp = `(?:\\*|(?:${lastTemplate}|${tmp}(?:-${tmp})?)(?:,(?:${lastTemplate}|${tmp}(?:-${tmp})?))*)`;
+    } else {
+      tmp = `(?:\\*|${tmp}(?:-${tmp})?(?:,${tmp}(?:-${tmp})?)*)`;
+    }
+    list.push(`${tmp}(?:\\/${numberMatchByPrefix(split)})?`);
+    return list.join("|");
+  };
+  let regex = "";
+  const join = (config, isLast) => {
+    const space = "\\s+";
+    let code = generate(config);
+    if (enableSlot) {
+      code = `(?<${config.type}>${code})`;
+    } else {
+      code = `(${code})`;
+    }
+    if (!isLast) {
+      code += space;
+    }
+    if (config.partial) {
+      if (isLast) {
+        regex = regex.slice(0, space.length * -1) + `(?:${space}${code})?`;
+        return;
+      } else {
+        code = `(?:${code})?`;
+      }
+    }
+    regex += code;
+  };
+  enableSecond && join({
+    type: "s",
+    max: enableMax ? default_max_second : place_value,
+    split: enableMaxSplit ? default_max_second : place_value,
+    fromZero: !default_min_second
+  });
+  join({
+    type: "m",
+    max: enableMax ? default_max_minute : place_value,
+    split: enableMaxSplit ? default_max_minute : place_value,
+    fromZero: !default_min_minute
+  });
+  join({
+    type: "h",
+    max: enableMax ? default_max_hour : place_value,
+    split: enableMaxSplit ? default_max_hour : place_value,
+    fromZero: !default_min_hour
+  });
+  join({
+    type: "D",
+    max: enableMax ? default_max_day : place_value,
+    split: enableMaxSplit ? default_max_day : place_value,
+    invalid: enableInvalid,
+    last: enableDayLast,
+    fromZero: !default_min_day
+  });
+  join({
+    type: "M",
+    max: enableMax ? default_max_month : place_value,
+    split: enableMaxSplit ? default_max_month : place_value,
+    fromZero: !default_min_month
+  });
+  join((() => {
+    const max = enableWeekSupport7 ? 7 : default_max_week;
+    const config = {
+      type: "w",
+      max: enableMax ? max : place_value,
+      split: enableMaxSplit ? 7 : place_value,
+      fromZero: !default_min_week,
+      invalid: enableInvalid,
+      last: enableWeekLast
+    };
+    if (enableWeekSupportDic) {
+      config.dic = weekDic;
+    }
+    return config;
+  })(), !enableYear);
+  enableYear && join({
+    type: "Y",
+    max: place_value,
+    split: place_value,
+    fromZero: true,
+    partial: true
+  }, true);
+  return {
+    regex,
+    enableSlot,
+    enableSecond,
+    enableYear,
+    enableDayLast,
+    enableWeekLast,
+    enableInvalid
+  };
+};
+class InvalidValue {
+  constructor(isEnableInvalid) {
+    this.isEnableInvalid = isEnableInvalid;
+  }
+  text() {
+    return this.isEnableInvalid ? "?" : "*";
+  }
+}
+const isInvalidValue = (value) => value instanceof InvalidValue;
+class LastValue {
+  constructor(value) {
+    this.value = value;
+  }
+}
+class DayLastValue extends LastValue {
+  text() {
+    const { value } = this;
+    return "L" + (value ? `-${value}` : "");
+  }
+}
+const isDayLastValue = (value) => value instanceof DayLastValue;
+class WeekLastValue extends LastValue {
+  text() {
+    return `${this.value}L`;
+  }
+}
+const isWeekLastValue = (value) => value instanceof WeekLastValue;
+class WildcardValue {
+  text() {
+    return "*";
+  }
+}
+const isWildcardValue = (value) => value instanceof WildcardValue;
+class RangeValue {
+  constructor(start, stop) {
+    this.start = start;
+    this.stop = stop;
+  }
+  text() {
+    return `${this.start}-${this.stop}`;
+  }
+}
+const isRangeValue = (value) => value instanceof RangeValue;
+class DigitsValue {
+  constructor(values, increment) {
+    this.values = values;
+    this.increment = increment;
+  }
+  text() {
+    const { values, increment } = this;
+    let tmp;
+    if (Array.isArray(values)) {
+      tmp = values.reduce((caches, data) => {
+        let tmp2;
+        if (isNumber(data)) {
+          tmp2 = `${data}`;
+        } else {
+          tmp2 = data.text();
+        }
+        return caches ? caches + "," + tmp2 : tmp2;
+      }, "");
+    } else {
+      tmp = values.text();
+    }
+    return increment ? `${tmp}/${increment}` : tmp;
+  }
+}
+const isDigitsValue = (value) => value instanceof DigitsValue;
+const re_num = /\d/;
+const parseDigit = (text) => {
+  if (re_num.test(text[0])) {
+    return parseInt(text);
+  } else {
+    return weekDic.item(text.toLocaleUpperCase());
+  }
+};
+const parseDigits = (text) => {
+  return text.split(",").map((text2) => {
+    const [a, b] = text2.split("-");
+    if (a === "L" && b === void 0) {
+      return new DayLastValue(0);
+    } else if (b === void 0) {
+      if (a.slice(-1) === "L") {
+        return new WeekLastValue(parseInt(a.slice(0, -1)));
+      } else {
+        return parseDigit(a);
+      }
+    } else {
+      if (a === "L") {
+        return new DayLastValue(parseInt(b));
+      } else {
+        return new RangeValue(parseDigit(a), parseDigit(b));
+      }
+    }
+  });
+};
+const validate = (value, min, max) => {
+  if (isInteger(value)) {
+    return value >= min && value <= max;
+  } else if (Array.isArray(value)) {
+    if (value.length !== 2) return false;
+    const [a, b] = value;
+    return isInteger(a) && isInteger(b) && a <= b && a >= min && b <= max;
+  }
+  return false;
+};
+const validateIncrement = (value, min, max) => {
+  return isInteger(value) && value > 0 && value >= min && value <= max;
+};
+const formaterDigits = (value, min, max) => {
+  let values;
+  if (value === "*") {
+    values = new WildcardValue();
+  } else if (Array.isArray(value)) {
+    const tmp = [];
+    value.some((data) => {
+      if (validate(data, min, max)) {
+        tmp.push(
+          isNumber(data) ? data : new RangeValue(data[0], data[1])
+        );
+        return false;
+      } else {
+        return true;
+      }
+    }) || (values = tmp);
+  } else if (validate(value, min, max)) {
+    values = [value];
+  }
+  return values;
+};
+const formaterLastDigits = (value, min, max, prototype) => {
+  let values;
+  if (value === "*") {
+    values = new WildcardValue();
+  } else {
+    const tmp = [];
+    const list = Array.isArray(value) ? value : [value];
+    list.some((data) => {
+      if (isString(data)) {
+        const result = parseDigits(data);
+        if (result.length === 1 && result[0] instanceof prototype && validate(result[0].value, min, max - 1)) {
+          tmp.push(result[0]);
+          return false;
+        }
+      } else if (validate(data, min, max)) {
+        tmp.push(
+          isNumber(data) ? data : new RangeValue(data[0], data[1])
+        );
+        return false;
+      }
+      return true;
+    }) || (values = tmp);
+  }
+  return values;
+};
+class Parse {
+  constructor(second, minute, hour, day, month, week, year, cron) {
+    this.cron = cron;
+    if (second) {
+      this.second = this.parse(second);
+    }
+    this.minute = this.parse(minute);
+    this.hour = this.parse(hour);
+    this.day = this.parse(day);
+    this.month = this.parse(month);
+    this.week = this.parse(week);
+    if (year) {
+      this.year = this.parse(year);
+    }
+  }
+  second;
+  minute;
+  hour;
+  day;
+  month;
+  week;
+  year;
+  parse(text) {
+    if (text === "?") return new InvalidValue(this.cron.isEnableInvalid);
+    const [slices, increment] = text.split("/");
+    return new DigitsValue(
+      slices === "*" ? new WildcardValue() : parseDigits(slices),
+      increment ? parseInt(increment) : void 0
+    );
+  }
+  setSecond(value, increment) {
+    if (!this.cron.isEnableSecond) return false;
+    const values = formaterDigits(value, default_min_second, default_max_second);
+    if (!values) return false;
+    const second = new DigitsValue(values);
+    if (validateIncrement(increment, default_min_second, default_max_second)) {
+      second.increment = increment;
+    }
+    this.second = second;
+    return true;
+  }
+  setMinute(value, increment) {
+    const values = formaterDigits(value, default_min_minute, default_max_minute);
+    if (!values) return false;
+    const minute = new DigitsValue(values);
+    if (validateIncrement(increment, default_min_minute, default_max_minute)) {
+      minute.increment = increment;
+    }
+    this.minute = minute;
+    return true;
+  }
+  setHour(value, increment) {
+    const values = formaterDigits(value, default_min_hour, default_max_hour);
+    if (!values) return false;
+    const hour = new DigitsValue(values);
+    if (validateIncrement(increment, default_min_hour, default_max_hour)) {
+      hour.increment = increment;
+    }
+    this.hour = hour;
+    return true;
+  }
+  setDayInvalid() {
+    this.day = new InvalidValue(this.cron.isEnableInvalid);
+    if (this.week instanceof InvalidValue) {
+      this.week = new DigitsValue(new WildcardValue());
+    }
+  }
+  setDay(value, increment) {
+    let values;
+    if (value === "?") {
+      this.setDayInvalid();
+      return true;
+    } else {
+      const tmp2 = formaterLastDigits(value, default_min_day, default_max_day, DayLastValue);
+      if (!tmp2) return false;
+      values = tmp2;
+    }
+    const tmp = new DigitsValue(values);
+    if (validateIncrement(increment, default_min_day, default_max_day)) {
+      tmp.increment = increment;
+    }
+    this.day = tmp;
+    const { week } = this;
+    if (isDigitsValue(week) && (week.increment !== void 0 || !isWildcardValue(week.values))) {
+      if (this.cron.isEnableInvalid) {
+        this.week = new InvalidValue(true);
+      } else {
+        week.values = new WildcardValue();
+        week.increment = void 0;
+      }
+    }
+    return true;
+  }
+  setMonth(value, increment) {
+    const values = formaterDigits(value, default_min_month, default_max_month);
+    if (!values) return false;
+    const month = new DigitsValue(values);
+    if (validateIncrement(increment, default_min_month, default_max_month)) {
+      month.increment = increment;
+    }
+    this.month = month;
+    return true;
+  }
+  setWeekInvalid() {
+    this.week = new InvalidValue(this.cron.isEnableInvalid);
+    if (this.day instanceof InvalidValue) {
+      this.day = new DigitsValue(new WildcardValue());
+    }
+  }
+  setWeek(value, increment) {
+    let values;
+    if (value === "?") {
+      this.setWeekInvalid();
+      return true;
+    } else {
+      const tmp2 = formaterLastDigits(value, default_min_week, default_max_week, WeekLastValue);
+      if (!tmp2) return false;
+      values = tmp2;
+    }
+    const tmp = new DigitsValue(values);
+    if (validateIncrement(increment, default_min_week, default_max_week)) {
+      tmp.increment = increment;
+    }
+    this.week = tmp;
+    const { day } = this;
+    if (isDigitsValue(day) && (day.increment !== void 0 || !isWildcardValue(day.values))) {
+      if (this.cron.isEnableInvalid) {
+        this.day = new InvalidValue(true);
+      } else {
+        day.values = new WildcardValue();
+        day.increment = void 0;
+      }
+    }
+    return true;
+  }
+  setYear(value, increment) {
+    if (!this.cron.isEnableYear) return false;
+    const values = formaterDigits(value, 0, MAX_SAFE_INTEGER);
+    if (!values) return false;
+    const year = new DigitsValue(values);
+    if (validateIncrement(increment, 0, MAX_SAFE_INTEGER)) {
+      year.increment = increment;
+    }
+    this.year = year;
+    return true;
+  }
+  text() {
+    const { cron, second, year } = this;
+    const list = [];
+    if (cron.isEnableSecond) {
+      list.push(second ? second.text() : "0");
+    }
+    list.push(this.minute.text());
+    list.push(this.hour.text());
+    list.push(this.day.text());
+    list.push(this.month.text());
+    list.push(this.week.text());
+    if (cron.isEnableYear && year) {
+      list.push(year.text());
+    }
+    return list.join(" ");
+  }
+}
+class Cron {
+  #options;
+  #regex;
+  get isEnableSecond() {
+    return this.#options.enableSecond;
+  }
+  get isEnableYear() {
+    return this.#options.enableYear;
+  }
+  get isEnableDayLast() {
+    return this.#options.enableDayLast;
+  }
+  get isEnableWeekLast() {
+    return this.#options.enableWeekLast;
+  }
+  get isEnableInvalid() {
+    return this.#options.enableInvalid;
+  }
+  constructor(options) {
+    const { regex } = this.#options = createCronRegexText(options);
+    this.#regex = new RegExp(`^${regex}$`);
+  }
+  parse(text) {
+    const matchs = text.trim().match(this.#regex);
+    if (!matchs) return;
+    const config = this.#options;
+    const { enableSecond, enableYear } = config;
+    let second;
+    let minute;
+    let hour;
+    let day;
+    let month;
+    let week;
+    let year;
+    if (config.enableSlot) {
+      const groups = matchs.groups;
+      if (enableSecond) {
+        second = groups.s;
+      }
+      minute = groups.m;
+      hour = groups.h;
+      day = groups.D;
+      month = groups.M;
+      week = groups.w;
+      if (enableYear) {
+        year = groups.Y;
+      }
+    } else {
+      let count = 1;
+      if (enableSecond) {
+        second = matchs[count++];
+      }
+      minute = matchs[count++];
+      hour = matchs[count++];
+      day = matchs[count++];
+      month = matchs[count++];
+      week = matchs[count++];
+      if (enableYear) {
+        year = matchs[count++];
+      }
+    }
+    return new Parse(second, minute, hour, day, month, week, year, this);
+  }
+}
+export {
+  Cron,
+  DayLastValue,
+  DigitsValue,
+  InvalidValue,
+  RangeValue,
+  WeekLastValue,
+  WildcardValue,
+  createCronRegexText,
+  default_max_day,
+  default_max_hour,
+  default_max_minute,
+  default_max_month,
+  default_max_second,
+  default_max_week,
+  default_min_day,
+  default_min_hour,
+  default_min_minute,
+  default_min_month,
+  default_min_second,
+  default_min_week,
+  isDayLastValue,
+  isDigitsValue,
+  isInvalidValue,
+  isRangeValue,
+  isWeekLastValue,
+  isWildcardValue,
+  weekDic
+};