@vitnode/core 1.2.0-canary.52 → 1.2.0-canary.54

package/dist/src/lib/api/should-cron-job-run.test.js

@@ -0,0 +1,213 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { shouldCronJobRun } from "./should-cron-job-run.js";
+describe("shouldCronJobRun", ()=>{
+    beforeEach(()=>{
+        // Reset any mocked console methods
+        vi.clearAllMocks();
+    });
+    describe("valid cron schedules", ()=>{
+        it("should return true when job has never run (lastRun is null)", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = null;
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+        });
+        it("should return true when enough time has passed since last run", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date("2024-01-01T10:00:00Z");
+            // Mock current time to be 2 hours later
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T12:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should return false when not enough time has passed since last run", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date("2024-01-01T11:30:00Z");
+            // Mock current time to be 15 minutes later (not enough for hourly job)
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T11:45:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(false);
+            vi.useRealTimers();
+        });
+        it("should handle daily job correctly", ()=>{
+            const schedule = "0 9 * * *"; // Every day at 9 AM
+            const lastRun = new Date("2024-01-01T09:00:00Z");
+            // Mock current time to be next day at 10 AM
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-02T10:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle weekly job correctly", ()=>{
+            const schedule = "0 9 * * 1"; // Every Monday at 9 AM
+            const lastRun = new Date("2024-01-01T09:00:00Z"); // Monday
+            // Mock current time to be next Monday
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-08T10:00:00Z")); // Next Monday
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle monthly job correctly", ()=>{
+            const schedule = "0 9 1 * *"; // First day of every month at 9 AM
+            const lastRun = new Date("2024-01-01T09:00:00Z");
+            // Mock current time to be next month
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-02-01T10:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle every minute job correctly", ()=>{
+            const schedule = "* * * * *"; // Every minute
+            const lastRun = new Date("2024-01-01T10:00:00Z");
+            // Mock current time to be 1 minute later
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T10:01:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle every 5 minutes job correctly", ()=>{
+            const schedule = "*/5 * * * *"; // Every 5 minutes
+            const lastRun = new Date("2024-01-01T10:00:00Z");
+            // Mock current time to be 3 minutes later (not enough)
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T10:03:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(false);
+            // Mock current time to be 5 minutes later (enough)
+            vi.setSystemTime(new Date("2024-01-01T10:05:00Z"));
+            const result2 = shouldCronJobRun(schedule, lastRun);
+            expect(result2).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle complex cron expressions", ()=>{
+            const schedule = "0 9-17 * * 1-5"; // 9 AM to 5 PM on weekdays
+            const lastRun = new Date("2024-01-01T09:00:00Z"); // Monday 9 AM
+            // Mock current time to be same day at 10 AM
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T10:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+    });
+    describe("invalid cron schedules", ()=>{
+        it("should return false and log error for invalid cron schedule", ()=>{
+            const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(()=>{});
+            const schedule = "invalid cron"; // Invalid schedule
+            const lastRun = null;
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("[VitNode]") && expect.stringContaining("Error parsing schedule") && expect.stringContaining("invalid cron"), expect.any(Error));
+            consoleErrorSpy.mockRestore();
+        });
+        it("should return false for malformed cron expression", ()=>{
+            const consoleErrorSpy = vi.spyOn(console, "error").mockImplementation(()=>{});
+            const schedule = "60 * * * *"; // Invalid minute (should be 0-59)
+            const lastRun = null;
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(false);
+            expect(consoleErrorSpy).toHaveBeenCalled();
+            consoleErrorSpy.mockRestore();
+        });
+        it("should return true for empty cron schedule (parsed as valid)", ()=>{
+            // Note: cron-parser actually parses empty string as a valid cron expression
+            const schedule = ""; // Empty schedule
+            const lastRun = null;
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+        });
+    });
+    describe("edge cases", ()=>{
+        it("should handle lastRun being exactly at the next scheduled time", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date("2024-01-01T10:00:00Z");
+            // Mock current time to be exactly at the next scheduled time
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T11:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle lastRun being in the future (clock skew)", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date("2024-01-01T12:00:00Z"); // Future time
+            // Mock current time to be earlier
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T11:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(false);
+            vi.useRealTimers();
+        });
+        it("should handle lastRun being epoch (new Date(0))", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date(0); // Epoch time
+            // Mock current time to be much later
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T10:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle yearly cron job", ()=>{
+            const schedule = "0 0 1 1 *"; // January 1st at midnight
+            const lastRun = new Date("2023-01-01T00:00:00Z");
+            // Mock current time to be next year
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T01:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle specific day of month with month", ()=>{
+            const schedule = "0 12 15 6 *"; // June 15th at noon
+            const lastRun = new Date("2023-06-15T12:00:00Z");
+            // Mock current time to be next year same date
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-06-15T13:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+    });
+    describe("timezone handling", ()=>{
+        it("should work with different timezone dates", ()=>{
+            const schedule = "0 9 * * *"; // Every day at 9 AM
+            const lastRun = new Date("2024-01-01T09:00:00+05:00"); // 9 AM in +5 timezone
+            // Mock current time to be next day in UTC
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-02T04:00:00Z")); // 9 AM in +5 timezone
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+    });
+    describe("performance and boundary conditions", ()=>{
+        it("should handle very old lastRun dates", ()=>{
+            const schedule = "0 * * * *"; // Every hour
+            const lastRun = new Date("1970-01-01T00:00:00Z"); // Very old date
+            // Current time
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-01-01T10:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+        it("should handle leap year considerations", ()=>{
+            const schedule = "0 0 29 2 *"; // February 29th (leap day)
+            const lastRun = new Date("2020-02-29T00:00:00Z"); // Last leap year
+            // Mock current time to be next leap year
+            vi.useFakeTimers();
+            vi.setSystemTime(new Date("2024-02-29T01:00:00Z"));
+            const result = shouldCronJobRun(schedule, lastRun);
+            expect(result).toBe(true);
+            vi.useRealTimers();
+        });
+    });
+});

package/dist/src/lib/colors.js

@@ -5,19 +5,21 @@ export const convertColor = {
         const f = (n)=>{
             const k = (n + h / 30) % 12;
             const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
-            return Math.round(255 * color).toString(16).padStart(2, '0');
+            return Math.round(255 * color).toString(16).padStart(2, "0");
         };
         return `${f(0)}${f(8)}${f(4)}`;
     },
     hexToHSL: (hex)=>{
         if (!hexRegex.test(hex)) return undefined;
-        let b = 0, g = 0, r = 0;
+        let b = 0;
+        let g = 0;
+        let r = 0;
         // 3 digits
-        if (hex.length == 4) {
+        if (hex.length === 4) {
             r = parseInt(hex[1] + hex[1], 16);
             g = parseInt(hex[2] + hex[2], 16);
             b = parseInt(hex[3] + hex[3], 16);
-        } else if (hex.length == 7) {
+        } else if (hex.length === 7) {
             r = parseInt(hex[1] + hex[2], 16);
             g = parseInt(hex[3] + hex[4], 16);
             b = parseInt(hex[5] + hex[6], 16);
@@ -25,15 +27,18 @@ export const convertColor = {
             return undefined;
         }
         // Check if any of the parsed values are NaN
-        if (isNaN(r) || isNaN(g) || isNaN(b)) {
+        if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b)) {
             return undefined;
         }
         r /= 255;
         g /= 255;
         b /= 255;
-        const max = Math.max(r, g, b), min = Math.min(r, g, b), l = (max + min) / 2;
-        let h = 0, s = 0;
-        if (max == min) {
+        const max = Math.max(r, g, b);
+        const min = Math.min(r, g, b);
+        const l = (max + min) / 2;
+        let h = 0;
+        let s = 0;
+        if (max === min) {
             h = s = 0; // achromatic
         } else {
             const d = max - min;
@@ -63,12 +68,16 @@ export const convertColor = {
         g /= 255;
         b /= 255;
         // Find greatest and smallest channel values
-        const cmax = Math.max(r, g, b), cmin = Math.min(r, g, b), delta = cmax - cmin;
-        let h = 0, l = 0, s = 0;
+        const cmax = Math.max(r, g, b);
+        const cmin = Math.min(r, g, b);
+        const delta = cmax - cmin;
+        let h = 0;
+        let l = 0;
+        let s = 0;
         // Calculate hue
-        if (delta == 0) h = 0;
-        else if (cmax == r) h = (g - b) / delta % 6;
-        else if (cmax == g) h = (b - r) / delta + 2;
+        if (delta === 0) h = 0;
+        else if (cmax === r) h = (g - b) / delta % 6;
+        else if (cmax === g) h = (b - r) / delta + 2;
         else h = (r - g) / delta + 4;
         h = Math.round(h * 60);
         // Make negative hues positive behind 360°
@@ -76,7 +85,7 @@ export const convertColor = {
         // Calculate lightness
         l = (cmax + cmin) / 2;
         // Calculate saturation
-        s = delta == 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
+        s = delta === 0 ? 0 : delta / (1 - Math.abs(2 * l - 1));
         // Multiply l and s by 100
         s = +(s * 100).toFixed(1);
         l = +(l * 100).toFixed(1);
@@ -92,7 +101,7 @@ export const convertColor = {
         const f = (n)=>{
             const k = (n + h / 30) % 12;
             const color = l - a * Math.max(Math.min(k - 3, 9 - k, 1), -1);
-            return Math.round(255 * color).toString(16).padStart(2, '0'); // convert to Hex and prefix "0" if needed
+            return Math.round(255 * color).toString(16).padStart(2, "0"); // convert to Hex and prefix "0" if needed
         };
         return {
             r: f(0),
@@ -107,19 +116,19 @@ export const rgbWithCommaRegex = /^rgb\(\s*([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][
 export const rgbWithoutCommaRegex = /^rgb\(\s*([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\s+([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\s+([0-9]|[1-9][0-9]|1[0-9][0-9]|2[0-4][0-9]|25[0-5])\s*\)$/;
 export const checkColorType = (strColor)=>{
     if (hexRegex.test(strColor)) {
-        return 'hex';
+        return "hex";
     }
     if (hslRegex.test(strColor)) {
-        return 'hsl';
+        return "hsl";
     }
     if (rgbWithoutCommaRegex.test(strColor) || rgbWithCommaRegex.test(strColor)) {
-        return 'rgb';
+        return "rgb";
     }
     return null;
 };
 export const getHSLFromString = (string)=>{
     if (!hslRegex.test(string)) return null;
-    const [h, s, l] = string.replaceAll('hsl(', '').replaceAll(')', '').replaceAll('%', '').split(',').map(Number);
+    const [h, s, l] = string.replaceAll("hsl(", "").replaceAll(")", "").replaceAll("%", "").split(",").map(Number);
     return {
         h,
         s,

package/dist/src/lib/colors.test.js

@@ -1,71 +1,71 @@
 import { describe, expect, it } from "vitest";
 import { checkColorType, convertColor, getHSLFromString, getStringFromHSL } from "./colors.js";
-describe('convertColor', ()=>{
-    describe('hslToHex', ()=>{
-        it('should convert HSL to hex correctly', ()=>{
+describe("convertColor", ()=>{
+    describe("hslToHex", ()=>{
+        it("should convert HSL to hex correctly", ()=>{
             const hsl = {
                 h: 0,
                 s: 100,
                 l: 50
             }; // Red
-            expect(convertColor.hslToHex(hsl)).toBe('ff0000');
+            expect(convertColor.hslToHex(hsl)).toBe("ff0000");
             const hsl2 = {
                 h: 120,
                 s: 100,
                 l: 50
             }; // Green
-            expect(convertColor.hslToHex(hsl2)).toBe('00ff00');
+            expect(convertColor.hslToHex(hsl2)).toBe("00ff00");
             const hsl3 = {
                 h: 240,
                 s: 100,
                 l: 50
             }; // Blue
-            expect(convertColor.hslToHex(hsl3)).toBe('0000ff');
+            expect(convertColor.hslToHex(hsl3)).toBe("0000ff");
         });
     });
-    describe('hexToHSL', ()=>{
-        it('should convert 6-digit hex to HSL correctly', ()=>{
-            expect(convertColor.hexToHSL('#ff0000')).toEqual({
+    describe("hexToHSL", ()=>{
+        it("should convert 6-digit hex to HSL correctly", ()=>{
+            expect(convertColor.hexToHSL("#ff0000")).toEqual({
                 h: 0,
                 s: 100,
                 l: 50
             });
-            expect(convertColor.hexToHSL('#00ff00')).toEqual({
+            expect(convertColor.hexToHSL("#00ff00")).toEqual({
                 h: 120,
                 s: 100,
                 l: 50
             });
-            expect(convertColor.hexToHSL('#0000ff')).toEqual({
+            expect(convertColor.hexToHSL("#0000ff")).toEqual({
                 h: 240,
                 s: 100,
                 l: 50
             });
         });
-        it('should convert 3-digit hex to HSL correctly', ()=>{
-            expect(convertColor.hexToHSL('#f00')).toEqual({
+        it("should convert 3-digit hex to HSL correctly", ()=>{
+            expect(convertColor.hexToHSL("#f00")).toEqual({
                 h: 0,
                 s: 100,
                 l: 50
             });
-            expect(convertColor.hexToHSL('#0f0')).toEqual({
+            expect(convertColor.hexToHSL("#0f0")).toEqual({
                 h: 120,
                 s: 100,
                 l: 50
             });
-            expect(convertColor.hexToHSL('#00f')).toEqual({
+            expect(convertColor.hexToHSL("#00f")).toEqual({
                 h: 240,
                 s: 100,
                 l: 50
             });
         });
-        it('should return undefined for invalid hex values', ()=>{
-            expect(convertColor.hexToHSL('#xyz')).toBeUndefined();
-            expect(convertColor.hexToHSL('#12')).toBeUndefined();
-            expect(convertColor.hexToHSL('invalid')).toBeUndefined();
+        it("should return undefined for invalid hex values", ()=>{
+            expect(convertColor.hexToHSL("#xyz")).toBeUndefined();
+            expect(convertColor.hexToHSL("#12")).toBeUndefined();
+            expect(convertColor.hexToHSL("invalid")).toBeUndefined();
         });
     });
-    describe('RGBToHSL', ()=>{
-        it('should convert RGB to HSL correctly', ()=>{
+    describe("RGBToHSL", ()=>{
+        it("should convert RGB to HSL correctly", ()=>{
             expect(convertColor.RGBToHSL(255, 0, 0)).toEqual({
                 h: 0,
                 s: 100,
@@ -93,81 +93,81 @@ describe('convertColor', ()=>{
             });
         });
     });
-    describe('hslToRgb', ()=>{
-        it('should convert HSL to RGB correctly', ()=>{
+    describe("hslToRgb", ()=>{
+        it("should convert HSL to RGB correctly", ()=>{
             expect(convertColor.hslToRgb(0, 100, 50)).toEqual({
-                r: 'ff',
-                g: '00',
-                b: '00'
+                r: "ff",
+                g: "00",
+                b: "00"
             });
             expect(convertColor.hslToRgb(120, 100, 50)).toEqual({
-                r: '00',
-                g: 'ff',
-                b: '00'
+                r: "00",
+                g: "ff",
+                b: "00"
             });
             expect(convertColor.hslToRgb(240, 100, 50)).toEqual({
-                r: '00',
-                g: '00',
-                b: 'ff'
+                r: "00",
+                g: "00",
+                b: "ff"
             });
         });
     });
 });
-describe('checkColorType', ()=>{
-    it('should identify hex colors correctly', ()=>{
-        expect(checkColorType('#fff')).toBe('hex');
-        expect(checkColorType('#ffffff')).toBe('hex');
-        expect(checkColorType('#FF0000')).toBe('hex');
+describe("checkColorType", ()=>{
+    it("should identify hex colors correctly", ()=>{
+        expect(checkColorType("#fff")).toBe("hex");
+        expect(checkColorType("#ffffff")).toBe("hex");
+        expect(checkColorType("#FF0000")).toBe("hex");
     });
-    it('should identify HSL colors correctly', ()=>{
-        expect(checkColorType('hsl(0, 100%, 50%)')).toBe('hsl');
-        expect(checkColorType('hsl(120, 60%, 70%)')).toBe('hsl');
+    it("should identify HSL colors correctly", ()=>{
+        expect(checkColorType("hsl(0, 100%, 50%)")).toBe("hsl");
+        expect(checkColorType("hsl(120, 60%, 70%)")).toBe("hsl");
     });
-    it('should identify RGB colors correctly', ()=>{
-        expect(checkColorType('rgb(255, 0, 0)')).toBe('rgb');
-        expect(checkColorType('rgb(255 0 0)')).toBe('rgb');
+    it("should identify RGB colors correctly", ()=>{
+        expect(checkColorType("rgb(255, 0, 0)")).toBe("rgb");
+        expect(checkColorType("rgb(255 0 0)")).toBe("rgb");
     });
-    it('should return null for invalid colors', ()=>{
-        expect(checkColorType('invalid')).toBeNull();
-        expect(checkColorType('rgb(300, 0, 0)')).toBeNull();
-        expect(checkColorType('hsl(400, 100%, 50%)')).toBeNull();
+    it("should return null for invalid colors", ()=>{
+        expect(checkColorType("invalid")).toBeNull();
+        expect(checkColorType("rgb(300, 0, 0)")).toBeNull();
+        expect(checkColorType("hsl(400, 100%, 50%)")).toBeNull();
     });
 });
-describe('getHSLFromString', ()=>{
-    it('should parse valid HSL strings correctly', ()=>{
-        expect(getHSLFromString('hsl(0, 100%, 50%)')).toEqual({
+describe("getHSLFromString", ()=>{
+    it("should parse valid HSL strings correctly", ()=>{
+        expect(getHSLFromString("hsl(0, 100%, 50%)")).toEqual({
             h: 0,
             s: 100,
             l: 50
         });
-        expect(getHSLFromString('hsl(120, 60%, 70%)')).toEqual({
+        expect(getHSLFromString("hsl(120, 60%, 70%)")).toEqual({
             h: 120,
             s: 60,
             l: 70
         });
     });
-    it('should return null for invalid HSL strings', ()=>{
-        expect(getHSLFromString('invalid')).toBeNull();
-        expect(getHSLFromString('rgb(255, 0, 0)')).toBeNull();
-        expect(getHSLFromString('hsl(400, 100%, 50%')).toBeNull();
+    it("should return null for invalid HSL strings", ()=>{
+        expect(getHSLFromString("invalid")).toBeNull();
+        expect(getHSLFromString("rgb(255, 0, 0)")).toBeNull();
+        expect(getHSLFromString("hsl(400, 100%, 50%")).toBeNull();
     });
 });
-describe('getStringFromHSL', ()=>{
-    it('should format HSL color object to string correctly', ()=>{
+describe("getStringFromHSL", ()=>{
+    it("should format HSL color object to string correctly", ()=>{
         expect(getStringFromHSL({
             h: 0,
             s: 100,
             l: 50
-        })).toBe('hsl(0, 100%, 50%)');
+        })).toBe("hsl(0, 100%, 50%)");
         expect(getStringFromHSL({
             h: 120,
             s: 60,
             l: 70
-        })).toBe('hsl(120, 60%, 70%)');
+        })).toBe("hsl(120, 60%, 70%)");
         expect(getStringFromHSL({
             h: 240,
             s: 50,
             l: 30
-        })).toBe('hsl(240, 50%, 30%)');
+        })).toBe("hsl(240, 50%, 30%)");
     });
 });

package/dist/src/lib/config.d.ts

@@ -1,4 +1,5 @@
 export declare const CONFIG: {
+    cronJobSecret: string;
     api: URL;
     web: URL;
     node_development: boolean;

package/dist/src/lib/config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/lib/config.ts"],"names":[],"mappings":"AAUA,eAAO,MAAM,MAAM;;;;CAGlB,CAAC"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../../src/lib/config.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,MAAM;;;;;CAIlB,CAAC"}

package/dist/src/lib/config.js

@@ -1,12 +1,14 @@
 const ENVS = {
-    api_url: process.env.NEXT_PUBLIC_API_URL,
-    web_url: process.env.NEXT_PUBLIC_WEB_URL
+    apiUrl: process.env.NEXT_PUBLIC_API_URL,
+    webUrl: process.env.NEXT_PUBLIC_WEB_URL,
+    cronConfig: process.env.CRON_SECRET || "default-cron-secret-change-in-production"
 };
 const urls = {
-    api: new URL(ENVS.api_url ?? 'http://localhost:3000'),
-    web: new URL(ENVS.web_url ?? 'http://localhost:3000')
+    api: new URL(ENVS.apiUrl ?? "http://localhost:3000"),
+    web: new URL(ENVS.webUrl ?? "http://localhost:3000")
 };
 export const CONFIG = {
-    node_development: process.env.NODE_ENV === 'development',
-    ...urls
+    node_development: process.env.NODE_ENV === "development",
+    ...urls,
+    cronJobSecret: ENVS.cronConfig
 };

package/dist/src/lib/ctrl-or-command-character.d.ts

@@ -0,0 +1,2 @@
+export declare const CtrlOrCommandCharacter: () => string;
+//# sourceMappingURL=ctrl-or-command-character.d.ts.map

package/dist/src/lib/ctrl-or-command-character.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ctrl-or-command-character.d.ts","sourceRoot":"","sources":["../../../src/lib/ctrl-or-command-character.tsx"],"names":[],"mappings":"AAEA,eAAO,MAAM,sBAAsB,cAUlC,CAAC"}

package/dist/src/lib/ctrl-or-command-character.js

@@ -0,0 +1,9 @@
+import React from "react";
+export const CtrlOrCommandCharacter = ()=>{
+    const [key, setKey] = React.useState("⌘");
+    React.useEffect(()=>{
+        const isWindows = window.navigator.userAgent.includes("Windows");
+        if (isWindows) setKey("Ctrl");
+    }, []);
+    return key;
+};

package/dist/src/lib/fetcher/cookie-from-string-to-object.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"cookie-from-string-to-object.d.ts","sourceRoot":"","sources":["../../../../src/lib/fetcher/cookie-from-string-to-object.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,GACnC,KAAK,MAAM,EAAE,KACZ;IAED,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;IAC1D,MAAM,EAAE,OAAO,CAAC;CACjB,EAcA,CAAC"}
+{"version":3,"file":"cookie-from-string-to-object.d.ts","sourceRoot":"","sources":["../../../../src/lib/fetcher/cookie-from-string-to-object.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,wBAAwB,GACnC,KAAK,MAAM,EAAE,KACZ;IACD,CAAC,GAAG,EAAE,MAAM,GAAG,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,SAAS,CAAC;IACxE,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,KAAK,GAAG,MAAM,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;IAC1D,MAAM,EAAE,OAAO,CAAC;CACjB,EAcA,CAAC"}

package/dist/src/lib/fetcher/cookie-from-string-to-object.js

@@ -1,5 +1,5 @@
 export const cookieFromStringToObject = (str)=>{
-    return str.map((item)=>Object.fromEntries(item.split('; ').map((v)=>{
+    return str.map((item)=>Object.fromEntries(item.split("; ").map((v)=>{
             const current = v.split(/=(.*)/s).map(decodeURIComponent);
             if (current.length === 1) {
                 return [