@wener/common 1.0.5 → 2.0.1

package/lib/data/parseSort.test.js

@@ -0,0 +1,188 @@
+import { describe, expect, test } from "vitest";
+import { parseSort } from "./parseSort.js";
+describe("parseSort", function () {
+    describe("basic parsing", function () {
+        test("handles empty inputs", function () {
+            expect(parseSort("")).toEqual([]);
+            expect(parseSort([])).toEqual([]);
+            expect(parseSort(null)).toEqual([]);
+            expect(parseSort(undefined)).toEqual([]);
+        });
+        test("handles simple field names", function () {
+            expect(parseSort("a")).toEqual([
+                {
+                    field: "a",
+                    order: "asc"
+                }
+            ]);
+            expect(parseSort([
+                "a"
+            ])).toEqual([
+                {
+                    field: "a",
+                    order: "asc"
+                }
+            ]);
+            expect(parseSort("a.b")).toEqual([
+                {
+                    field: "a.b",
+                    order: "asc"
+                }
+            ]);
+        });
+        test("handles prefix notation", function () {
+            expect(parseSort("-a")).toEqual([
+                {
+                    field: "a",
+                    order: "desc"
+                }
+            ]);
+            expect(parseSort("+b")).toEqual([
+                {
+                    field: "b",
+                    order: "asc"
+                }
+            ]);
+            expect(parseSort("-a,+b")).toEqual([
+                {
+                    field: "a",
+                    order: "desc"
+                },
+                {
+                    field: "b",
+                    order: "asc"
+                }
+            ]);
+        });
+    });
+    describe("explicit ordering", function () {
+        test("handles explicit order keywords", function () {
+            expect(parseSort("a asc")).toEqual([
+                {
+                    field: "a",
+                    order: "asc"
+                }
+            ]);
+            expect(parseSort("a desc")).toEqual([
+                {
+                    field: "a",
+                    order: "desc"
+                }
+            ]);
+            expect(parseSort("-a asc")).toEqual([
+                {
+                    field: "a",
+                    order: "asc"
+                }
+            ]); // explicit order overrides prefix
+        });
+    });
+    describe("nulls handling", function () {
+        test("handles nulls specification", function () {
+            expect(parseSort("a asc nulls last")).toEqual([
+                {
+                    field: "a",
+                    order: "asc",
+                    nulls: "last"
+                }
+            ]);
+            expect(parseSort("a asc nulls first")).toEqual([
+                {
+                    field: "a",
+                    order: "asc",
+                    nulls: "first"
+                }
+            ]);
+            expect(parseSort("a desc nulls last")).toEqual([
+                {
+                    field: "a",
+                    order: "desc",
+                    nulls: "last"
+                }
+            ]);
+            expect(parseSort("a nulls first")).toEqual([
+                {
+                    field: "a",
+                    order: "asc",
+                    nulls: "first"
+                }
+            ]);
+            expect(parseSort("-a nulls first")).toEqual([
+                {
+                    field: "a",
+                    order: "desc",
+                    nulls: "first"
+                }
+            ]);
+            // Alternative syntax
+            expect(parseSort("a asc last")).toEqual([
+                {
+                    field: "a",
+                    order: "asc",
+                    nulls: "last"
+                }
+            ]);
+        });
+    });
+    describe("object notation", function () {
+        test("handles object input", function () {
+            expect(parseSort([
+                {
+                    field: "a",
+                    order: "asc"
+                }
+            ])).toEqual([
+                {
+                    field: "a",
+                    order: "asc"
+                }
+            ]);
+            expect(parseSort([
+                {
+                    field: "a",
+                    order: "asc",
+                    nulls: "last"
+                }
+            ])).toEqual([
+                {
+                    field: "a",
+                    order: "asc",
+                    nulls: "last"
+                }
+            ]);
+        });
+    });
+    describe("invalid inputs", function () {
+        test("handles invalid inputs gracefully", function () {
+            expect(parseSort([
+                {
+                    order: "asc"
+                }
+            ])).toEqual([]);
+            expect(parseSort([
+                "a,,",
+                {
+                    field: "",
+                    order: "asc"
+                }
+            ])).toEqual([
+                {
+                    field: "a",
+                    order: "asc"
+                }
+            ]);
+            expect(parseSort([
+                ",,",
+                {
+                    field: "a",
+                    order: "asc"
+                }
+            ])).toEqual([
+                {
+                    field: "a",
+                    order: "asc"
+                }
+            ]);
+        });
+    });
+});

package/lib/data/resolvePagination.js

@@ -1,8 +1,9 @@
 import { maybeFunction } from "@wener/utils";
-import { clamp, mapValues, omitBy, pick } from "es-toolkit";
+import { mapValues, omitBy, pick } from "es-toolkit";
 import { maybeNumber } from "./maybeNumber.js";
-export function resolvePagination(page, options = {}) {
-    let out = omitBy(mapValues(//
+export function resolvePagination(page) {
+    var options = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {};
+    var out = omitBy(mapValues(//
     pick(page, [
         "limit",
         "offset",
@@ -10,27 +11,37 @@ export function resolvePagination(page, options = {}) {
         "pageNumber",
         "pageIndex"
     ]), // to Number
-    (v) => maybeNumber(v)), (v) => v === undefined || v === null);
-    let { pageSize } = out;
+    function (v) {
+        return maybeNumber(v);
+    }), function (v) {
+        return v === undefined || v === null;
+    });
+    var pageSize = out.pageSize;
     if (options.pageSize) {
         pageSize = maybeFunction(options.pageSize, pageSize);
     }
-    pageSize ??= 20;
-    pageSize = clamp(pageSize, 1, options.maxPageSize ?? 1000);
-    let { pageNumber = 1, pageIndex, limit, offset } = out;
+    pageSize !== null && pageSize !== void 0 ? pageSize : pageSize = resolvePagination.pageSize;
+    var _out_pageNumber = out.pageNumber, pageNumber = _out_pageNumber === void 0 ? 1 : _out_pageNumber, pageIndex = out.pageIndex;
     // page index over page number
     pageNumber = Math.max(pageNumber, 1);
-    pageIndex = Math.max(pageIndex ?? pageNumber - 1, 0);
-    limit = Math.max(1, limit ?? pageSize);
-    offset = Math.max(0, offset ?? pageSize * pageIndex);
+    pageIndex = Math.max(pageIndex !== null && pageIndex !== void 0 ? pageIndex : pageNumber - 1, 0);
+    var _out_limit = out.limit, limit = _out_limit === void 0 ? pageSize : _out_limit, _out_offset = out.offset, offset = _out_offset === void 0 ? pageSize * pageIndex : _out_offset;
+    limit = Math.max(1, limit);
+    offset = Math.max(0, offset);
+    if (options.maxLimit) {
+        limit = Math.min(limit, options.maxLimit);
+    }
+    if (options.maxOffset) {
+        offset = Math.min(offset, options.maxOffset);
+    }
     pageSize = limit;
     pageIndex = Math.floor(offset / pageSize);
     return {
-        limit,
-        offset,
-        pageSize,
+        limit: limit,
+        offset: offset,
+        pageSize: pageSize,
         pageNumber: pageIndex + 1,
-        pageIndex
+        pageIndex: pageIndex
     };
 }
-//# sourceMappingURL=resolvePagination.js.map
+resolvePagination.pageSize = 20;

package/lib/data/resolvePagination.test.js

@@ -0,0 +1,232 @@
+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 { resolvePagination } from "./resolvePagination.js";
+test(resolvePagination.name, function () {
+    var testCases = [
+        [
+            "pageSize with null pageIndex",
+            {
+                pageSize: "10",
+                pageIndex: null
+            },
+            {
+                limit: 10,
+                offset: 0,
+                pageSize: 10,
+                pageNumber: 1,
+                pageIndex: 0
+            }
+        ],
+        [
+            "pageSize with pageIndex",
+            {
+                pageSize: "10",
+                pageIndex: 1
+            },
+            {
+                limit: 10,
+                offset: 10,
+                pageSize: 10,
+                pageNumber: 2,
+                pageIndex: 1
+            }
+        ],
+        [
+            "pageSize with pageIndex 2",
+            {
+                pageSize: "10",
+                pageIndex: 2
+            },
+            {
+                limit: 10,
+                offset: 20,
+                pageSize: 10,
+                pageNumber: 3,
+                pageIndex: 2
+            }
+        ],
+        [
+            "limit with null offset",
+            {
+                limit: "10",
+                offset: null
+            },
+            {
+                limit: 10,
+                offset: 0,
+                pageSize: 10,
+                pageNumber: 1,
+                pageIndex: 0
+            }
+        ],
+        [
+            "limit with offset",
+            {
+                limit: "10",
+                offset: "20"
+            },
+            {
+                limit: 10,
+                offset: 20,
+                pageSize: 10,
+                pageNumber: 3,
+                pageIndex: 2
+            }
+        ],
+        [
+            "null limit with offset",
+            {
+                limit: null,
+                offset: "20"
+            },
+            {
+                limit: 20,
+                offset: 20,
+                pageSize: 20,
+                pageNumber: 2,
+                pageIndex: 1
+            }
+        ],
+        [
+            "empty input",
+            {},
+            {
+                limit: 20,
+                offset: 0,
+                pageSize: 20,
+                pageNumber: 1,
+                pageIndex: 0
+            }
+        ],
+        [
+            "negative values",
+            {
+                pageSize: "-5",
+                pageIndex: "-1",
+                limit: "-10",
+                offset: "-20"
+            },
+            {
+                limit: 1,
+                offset: 0,
+                pageSize: 1,
+                pageNumber: 1,
+                pageIndex: 0
+            }
+        ],
+        [
+            "custom pageNumber",
+            {
+                pageNumber: 3,
+                pageSize: 15
+            },
+            {
+                limit: 15,
+                offset: 30,
+                pageSize: 15,
+                pageNumber: 3,
+                pageIndex: 2
+            }
+        ]
+    ];
+    var _iteratorNormalCompletion = true, _didIteratorError = false, _iteratorError = undefined;
+    try {
+        for (var _iterator = testCases[Symbol.iterator](), _step; !(_iteratorNormalCompletion = (_step = _iterator.next()).done); _iteratorNormalCompletion = true) {
+            var _step_value = _sliced_to_array(_step.value, 3), description = _step_value[0], input = _step_value[1], expected = _step_value[2];
+            var result = resolvePagination(input);
+            expect(result, description).toMatchObject(expected);
+        }
+    }
+    catch (err) {
+        _didIteratorError = true;
+        _iteratorError = err;
+    }
+    finally {
+        try {
+            if (!_iteratorNormalCompletion && _iterator.return != null) {
+                _iterator.return();
+            }
+        }
+        finally {
+            if (_didIteratorError) {
+                throw _iteratorError;
+            }
+        }
+    }
+});
+test("".concat(resolvePagination.name, " with options"), function () {
+    expect(resolvePagination({
+        pageSize: "200"
+    }, {
+        maxLimit: 50
+    })).toMatchObject({
+        pageSize: 50,
+        limit: 50
+    });
+    expect(resolvePagination({}, {
+        pageSize: 30
+    })).toMatchObject({
+        pageSize: 30,
+        limit: 30
+    });
+});

package/lib/data/types.d.js

@@ -1,3 +1 @@
 export { };
-
-//# sourceMappingURL=types.d.js.map

package/lib/index.js

@@ -4,4 +4,3 @@
 /**
  * @deprecated
  */ export { resolvePagination as normalizePagination } from "./data/resolvePagination.js";
-//# sourceMappingURL=index.js.map