@wener/common 1.0.5 → 2.0.2

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/dayjs/dayjs.js

@@ -0,0 +1,38 @@
+import dayjs from 'dayjs';
+import advancedFormat from 'dayjs/plugin/advancedFormat';
+import dayOfYear from 'dayjs/plugin/dayOfYear';
+import duration from 'dayjs/plugin/duration';
+import isBetween from 'dayjs/plugin/isBetween';
+import isSameOrAfter from 'dayjs/plugin/isSameOrAfter';
+import isSameOrBefore from 'dayjs/plugin/isSameOrBefore';
+import isToday from 'dayjs/plugin/isToday';
+import isTomorrow from 'dayjs/plugin/isTomorrow';
+import isYesterday from 'dayjs/plugin/isYesterday';
+import localeData from 'dayjs/plugin/localeData';
+import objectSupport from 'dayjs/plugin/objectSupport';
+import quarterOfYear from 'dayjs/plugin/quarterOfYear';
+import relativeTime from 'dayjs/plugin/relativeTime';
+import timezone from 'dayjs/plugin/timezone';
+import toObject from 'dayjs/plugin/toObject';
+import utc from 'dayjs/plugin/utc';
+import 'dayjs/locale/zh-cn';
+import 'dayjs/locale/zh';
+dayjs.extend(advancedFormat);
+dayjs.extend(dayOfYear);
+dayjs.extend(duration);
+dayjs.extend(isBetween);
+dayjs.extend(isSameOrAfter);
+dayjs.extend(isSameOrBefore);
+dayjs.extend(isToday);
+dayjs.extend(isTomorrow);
+dayjs.extend(isYesterday);
+dayjs.extend(localeData);
+dayjs.extend(objectSupport);
+dayjs.extend(quarterOfYear);
+dayjs.extend(relativeTime);
+dayjs.extend(timezone);
+dayjs.extend(toObject);
+dayjs.extend(utc);
+dayjs.locale('zh-cn');
+dayjs.tz.setDefault('Asia/Shanghai');
+export { dayjs };

package/lib/dayjs/formatDuration.js

@@ -0,0 +1,58 @@
+import { parseDuration } from "./parseDuration.js";
+export function formatDuration(value, o) {
+    var v = parseDuration(value);
+    if (v === undefined || v === null) {
+        return;
+    }
+    var _ref = o || {}, format = _ref.format, humanize = _ref.humanize, iso = _ref.iso;
+    // Use local variables instead of modifying o directly
+    switch (format) {
+        case "human":
+        case "humanize":
+            humanize = true;
+            format = undefined;
+            break;
+        case "iso":
+            iso = true;
+            format = undefined;
+            break;
+        case "auto":
+            format = undefined;
+            break;
+    }
+    if (humanize) {
+        return v.humanize();
+    }
+    if (iso) {
+        return v.toISOString();
+    }
+    if (format) {
+        return v.format(format);
+    }
+    // auto format
+    // 1h2m3s
+    if (v.asDays() > 1) {
+        var s = v.toISOString();
+        return s.replace("P", "").replace("T", "").toLowerCase();
+    }
+    {
+        var parts = [];
+        var h = v.hours();
+        var m = v.minutes();
+        var s1 = v.seconds();
+        var ms = v.milliseconds();
+        if (h > 0) {
+            parts.push("".concat(h, "h"));
+        }
+        if (m > 0) {
+            parts.push("".concat(m, "m"));
+        }
+        if (s1 > 0) {
+            parts.push("".concat(s1, "s"));
+        }
+        if (ms > 0 || h === 0 && m === 0 && s1 === 0) {
+            parts.push("".concat(ms, "ms"));
+        }
+        return parts.join("");
+    }
+}

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,3 @@
+export { dayjs } from "./dayjs.js";
+export { parseDuration } from "./parseDuration.js";
+export { formatDuration } from "./formatDuration.js";

package/lib/dayjs/parseDuration.js

@@ -0,0 +1,32 @@
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { dayjs } from "./dayjs.js";
+export function parseDuration(value) {
+    if (!value && value !== 0) {
+        return;
+    }
+    var 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 === "undefined" ? "undefined" : _type_of(value)) === "object" && "value" in value) {
+        duration = dayjs.duration(value.value, value.unit);
+    }
+    else if (dayjs.isDuration(value)) {
+        duration = value;
+    }
+    else if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === "object") {
+        duration = dayjs.duration(value);
+    }
+    else {
+        console.warn("Invalid duration value:", value);
+        return;
+    }
+    return duration;
+}

package/lib/decimal/index.js

@@ -0,0 +1 @@
+export { parseDecimal } from "./parseDecimal.js";

package/lib/decimal/parseDecimal.js

@@ -0,0 +1,13 @@
+import Decimal from 'decimal.js';
+export function parseDecimal(v) {
+    switch(v){
+        case '':
+        case undefined:
+        case null:
+            return undefined;
+    }
+    if (Decimal.isDecimal(v)) {
+        return v;
+    }
+    return new Decimal(v);
+}

package/lib/foundation/schema/SexType.js

@@ -0,0 +1,14 @@
+import { z } from 'zod/v4';
+// Sex 指的是生理性别/生物性别，通常由出生时的生物特征决定
+export var SexType = Object.freeze({
+    __proto__: null,
+    Male: 'Male',
+    Female: 'Female'
+});
+export var SexTypeSchema = z.union([
+    //
+    z.literal(SexType.Male).describe('男'),
+    z.literal(SexType.Female).describe('女')
+]).describe('性别').meta({
+    title: 'SexType'
+});

package/lib/foundation/schema/index.js

@@ -0,0 +1 @@
+export { SexType, SexTypeSchema } from "./SexType.js";

package/lib/foundation/schema/parseSexType.js

@@ -0,0 +1,18 @@
+import { SexType } from "./SexType.js";
+export function parseSexType(s) {
+    if (!s)
+        return undefined;
+    switch (s.toLowerCase()) {
+        case "\u2642":
+        case "\u7537":
+        case "male":
+        case "man":
+            return SexType.Male;
+        case "\u2640":
+        case "\u5973":
+        case "female":
+        case "woman":
+            return SexType.Female;
+    }
+    return undefined;
+}

package/lib/foundation/schema/types.js

@@ -0,0 +1,5 @@
+import z from 'zod/v4';
+export var CoordinatesSchema = z.object({
+    latitude: z.number().min(-90).max(90).describe('纬度'),
+    longitude: z.number().min(-180).max(180).describe('经度')
+}).describe('坐标信息');

package/lib/index.js

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