@wener/common 1.0.4 → 2.0.1

package/lib/cn/UnifiedSocialCreditCode.js

@@ -1,6 +1,6 @@
 import { Mod31Checksum } from "./Mod31Checksum.js";
 (function (UnifiedSocialCreditCode) {
-    const CodeLabels = {
+    var CodeLabels = {
         1: {
             label: "\u673A\u6784\u7F16\u5236",
             children: {
@@ -64,41 +64,46 @@ import { Mod31Checksum } from "./Mod31Checksum.js";
     UnifiedSocialCreditCode.pattern = /^([159][1239]|Y1)[0-9]{6}[0-9A-HJ-NP-RTUWXY]{10}$/; // 无 I O Z S V
     UnifiedSocialCreditCode.Checksum = new Mod31Checksum();
     function parse(s) {
-        let bureau = s[0];
-        let subjectType = s[1];
-        let division = s.slice(2, 8); // 第3~8位，共6位，正确
-        let subject = s.slice(8, 17); // 第9~17位，共9位
-        let checksum = s.slice(17, 18); // 第18位，校验码
-        const labels = [];
-        let l1 = CodeLabels[bureau];
-        l1 && labels.push(l1?.label);
-        let l2 = l1?.children?.[subjectType];
-        l2 && labels.push(l2?.label);
+        var _l1_children;
+        var bureau = s[0];
+        var subjectType = s[1];
+        var division = s.slice(2, 8); // 第3~8位，共6位，正确
+        var subject = s.slice(8, 17); // 第9~17位，共9位
+        var checksum = s.slice(17, 18); // 第18位，校验码
+        var labels = [];
+        var l1 = CodeLabels[bureau];
+        l1 && labels.push(l1 === null || l1 === void 0 ? void 0 : l1.label);
+        var l2 = l1 === null || l1 === void 0 ? void 0 : (_l1_children = l1.children) === null || _l1_children === void 0 ? void 0 : _l1_children[subjectType];
+        l2 && labels.push(l2 === null || l2 === void 0 ? void 0 : l2.label);
         return {
-            bureau,
-            subjectType,
-            division,
-            subject,
-            checksum,
+            bureau: bureau,
+            subjectType: subjectType,
+            division: division,
+            subject: subject,
+            checksum: checksum,
             codes: [
                 bureau,
                 subjectType,
                 division,
                 subject
             ],
-            labels
+            labels: labels
         };
     }
     UnifiedSocialCreditCode.parse = parse;
-    function format({ bureau, subjectType, division, subject, checksum }) {
-        const base = `${bureau}${subjectType}${division}${subject}`;
-        checksum ||= UnifiedSocialCreditCode.Checksum.compute(base);
-        return `${base}${checksum}`;
+    function format(param) {
+        var bureau = param.bureau, subjectType = param.subjectType, division = param.division, subject = param.subject, checksum = param.checksum;
+        var base = "".concat(bureau).concat(subjectType).concat(division).concat(subject);
+        checksum || (checksum = UnifiedSocialCreditCode.Checksum.compute(base));
+        return "".concat(base).concat(checksum);
     }
     UnifiedSocialCreditCode.format = format;
-    function next(s, delta = 1) {
-        const sp = s.split("").map((v) => UnifiedSocialCreditCode.Checksum.numbers[v]);
-        for (let i = sp.length - 1; i >= 0; i--) {
+    function next(s) {
+        var delta = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1;
+        var sp = s.split("").map(function (v) {
+            return UnifiedSocialCreditCode.Checksum.numbers[v];
+        });
+        for (var i = sp.length - 1; i >= 0; i--) {
             if (delta > 0 && sp[i] < 30 || delta < 0 && sp[i] > 0) {
                 sp[i] += delta;
                 break;
@@ -110,9 +115,10 @@ import { Mod31Checksum } from "./Mod31Checksum.js";
                 sp[i] = 30;
             }
         }
-        return sp.map((v) => UnifiedSocialCreditCode.Checksum.chars[v]).join("");
+        return sp.map(function (v) {
+            return UnifiedSocialCreditCode.Checksum.chars[v];
+        }).join("");
     }
     UnifiedSocialCreditCode.next = next;
 })(UnifiedSocialCreditCode || (UnifiedSocialCreditCode = {}));
 export var UnifiedSocialCreditCode;
-//# sourceMappingURL=UnifiedSocialCreditCode.js.map

package/lib/cn/UnifiedSocialCreditCode.test.js

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "vitest";
+import { UnifiedSocialCreditCode } from "./UnifiedSocialCreditCode.js";
+describe("UnifiedSocialCreditCode", function () {
+    it("should parse", function () {
+        for (var _i = 0, _iter = [
+            //
+            "91330106673959654P",
+            "91330106MA2CFLDG4R"
+        ]; _i < _iter.length; _i++) {
+            var a = _iter[_i];
+            var out = UnifiedSocialCreditCode.parse(a);
+            expect(UnifiedSocialCreditCode.format(out)).toBe(a);
+            expect(out).toMatchSnapshot();
+        }
+    });
+});

package/lib/cn/formatDate.js

@@ -2,14 +2,12 @@ export function formatDate(date, format) {
     switch(format){
         case 'yyyyMMDD':
             {
-                const year = date.getFullYear();
-                const month = (date.getMonth() + 1).toString().padStart(2, '0');
-                const day = date.getDate().toString().padStart(2, '0');
-                return `${year}${month}${day}`;
+                var year = date.getFullYear();
+                var month = (date.getMonth() + 1).toString().padStart(2, '0');
+                var day = date.getDate().toString().padStart(2, '0');
+                return "".concat(year).concat(month).concat(day);
             }
         default:
-            throw new Error(`Invalid format`);
+            throw new Error("Invalid format");
     }
 }
-
-//# sourceMappingURL=formatDate.js.map

package/lib/cn/index.js

@@ -1,4 +1,3 @@
 export { ResidentIdentityCardNumber } from "./ResidentIdentityCardNumber.js";
 export { DivisionCode } from "./DivisionCode.js";
 export { UnifiedSocialCreditCode } from "./UnifiedSocialCreditCode.js";
-//# sourceMappingURL=index.js.map

package/lib/cn/parseSex.js

@@ -18,5 +18,3 @@ export function parseSex(s) {
     }
     return undefined;
 }
-
-//# sourceMappingURL=parseSex.js.map

package/lib/cn/types.d.js

@@ -4,5 +4,3 @@
  * @see https://en.wikipedia.org/wiki/Resident_Identity_Card
  * @see https://en.wikipedia.org/wiki/Foreign_Permanent_Resident_ID_Card
  */ export { };
-
-//# sourceMappingURL=types.d.js.map

package/lib/consola/createStandardConsolaReporter.js

@@ -0,0 +1,18 @@
+import { formatLogObject } from "./formatLogObject.js";
+export function createStandardConsolaReporter() {
+    var _ref = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {}, _ref_format = _ref.format, format = _ref_format === void 0 ? formatLogObject : _ref_format;
+    return {
+        log: function (o, ctx) {
+            var out = format(o, ctx);
+            var fn = console.log;
+            var level = o.level;
+            if (level < 1) {
+                fn = console.error;
+            }
+            else if (level === 1) {
+                fn = console.warn;
+            }
+            fn(out);
+        }
+    };
+}

package/lib/consola/formatLogObject.js

@@ -0,0 +1,226 @@
+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 _array_without_holes(arr) {
+    if (Array.isArray(arr)) return _array_like_to_array(arr);
+}
+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;
+}
+function _iterable_to_array(iter) {
+    if (typeof Symbol !== "undefined" && iter[Symbol.iterator] != null || iter["@@iterator"] != null) return Array.from(iter);
+}
+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 _non_iterable_spread() {
+    throw new TypeError("Invalid attempt to spread non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+function _object_spread(target) {
+    for(var i = 1; i < arguments.length; i++){
+        var source = arguments[i] != null ? arguments[i] : {};
+        var ownKeys = Object.keys(source);
+        if (typeof Object.getOwnPropertySymbols === "function") {
+            ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+            }));
+        }
+        ownKeys.forEach(function(key) {
+            _define_property(target, key, source[key]);
+        });
+    }
+    return target;
+}
+function ownKeys(object, enumerableOnly) {
+    var keys = Object.keys(object);
+    if (Object.getOwnPropertySymbols) {
+        var symbols = Object.getOwnPropertySymbols(object);
+        if (enumerableOnly) {
+            symbols = symbols.filter(function(sym) {
+                return Object.getOwnPropertyDescriptor(object, sym).enumerable;
+            });
+        }
+        keys.push.apply(keys, symbols);
+    }
+    return keys;
+}
+function _object_spread_props(target, source) {
+    source = source != null ? source : {};
+    if (Object.getOwnPropertyDescriptors) {
+        Object.defineProperties(target, Object.getOwnPropertyDescriptors(source));
+    } else {
+        ownKeys(Object(source)).forEach(function(key) {
+            Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key));
+        });
+    }
+    return target;
+}
+function _to_array(arr) {
+    return _array_with_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_rest();
+}
+function _to_consumable_array(arr) {
+    return _array_without_holes(arr) || _iterable_to_array(arr) || _unsupported_iterable_to_array(arr) || _non_iterable_spread();
+}
+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 colors from 'chalk';
+import dayjs from 'dayjs';
+import { isDevelopment } from 'std-env';
+var levelColors = {
+    trace: colors.gray,
+    debug: colors.cyan,
+    info: colors.blueBright,
+    warn: colors.yellow,
+    error: colors.red,
+    fatal: colors.bgRed.white,
+    silent: colors.white,
+    log: colors.white,
+    success: colors.green,
+    fail: colors.red,
+    ready: colors.green,
+    start: colors.cyan,
+    box: colors.white,
+    verbose: colors.green
+};
+var levelShort = {
+    trace: 'TRAC',
+    debug: 'DEBG',
+    info: 'INFO',
+    warn: 'WARN',
+    error: 'ERRO',
+    fatal: 'FATL',
+    silent: 'SLNT',
+    log: 'LOG ',
+    success: 'SUCC',
+    fail: 'FAIL',
+    ready: 'READ',
+    start: 'STRT',
+    box: 'BOX ',
+    verbose: 'VERB'
+};
+var start = Date.now();
+export function formatLogObject(o, ctx) {
+    var date = o.date, type = o.type, tag = o.tag;
+    type = type === 'log' ? 'info' : type;
+    var color = levelColors[type] || colors.white;
+    var levelText = levelShort[type] || type.toUpperCase().slice(0, 4); // Get first 4 chars, consistent uppercase
+    var line = '';
+    var out = [];
+    // Timestamp
+    if (isDevelopment) {
+        // process.hrtime.bigint()
+        var diff = (date.getTime() - start) / 1000;
+        out.push(colors.gray(diff.toFixed(3).padStart(7, ' ')));
+    } else {
+        out.push(colors.gray(dayjs(date).format('YYYY-MM-DD HH:mm:ss.SSS')));
+    }
+    // Log Level (colored)
+    // Pad to 4 characters
+    out.push(color(levelText.padEnd(4, ' ')));
+    if (tag) {
+        out.push(colors.yellow("[".concat(tag, "]"))); // Added color for tag
+    }
+    {
+        var _formatArgs_split = _to_array(formatArgs(o.args, ctx).split('\n')), message = _formatArgs_split[0], additional = _formatArgs_split.slice(1);
+        out.push(characterFormat(message));
+        line = out.join(' ');
+        if (additional.length > 0) {
+            line += characterFormat(additional.join('\n'));
+        }
+        if (type === 'trace') {
+            var _err = new Error('Trace: ' + o.message);
+            line += formatStack(_err.stack || '', _err.message);
+        }
+    }
+    // if (!message && typeof args[0] === 'string') {
+    //   message = args.shift();
+    // }
+    // if (message) {
+    //   out.push(message);
+    // }
+    // if (args.length) {
+    //   out.push(...args.map((a) => (typeof a === 'string' ? a : JSON.stringify(a)))); // Handle non-string args
+    // }
+    // todo format error
+    // https://github.com/unjs/consola/blob/main/src/reporters/fancy.ts
+    // return out.join('  '); // Increased spacing for better readability
+    return line;
+}
+function characterFormat(str) {
+    return str// highlight backticks
+    .replace(/`([^`]+)`/gm, function(_, m) {
+        return colors.cyan(m);
+    })// underline underscores
+    .replace(/\s+_([^_]+)_\s+/gm, function(_, m) {
+        return " ".concat(colors.underline(m), " ");
+    });
+}
+function parseStack(stack, message) {
+    // const cwd = process.cwd() + sep;
+    var lines = stack.split('\n').splice(message.split('\n').length).map(function(l) {
+        return l.trim().replace('file://', '');
+    });
+    return lines;
+}
+function formatStack(stack, message, opts) {
+    var indent = '  '.repeat(((opts === null || opts === void 0 ? void 0 : opts.errorLevel) || 0) + 1);
+    return "\n".concat(indent) + parseStack(stack, message).map(function(line) {
+        return '  ' + line.replace(/^at +/, function(m) {
+            return colors.gray(m);
+        }).replace(/\((.+)\)/, function(_, m) {
+            return "(".concat(colors.cyan(m), ")");
+        });
+    }).join("\n".concat(indent));
+}
+function formatArgs(args, opts) {
+    var _args = args.map(function(arg) {
+        if (arg && typeof arg.stack === 'string') {
+            return formatError(arg, opts);
+        }
+        return arg;
+    });
+    // Only supported with Node >= 10
+    // https://nodejs.org/api/util.html#util_util_inspect_object_options
+    return formatWithOptions.apply(void 0, [
+        opts
+    ].concat(_to_consumable_array(_args)));
+}
+function formatWithOptions(o) {
+    for(var _len = arguments.length, params = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++){
+        params[_key - 1] = arguments[_key];
+    }
+    // import { formatWithOptions } from 'node:util';
+    return params.join(' ');
+}
+function formatError(err, opts) {
+    var _err_message;
+    var message = (_err_message = err.message) !== null && _err_message !== void 0 ? _err_message : formatWithOptions(opts, err);
+    var stack = err.stack ? formatStack(err.stack, message, opts) : '';
+    var level = (opts === null || opts === void 0 ? void 0 : opts.errorLevel) || 0;
+    var causedPrefix = level > 0 ? "".concat('  '.repeat(level), "[cause]: ") : '';
+    var causedError = err.cause ? '\n\n' + formatError(err.cause, _object_spread_props(_object_spread({}, opts), {
+        errorLevel: level + 1
+    })) : '';
+    return causedPrefix + message + '\n' + stack + causedError;
+}

package/lib/consola/index.js

@@ -0,0 +1,2 @@
+export { formatLogObject } from "./formatLogObject.js";
+export { createStandardConsolaReporter } from "./createStandardConsolaReporter.js";

package/lib/data/formatSort.js

@@ -1,15 +1,14 @@
 export function formatSort(s) {
-    return s.map(({ field, order, nulls })=>{
+    return s.map(function(param) {
+        var field = param.field, order = param.order, nulls = param.nulls;
         if (!field) return '';
-        let r = field;
+        var r = field;
         if (order) {
-            r += ` ${order}`;
+            r += " ".concat(order);
         }
         if (nulls) {
-            r += ` nulls ${nulls}`;
+            r += " nulls ".concat(nulls);
         }
         return r;
     }).filter(Boolean);
 }
-
-//# sourceMappingURL=formatSort.js.map

package/lib/data/formatSort.test.js

@@ -0,0 +1,34 @@
+import { expect, test } from "vitest";
+import { formatSort } from "./formatSort.js";
+test("formatSort", function () {
+    expect(formatSort([
+        {
+            field: "name",
+            order: "asc"
+        }
+    ])).toEqual([
+        "name asc"
+    ]);
+    expect(formatSort([
+        {
+            field: "age",
+            order: "desc",
+            nulls: "last"
+        }
+    ])).toEqual([
+        "age desc nulls last"
+    ]);
+    expect(formatSort([
+        {
+            field: "name",
+            order: "asc"
+        },
+        {
+            field: "age",
+            order: "desc"
+        }
+    ])).toEqual([
+        "name asc",
+        "age desc"
+    ]);
+});

package/lib/data/index.js

@@ -1,4 +1,3 @@
 export { resolvePagination } from "./resolvePagination.js";
 export { parseSort } from "./parseSort.js";
 export { formatSort } from "./formatSort.js";
-//# sourceMappingURL=index.js.map

package/lib/data/maybeNumber.js

@@ -1,22 +1,28 @@
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
 export function maybeNumber(v) {
     if (v === null || v === undefined) {
         return undefined;
     }
-    switch(typeof v){
+    switch(typeof v === "undefined" ? "undefined" : _type_of(v)){
         case 'number':
             return v;
         case 'bigint':
+            if (v > BigInt(Number.MAX_SAFE_INTEGER) || v < BigInt(Number.MIN_SAFE_INTEGER)) {
+                throw new Error("bigint out of range");
+            }
             return Number(v);
         case 'string':
-            if (v === '') {
+            v = v.trim();
+            if (!v) {
                 return undefined;
             }
     }
-    const n = Number(v);
+    var n = Number(v);
     if (isNaN(n)) {
         return undefined;
     }
     return n;
 }
-
-//# sourceMappingURL=maybeNumber.js.map

package/lib/data/parseSort.js

@@ -1,4 +1,8 @@
-import { arrayOfMaybeArray } from "@wener/utils";
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+import { arrayOfMaybeArray } from '@wener/utils';
 /**
  * Parses various format of sort specifications into standardized SortRule objects
  *
@@ -17,13 +21,13 @@ import { arrayOfMaybeArray } from "@wener/utils";
     if (!order) {
         return [];
     }
-    return arrayOfMaybeArray(order).flatMap((v)=>{
+    return arrayOfMaybeArray(order).flatMap(function(v) {
         if (!v) return [];
-        if (typeof v === 'object') {
+        if ((typeof v === "undefined" ? "undefined" : _type_of(v)) === 'object') {
             if (!v.field) {
                 return [];
             }
-            const rule = {
+            var rule = {
                 field: v.field,
                 order: normalizeOrder(v.order)
             };
@@ -32,26 +36,28 @@ import { arrayOfMaybeArray } from "@wener/utils";
             }
             return rule;
         }
-        return v.split(',').map((v)=>v.trim()).filter(Boolean).map(_parse);
+        return v.split(',').map(function(v) {
+            return v.trim();
+        }).filter(Boolean).map(_parse);
     });
 }
 /**
  * Normalizes order values to 'asc' or 'desc'
  */ function normalizeOrder(order) {
-    return order?.toLowerCase() === 'asc' ? 'asc' : 'desc';
+    return (order === null || order === void 0 ? void 0 : order.toLowerCase()) === 'asc' ? 'asc' : 'desc';
 }
 /**
  * Normalizes nulls values to 'last' or 'first'
  */ function normalizeNulls(nulls) {
-    return nulls?.toLowerCase() === 'last' ? 'last' : 'first';
+    return (nulls === null || nulls === void 0 ? void 0 : nulls.toLowerCase()) === 'last' ? 'last' : 'first';
 }
 function _parse(v) {
-    const sp = v.split(/\s+/);
-    let field = '';
-    let order;
-    let nulls;
+    var sp = v.split(/\s+/);
+    var field = '';
+    var order;
+    var nulls;
     // Handle first token which should be the field name (possibly with +/- prefix)
-    const f = sp.shift();
+    var f = sp.shift();
     if (!f) return {
         field: '',
         order: 'asc'
@@ -64,7 +70,8 @@ function _parse(v) {
     }
     // Process remaining tokens
     while(sp.length > 0){
-        const token = sp.shift()?.trim()?.toLowerCase();
+        var _sp_shift_trim, _sp_shift;
+        var token = (_sp_shift = sp.shift()) === null || _sp_shift === void 0 ? void 0 : (_sp_shift_trim = _sp_shift.trim()) === null || _sp_shift_trim === void 0 ? void 0 : _sp_shift_trim.toLowerCase();
         if (!token) continue;
         switch(token){
             case 'asc':
@@ -72,7 +79,8 @@ function _parse(v) {
                 order = token;
                 break;
             case 'nulls':
-                nulls = sp.shift()?.trim()?.toLowerCase() === 'last' ? 'last' : 'first';
+                var _sp_shift_trim1, _sp_shift1;
+                nulls = ((_sp_shift1 = sp.shift()) === null || _sp_shift1 === void 0 ? void 0 : (_sp_shift_trim1 = _sp_shift1.trim()) === null || _sp_shift_trim1 === void 0 ? void 0 : _sp_shift_trim1.toLowerCase()) === 'last' ? 'last' : 'first';
                 break;
             case 'last':
             case 'first':
@@ -80,16 +88,14 @@ function _parse(v) {
                 break;
         }
     }
-    order ||= 'asc';
+    order || (order = 'asc');
     // Only include nulls if specified
     return nulls ? {
-        field,
-        order,
-        nulls
+        field: field,
+        order: order,
+        nulls: nulls
     } : {
-        field,
-        order
+        field: field,
+        order: order
     };
 }
-
-//# sourceMappingURL=parseSort.js.map