@wabot-dev/framework 0.4.0-beta.2 → 0.4.0-beta.4

package/dist/src/node_modules/cron-parser/dist/fields/CronField.js

@@ -0,0 +1,193 @@
+import { __exports as CronField } from '../../../../_virtual/CronField.js';
+
+var hasRequiredCronField;
+
+function requireCronField () {
+	if (hasRequiredCronField) return CronField;
+	hasRequiredCronField = 1;
+	Object.defineProperty(CronField, "__esModule", { value: true });
+	CronField.CronField = void 0;
+	/**
+	 * Represents a field within a cron expression.
+	 * This is a base class and should not be instantiated directly.
+	 * @class CronField
+	 */
+	let CronField$1 = class CronField {
+	    #hasLastChar = false;
+	    #hasQuestionMarkChar = false;
+	    #wildcard = false;
+	    #values = [];
+	    options = { rawValue: '' };
+	    /**
+	     * Returns the minimum value allowed for this field.
+	     */
+	    /* istanbul ignore next */ static get min() {
+	        /* istanbul ignore next */
+	        throw new Error('min must be overridden');
+	    }
+	    /**
+	     * Returns the maximum value allowed for this field.
+	     */
+	    /* istanbul ignore next */ static get max() {
+	        /* istanbul ignore next */
+	        throw new Error('max must be overridden');
+	    }
+	    /**
+	     * Returns the allowed characters for this field.
+	     */
+	    /* istanbul ignore next */ static get chars() {
+	        /* istanbul ignore next - this is overridden */
+	        return Object.freeze([]);
+	    }
+	    /**
+	     * Returns the regular expression used to validate this field.
+	     */
+	    static get validChars() {
+	        return /^[?,*\dH/-]+$|^.*H\(\d+-\d+\)\/\d+.*$|^.*H\(\d+-\d+\).*$|^.*H\/\d+.*$/;
+	    }
+	    /**
+	     * Returns the constraints for this field.
+	     */
+	    static get constraints() {
+	        return { min: this.min, max: this.max, chars: this.chars, validChars: this.validChars };
+	    }
+	    /**
+	     * CronField constructor. Initializes the field with the provided values.
+	     * @param {number[] | string[]} values - Values for this field
+	     * @param {CronFieldOptions} [options] - Options provided by the parser
+	     * @throws {TypeError} if the constructor is called directly
+	     * @throws {Error} if validation fails
+	     */
+	    constructor(values, options = { rawValue: '' }) {
+	        if (!Array.isArray(values)) {
+	            throw new Error(`${this.constructor.name} Validation error, values is not an array`);
+	        }
+	        if (!(values.length > 0)) {
+	            throw new Error(`${this.constructor.name} Validation error, values contains no values`);
+	        }
+	        /* istanbul ignore next */
+	        this.options = {
+	            ...options,
+	            rawValue: options.rawValue ?? '',
+	        };
+	        this.#values = values.sort(CronField.sorter);
+	        this.#wildcard = this.options.wildcard !== undefined ? this.options.wildcard : this.#isWildcardValue();
+	        this.#hasLastChar = this.options.rawValue.includes('L') || values.includes('L');
+	        this.#hasQuestionMarkChar = this.options.rawValue.includes('?') || values.includes('?');
+	    }
+	    /**
+	     * Returns the minimum value allowed for this field.
+	     * @returns {number}
+	     */
+	    get min() {
+	        // return the static value from the child class
+	        return this.constructor.min;
+	    }
+	    /**
+	     * Returns the maximum value allowed for this field.
+	     * @returns {number}
+	     */
+	    get max() {
+	        // return the static value from the child class
+	        return this.constructor.max;
+	    }
+	    /**
+	     * Returns an array of allowed special characters for this field.
+	     * @returns {string[]}
+	     */
+	    get chars() {
+	        // return the frozen static value from the child class
+	        return this.constructor.chars;
+	    }
+	    /**
+	     * Indicates whether this field has a "last" character.
+	     * @returns {boolean}
+	     */
+	    get hasLastChar() {
+	        return this.#hasLastChar;
+	    }
+	    /**
+	     * Indicates whether this field has a "question mark" character.
+	     * @returns {boolean}
+	     */
+	    get hasQuestionMarkChar() {
+	        return this.#hasQuestionMarkChar;
+	    }
+	    /**
+	     * Indicates whether this field is a wildcard.
+	     * @returns {boolean}
+	     */
+	    get isWildcard() {
+	        return this.#wildcard;
+	    }
+	    /**
+	     * Returns an array of allowed values for this field.
+	     * @returns {CronFieldType}
+	     */
+	    get values() {
+	        return this.#values;
+	    }
+	    /**
+	     * Helper function to sort values in ascending order.
+	     * @param {number | string} a - First value to compare
+	     * @param {number | string} b - Second value to compare
+	     * @returns {number} - A negative, zero, or positive value, depending on the sort order
+	     */
+	    static sorter(a, b) {
+	        const aIsNumber = typeof a === 'number';
+	        const bIsNumber = typeof b === 'number';
+	        if (aIsNumber && bIsNumber)
+	            return a - b;
+	        if (!aIsNumber && !bIsNumber)
+	            return a.localeCompare(b);
+	        return aIsNumber ? /* istanbul ignore next - A will always be a number until L-2 is supported */ -1 : 1;
+	    }
+	    /**
+	     * Serializes the field to an object.
+	     * @returns {SerializedCronField}
+	     */
+	    serialize() {
+	        return {
+	            wildcard: this.#wildcard,
+	            values: this.#values,
+	        };
+	    }
+	    /**
+	     * Validates the field values against the allowed range and special characters.
+	     * @throws {Error} if validation fails
+	     */
+	    validate() {
+	        let badValue;
+	        const charsString = this.chars.length > 0 ? ` or chars ${this.chars.join('')}` : '';
+	        const charTest = (value) => (char) => new RegExp(`^\\d{0,2}${char}$`).test(value);
+	        const rangeTest = (value) => {
+	            badValue = value;
+	            return typeof value === 'number' ? value >= this.min && value <= this.max : this.chars.some(charTest(value));
+	        };
+	        const isValidRange = this.#values.every(rangeTest);
+	        if (!isValidRange) {
+	            throw new Error(`${this.constructor.name} Validation error, got value ${badValue} expected range ${this.min}-${this.max}${charsString}`);
+	        }
+	        // check for duplicate value in this.#values array
+	        const duplicate = this.#values.find((value, index) => this.#values.indexOf(value) !== index);
+	        if (duplicate) {
+	            throw new Error(`${this.constructor.name} Validation error, duplicate values found: ${duplicate}`);
+	        }
+	    }
+	    /**
+	     * Determines if the field is a wildcard based on the values.
+	     * When options.rawValue is not empty, it checks if the raw value is a wildcard, otherwise it checks if all values in the range are included.
+	     * @returns {boolean}
+	     */
+	    #isWildcardValue() {
+	        if (this.options.rawValue.length > 0) {
+	            return ['*', '?'].includes(this.options.rawValue);
+	        }
+	        return Array.from({ length: this.max - this.min + 1 }, (_, i) => i + this.min).every((value) => this.#values.includes(value));
+	    }
+	};
+	CronField.CronField = CronField$1;
+	return CronField;
+}
+
+export { requireCronField as __require };

package/dist/src/node_modules/cron-parser/dist/fields/CronHour.js

@@ -0,0 +1,51 @@
+import { __exports as CronHour } from '../../../../_virtual/CronHour.js';
+import { __require as requireCronField } from './CronField.js';
+
+var hasRequiredCronHour;
+
+function requireCronHour () {
+	if (hasRequiredCronHour) return CronHour;
+	hasRequiredCronHour = 1;
+	Object.defineProperty(CronHour, "__esModule", { value: true });
+	CronHour.CronHour = void 0;
+	const CronField_1 = requireCronField();
+	const MIN_HOUR = 0;
+	const MAX_HOUR = 23;
+	const HOUR_CHARS = Object.freeze([]);
+	/**
+	 * Represents the "hour" field within a cron expression.
+	 * @class CronHour
+	 * @extends CronField
+	 */
+	let CronHour$1 = class CronHour extends CronField_1.CronField {
+	    static get min() {
+	        return MIN_HOUR;
+	    }
+	    static get max() {
+	        return MAX_HOUR;
+	    }
+	    static get chars() {
+	        return HOUR_CHARS;
+	    }
+	    /**
+	     * CronHour constructor. Initializes the "hour" field with the provided values.
+	     * @param {HourRange[]} values - Values for the "hour" field
+	     * @param {CronFieldOptions} [options] - Options provided by the parser
+	     */
+	    constructor(values, options) {
+	        super(values, options);
+	        this.validate();
+	    }
+	    /**
+	     * Returns an array of allowed values for the "hour" field.
+	     * @returns {HourRange[]}
+	     */
+	    get values() {
+	        return super.values;
+	    }
+	};
+	CronHour.CronHour = CronHour$1;
+	return CronHour;
+}
+
+export { requireCronHour as __require };

package/dist/src/node_modules/cron-parser/dist/fields/CronMinute.js

@@ -0,0 +1,51 @@
+import { __exports as CronMinute } from '../../../../_virtual/CronMinute.js';
+import { __require as requireCronField } from './CronField.js';
+
+var hasRequiredCronMinute;
+
+function requireCronMinute () {
+	if (hasRequiredCronMinute) return CronMinute;
+	hasRequiredCronMinute = 1;
+	Object.defineProperty(CronMinute, "__esModule", { value: true });
+	CronMinute.CronMinute = void 0;
+	const CronField_1 = requireCronField();
+	const MIN_MINUTE = 0;
+	const MAX_MINUTE = 59;
+	const MINUTE_CHARS = Object.freeze([]);
+	/**
+	 * Represents the "second" field within a cron expression.
+	 * @class CronSecond
+	 * @extends CronField
+	 */
+	let CronMinute$1 = class CronMinute extends CronField_1.CronField {
+	    static get min() {
+	        return MIN_MINUTE;
+	    }
+	    static get max() {
+	        return MAX_MINUTE;
+	    }
+	    static get chars() {
+	        return MINUTE_CHARS;
+	    }
+	    /**
+	     * CronSecond constructor. Initializes the "second" field with the provided values.
+	     * @param {SixtyRange[]} values - Values for the "second" field
+	     * @param {CronFieldOptions} [options] - Options provided by the parser
+	     */
+	    constructor(values, options) {
+	        super(values, options);
+	        this.validate();
+	    }
+	    /**
+	     * Returns an array of allowed values for the "second" field.
+	     * @returns {SixtyRange[]}
+	     */
+	    get values() {
+	        return super.values;
+	    }
+	};
+	CronMinute.CronMinute = CronMinute$1;
+	return CronMinute;
+}
+
+export { requireCronMinute as __require };

package/dist/src/node_modules/cron-parser/dist/fields/CronMonth.js

@@ -0,0 +1,56 @@
+import { __exports as CronMonth } from '../../../../_virtual/CronMonth.js';
+import { __require as requireCronDate } from '../CronDate.js';
+import { __require as requireCronField } from './CronField.js';
+
+var hasRequiredCronMonth;
+
+function requireCronMonth () {
+	if (hasRequiredCronMonth) return CronMonth;
+	hasRequiredCronMonth = 1;
+	Object.defineProperty(CronMonth, "__esModule", { value: true });
+	CronMonth.CronMonth = void 0;
+	const CronDate_1 = requireCronDate();
+	const CronField_1 = requireCronField();
+	const MIN_MONTH = 1;
+	const MAX_MONTH = 12;
+	const MONTH_CHARS = Object.freeze([]);
+	/**
+	 * Represents the "day of the month" field within a cron expression.
+	 * @class CronDayOfMonth
+	 * @extends CronField
+	 */
+	let CronMonth$1 = class CronMonth extends CronField_1.CronField {
+	    static get min() {
+	        return MIN_MONTH;
+	    }
+	    static get max() {
+	        return MAX_MONTH;
+	    }
+	    static get chars() {
+	        return MONTH_CHARS;
+	    }
+	    static get daysInMonth() {
+	        return CronDate_1.DAYS_IN_MONTH;
+	    }
+	    /**
+	     * CronDayOfMonth constructor. Initializes the "day of the month" field with the provided values.
+	     * @param {MonthRange[]} values - Values for the "day of the month" field
+	     * @param {CronFieldOptions} [options] - Options provided by the parser
+	     */
+	    constructor(values, options) {
+	        super(values, options);
+	        this.validate();
+	    }
+	    /**
+	     * Returns an array of allowed values for the "day of the month" field.
+	     * @returns {MonthRange[]}
+	     */
+	    get values() {
+	        return super.values;
+	    }
+	};
+	CronMonth.CronMonth = CronMonth$1;
+	return CronMonth;
+}
+
+export { requireCronMonth as __require };

package/dist/src/node_modules/cron-parser/dist/fields/CronSecond.js

@@ -0,0 +1,51 @@
+import { __exports as CronSecond } from '../../../../_virtual/CronSecond.js';
+import { __require as requireCronField } from './CronField.js';
+
+var hasRequiredCronSecond;
+
+function requireCronSecond () {
+	if (hasRequiredCronSecond) return CronSecond;
+	hasRequiredCronSecond = 1;
+	Object.defineProperty(CronSecond, "__esModule", { value: true });
+	CronSecond.CronSecond = void 0;
+	const CronField_1 = requireCronField();
+	const MIN_SECOND = 0;
+	const MAX_SECOND = 59;
+	const SECOND_CHARS = Object.freeze([]);
+	/**
+	 * Represents the "second" field within a cron expression.
+	 * @class CronSecond
+	 * @extends CronField
+	 */
+	let CronSecond$1 = class CronSecond extends CronField_1.CronField {
+	    static get min() {
+	        return MIN_SECOND;
+	    }
+	    static get max() {
+	        return MAX_SECOND;
+	    }
+	    static get chars() {
+	        return SECOND_CHARS;
+	    }
+	    /**
+	     * CronSecond constructor. Initializes the "second" field with the provided values.
+	     * @param {SixtyRange[]} values - Values for the "second" field
+	     * @param {CronFieldOptions} [options] - Options provided by the parser
+	     */
+	    constructor(values, options) {
+	        super(values, options);
+	        this.validate();
+	    }
+	    /**
+	     * Returns an array of allowed values for the "second" field.
+	     * @returns {SixtyRange[]}
+	     */
+	    get values() {
+	        return super.values;
+	    }
+	};
+	CronSecond.CronSecond = CronSecond$1;
+	return CronSecond;
+}
+
+export { requireCronSecond as __require };

package/dist/src/node_modules/cron-parser/dist/fields/index.js

@@ -0,0 +1,44 @@
+import { __exports as fields } from '../../../../_virtual/index3.js';
+import { __require as requireTypes } from './types.js';
+import { __require as requireCronDayOfMonth } from './CronDayOfMonth.js';
+import { __require as requireCronDayOfWeek } from './CronDayOfWeek.js';
+import { __require as requireCronField } from './CronField.js';
+import { __require as requireCronHour } from './CronHour.js';
+import { __require as requireCronMinute } from './CronMinute.js';
+import { __require as requireCronMonth } from './CronMonth.js';
+import { __require as requireCronSecond } from './CronSecond.js';
+
+var hasRequiredFields;
+
+function requireFields () {
+	if (hasRequiredFields) return fields;
+	hasRequiredFields = 1;
+	(function (exports) {
+		var __createBinding = (fields && fields.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (fields && fields.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		__exportStar(requireTypes(), exports);
+		__exportStar(requireCronDayOfMonth(), exports);
+		__exportStar(requireCronDayOfWeek(), exports);
+		__exportStar(requireCronField(), exports);
+		__exportStar(requireCronHour(), exports);
+		__exportStar(requireCronMinute(), exports);
+		__exportStar(requireCronMonth(), exports);
+		__exportStar(requireCronSecond(), exports); 
+	} (fields));
+	return fields;
+}
+
+export { requireFields as __require };

package/dist/src/node_modules/cron-parser/dist/fields/types.js

@@ -0,0 +1,12 @@
+import { __exports as types } from '../../../../_virtual/types.js';
+
+var hasRequiredTypes;
+
+function requireTypes () {
+	if (hasRequiredTypes) return types;
+	hasRequiredTypes = 1;
+	Object.defineProperty(types, "__esModule", { value: true });
+	return types;
+}
+
+export { requireTypes as __require };

package/dist/src/node_modules/cron-parser/dist/index.js

@@ -0,0 +1,49 @@
+import { __exports as dist } from '../../../_virtual/index2.js';
+import { __require as requireCronExpressionParser } from './CronExpressionParser.js';
+import { __require as requireCronDate } from './CronDate.js';
+import { __require as requireCronFieldCollection } from './CronFieldCollection.js';
+import { __require as requireCronExpression } from './CronExpression.js';
+import { __require as requireCronFileParser } from './CronFileParser.js';
+import { __require as requireFields } from './fields/index.js';
+
+var hasRequiredDist;
+
+function requireDist () {
+	if (hasRequiredDist) return dist;
+	hasRequiredDist = 1;
+	(function (exports) {
+		var __createBinding = (dist && dist.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    var desc = Object.getOwnPropertyDescriptor(m, k);
+		    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+		      desc = { enumerable: true, get: function() { return m[k]; } };
+		    }
+		    Object.defineProperty(o, k2, desc);
+		}) : (function(o, m, k, k2) {
+		    if (k2 === undefined) k2 = k;
+		    o[k2] = m[k];
+		}));
+		var __exportStar = (dist && dist.__exportStar) || function(m, exports) {
+		    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+		};
+		Object.defineProperty(exports, "__esModule", { value: true });
+		exports.CronFileParser = exports.CronExpressionParser = exports.CronExpression = exports.CronFieldCollection = exports.CronDate = void 0;
+		/* istanbul ignore file */
+		const CronExpressionParser_1 = requireCronExpressionParser();
+		var CronDate_1 = requireCronDate();
+		Object.defineProperty(exports, "CronDate", { enumerable: true, get: function () { return CronDate_1.CronDate; } });
+		var CronFieldCollection_1 = requireCronFieldCollection();
+		Object.defineProperty(exports, "CronFieldCollection", { enumerable: true, get: function () { return CronFieldCollection_1.CronFieldCollection; } });
+		var CronExpression_1 = requireCronExpression();
+		Object.defineProperty(exports, "CronExpression", { enumerable: true, get: function () { return CronExpression_1.CronExpression; } });
+		var CronExpressionParser_2 = requireCronExpressionParser();
+		Object.defineProperty(exports, "CronExpressionParser", { enumerable: true, get: function () { return CronExpressionParser_2.CronExpressionParser; } });
+		var CronFileParser_1 = requireCronFileParser();
+		Object.defineProperty(exports, "CronFileParser", { enumerable: true, get: function () { return CronFileParser_1.CronFileParser; } });
+		__exportStar(requireFields(), exports);
+		exports.default = CronExpressionParser_1.CronExpressionParser; 
+	} (dist));
+	return dist;
+}
+
+export { requireDist as __require };

package/dist/src/node_modules/cron-parser/dist/utils/random.js

@@ -0,0 +1,48 @@
+import { __exports as random } from '../../../../_virtual/random.js';
+
+var hasRequiredRandom;
+
+function requireRandom () {
+	if (hasRequiredRandom) return random;
+	hasRequiredRandom = 1;
+	Object.defineProperty(random, "__esModule", { value: true });
+	random.seededRandom = seededRandom;
+	/**
+	 * Computes a numeric hash from a given string
+	 * @param {string} str A value to hash
+	 * @returns {number} A numeric hash computed from the given value
+	 */
+	function xfnv1a(str) {
+	    let h = 2166136261 >>> 0;
+	    for (let i = 0; i < str.length; i++) {
+	        h ^= str.charCodeAt(i);
+	        h = Math.imul(h, 16777619);
+	    }
+	    return () => h >>> 0;
+	}
+	/**
+	 * Initialize a new PRNG using a given seed
+	 * @param {number} seed The seed used to initialize the PRNG
+	 * @returns {PRNG} A random number generator
+	 */
+	function mulberry32(seed) {
+	    return () => {
+	        let t = (seed += 0x6d2b79f5);
+	        t = Math.imul(t ^ (t >>> 15), t | 1);
+	        t ^= t + Math.imul(t ^ (t >>> 7), t | 61);
+	        return ((t ^ (t >>> 14)) >>> 0) / 4294967296;
+	    };
+	}
+	/**
+	 * Generates a PRNG using a given seed. When not provided, the seed is randomly generated
+	 * @param {string} str A string to derive the seed from
+	 * @returns {PRNG} A random number generator correctly seeded
+	 */
+	function seededRandom(str) {
+	    const seed = str ? xfnv1a(str)() : Math.floor(Math.random() * 10_000_000_000);
+	    return mulberry32(seed);
+	}
+	return random;
+}
+
+export { requireRandom as __require };