@wener/common 1.0.5 → 2.0.2

package/lib/consola/formatLogObject.js

@@ -1,7 +1,93 @@
-import colors from "chalk";
-import dayjs from "dayjs";
-import { isDevelopment } from "std-env";
-const levelColors = {
+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, { Chalk } from 'chalk';
+import dayjs from 'dayjs';
+import { isDevelopment } from 'std-env';
+var LevelColors = {
     trace: colors.gray,
     debug: colors.cyan,
     info: colors.blueBright,
@@ -17,7 +103,7 @@ const levelColors = {
     box: colors.white,
     verbose: colors.green
 };
-const levelShort = {
+var levelShort = {
     trace: 'TRAC',
     debug: 'DEBG',
     info: 'INFO',
@@ -33,37 +119,49 @@ const levelShort = {
     box: 'BOX ',
     verbose: 'VERB'
 };
-const start = Date.now();
+var start = Date.now();
+var Colors = colors;
+var NoColors = new Chalk({
+    level: 0
+});
 export function formatLogObject(o, ctx) {
-    let { date, type, tag } = o;
+    var _ctx_options_formatOptions, _ctx_options;
+    var shouldColor = Boolean((_ctx_options = ctx.options) === null || _ctx_options === void 0 ? void 0 : (_ctx_options_formatOptions = _ctx_options.formatOptions) === null || _ctx_options_formatOptions === void 0 ? void 0 : _ctx_options_formatOptions.colors);
+    var date = o.date, type = o.type, tag = o.tag;
     type = type === 'log' ? 'info' : type;
-    const color = levelColors[type] || colors.white;
-    const levelText = levelShort[type] || type.toUpperCase().slice(0, 4); // Get first 4 chars, consistent uppercase
-    let line = '';
-    let out = [];
+    var _$colors = shouldColor ? Colors : NoColors;
+    var color = LevelColors[type] || _$colors.white;
+    if (!shouldColor) {
+        color = function(v) {
+            return v;
+        };
+    }
+    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()
-        let diff = (date.getTime() - start) / 1000;
-        out.push(colors.gray(diff.toFixed(3).padStart(7, ' ')));
+        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')));
+        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(`[${tag}]`)); // Added color for tag
+        out.push(_$colors.yellow("[".concat(tag, "]"))); // Added color for tag
     }
     {
-        const [message, ...additional] = formatArgs(o.args, ctx).split('\n');
+        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') {
-            const _err = new Error('Trace: ' + o.message);
+            var _err = new Error('Trace: ' + o.message);
             line += formatStack(_err.stack || '', _err.message);
         }
     }
@@ -83,20 +181,32 @@ export function formatLogObject(o, ctx) {
 }
 function characterFormat(str) {
     return str// highlight backticks
-    .replace(/`([^`]+)`/gm, (_, m)=>colors.cyan(m))// underline underscores
-    .replace(/\s+_([^_]+)_\s+/gm, (_, m)=>` ${colors.underline(m)} `);
+    .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;
-    const lines = stack.split('\n').splice(message.split('\n').length).map((l)=>l.trim().replace('file://', ''));
+    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) {
-    const indent = '  '.repeat((opts?.errorLevel || 0) + 1);
-    return `\n${indent}` + parseStack(stack, message).map((line)=>'  ' + line.replace(/^at +/, (m)=>colors.gray(m)).replace(/\((.+)\)/, (_, m)=>`(${colors.cyan(m)})`)).join(`\n${indent}`);
+    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) {
-    const _args = args.map((arg)=>{
+    var _args = args.map(function(arg) {
         if (arg && typeof arg.stack === 'string') {
             return formatError(arg, opts);
         }
@@ -104,22 +214,25 @@ function formatArgs(args, opts) {
     });
     // Only supported with Node >= 10
     // https://nodejs.org/api/util.html#util_util_inspect_object_options
-    return formatWithOptions(opts, ..._args);
+    return formatWithOptions.apply(void 0, [
+        opts
+    ].concat(_to_consumable_array(_args)));
 }
-function formatWithOptions(o, ...params) {
+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) {
-    const message = err.message ?? formatWithOptions(opts, err);
-    const stack = err.stack ? formatStack(err.stack, message, opts) : '';
-    const level = opts?.errorLevel || 0;
-    const causedPrefix = level > 0 ? `${'  '.repeat(level)}[cause]: ` : '';
-    const causedError = err.cause ? '\n\n' + formatError(err.cause, {
-        ...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;
 }
-
-//# sourceMappingURL=formatLogObject.js.map

package/lib/consola/index.js

@@ -1,3 +1,2 @@
 export { formatLogObject } from "./formatLogObject.js";
 export { createStandardConsolaReporter } from "./createStandardConsolaReporter.js";
-//# sourceMappingURL=index.js.map

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

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"
+                }
+            ]);
+        });
+    });
+});