@wener/common 2.0.3 → 2.0.6

package/lib/data/parseSort.js

@@ -1,4 +1,4 @@
-import { arrayOfMaybeArray } from "@wener/utils";
+import { arrayOfMaybeArray } from '@wener/utils';
 /**
  * Parses various format of sort specifications into standardized SortRule objects
  *
@@ -14,82 +14,89 @@ import { arrayOfMaybeArray } from "@wener/utils";
  * parseSort('name asc nulls last')     // [{ field: 'name', order: 'asc', nulls: 'last' }]
  * parseSort([{ field: 'name' }])       // [{ field: 'name', order: 'asc' }]
  */ export function parseSort(order) {
-    if (!order) {
-        return [];
-    }
-    return arrayOfMaybeArray(order).flatMap((v)=>{
-        if (!v) return [];
-        if (typeof v === 'object') {
-            if (!v.field) {
-                return [];
-            }
-            const rule = {
-                field: v.field,
-                order: normalizeOrder(v.order)
-            };
-            if (v.nulls) {
-                rule.nulls = normalizeNulls(v.nulls);
-            }
-            return rule;
-        }
-        return v.split(',').map((v)=>v.trim()).filter(Boolean).map(_parse);
-    });
+	if (!order) {
+		return [];
+	}
+	return arrayOfMaybeArray(order).flatMap((v) => {
+		if (!v) return [];
+		if (typeof v === 'object') {
+			if (!v.field) {
+				return [];
+			}
+			const rule = {
+				field: v.field,
+				order: normalizeOrder(v.order),
+			};
+			if (v.nulls) {
+				rule.nulls = normalizeNulls(v.nulls);
+			}
+			return rule;
+		}
+		return v
+			.split(',')
+			.map((v) => v.trim())
+			.filter(Boolean)
+			.map(_parse);
+	});
 }
 /**
  * Normalizes order values to 'asc' or 'desc'
  */ function normalizeOrder(order) {
-    return order?.toLowerCase() === 'asc' ? 'asc' : 'desc';
+	return order?.toLowerCase() === 'asc' ? 'asc' : 'desc';
 }
 /**
  * Normalizes nulls values to 'last' or 'first'
  */ function normalizeNulls(nulls) {
-    return nulls?.toLowerCase() === 'last' ? 'last' : 'first';
+	return nulls?.toLowerCase() === 'last' ? 'last' : 'first';
 }
 function _parse(v) {
-    const sp = v.split(/\s+/);
-    let field = '';
-    let order;
-    let nulls;
-    // Handle first token which should be the field name (possibly with +/- prefix)
-    const f = sp.shift();
-    if (!f) return {
-        field: '',
-        order: 'asc'
-    }; // Defensive programming
-    if (f.startsWith('-') || f.startsWith('+')) {
-        field = f.slice(1).trim();
-        order = f.startsWith('-') ? 'desc' : 'asc';
-    } else {
-        field = f.trim();
-    }
-    // Process remaining tokens
-    while(sp.length > 0){
-        const token = sp.shift()?.trim()?.toLowerCase();
-        if (!token) continue;
-        switch(token){
-            case 'asc':
-            case 'desc':
-                order = token;
-                break;
-            case 'nulls':
-                nulls = sp.shift()?.trim()?.toLowerCase() === 'last' ? 'last' : 'first';
-                break;
-            case 'last':
-            case 'first':
-                nulls = token;
-                break;
-        }
-    }
-    order ||= 'asc';
-    // Only include nulls if specified
-    return nulls ? {
-        field,
-        order,
-        nulls
-    } : {
-        field,
-        order
-    };
+	const sp = v.split(/\s+/);
+	let field = '';
+	let order;
+	let nulls;
+	// Handle first token which should be the field name (possibly with +/- prefix)
+	const f = sp.shift();
+	if (!f)
+		return {
+			field: '',
+			order: 'asc',
+		}; // Defensive programming
+	if (f.startsWith('-') || f.startsWith('+')) {
+		field = f.slice(1).trim();
+		order = f.startsWith('-') ? 'desc' : 'asc';
+	} else {
+		field = f.trim();
+	}
+	// Process remaining tokens
+	while (sp.length > 0) {
+		const token = sp.shift()?.trim()?.toLowerCase();
+		if (!token) continue;
+		switch (token) {
+			case 'asc':
+			case 'desc':
+				order = token;
+				break;
+			case 'nulls':
+				nulls = sp.shift()?.trim()?.toLowerCase() === 'last' ? 'last' : 'first';
+				break;
+			case 'last':
+			case 'first':
+				nulls = token;
+				break;
+		}
+	}
+	order ||= 'asc';
+	// Only include nulls if specified
+	return nulls
+		? {
+				field,
+				order,
+				nulls,
+			}
+		: {
+				field,
+				order,
+			};
 }
 
-//# sourceMappingURL=parseSort.js.map
+//# sourceMappingURL=parseSort.js.map

package/lib/data/parseSort.test.js

@@ -1,188 +1,197 @@
-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"
-                }
-            ]);
-        });
-    });
+import { describe, expect, test } from 'vitest';
+import { parseSort } from './parseSort.js';
+
+describe('parseSort', () => {
+	describe('basic parsing', () => {
+		test('handles empty inputs', () => {
+			expect(parseSort('')).toEqual([]);
+			expect(parseSort([])).toEqual([]);
+			expect(parseSort(null)).toEqual([]);
+			expect(parseSort(undefined)).toEqual([]);
+		});
+		test('handles simple field names', () => {
+			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', () => {
+			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', () => {
+		test('handles explicit order keywords', () => {
+			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', () => {
+		test('handles nulls specification', () => {
+			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', () => {
+		test('handles object input', () => {
+			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', () => {
+		test('handles invalid inputs gracefully', () => {
+			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,43 +1,42 @@
-import { maybeFunction } from "@wener/utils";
-import { mapValues, omitBy, pick } from "es-toolkit";
-import { maybeNumber } from "./maybeNumber.js";
+import { maybeFunction } from '@wener/utils';
+import { mapValues, omitBy, pick } from 'es-toolkit';
+import { maybeNumber } from './maybeNumber.js';
 export function resolvePagination(page, options = {}) {
-    let out = omitBy(mapValues(//
-    pick(page, [
-        "limit",
-        "offset",
-        "pageSize",
-        "pageNumber",
-        "pageIndex"
-    ]), // to Number
-    (v) => maybeNumber(v)), (v) => v === undefined || v === null);
-    let { pageSize } = out;
-    if (options.pageSize) {
-        pageSize = maybeFunction(options.pageSize, pageSize);
-    }
-    pageSize ??= resolvePagination.pageSize;
-    let { pageNumber = 1, pageIndex } = out;
-    // page index over page number
-    pageNumber = Math.max(pageNumber, 1);
-    pageIndex = Math.max(pageIndex ?? pageNumber - 1, 0);
-    let { limit = pageSize, offset = pageSize * pageIndex } = out;
-    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,
-        pageNumber: pageIndex + 1,
-        pageIndex
-    };
+	let out = omitBy(
+		mapValues(
+			//
+			pick(page, ['limit', 'offset', 'pageSize', 'pageNumber', 'pageIndex']), // to Number
+			(v) => maybeNumber(v),
+		),
+		(v) => v === undefined || v === null,
+	);
+	let { pageSize } = out;
+	if (options.pageSize) {
+		pageSize = maybeFunction(options.pageSize, pageSize);
+	}
+	pageSize ??= resolvePagination.pageSize;
+	let { pageNumber = 1, pageIndex } = out;
+	// page index over page number
+	pageNumber = Math.max(pageNumber, 1);
+	pageIndex = Math.max(pageIndex ?? pageNumber - 1, 0);
+	let { limit = pageSize, offset = pageSize * pageIndex } = out;
+	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,
+		pageNumber: pageIndex + 1,
+		pageIndex,
+	};
 }
 resolvePagination.pageSize = 20;
 //# sourceMappingURL=resolvePagination.js.map