@wener/common 2.0.1 → 2.0.3

package/lib/dayjs/formatDuration.test.js

@@ -0,0 +1,90 @@
+function _array_like_to_array(arr, len) {
+    if (len == null || len > arr.length)
+        len = arr.length;
+    for (var i = 0, arr2 = new Array(len); i < len; i++)
+        arr2[i] = arr[i];
+    return arr2;
+}
+function _array_with_holes(arr) {
+    if (Array.isArray(arr))
+        return arr;
+}
+function _iterable_to_array_limit(arr, i) {
+    var _i = arr == null ? null : typeof Symbol !== "undefined" && arr[Symbol.iterator] || arr["@@iterator"];
+    if (_i == null)
+        return;
+    var _arr = [];
+    var _n = true;
+    var _d = false;
+    var _s, _e;
+    try {
+        for (_i = _i.call(arr); !(_n = (_s = _i.next()).done); _n = true) {
+            _arr.push(_s.value);
+            if (i && _arr.length === i)
+                break;
+        }
+    }
+    catch (err) {
+        _d = true;
+        _e = err;
+    }
+    finally {
+        try {
+            if (!_n && _i["return"] != null)
+                _i["return"]();
+        }
+        finally {
+            if (_d)
+                throw _e;
+        }
+    }
+    return _arr;
+}
+function _non_iterable_rest() {
+    throw new TypeError("Invalid attempt to destructure non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _sliced_to_array(arr, i) {
+    return _array_with_holes(arr) || _iterable_to_array_limit(arr, i) || _unsupported_iterable_to_array(arr, i) || _non_iterable_rest();
+}
+function _unsupported_iterable_to_array(o, minLen) {
+    if (!o)
+        return;
+    if (typeof o === "string")
+        return _array_like_to_array(o, minLen);
+    var n = Object.prototype.toString.call(o).slice(8, -1);
+    if (n === "Object" && o.constructor)
+        n = o.constructor.name;
+    if (n === "Map" || n === "Set")
+        return Array.from(n);
+    if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n))
+        return _array_like_to_array(o, minLen);
+}
+import { expect, test } from "vitest";
+import { formatDuration } from "./formatDuration.js";
+test("formatDuration", function () {
+    for (var _i = 0, _iter = [
+        [
+            0,
+            "0ms"
+        ],
+        [
+            1000,
+            "1s"
+        ],
+        [
+            1000 * 60,
+            "1m"
+        ],
+        [
+            1000 * 60 + 1000,
+            "1m1s"
+        ],
+        [
+            1000 * 60 + 1000 + 1,
+            "1m1s1ms"
+        ]
+    ]; _i < _iter.length; _i++) {
+        var _iter__i = _sliced_to_array(_iter[_i], 2), a = _iter__i[0], b = _iter__i[1];
+        expect(formatDuration(a)).toBe(b);
+    }
+});

package/lib/dayjs/index.js

@@ -0,0 +1,5 @@
+export { dayjs } from "./dayjs.js";
+export { parseDuration } from "./parseDuration.js";
+export { formatDuration } from "./formatDuration.js";
+export { resolveRelativeTime } from "./resolveRelativeTime.js";
+//# sourceMappingURL=index.js.map

package/lib/dayjs/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/dayjs/index.ts"],"sourcesContent":["export { dayjs } from './dayjs';\nexport { parseDuration, type MaybeDuration } from './parseDuration';\nexport { formatDuration } from './formatDuration';\n\nexport { resolveRelativeTime } from './resolveRelativeTime';\n"],"names":["dayjs","parseDuration","formatDuration","resolveRelativeTime"],"mappings":"AAAA,SAASA,KAAK,QAAQ,UAAU;AAChC,SAASC,aAAa,QAA4B,kBAAkB;AACpE,SAASC,cAAc,QAAQ,mBAAmB;AAElD,SAASC,mBAAmB,QAAQ,wBAAwB"}

package/lib/dayjs/parseDuration.js

@@ -0,0 +1,29 @@
+import { dayjs } from "./dayjs.js";
+export function parseDuration(value) {
+    if (!value && value !== 0) {
+        return;
+    }
+    let duration;
+    if (typeof value === "number") {
+        duration = dayjs.duration(value);
+    }
+    else if (typeof value === "string" && value.startsWith("P")) {
+        // PT0S
+        duration = dayjs.duration(value);
+    }
+    else if (typeof value === "object" && "value" in value) {
+        duration = dayjs.duration(value.value, value.unit);
+    }
+    else if (dayjs.isDuration(value)) {
+        duration = value;
+    }
+    else if (typeof value === "object") {
+        duration = dayjs.duration(value);
+    }
+    else {
+        console.warn(`Invalid duration value:`, value);
+        return;
+    }
+    return duration;
+}
+//# sourceMappingURL=parseDuration.js.map

package/lib/dayjs/parseDuration.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/dayjs/parseDuration.ts"],"sourcesContent":["import type { OpUnitType, UnitTypeLongPlural } from 'dayjs';\nimport type { Duration } from 'dayjs/plugin/duration';\nimport { dayjs } from './dayjs';\n\nexport type MaybeDuration =\n\t| number\n\t| string\n\t| Duration\n\t| Partial<{\n\t\t\t[unit in Exclude<UnitTypeLongPlural, 'dates'> | 'weeks']: number;\n\t  }>\n\t| {\n\t\t\tvalue: number;\n\t\t\tunit?: Exclude<OpUnitType, 'date' | 'dates'>;\n\t  }\n\t| undefined\n\t| null;\n\nexport function parseDuration(value: MaybeDuration): Duration | undefined {\n\tif (!value && value !== 0) {\n\t\treturn;\n\t}\n\tlet duration: Duration;\n\tif (typeof value === 'number') {\n\t\tduration = dayjs.duration(value);\n\t} else if (typeof value === 'string' && value.startsWith('P')) {\n\t\t// PT0S\n\t\tduration = dayjs.duration(value);\n\t} else if (typeof value === 'object' && 'value' in value) {\n\t\tduration = dayjs.duration(value.value, value.unit);\n\t} else if (dayjs.isDuration(value)) {\n\t\tduration = value;\n\t} else if (typeof value === 'object') {\n\t\tduration = dayjs.duration(value);\n\t} else {\n\t\tconsole.warn(`Invalid duration value:`, value);\n\t\treturn;\n\t}\n\treturn duration;\n}\n"],"names":["dayjs","parseDuration","value","duration","startsWith","unit","isDuration","console","warn"],"mappings":"AAEA,SAASA,KAAK,QAAQ,UAAU;AAgBhC,OAAO,SAASC,cAAcC,KAAoB;IACjD,IAAI,CAACA,SAASA,UAAU,GAAG;QAC1B;IACD;IACA,IAAIC;IACJ,IAAI,OAAOD,UAAU,UAAU;QAC9BC,WAAWH,MAAMG,QAAQ,CAACD;IAC3B,OAAO,IAAI,OAAOA,UAAU,YAAYA,MAAME,UAAU,CAAC,MAAM;QAC9D,OAAO;QACPD,WAAWH,MAAMG,QAAQ,CAACD;IAC3B,OAAO,IAAI,OAAOA,UAAU,YAAY,WAAWA,OAAO;QACzDC,WAAWH,MAAMG,QAAQ,CAACD,MAAMA,KAAK,EAAEA,MAAMG,IAAI;IAClD,OAAO,IAAIL,MAAMM,UAAU,CAACJ,QAAQ;QACnCC,WAAWD;IACZ,OAAO,IAAI,OAAOA,UAAU,UAAU;QACrCC,WAAWH,MAAMG,QAAQ,CAACD;IAC3B,OAAO;QACNK,QAAQC,IAAI,CAAC,CAAC,uBAAuB,CAAC,EAAEN;QACxC;IACD;IACA,OAAOC;AACR"}

package/lib/dayjs/parseRelativeTime.js

@@ -0,0 +1,90 @@
+import dayjs from "dayjs";
+import { checkDurationUnit, RelativeDurationUnits } from "./resolveRelativeTime.js";
+/**
+ * Parses a relative time string and returns an array of operations.
+ *
+ * @param s - The relative time string to parse (must start with "now")
+ * @returns Array of operations that can be applied sequentially
+ * @throws {Error} When the format is invalid
+ *
+ * @example
+ * ```typescript
+ * parseRelativeTime('now-1h+30m')    // [{ operator: '-', duration: dayjs.duration(1, 'h') }, { operator: '+', duration: dayjs.duration(30, 'm') }]
+ * parseRelativeTime('now+1d6h')      // [{ operator: '+', duration: dayjs.duration({ days: 1, hours: 6 }) }]
+ * parseRelativeTime('now/d')         // [{ operator: '/', unit: 'd' }]
+ * parseRelativeTime('now\\M')        // [{ operator: '\\', unit: 'M' }]
+ * parseRelativeTime('now-1M/M')      // [{ operator: '-', duration: dayjs.duration(1, 'M') }, { operator: '/', unit: 'M' }]
+ * parseRelativeTime('now+500ms')     // [{ operator: '+', duration: dayjs.duration(500, 'ms') }]
+ * ```
+ */ export function parseRelativeTime(s) {
+    if (typeof s !== "string" || !s.startsWith("now")) {
+        throw new Error(`Invalid relative time format: ${s}`);
+    }
+    const remaining = s.slice(3); // Remove 'now'
+    if (!remaining) {
+        return [];
+    }
+    const operations = [];
+    // Single regex to match all operations: <op><duration_spec> or <op><unit>
+    // Where duration_spec can be: 1h, 1d6h, 500ms, etc.
+    const operationRegex = /([+\-/\\])([^+\-/\\]+)/g;
+    let match;
+    let lastIndex = 0;
+    while ((match = operationRegex.exec(remaining)) !== null) {
+        const [, operator, operand] = match;
+        if (operator === "/" || operator === "\\") {
+            // Truncation operation - single unit only
+            checkDurationUnit(operand.trim());
+            operations.push({
+                operator: operator,
+                unit: operand.trim()
+            });
+        }
+        else {
+            // Addition or subtraction operation - parse complex duration
+            const parsedDuration = parseDurationSpec(operand.trim());
+            operations.push({
+                operator: operator,
+                duration: parsedDuration
+            });
+        }
+        lastIndex = operationRegex.lastIndex;
+    }
+    // Check if we parsed the entire remaining string
+    if (lastIndex < remaining.length) {
+        throw new Error(`Invalid relative time format: ${s}`);
+    }
+    return operations;
+}
+/**
+ * Parses a duration specification like "1h", "1d6h", "500ms" into a dayjs Duration.
+ * Supports multiple units in a single specification.
+ */ function parseDurationSpec(spec) {
+    // Match all number+unit pairs: 1d, 6h, 30m, 500ms, etc.
+    const durationRegex = /(\d+)(ms|[smhdwMQy])/g;
+    const durationObj = {};
+    let match;
+    let hasMatch = false;
+    while ((match = durationRegex.exec(spec)) !== null) {
+        const [, amountStr, unit] = match;
+        checkDurationUnit(unit);
+        const amount = parseInt(amountStr, 10);
+        // Dayjs duration supports unit strings directly
+        durationObj[unit] = (durationObj[unit] || 0) + amount;
+        hasMatch = true;
+    }
+    if (!hasMatch) {
+        // Check if there are invalid units by looking for number+invalid_unit patterns
+        const invalidUnitRegex = /\d+([a-zA-Z]+)/g;
+        let invalidMatch;
+        while ((invalidMatch = invalidUnitRegex.exec(spec)) !== null) {
+            const [, unit] = invalidMatch;
+            if (!RelativeDurationUnits.includes(unit)) {
+                throw new Error(`Invalid unit: ${unit}`);
+            }
+        }
+        throw new Error(`Invalid duration specification: ${spec}`);
+    }
+    return dayjs.duration(durationObj);
+}
+//# sourceMappingURL=parseRelativeTime.js.map

package/lib/dayjs/parseRelativeTime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/dayjs/parseRelativeTime.ts"],"sourcesContent":["import dayjs from 'dayjs';\nimport type { Duration } from 'dayjs/plugin/duration';\nimport { checkDurationUnit, RelativeDurationUnits, type RelativeDurationUnit } from './resolveRelativeTime';\n\nexport type TimeOperation =\n\t| {\n\t\t\toperator: '+' | '-';\n\t\t\tduration: Duration;\n\t  }\n\t| {\n\t\t\toperator: '/' | '\\\\';\n\t\t\tunit: RelativeDurationUnit;\n\t  };\n\n/**\n * Parses a relative time string and returns an array of operations.\n *\n * @param s - The relative time string to parse (must start with \"now\")\n * @returns Array of operations that can be applied sequentially\n * @throws {Error} When the format is invalid\n *\n * @example\n * ```typescript\n * parseRelativeTime('now-1h+30m')    // [{ operator: '-', duration: dayjs.duration(1, 'h') }, { operator: '+', duration: dayjs.duration(30, 'm') }]\n * parseRelativeTime('now+1d6h')      // [{ operator: '+', duration: dayjs.duration({ days: 1, hours: 6 }) }]\n * parseRelativeTime('now/d')         // [{ operator: '/', unit: 'd' }]\n * parseRelativeTime('now\\\\M')        // [{ operator: '\\\\', unit: 'M' }]\n * parseRelativeTime('now-1M/M')      // [{ operator: '-', duration: dayjs.duration(1, 'M') }, { operator: '/', unit: 'M' }]\n * parseRelativeTime('now+500ms')     // [{ operator: '+', duration: dayjs.duration(500, 'ms') }]\n * ```\n */\nexport function parseRelativeTime(s: string): TimeOperation[] {\n\tif (typeof s !== 'string' || !s.startsWith('now')) {\n\t\tthrow new Error(`Invalid relative time format: ${s}`);\n\t}\n\n\tconst remaining = s.slice(3); // Remove 'now'\n\n\tif (!remaining) {\n\t\treturn [];\n\t}\n\n\tconst operations: TimeOperation[] = [];\n\n\t// Single regex to match all operations: <op><duration_spec> or <op><unit>\n\t// Where duration_spec can be: 1h, 1d6h, 500ms, etc.\n\tconst operationRegex = /([+\\-/\\\\])([^+\\-/\\\\]+)/g;\n\tlet match: RegExpExecArray | null;\n\tlet lastIndex = 0;\n\n\twhile ((match = operationRegex.exec(remaining)) !== null) {\n\t\tconst [, operator, operand] = match;\n\n\t\tif (operator === '/' || operator === '\\\\') {\n\t\t\t// Truncation operation - single unit only\n\t\t\tcheckDurationUnit(operand.trim());\n\t\t\toperations.push({\n\t\t\t\toperator: operator as '/' | '\\\\',\n\t\t\t\tunit: operand.trim() as RelativeDurationUnit,\n\t\t\t});\n\t\t} else {\n\t\t\t// Addition or subtraction operation - parse complex duration\n\t\t\tconst parsedDuration = parseDurationSpec(operand.trim());\n\t\t\toperations.push({\n\t\t\t\toperator: operator as '+' | '-',\n\t\t\t\tduration: parsedDuration,\n\t\t\t});\n\t\t}\n\t\tlastIndex = operationRegex.lastIndex;\n\t}\n\n\t// Check if we parsed the entire remaining string\n\tif (lastIndex < remaining.length) {\n\t\tthrow new Error(`Invalid relative time format: ${s}`);\n\t}\n\n\treturn operations;\n}\n\n/**\n * Parses a duration specification like \"1h\", \"1d6h\", \"500ms\" into a dayjs Duration.\n * Supports multiple units in a single specification.\n */\nfunction parseDurationSpec(spec: string): Duration {\n\t// Match all number+unit pairs: 1d, 6h, 30m, 500ms, etc.\n\tconst durationRegex = /(\\d+)(ms|[smhdwMQy])/g;\n\tconst durationObj: Record<string, number> = {};\n\tlet match: RegExpExecArray | null;\n\tlet hasMatch = false;\n\n\twhile ((match = durationRegex.exec(spec)) !== null) {\n\t\tconst [, amountStr, unit] = match;\n\t\tcheckDurationUnit(unit);\n\t\tconst amount = parseInt(amountStr, 10);\n\n\t\t// Dayjs duration supports unit strings directly\n\t\tdurationObj[unit] = (durationObj[unit] || 0) + amount;\n\t\thasMatch = true;\n\t}\n\n\tif (!hasMatch) {\n\t\t// Check if there are invalid units by looking for number+invalid_unit patterns\n\t\tconst invalidUnitRegex = /\\d+([a-zA-Z]+)/g;\n\t\tlet invalidMatch: RegExpExecArray | null;\n\t\twhile ((invalidMatch = invalidUnitRegex.exec(spec)) !== null) {\n\t\t\tconst [, unit] = invalidMatch;\n\t\t\tif (!RelativeDurationUnits.includes(unit as RelativeDurationUnit)) {\n\t\t\t\tthrow new Error(`Invalid unit: ${unit}`);\n\t\t\t}\n\t\t}\n\t\tthrow new Error(`Invalid duration specification: ${spec}`);\n\t}\n\n\treturn dayjs.duration(durationObj);\n}\n"],"names":["dayjs","checkDurationUnit","RelativeDurationUnits","parseRelativeTime","s","startsWith","Error","remaining","slice","operations","operationRegex","match","lastIndex","exec","operator","operand","trim","push","unit","parsedDuration","parseDurationSpec","duration","length","spec","durationRegex","durationObj","hasMatch","amountStr","amount","parseInt","invalidUnitRegex","invalidMatch","includes"],"mappings":"AAAA,OAAOA,WAAW,QAAQ;AAE1B,SAASC,iBAAiB,EAAEC,qBAAqB,QAAmC,wBAAwB;AAY5G;;;;;;;;;;;;;;;;CAgBC,GACD,OAAO,SAASC,kBAAkBC,CAAS;IAC1C,IAAI,OAAOA,MAAM,YAAY,CAACA,EAAEC,UAAU,CAAC,QAAQ;QAClD,MAAM,IAAIC,MAAM,CAAC,8BAA8B,EAAEF,GAAG;IACrD;IAEA,MAAMG,YAAYH,EAAEI,KAAK,CAAC,IAAI,eAAe;IAE7C,IAAI,CAACD,WAAW;QACf,OAAO,EAAE;IACV;IAEA,MAAME,aAA8B,EAAE;IAEtC,0EAA0E;IAC1E,oDAAoD;IACpD,MAAMC,iBAAiB;IACvB,IAAIC;IACJ,IAAIC,YAAY;IAEhB,MAAO,AAACD,CAAAA,QAAQD,eAAeG,IAAI,CAACN,UAAS,MAAO,KAAM;QACzD,MAAM,GAAGO,UAAUC,QAAQ,GAAGJ;QAE9B,IAAIG,aAAa,OAAOA,aAAa,MAAM;YAC1C,0CAA0C;YAC1Cb,kBAAkBc,QAAQC,IAAI;YAC9BP,WAAWQ,IAAI,CAAC;gBACfH,UAAUA;gBACVI,MAAMH,QAAQC,IAAI;YACnB;QACD,OAAO;YACN,6DAA6D;YAC7D,MAAMG,iBAAiBC,kBAAkBL,QAAQC,IAAI;YACrDP,WAAWQ,IAAI,CAAC;gBACfH,UAAUA;gBACVO,UAAUF;YACX;QACD;QACAP,YAAYF,eAAeE,SAAS;IACrC;IAEA,iDAAiD;IACjD,IAAIA,YAAYL,UAAUe,MAAM,EAAE;QACjC,MAAM,IAAIhB,MAAM,CAAC,8BAA8B,EAAEF,GAAG;IACrD;IAEA,OAAOK;AACR;AAEA;;;CAGC,GACD,SAASW,kBAAkBG,IAAY;IACtC,wDAAwD;IACxD,MAAMC,gBAAgB;IACtB,MAAMC,cAAsC,CAAC;IAC7C,IAAId;IACJ,IAAIe,WAAW;IAEf,MAAO,AAACf,CAAAA,QAAQa,cAAcX,IAAI,CAACU,KAAI,MAAO,KAAM;QACnD,MAAM,GAAGI,WAAWT,KAAK,GAAGP;QAC5BV,kBAAkBiB;QAClB,MAAMU,SAASC,SAASF,WAAW;QAEnC,gDAAgD;QAChDF,WAAW,CAACP,KAAK,GAAG,AAACO,CAAAA,WAAW,CAACP,KAAK,IAAI,CAAA,IAAKU;QAC/CF,WAAW;IACZ;IAEA,IAAI,CAACA,UAAU;QACd,+EAA+E;QAC/E,MAAMI,mBAAmB;QACzB,IAAIC;QACJ,MAAO,AAACA,CAAAA,eAAeD,iBAAiBjB,IAAI,CAACU,KAAI,MAAO,KAAM;YAC7D,MAAM,GAAGL,KAAK,GAAGa;YACjB,IAAI,CAAC7B,sBAAsB8B,QAAQ,CAACd,OAA+B;gBAClE,MAAM,IAAIZ,MAAM,CAAC,cAAc,EAAEY,MAAM;YACxC;QACD;QACA,MAAM,IAAIZ,MAAM,CAAC,gCAAgC,EAAEiB,MAAM;IAC1D;IAEA,OAAOvB,MAAMqB,QAAQ,CAACI;AACvB"}

package/lib/dayjs/parseRelativeTime.test.js

@@ -0,0 +1,247 @@
+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;
+}
+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
+            })
+        });
+    });
+});

package/lib/dayjs/resolveRelativeTime.js

@@ -0,0 +1,158 @@
+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);
+/**
+ * Resolves a Grafana-style relative time string and returns the corresponding Date.
+ *
+ * @param s - The relative time string to parse (must start with "now")
+ * @param now - Optional reference date. If undefined, uses current time
+ * @returns The calculated Date based on the relative time expression
+ *
+ * @throws {Error} When the format is invalid or contains unsupported operators/units
+ *
+ * ## Syntax
+ *
+ * All expressions must start with `now` followed by optional operations:
+ *
+ * ### Operators
+ * - `-` - Subtraction (e.g., `now-1h` for one hour ago)
+ * - `+` - Addition (e.g., `now+1d` for one day from now)
+ * - `/` - Truncation to beginning of time unit (e.g., `now/d` for start of current day)
+ * - `\` - Truncation to end of time unit (e.g., `now\d` for end of current day)
+ *
+ * ### Time Units
+ * - `s` - seconds
+ * - `m` - minutes
+ * - `h` - hours
+ * - `d` - days
+ * - `w` - weeks
+ * - `M` - months
+ * - `Q` - quarters
+ * - `y` - years
+ *
+ * ### Operations
+ * Operations are processed sequentially from left to right:
+ * - **Addition/Subtraction**: `now±{count}{unit}` (e.g., `now-24h`, `now+1d`)
+ * - **Truncation to start**: `now/{unit}` (e.g., `now/d`, `now/M`)
+ * - **Truncation to end**: `now\{unit}` (e.g., `now\d`, `now\M`)
+ * - **Complex**: Multiple operations can be chained (e.g., `now-1M/M`, `now\d`, `now-1y\y`)
+ *
+ * @example
+ * ```typescript
+ * // Basic usage
+ * resolveRelativeTime('now')           // Current time
+ * resolveRelativeTime('now-1h')        // One hour ago
+ * resolveRelativeTime('now+1d')        // One day from now
+ * resolveRelativeTime('now/d')         // Start of current day
+ * resolveRelativeTime('now\\d')        // End of current day
+ *
+ * // Common patterns
+ * resolveRelativeTime('now-24h')       // Last 24 hours
+ * resolveRelativeTime('now-7d')        // Last 7 days
+ * resolveRelativeTime('now/M')         // Start of current month
+ * resolveRelativeTime('now\\M')        // End of current month
+ * resolveRelativeTime('now-1M/M')      // Start of previous month
+ * resolveRelativeTime('now-1M\\M')     // End of previous month
+ * resolveRelativeTime('now/w')         // Start of current week
+ * resolveRelativeTime('now\\w')        // End of current week
+ * resolveRelativeTime('now/y')         // Start of current year
+ * resolveRelativeTime('now\\y')        // End of current year
+ *
+ * // Complex expressions
+ * resolveRelativeTime('now/d+1d-1s')   // End of current day (alternative method)
+ * resolveRelativeTime('now\\d')        // End of current day (direct method)
+ * resolveRelativeTime('now-1w+2d-3h')  // 1 week ago, plus 2 days, minus 3 hours
+ *
+ * // With reference date
+ * const refDate = new Date('2024-03-15T14:30:45.123Z');
+ * resolveRelativeTime('now-1h', refDate);  // One hour before reference date
+ * resolveRelativeTime('now\\d', refDate);  // End of reference day
+ * ```
+ */ export function resolveRelativeTime(s, now) {
+    {
+        let out;
+        if (!s) {} else if (s instanceof Date) {
+            out = s;
+        } else if (typeof s === 'number') {
+            out = new Date(s);
+        } else if (!s.startsWith('now')) {
+            out = new Date(s);
+        }
+        if (out) {
+            if (isNaN(out.getTime())) {
+                throw new Error(`Invalid date: ${s}`);
+            }
+            return out;
+        }
+    }
+    if (typeof s !== 'string' || !s.startsWith('now')) {
+        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'
+];
+/**
+ * Type guard to validate and assert that a string is a valid time unit.
+ *
+ * @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}`);
+    }
+}
+
+//# sourceMappingURL=resolveRelativeTime.js.map

package/lib/dayjs/resolveRelativeTime.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/dayjs/resolveRelativeTime.ts"],"sourcesContent":["import dayjs from 'dayjs';\nimport duration from 'dayjs/plugin/duration';\nimport quarterOfYear from 'dayjs/plugin/quarterOfYear';\nimport weekOfYear from 'dayjs/plugin/weekOfYear';\n\ndayjs.extend(duration);\ndayjs.extend(quarterOfYear);\ndayjs.extend(weekOfYear);\n\n/**\n * Resolves a Grafana-style relative time string and returns the corresponding Date.\n *\n * @param s - The relative time string to parse (must start with \"now\")\n * @param now - Optional reference date. If undefined, uses current time\n * @returns The calculated Date based on the relative time expression\n *\n * @throws {Error} When the format is invalid or contains unsupported operators/units\n *\n * ## Syntax\n *\n * All expressions must start with `now` followed by optional operations:\n *\n * ### Operators\n * - `-` - Subtraction (e.g., `now-1h` for one hour ago)\n * - `+` - Addition (e.g., `now+1d` for one day from now)\n * - `/` - Truncation to beginning of time unit (e.g., `now/d` for start of current day)\n * - `\\` - Truncation to end of time unit (e.g., `now\\d` for end of current day)\n *\n * ### Time Units\n * - `s` - seconds\n * - `m` - minutes\n * - `h` - hours\n * - `d` - days\n * - `w` - weeks\n * - `M` - months\n * - `Q` - quarters\n * - `y` - years\n *\n * ### Operations\n * Operations are processed sequentially from left to right:\n * - **Addition/Subtraction**: `now±{count}{unit}` (e.g., `now-24h`, `now+1d`)\n * - **Truncation to start**: `now/{unit}` (e.g., `now/d`, `now/M`)\n * - **Truncation to end**: `now\\{unit}` (e.g., `now\\d`, `now\\M`)\n * - **Complex**: Multiple operations can be chained (e.g., `now-1M/M`, `now\\d`, `now-1y\\y`)\n *\n * @example\n * ```typescript\n * // Basic usage\n * resolveRelativeTime('now')           // Current time\n * resolveRelativeTime('now-1h')        // One hour ago\n * resolveRelativeTime('now+1d')        // One day from now\n * resolveRelativeTime('now/d')         // Start of current day\n * resolveRelativeTime('now\\\\d')        // End of current day\n *\n * // Common patterns\n * resolveRelativeTime('now-24h')       // Last 24 hours\n * resolveRelativeTime('now-7d')        // Last 7 days\n * resolveRelativeTime('now/M')         // Start of current month\n * resolveRelativeTime('now\\\\M')        // End of current month\n * resolveRelativeTime('now-1M/M')      // Start of previous month\n * resolveRelativeTime('now-1M\\\\M')     // End of previous month\n * resolveRelativeTime('now/w')         // Start of current week\n * resolveRelativeTime('now\\\\w')        // End of current week\n * resolveRelativeTime('now/y')         // Start of current year\n * resolveRelativeTime('now\\\\y')        // End of current year\n *\n * // Complex expressions\n * resolveRelativeTime('now/d+1d-1s')   // End of current day (alternative method)\n * resolveRelativeTime('now\\\\d')        // End of current day (direct method)\n * resolveRelativeTime('now-1w+2d-3h')  // 1 week ago, plus 2 days, minus 3 hours\n *\n * // With reference date\n * const refDate = new Date('2024-03-15T14:30:45.123Z');\n * resolveRelativeTime('now-1h', refDate);  // One hour before reference date\n * resolveRelativeTime('now\\\\d', refDate);  // End of reference day\n * ```\n */\nexport function resolveRelativeTime(s: string | Date | number, now?: Date | undefined): Date {\n\t{\n\t\tlet out: Date | undefined;\n\t\tif (!s) {\n\t\t} else if (s instanceof Date) {\n\t\t\tout = s;\n\t\t} else if (typeof s === 'number') {\n\t\t\tout = new Date(s);\n\t\t} else if (!s.startsWith('now')) {\n\t\t\tout = new Date(s);\n\t\t}\n\t\tif (out) {\n\t\t\tif (isNaN(out.getTime())) {\n\t\t\t\tthrow new Error(`Invalid date: ${s}`);\n\t\t\t}\n\t\t\treturn out;\n\t\t}\n\t}\n\n\tif (typeof s !== 'string' || !s.startsWith('now')) {\n\t\tthrow new Error(`Invalid relative time format: ${s}`);\n\t}\n\n\tlet current = dayjs(now);\n\tconst remaining = s.slice(3); // Remove 'now'\n\n\tif (!remaining) {\n\t\treturn current.toDate();\n\t}\n\n\t// Split by operators while keeping them in the result\n\tconst parts = remaining.split(/([+\\-/\\\\])/).filter((part) => part !== '');\n\n\tfor (let i = 0; i < parts.length; i += 2) {\n\t\tconst operator = parts[i];\n\t\tconst operand = parts[i + 1];\n\n\t\tif (!operator || !operand) {\n\t\t\tthrow new Error(`Invalid relative time format: ${s}`);\n\t\t}\n\n\t\tif (operator === '/') {\n\t\t\t// Truncation to start operation\n\t\t\tcheckDurationUnit(operand);\n\t\t\tcurrent = current.startOf(operand);\n\t\t} else if (operator === '\\\\') {\n\t\t\t// Truncation to end operation\n\t\t\tcheckDurationUnit(operand);\n\t\t\tcurrent = current.endOf(operand);\n\t\t} else {\n\t\t\t// Addition or subtraction operation\n\t\t\tconst match = operand.match(/^(\\d+)([smhdwMQy])$/);\n\t\t\tif (!match) {\n\t\t\t\tthrow new Error(`Invalid time operand: ${operand}`);\n\t\t\t}\n\n\t\t\tconst [, amountStr, unit] = match;\n\t\t\tcheckDurationUnit(unit);\n\t\t\tconst amount = parseInt(amountStr, 10);\n\n\t\t\tif (operator === '+') {\n\t\t\t\tcurrent = current.add(amount, unit as 'w');\n\t\t\t} else if (operator === '-') {\n\t\t\t\tcurrent = current.subtract(amount, unit as 'Q');\n\t\t\t} else {\n\t\t\t\tthrow new Error(`Invalid operator: ${operator}`);\n\t\t\t}\n\t\t}\n\t}\n\n\treturn current.toDate();\n}\n\n/** Array of all valid time units */\nexport const RelativeDurationUnits = ['ms', 's', 'm', 'h', 'd', 'w', 'M', 'Q', 'y'] as const;\n\n/** Valid time units for relative time expressions */\nexport type RelativeDurationUnit = (typeof RelativeDurationUnits)[number];\n\n/**\n * Type guard to validate and assert that a string is a valid time unit.\n *\n * @param u - The string to check\n * @throws {Error} When the unit is not supported\n */\nexport function checkDurationUnit(u: string): asserts u is RelativeDurationUnit {\n\tif (!RelativeDurationUnits.includes(u as RelativeDurationUnit)) {\n\t\tthrow new Error(`Invalid unit: ${u}`);\n\t}\n}\n"],"names":["dayjs","duration","quarterOfYear","weekOfYear","extend","resolveRelativeTime","s","now","out","Date","startsWith","isNaN","getTime","Error","current","remaining","slice","toDate","parts","split","filter","part","i","length","operator","operand","checkDurationUnit","startOf","endOf","match","amountStr","unit","amount","parseInt","add","subtract","RelativeDurationUnits","u","includes"],"mappings":"AAAA,OAAOA,WAAW,QAAQ;AAC1B,OAAOC,cAAc,wBAAwB;AAC7C,OAAOC,mBAAmB,6BAA6B;AACvD,OAAOC,gBAAgB,0BAA0B;AAEjDH,MAAMI,MAAM,CAACH;AACbD,MAAMI,MAAM,CAACF;AACbF,MAAMI,MAAM,CAACD;AAEb;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmEC,GACD,OAAO,SAASE,oBAAoBC,CAAyB,EAAEC,GAAsB;IACpF;QACC,IAAIC;QACJ,IAAI,CAACF,GAAG,CACR,OAAO,IAAIA,aAAaG,MAAM;YAC7BD,MAAMF;QACP,OAAO,IAAI,OAAOA,MAAM,UAAU;YACjCE,MAAM,IAAIC,KAAKH;QAChB,OAAO,IAAI,CAACA,EAAEI,UAAU,CAAC,QAAQ;YAChCF,MAAM,IAAIC,KAAKH;QAChB;QACA,IAAIE,KAAK;YACR,IAAIG,MAAMH,IAAII,OAAO,KAAK;gBACzB,MAAM,IAAIC,MAAM,CAAC,cAAc,EAAEP,GAAG;YACrC;YACA,OAAOE;QACR;IACD;IAEA,IAAI,OAAOF,MAAM,YAAY,CAACA,EAAEI,UAAU,CAAC,QAAQ;QAClD,MAAM,IAAIG,MAAM,CAAC,8BAA8B,EAAEP,GAAG;IACrD;IAEA,IAAIQ,UAAUd,MAAMO;IACpB,MAAMQ,YAAYT,EAAEU,KAAK,CAAC,IAAI,eAAe;IAE7C,IAAI,CAACD,WAAW;QACf,OAAOD,QAAQG,MAAM;IACtB;IAEA,sDAAsD;IACtD,MAAMC,QAAQH,UAAUI,KAAK,CAAC,cAAcC,MAAM,CAAC,CAACC,OAASA,SAAS;IAEtE,IAAK,IAAIC,IAAI,GAAGA,IAAIJ,MAAMK,MAAM,EAAED,KAAK,EAAG;QACzC,MAAME,WAAWN,KAAK,CAACI,EAAE;QACzB,MAAMG,UAAUP,KAAK,CAACI,IAAI,EAAE;QAE5B,IAAI,CAACE,YAAY,CAACC,SAAS;YAC1B,MAAM,IAAIZ,MAAM,CAAC,8BAA8B,EAAEP,GAAG;QACrD;QAEA,IAAIkB,aAAa,KAAK;YACrB,gCAAgC;YAChCE,kBAAkBD;YAClBX,UAAUA,QAAQa,OAAO,CAACF;QAC3B,OAAO,IAAID,aAAa,MAAM;YAC7B,8BAA8B;YAC9BE,kBAAkBD;YAClBX,UAAUA,QAAQc,KAAK,CAACH;QACzB,OAAO;YACN,oCAAoC;YACpC,MAAMI,QAAQJ,QAAQI,KAAK,CAAC;YAC5B,IAAI,CAACA,OAAO;gBACX,MAAM,IAAIhB,MAAM,CAAC,sBAAsB,EAAEY,SAAS;YACnD;YAEA,MAAM,GAAGK,WAAWC,KAAK,GAAGF;YAC5BH,kBAAkBK;YAClB,MAAMC,SAASC,SAASH,WAAW;YAEnC,IAAIN,aAAa,KAAK;gBACrBV,UAAUA,QAAQoB,GAAG,CAACF,QAAQD;YAC/B,OAAO,IAAIP,aAAa,KAAK;gBAC5BV,UAAUA,QAAQqB,QAAQ,CAACH,QAAQD;YACpC,OAAO;gBACN,MAAM,IAAIlB,MAAM,CAAC,kBAAkB,EAAEW,UAAU;YAChD;QACD;IACD;IAEA,OAAOV,QAAQG,MAAM;AACtB;AAEA,kCAAkC,GAClC,OAAO,MAAMmB,wBAAwB;IAAC;IAAM;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;IAAK;CAAI,CAAU;AAK7F;;;;;CAKC,GACD,OAAO,SAASV,kBAAkBW,CAAS;IAC1C,IAAI,CAACD,sBAAsBE,QAAQ,CAACD,IAA4B;QAC/D,MAAM,IAAIxB,MAAM,CAAC,cAAc,EAAEwB,GAAG;IACrC;AACD"}