cron-converter-u2q 1.3.1 → 1.3.3

package/lib/converter.d.ts

@@ -4,18 +4,13 @@ export declare class CronConverterU2Q {
      * @param unixExpression - the unix expression
      * @returns the corresponding quartz expression
      */
-    static unixToQuartz(unixExpression: string): string;
+    static unixToQuartz(unixExpression: string, year?: string): string;
     /**
      * Converts a quartz cron expression to a unix cron expression
      * @param quartzExpression - the quartz expression
      * @returns the corresponding unix expression
      */
     static quartzToUnix(quartzExpression: string): string;
-    /**
-     * Converts interval parts for both Unix and Quartz expressions.
-     * In both directions, normalises step notation to the Unix `*\/N` format.
-     */
-    private static convertIntervalParts;
     /**
      * Converts Unix DOW to Quartz DOW, supporting lists, ranges, and special cases.
      * Unix: 0=Sun, 1=Mon, ..., 6=Sat, 7=Sun(alias)

package/lib/converter.js

@@ -9,10 +9,10 @@ class CronConverterU2Q {
      * @param unixExpression - the unix expression
      * @returns the corresponding quartz expression
      */
-    static unixToQuartz(unixExpression) {
+    static unixToQuartz(unixExpression, year = '*') {
         validator_1.CronValidatorU2Q.validateUnix(unixExpression);
         const parts = helper_1.ExpressionHelper.GetExpressionParts(unixExpression);
-        const [min, hour, dom, month, dow] = parts.map(part => this.convertIntervalParts(part));
+        const [min, hour, dom, month, dow] = parts;
         // Enhanced DOW conversion: handle lists, ranges, and special cases
         let quartzDow = this.unixDowToQuartz(dow);
         let quartzDom = dom;
@@ -24,7 +24,14 @@ class CronConverterU2Q {
         else if (dom !== '*' && dow === '*') {
             quartzDow = '?';
         }
-        return `0 ${min} ${hour} ${quartzDom} ${month} ${quartzDow} *`;
+        else if (dom !== '*' && dow !== '*') {
+            throw new Error("Quartz cron does not support specifying both Day of Month and Day of Week");
+        }
+        const result = `0 ${min} ${hour} ${quartzDom} ${month} ${quartzDow} ${year}`;
+        if (year !== '*') {
+            validator_1.CronValidatorU2Q.validateQuartz(result);
+        }
+        return result;
     }
     /**
      * Converts a quartz cron expression to a unix cron expression
@@ -34,7 +41,7 @@ class CronConverterU2Q {
     static quartzToUnix(quartzExpression) {
         validator_1.CronValidatorU2Q.validateQuartz(quartzExpression);
         const parts = helper_1.ExpressionHelper.GetExpressionParts(quartzExpression);
-        const [_, min, hour, dom, month, dow] = parts.map(part => this.convertIntervalParts(part, true));
+        const [_, min, hour, dom, month, dow] = parts.map(part => part.replace(/^0\/(\d+)$/, '*/$1'));
         if (dom.includes('L') || dom.includes('W')) {
             throw new Error("Unix cron does not support 'L' or 'W' in Day of Month");
         }
@@ -46,16 +53,6 @@ class CronConverterU2Q {
         let unixDom = dom === '?' ? '*' : dom;
         return `${min} ${hour} ${unixDom} ${month} ${unixDow}`;
     }
-    /**
-     * Converts interval parts for both Unix and Quartz expressions.
-     * In both directions, normalises step notation to the Unix `*\/N` format.
-     */
-    static convertIntervalParts(part, isQuartz = false) {
-        if (isQuartz) {
-            return part.replace(/^0\/(\d+)$/, '*/$1');
-        }
-        return part;
-    }
     /**
      * Converts Unix DOW to Quartz DOW, supporting lists, ranges, and special cases.
      * Unix: 0=Sun, 1=Mon, ..., 6=Sat, 7=Sun(alias)
@@ -64,8 +61,10 @@ class CronConverterU2Q {
     static unixDowToQuartz(dow) {
         if (dow === '*' || dow === '?')
             return dow;
-        if (dow.includes(','))
-            return dow.split(',').map(d => this.unixDowToQuartz(d)).join(',');
+        if (dow.includes(',')) {
+            const mapped = dow.split(',').map(d => this.unixDowToQuartz(d));
+            return Array.from(new Set(mapped)).join(',');
+        }
         if (dow.includes('-'))
             return dow.split('-').map(d => this.unixDowToQuartz(d)).join('-');
         if (dow.endsWith('L')) {
@@ -92,8 +91,10 @@ class CronConverterU2Q {
         if (dow === '*' || dow === '?')
             return dow === '?' ? '*' : dow;
         // Split compound expressions so each element is converted individually
-        if (dow.includes(','))
-            return dow.split(',').map(d => this.quartzDowToUnix(d)).join(',');
+        if (dow.includes(',')) {
+            const mapped = dow.split(',').map(d => this.quartzDowToUnix(d));
+            return Array.from(new Set(mapped)).join(',');
+        }
         if (dow.includes('-'))
             return dow.split('-').map(d => this.quartzDowToUnix(d)).join('-');
         // Last (L) — convert the numeric day part, preserve L suffix

package/lib/helper.js

@@ -4,10 +4,10 @@ exports.ExpressionHelper = void 0;
 class ExpressionHelper {
     static GetExpressionParts(expression) {
         this.validateIfNullOrEmpty(expression);
-        const parts = expression.split(this.delimiter).map(part => part.trim());
+        const parts = expression.trim().split(/\s+/);
         if (this.quartzExpressionLengths.includes(parts.length))
             return parts;
-        if (this.unixExpressionLength == parts.length)
+        if (this.unixExpressionLength === parts.length)
             return parts;
         throw new Error(`Invalid cron expression!`);
     }

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "cron-converter-u2q",
-  "version": "1.3.1",
+  "version": "1.3.3",
   "description": "Converts cron expressions between unix and quartz formats",
   "main": "lib/index.js",
-  "types": "types/index.d.ts",
+  "types": "lib/index.d.ts",
   "scripts": {
     "build": "tsc",
     "test": "jest --no-watchman --coverage",

package/src/__tests__/index.test.ts

@@ -290,6 +290,49 @@ describe("Converter: error handling", () => {
   test("quartzToUnix throws on 8-field expression", () => {
     expect(() => converter.quartzToUnix("* * * * * * * *")).toThrow();
   });
+
+  test("unixToQuartz throws when both DOM and DOW are specific", () => {
+    expect(() => converter.unixToQuartz("0 0 15 * 1")).toThrow("Quartz cron does not support specifying both Day of Month and Day of Week");
+  });
+});
+
+describe("Converter: deduplication of DOW values", () => {
+  test("unixToQuartz deduplicates redundant DOW values (e.g. 0,7)", () => {
+    expect(converter.unixToQuartz("0 0 * * 0,7")).toBe("0 0 0 ? * 1 *");
+  });
+
+  test("quartzToUnix deduplicates redundant DOW values (e.g. 2,2)", () => {
+    expect(converter.quartzToUnix("0 0 0 ? * 2,2")).toBe("0 0 * * 1");
+  });
+});
+
+describe("ExpressionHelper whitespace robustness", () => {
+  test("handles multiple spaces, tabs, and leading/trailing whitespace correctly", () => {
+    expect(converter.unixToQuartz("  0   12   *   *   *  ")).toBe("0 0 12 * * * *");
+    expect(converter.unixToQuartz("0\t12\t*\t*\t*")).toBe("0 0 12 * * * *");
+  });
+});
+
+describe("Converter: optional year parameter", () => {
+  test("unixToQuartz accepts specific year", () => {
+    expect(converter.unixToQuartz("0 12 * * 1", "2026")).toBe("0 0 12 ? * 2 2026");
+  });
+
+  test("unixToQuartz throws on invalid specific year", () => {
+    expect(() => converter.unixToQuartz("0 12 * * 1", "invalid_year")).toThrow();
+    expect(() => converter.unixToQuartz("0 12 * * 1", "1969")).toThrow(); // out of range
+  });
+
+  test("round-tripping Quartz -> Unix -> Quartz with specific years", () => {
+    const originalQuartz = "0 0 12 ? * 2 2026";
+    const unix = converter.quartzToUnix(originalQuartz); // "0 12 * * 1"
+    
+    const parts = originalQuartz.split(/\s+/);
+    const year = parts.length === 7 ? parts[6] : "*";
+    
+    const reconstructedQuartz = converter.unixToQuartz(unix, year);
+    expect(reconstructedQuartz).toBe(originalQuartz);
+  });
 });
 
 describe("Validator Checks", () => {

package/src/converter.ts

@@ -7,10 +7,10 @@ export class CronConverterU2Q {
      * @param unixExpression - the unix expression
      * @returns the corresponding quartz expression
      */
-    public static unixToQuartz(unixExpression: string): string {
+    public static unixToQuartz(unixExpression: string, year = '*'): string {
         CronValidatorU2Q.validateUnix(unixExpression);
         const parts = helper.GetExpressionParts(unixExpression);
-        const [min, hour, dom, month, dow] = parts.map(part => this.convertIntervalParts(part));
+        const [min, hour, dom, month, dow] = parts;
 
         // Enhanced DOW conversion: handle lists, ranges, and special cases
         let quartzDow = this.unixDowToQuartz(dow);
@@ -22,9 +22,15 @@ export class CronConverterU2Q {
             quartzDom = '?';
         } else if (dom !== '*' && dow === '*') {
             quartzDow = '?';
+        } else if (dom !== '*' && dow !== '*') {
+            throw new Error("Quartz cron does not support specifying both Day of Month and Day of Week");
         }
 
-        return `0 ${min} ${hour} ${quartzDom} ${month} ${quartzDow} *`;
+        const result = `0 ${min} ${hour} ${quartzDom} ${month} ${quartzDow} ${year}`;
+        if (year !== '*') {
+            CronValidatorU2Q.validateQuartz(result);
+        }
+        return result;
     }
 
     /**
@@ -35,7 +41,7 @@ export class CronConverterU2Q {
     public static quartzToUnix(quartzExpression: string): string {
         CronValidatorU2Q.validateQuartz(quartzExpression);
         const parts = helper.GetExpressionParts(quartzExpression);
-        const [_, min, hour, dom, month, dow] = parts.map(part => this.convertIntervalParts(part, true));
+        const [_, min, hour, dom, month, dow] = parts.map(part => part.replace(/^0\/(\d+)$/, '*/$1'));
 
         if (dom.includes('L') || dom.includes('W')) {
             throw new Error("Unix cron does not support 'L' or 'W' in Day of Month");
@@ -51,17 +57,6 @@ export class CronConverterU2Q {
         return `${min} ${hour} ${unixDom} ${month} ${unixDow}`;
     }
 
-    /**
-     * Converts interval parts for both Unix and Quartz expressions.
-     * In both directions, normalises step notation to the Unix `*\/N` format.
-     */
-    private static convertIntervalParts(part: string, isQuartz = false): string {
-        if (isQuartz) {
-            return part.replace(/^0\/(\d+)$/, '*/$1');
-        }
-        return part;
-    }
-
     /**
      * Converts Unix DOW to Quartz DOW, supporting lists, ranges, and special cases.
      * Unix: 0=Sun, 1=Mon, ..., 6=Sat, 7=Sun(alias)
@@ -69,7 +64,10 @@ export class CronConverterU2Q {
      */
     private static unixDowToQuartz(dow: string): string {
         if (dow === '*' || dow === '?') return dow;
-        if (dow.includes(',')) return dow.split(',').map(d => this.unixDowToQuartz(d)).join(',');
+        if (dow.includes(',')) {
+            const mapped = dow.split(',').map(d => this.unixDowToQuartz(d));
+            return Array.from(new Set(mapped)).join(',');
+        }
         if (dow.includes('-')) return dow.split('-').map(d => this.unixDowToQuartz(d)).join('-');
         if (dow.endsWith('L')) {
             const day = dow.slice(0, -1);
@@ -94,7 +92,10 @@ export class CronConverterU2Q {
         if (dow === '*' || dow === '?') return dow === '?' ? '*' : dow;
 
         // Split compound expressions so each element is converted individually
-        if (dow.includes(',')) return dow.split(',').map(d => this.quartzDowToUnix(d)).join(',');
+        if (dow.includes(',')) {
+            const mapped = dow.split(',').map(d => this.quartzDowToUnix(d));
+            return Array.from(new Set(mapped)).join(',');
+        }
         if (dow.includes('-')) return dow.split('-').map(d => this.quartzDowToUnix(d)).join('-');
 
         // Last (L) — convert the numeric day part, preserve L suffix

package/src/helper.ts

@@ -5,9 +5,9 @@ export class ExpressionHelper {
 
     public static GetExpressionParts(expression: string): string[] {
         this.validateIfNullOrEmpty(expression);
-        const parts = expression.split(this.delimiter).map(part => part.trim());
+        const parts = expression.trim().split(/\s+/);
         if (this.quartzExpressionLengths.includes(parts.length)) return parts;
-        if (this.unixExpressionLength == parts.length) return parts;
+        if (this.unixExpressionLength === parts.length) return parts;
 
         throw new Error(`Invalid cron expression!`)
     }

package/types/index.d.ts

@@ -1,6 +1,6 @@
 declare module 'cron-converter-u2q' {
     export class CronConverterU2Q {
-        static unixToQuartz(unixExpression: string): string;
+        static unixToQuartz(unixExpression: string, year?: string): string;
         static quartzToUnix(quartzExpression: string): string;
     }