@wener/common 2.0.5 → 2.0.6

package/lib/dayjs/parseRelativeTime.test.js

@@ -1,247 +1,231 @@
 function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    }
-    else {
-        obj[key] = value;
-    }
-    return obj;
+	if (key in obj) {
+		Object.defineProperty(obj, key, {
+			value: value,
+			enumerable: true,
+			configurable: true,
+			writable: true,
+		});
+	} else {
+		obj[key] = value;
+	}
+	return obj;
 }
-import dayjs from "dayjs";
-import duration from "dayjs/plugin/duration";
-import { describe, expect, it } from "vitest";
-import { parseRelativeTime } from "./parseRelativeTime.js";
+
+import dayjs from 'dayjs';
+import duration from 'dayjs/plugin/duration';
+import { describe, expect, it } from 'vitest';
+import { parseRelativeTime } from './parseRelativeTime.js';
+
 dayjs.extend(duration);
-describe("parseRelativeTime", function () {
-    it("should return empty array for \"now\"", function () {
-        var result = parseRelativeTime("now");
-        expect(result).toEqual([]);
-    });
-    it("should parse simple addition operations", function () {
-        var result = parseRelativeTime("now+1h");
-        expect(result).toHaveLength(1);
-        expect(result[0]).toEqual({
-            operator: "+",
-            duration: dayjs.duration({
-                hours: 1
-            })
-        });
-    });
-    it("should parse simple subtraction operations", function () {
-        var result = parseRelativeTime("now-30m");
-        expect(result).toHaveLength(1);
-        expect(result[0]).toEqual({
-            operator: "-",
-            duration: dayjs.duration({
-                minutes: 30
-            })
-        });
-    });
-    it("should parse milliseconds", function () {
-        var result = parseRelativeTime("now+500ms");
-        expect(result).toHaveLength(1);
-        expect(result[0]).toEqual({
-            operator: "+",
-            duration: dayjs.duration({
-                milliseconds: 500
-            })
-        });
-    });
-    it("should parse complex duration combinations", function () {
-        var result = parseRelativeTime("now+1d6h30m");
-        expect(result).toHaveLength(1);
-        expect(result[0]).toEqual({
-            operator: "+",
-            duration: dayjs.duration({
-                days: 1,
-                hours: 6,
-                minutes: 30
-            })
-        });
-    });
-    it("should parse truncation operations", function () {
-        var result = parseRelativeTime("now/d");
-        expect(result).toHaveLength(1);
-        expect(result[0]).toEqual({
-            operator: "/",
-            unit: "d"
-        });
-        var result2 = parseRelativeTime("now\\M");
-        expect(result2).toHaveLength(1);
-        expect(result2[0]).toEqual({
-            operator: "\\",
-            unit: "M"
-        });
-    });
-    it("should parse multiple operations", function () {
-        var result = parseRelativeTime("now-1h+30m");
-        expect(result).toHaveLength(2);
-        expect(result[0]).toEqual({
-            operator: "-",
-            duration: dayjs.duration({
-                hours: 1
-            })
-        });
-        expect(result[1]).toEqual({
-            operator: "+",
-            duration: dayjs.duration({
-                minutes: 30
-            })
-        });
-    });
-    it("should parse mixed arithmetic and truncation operations", function () {
-        var result = parseRelativeTime("now-1M/M");
-        expect(result).toHaveLength(2);
-        expect(result[0]).toEqual({
-            operator: "-",
-            duration: dayjs.duration({
-                months: 1
-            })
-        });
-        expect(result[1]).toEqual({
-            operator: "/",
-            unit: "M"
-        });
-    });
-    it("should handle all supported units", function () {
-        var units = [
-            "ms",
-            "s",
-            "m",
-            "h",
-            "d",
-            "w",
-            "M",
-            "Q",
-            "y"
-        ];
-        var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
-        try {
-            for (var _iterator = units[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
-                var unit = _step.value;
-                var result = parseRelativeTime("now+1".concat(unit));
-                expect(result).toHaveLength(1);
-                expect(result[0]).toEqual({
-                    operator: "+",
-                    duration: dayjs.duration(_define_property({}, unit, 1))
-                });
-            }
-        }
-        catch (err) {
-            _didIteratorError = true;
-            _iteratorError = err;
-        }
-        finally {
-            try {
-                if (!_iteratorNormalCompletion && _iterator.return != null) {
-                    _iterator.return();
-                }
-            }
-            finally {
-                if (_didIteratorError) {
-                    throw _iteratorError;
-                }
-            }
-        }
-    });
-    it("should handle complex multi-unit expressions", function () {
-        var result = parseRelativeTime("now+1y2M3w4d5h6m7s8ms");
-        expect(result).toHaveLength(1);
-        expect(result[0]).toEqual({
-            operator: "+",
-            duration: dayjs.duration({
-                years: 1,
-                months: 2,
-                weeks: 3,
-                days: 4,
-                hours: 5,
-                minutes: 6,
-                seconds: 7,
-                milliseconds: 8
-            })
-        });
-    });
-    it("should handle same unit multiple times (should sum)", function () {
-        var result = parseRelativeTime("now+1h2h3h");
-        expect(result).toHaveLength(1);
-        expect(result[0]).toEqual({
-            operator: "+",
-            duration: dayjs.duration({
-                hours: 6
-            })
-        });
-    });
-    it("should throw error for invalid format", function () {
-        expect(function () {
-            return parseRelativeTime("invalid");
-        }).toThrow("Invalid relative time format");
-        expect(function () {
-            return parseRelativeTime("now+");
-        }).toThrow("Invalid relative time format");
-        expect(function () {
-            return parseRelativeTime("now+abc");
-        }).toThrow("Invalid duration specification");
-    });
-    it("should throw error for invalid units in truncation", function () {
-        expect(function () {
-            return parseRelativeTime("now/invalid");
-        }).toThrow("Invalid unit");
-    });
-    it("should throw error for invalid units in duration", function () {
-        expect(function () {
-            return parseRelativeTime("now+1invalid");
-        }).toThrow("Invalid unit");
-    });
-    it("should handle whitespace correctly", function () {
-        // The regex should handle operands without extra whitespace issues
-        var result = parseRelativeTime("now+1h30m");
-        expect(result).toHaveLength(1);
-        expect(result[0]).toEqual({
-            operator: "+",
-            duration: dayjs.duration({
-                hours: 1,
-                minutes: 30
-            })
-        });
-    });
-    it("should parse real-world examples", function () {
-        // Last 24 hours
-        var result1 = parseRelativeTime("now-24h");
-        expect(result1).toHaveLength(1);
-        expect(result1[0]).toEqual({
-            operator: "-",
-            duration: dayjs.duration({
-                hours: 24
-            })
-        });
-        // Start of previous month
-        var result2 = parseRelativeTime("now-1M/M");
-        expect(result2).toHaveLength(2);
-        expect(result2[0]).toEqual({
-            operator: "-",
-            duration: dayjs.duration({
-                months: 1
-            })
-        });
-        expect(result2[1]).toEqual({
-            operator: "/",
-            unit: "M"
-        });
-        // Complex time ago
-        var result3 = parseRelativeTime("now-1w2d3h");
-        expect(result3).toHaveLength(1);
-        expect(result3[0]).toEqual({
-            operator: "-",
-            duration: dayjs.duration({
-                weeks: 1,
-                days: 2,
-                hours: 3
-            })
-        });
-    });
+describe('parseRelativeTime', () => {
+	it('should return empty array for "now"', () => {
+		var result = parseRelativeTime('now');
+		expect(result).toEqual([]);
+	});
+	it('should parse simple addition operations', () => {
+		var result = parseRelativeTime('now+1h');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({
+				hours: 1,
+			}),
+		});
+	});
+	it('should parse simple subtraction operations', () => {
+		var result = parseRelativeTime('now-30m');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({
+				minutes: 30,
+			}),
+		});
+	});
+	it('should parse milliseconds', () => {
+		var result = parseRelativeTime('now+500ms');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({
+				milliseconds: 500,
+			}),
+		});
+	});
+	it('should parse complex duration combinations', () => {
+		var result = parseRelativeTime('now+1d6h30m');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({
+				days: 1,
+				hours: 6,
+				minutes: 30,
+			}),
+		});
+	});
+	it('should parse truncation operations', () => {
+		var result = parseRelativeTime('now/d');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '/',
+			unit: 'd',
+		});
+		var result2 = parseRelativeTime('now\\M');
+		expect(result2).toHaveLength(1);
+		expect(result2[0]).toEqual({
+			operator: '\\',
+			unit: 'M',
+		});
+	});
+	it('should parse multiple operations', () => {
+		var result = parseRelativeTime('now-1h+30m');
+		expect(result).toHaveLength(2);
+		expect(result[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({
+				hours: 1,
+			}),
+		});
+		expect(result[1]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({
+				minutes: 30,
+			}),
+		});
+	});
+	it('should parse mixed arithmetic and truncation operations', () => {
+		var result = parseRelativeTime('now-1M/M');
+		expect(result).toHaveLength(2);
+		expect(result[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({
+				months: 1,
+			}),
+		});
+		expect(result[1]).toEqual({
+			operator: '/',
+			unit: 'M',
+		});
+	});
+	it('should handle all supported units', () => {
+		var units = ['ms', 's', 'm', 'h', 'd', 'w', 'M', 'Q', 'y'];
+		var _iteratorNormalCompletion = true,
+			_didIteratorError = false,
+			_iteratorError;
+		try {
+			for (
+				var _iterator = units[Symbol.iterator](), _step;
+				!(_iteratorNormalCompletion = (_step = _iterator.next()).done);
+				_iteratorNormalCompletion = true
+			) {
+				var unit = _step.value;
+				var result = parseRelativeTime('now+1'.concat(unit));
+				expect(result).toHaveLength(1);
+				expect(result[0]).toEqual({
+					operator: '+',
+					duration: dayjs.duration(_define_property({}, unit, 1)),
+				});
+			}
+		} catch (err) {
+			_didIteratorError = true;
+			_iteratorError = err;
+		} finally {
+			try {
+				if (!_iteratorNormalCompletion && _iterator.return != null) {
+					_iterator.return();
+				}
+			} finally {
+				if (_didIteratorError) {
+					throw _iteratorError;
+				}
+			}
+		}
+	});
+	it('should handle complex multi-unit expressions', () => {
+		var result = parseRelativeTime('now+1y2M3w4d5h6m7s8ms');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({
+				years: 1,
+				months: 2,
+				weeks: 3,
+				days: 4,
+				hours: 5,
+				minutes: 6,
+				seconds: 7,
+				milliseconds: 8,
+			}),
+		});
+	});
+	it('should handle same unit multiple times (should sum)', () => {
+		var result = parseRelativeTime('now+1h2h3h');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({
+				hours: 6,
+			}),
+		});
+	});
+	it('should throw error for invalid format', () => {
+		expect(() => parseRelativeTime('invalid')).toThrow('Invalid relative time format');
+		expect(() => parseRelativeTime('now+')).toThrow('Invalid relative time format');
+		expect(() => parseRelativeTime('now+abc')).toThrow('Invalid duration specification');
+	});
+	it('should throw error for invalid units in truncation', () => {
+		expect(() => parseRelativeTime('now/invalid')).toThrow('Invalid unit');
+	});
+	it('should throw error for invalid units in duration', () => {
+		expect(() => parseRelativeTime('now+1invalid')).toThrow('Invalid unit');
+	});
+	it('should handle whitespace correctly', () => {
+		// The regex should handle operands without extra whitespace issues
+		var result = parseRelativeTime('now+1h30m');
+		expect(result).toHaveLength(1);
+		expect(result[0]).toEqual({
+			operator: '+',
+			duration: dayjs.duration({
+				hours: 1,
+				minutes: 30,
+			}),
+		});
+	});
+	it('should parse real-world examples', () => {
+		// Last 24 hours
+		var result1 = parseRelativeTime('now-24h');
+		expect(result1).toHaveLength(1);
+		expect(result1[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({
+				hours: 24,
+			}),
+		});
+		// Start of previous month
+		var result2 = parseRelativeTime('now-1M/M');
+		expect(result2).toHaveLength(2);
+		expect(result2[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({
+				months: 1,
+			}),
+		});
+		expect(result2[1]).toEqual({
+			operator: '/',
+			unit: 'M',
+		});
+		// Complex time ago
+		var result3 = parseRelativeTime('now-1w2d3h');
+		expect(result3).toHaveLength(1);
+		expect(result3[0]).toEqual({
+			operator: '-',
+			duration: dayjs.duration({
+				weeks: 1,
+				days: 2,
+				hours: 3,
+			}),
+		});
+	});
 });

package/lib/dayjs/resolveRelativeTime.js

@@ -1,77 +1,78 @@
-import { parseDate } from "@wener/utils";
-import dayjs from "dayjs";
-import duration from "dayjs/plugin/duration";
-import quarterOfYear from "dayjs/plugin/quarterOfYear";
-import weekOfYear from "dayjs/plugin/weekOfYear";
+import { parseDate } from '@wener/utils';
+import dayjs from 'dayjs';
+import duration from 'dayjs/plugin/duration';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import weekOfYear from 'dayjs/plugin/weekOfYear';
+
 dayjs.extend(duration);
 dayjs.extend(quarterOfYear);
 dayjs.extend(weekOfYear);
 export function resolveRelativeTime(s, now) {
-    {
-        let out = parseDate(s);
-        if (out) {
-            return out;
-        }
-        if (s == null) {
-            return;
-        }
-    }
-    if (typeof s === 'string' && s.startsWith('now')) {
-    // valid
-    } else {
-        throw new Error(`Invalid relative time format: ${s}`);
-    }
-    let current = dayjs(now);
-    const remaining = s.slice(3); // Remove 'now'
-    if (!remaining) {
-        return current.toDate();
-    }
-    // Split by operators while keeping them in the result
-    const parts = remaining.split(/([+\-/\\])/).filter((part)=>part !== '');
-    for(let i = 0; i < parts.length; i += 2){
-        const operator = parts[i];
-        const operand = parts[i + 1];
-        if (!operator || !operand) {
-            throw new Error(`Invalid relative time format: ${s}`);
-        }
-        if (operator === '/') {
-            // Truncation to start operation
-            checkDurationUnit(operand);
-            current = current.startOf(operand);
-        } else if (operator === '\\') {
-            // Truncation to end operation
-            checkDurationUnit(operand);
-            current = current.endOf(operand);
-        } else {
-            // Addition or subtraction operation
-            const match = operand.match(/^(\d+)([smhdwMQy])$/);
-            if (!match) {
-                throw new Error(`Invalid time operand: ${operand}`);
-            }
-            const [, amountStr, unit] = match;
-            checkDurationUnit(unit);
-            const amount = parseInt(amountStr, 10);
-            if (operator === '+') {
-                current = current.add(amount, unit);
-            } else if (operator === '-') {
-                current = current.subtract(amount, unit);
-            } else {
-                throw new Error(`Invalid operator: ${operator}`);
-            }
-        }
-    }
-    return current.toDate();
+	{
+		let out = parseDate(s);
+		if (out) {
+			return out;
+		}
+		if (s == null) {
+			return;
+		}
+	}
+	if (typeof s === 'string' && s.startsWith('now')) {
+		// valid
+	} else {
+		throw new Error(`Invalid relative time format: ${s}`);
+	}
+	let current = dayjs(now);
+	const remaining = s.slice(3); // Remove 'now'
+	if (!remaining) {
+		return current.toDate();
+	}
+	// Split by operators while keeping them in the result
+	const parts = remaining.split(/([+\-/\\])/).filter((part) => part !== '');
+	for (let i = 0; i < parts.length; i += 2) {
+		const operator = parts[i];
+		const operand = parts[i + 1];
+		if (!operator || !operand) {
+			throw new Error(`Invalid relative time format: ${s}`);
+		}
+		if (operator === '/') {
+			// Truncation to start operation
+			checkDurationUnit(operand);
+			current = current.startOf(operand);
+		} else if (operator === '\\') {
+			// Truncation to end operation
+			checkDurationUnit(operand);
+			current = current.endOf(operand);
+		} else {
+			// Addition or subtraction operation
+			const match = operand.match(/^(\d+)([smhdwMQy])$/);
+			if (!match) {
+				throw new Error(`Invalid time operand: ${operand}`);
+			}
+			const [, amountStr, unit] = match;
+			checkDurationUnit(unit);
+			const amount = parseInt(amountStr, 10);
+			if (operator === '+') {
+				current = current.add(amount, unit);
+			} else if (operator === '-') {
+				current = current.subtract(amount, unit);
+			} else {
+				throw new Error(`Invalid operator: ${operator}`);
+			}
+		}
+	}
+	return current.toDate();
 }
 /** Array of all valid time units */ export const RelativeDurationUnits = [
-    'ms',
-    's',
-    'm',
-    'h',
-    'd',
-    'w',
-    'M',
-    'Q',
-    'y'
+	'ms',
+	's',
+	'm',
+	'h',
+	'd',
+	'w',
+	'M',
+	'Q',
+	'y',
 ];
 /**
  * Type guard to validate and assert that a string is a valid time unit.
@@ -79,9 +80,9 @@ export function resolveRelativeTime(s, now) {
  * @param u - The string to check
  * @throws {Error} When the unit is not supported
  */ export function checkDurationUnit(u) {
-    if (!RelativeDurationUnits.includes(u)) {
-        throw new Error(`Invalid unit: ${u}`);
-    }
+	if (!RelativeDurationUnits.includes(u)) {
+		throw new Error(`Invalid unit: ${u}`);
+	}
 }
 
-//# sourceMappingURL=resolveRelativeTime.js.map
+//# sourceMappingURL=resolveRelativeTime.js.map