@wener/utils 1.1.50 → 1.1.53

package/src/server/polyfill/polyfillFetch.ts

@@ -3,25 +3,15 @@ import type { MaybePromise } from '../../asyncs/MaybePromise';
 export function polyfillFetch(nodeFetch: typeof import('node-fetch')): boolean;
 export function polyfillFetch(nodeFetch?: undefined): Promise<boolean>;
 export function polyfillFetch(nodeFetch?: typeof import('node-fetch')): MaybePromise<boolean> {
-  if ('fetch' in globalThis) {
-    return false;
-  }
-  // sync mode
-  if (nodeFetch) {
-    const { default: fetch, Response, Headers, Request, AbortError, FetchError, FormData, Blob, File } = nodeFetch;
-    Object.assign(globalThis, {
-      fetch,
-      Response,
-      Headers,
-      Request,
-      AbortError,
-      FetchError,
-      FormData,
-      Blob,
-      File,
-    });
-    // abort controller
-    return true;
-  }
-  return import('node-fetch').then((v) => polyfillFetch(v));
+	if ('fetch' in globalThis) {
+		return false;
+	}
+	// sync mode
+	if (nodeFetch) {
+		const { default: fetch, Response, Headers, Request, AbortError, FetchError, FormData, Blob, File } = nodeFetch;
+		Object.assign(globalThis, { fetch, Response, Headers, Request, AbortError, FetchError, FormData, Blob, File });
+		// abort controller
+		return true;
+	}
+	return import('node-fetch').then((v) => polyfillFetch(v));
 }

package/src/server/polyfill/polyfillJsDom.ts

@@ -1,88 +1,76 @@
 import type { ConstructorOptions, ResourceLoaderConstructorOptions } from 'jsdom';
-import { getGlobalThis } from '../../runtime/getGlobalThis';
+import { getGlobalThis } from '../../web/getGlobalThis';
 
 export async function polyfillJsDom() {
-  if (typeof window !== 'undefined') {
-    return false;
-  }
+	if (typeof window !== 'undefined') {
+		return false;
+	}
 
-  const globalThis = getGlobalThis();
+	const globalThis = getGlobalThis();
 
-  const { ResourceLoader, JSDOM } = await import('jsdom');
+	const { ResourceLoader, JSDOM } = await import('jsdom');
 
-  // https://github.com/lukechilds/window/blob/master/src/index.js
-  // eslint-disable-next-line @typescript-eslint/no-extraneous-class
-  class Window {
-    constructor(opts: ResourceLoaderConstructorOptions & ConstructorOptions = {}) {
-      const { proxy, strictSSL, userAgent, ...jsdomOpts } = opts;
-      const resources = new ResourceLoader({
-        proxy,
-        strictSSL,
-        userAgent,
-      });
-      return new JSDOM(
-        '',
-        Object.assign(jsdomOpts, {
-          resources,
-        }),
-      ).window;
-    }
-  }
+	// https://github.com/lukechilds/window/blob/master/src/index.js
+	// eslint-disable-next-line @typescript-eslint/no-extraneous-class
+	class Window {
+		constructor(opts: ResourceLoaderConstructorOptions & ConstructorOptions = {}) {
+			const { proxy, strictSSL, userAgent, ...jsdomOpts } = opts;
+			const resources = new ResourceLoader({ proxy, strictSSL, userAgent });
+			return new JSDOM('', Object.assign(jsdomOpts, { resources })).window;
+		}
+	}
 
-  // https://github.com/lukechilds/browser-env/blob/master/src/index.js
-  // Default jsdom config.
-  // These settings must override any custom settings to make sure we can iterate
-  // over the window object.
-  const defaultJsdomConfig = {
-    // features: {
-    //   FetchExternalResources: false,
-    //   ProcessExternalResources: false,
-    // },
-  };
-  // IIFE executed on import to return an array of global Node.js properties that
-  // conflict with global browser properties.
-  const protectedProperties = (() =>
-    Object.getOwnPropertyNames(new Window(defaultJsdomConfig)).filter(
-      (prop) => typeof globalThis[prop as keyof typeof globalThis] !== 'undefined',
-    ))();
+	// https://github.com/lukechilds/browser-env/blob/master/src/index.js
+	// Default jsdom config.
+	// These settings must override any custom settings to make sure we can iterate
+	// over the window object.
+	const defaultJsdomConfig = {
+		// features: {
+		//   FetchExternalResources: false,
+		//   ProcessExternalResources: false,
+		// },
+	};
+	// IIFE executed on import to return an array of global Node.js properties that
+	// conflict with global browser properties.
+	const protectedProperties = (() =>
+		Object.getOwnPropertyNames(new Window(defaultJsdomConfig)).filter(
+			(prop) => typeof globalThis[prop as keyof typeof globalThis] !== 'undefined',
+		))();
 
-  function installEnv(...args: any[]) {
-    // Sets up global browser environment
-    // Extract options from args
-    const properties = args.filter((arg: any) => Array.isArray(arg))[0];
-    const userJsdomConfig = args.filter((arg: any) => !Array.isArray(arg))[0];
+	function installEnv(...args: any[]) {
+		// Sets up global browser environment
+		// Extract options from args
+		const properties = args.filter((arg: any) => Array.isArray(arg))[0];
+		const userJsdomConfig = args.filter((arg: any) => !Array.isArray(arg))[0];
 
-    // Create window object
-    const window = new Window(Object.assign({}, userJsdomConfig, defaultJsdomConfig));
+		// Create window object
+		const window = new Window(Object.assign({}, userJsdomConfig, defaultJsdomConfig));
 
-    // Get all global browser properties
-    Object.getOwnPropertyNames(window)
+		// Get all global browser properties
+		Object.getOwnPropertyNames(window)
 
-      // Remove protected properties
-      .filter((prop) => !protectedProperties.includes(prop))
+			// Remove protected properties
+			.filter((prop) => !protectedProperties.includes(prop))
 
-      // If we're only applying specific required properties remove everything else
-      .filter((prop) => !(properties && properties.indexOf(prop) === -1))
-      .filter((prop) => {
-        switch (prop) {
-          case 'undefined':
-            return false;
-        }
-        return true;
-      })
+			// If we're only applying specific required properties remove everything else
+			.filter((prop) => !(properties && properties.indexOf(prop) === -1))
+			.filter((prop) => {
+				switch (prop) {
+					case 'undefined':
+						return false;
+				}
+				return true;
+			})
 
-      // Copy what's left to the Node.js global scope
-      .forEach((prop) => {
-        // console.debug(`define globalThis.${prop}`);
-        Object.defineProperty(globalThis, prop, {
-          configurable: true,
-          get: () => window[prop as keyof Window] as any,
-        });
-      });
+			// Copy what's left to the Node.js global scope
+			.forEach((prop) => {
+				// console.debug(`define globalThis.${prop}`);
+				Object.defineProperty(globalThis, prop, { configurable: true, get: () => window[prop as keyof Window] as any });
+			});
 
-    return window;
-  }
+		return window;
+	}
 
-  installEnv({ url: 'http://localhost' });
-  return true;
+	installEnv({ url: 'http://localhost' });
+	return true;
 }

package/src/server/polyfill/polyfillWebSocket.ts

@@ -1,21 +1,21 @@
 import type { MaybePromise } from '../../asyncs/MaybePromise';
-import { getGlobalThis } from '../../runtime/getGlobalThis';
+import { getGlobalThis } from '../../web/getGlobalThis';
 
 export function polyfillWebSocket(ws: any): boolean;
 export function polyfillWebSocket(ws?: undefined): Promise<boolean>;
 export function polyfillWebSocket(ws?: any): MaybePromise<boolean> {
-  const globalThis = getGlobalThis();
-  if ('WebSocket' in globalThis) {
-    return false;
-  }
-  if (ws && 'then' in ws) {
-    return ws.then((v: any) => {
-      return polyfillWebSocket(v?.default || v);
-    });
-  }
-  if (ws) {
-    const { WebSocket } = ws;
-    Object.assign(globalThis, { WebSocket });
-  }
-  return import('ws').then((ws) => polyfillWebSocket(ws));
+	const globalThis = getGlobalThis();
+	if ('WebSocket' in globalThis) {
+		return false;
+	}
+	if (ws && 'then' in ws) {
+		return ws.then((v: any) => {
+			return polyfillWebSocket(v?.default || v);
+		});
+	}
+	if (ws) {
+		const { WebSocket } = ws;
+		Object.assign(globalThis, { WebSocket });
+	}
+	return import('ws').then((ws) => polyfillWebSocket(ws));
 }

package/src/strings/bytes.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, test } from 'vitest';
+import { formatBytes } from './formatBytes';
+import { parseBytes } from './parseBytes';
+
+describe('bytes', () => {
+	describe('formatBytes', () => {
+		const testCases: [number, any, string][] = [
+			// IEC standard by default
+			[1024, undefined, '1.0 KiB'],
+			[1024 * 1024, undefined, '1.0 MiB'],
+			[1536, undefined, '1.5 KiB'],
+			// SI standard
+			[1000, true, '1.0 kB'],
+			[1000 * 1000, true, '1.0 MB'],
+			[1500, true, '1.5 kB'],
+			// Small byte values
+			[100, undefined, '100 B'],
+			[999, undefined, '999 B'],
+			[1023, undefined, '1023 B'],
+			// SI small byte values
+			[100, true, '100 B'],
+			[999, true, '999 B'],
+			// Decimal places
+			[1536, { dp: 2 }, '1.50 KiB'],
+			[1536, { dp: 3 }, '1.500 KiB'],
+			// Force unit
+			[1024 * 1024, { unit: 'KiB' }, '1024.0 KiB'],
+			[1000 * 1000, { si: true, unit: 'kB' }, '1000.0 kB'],
+		];
+
+		test('should format bytes correctly', () => {
+			for (const [bytes, options, expected] of testCases) {
+				expect(formatBytes(bytes, options as any)).toBe(expected);
+			}
+		});
+	});
+
+	describe('parseBytes', () => {
+		const validTestCases: [string, ReturnType<typeof parseBytes>][] = [
+			['1B', { value: 1, unit: 'B', bytes: 1 }],
+			['1KB', { value: 1, unit: 'KB', bytes: 1000 }],
+			['1KiB', { value: 1, unit: 'KiB', bytes: 1024 }],
+			['1.5GB', { value: 1.5, unit: 'GB', bytes: 1.5 * 1000 ** 3 }],
+			['2TiB', { value: 2, unit: 'TiB', bytes: 2 * 1024 ** 4 }],
+			// single letter
+			['1G', { value: 1, unit: 'G', bytes: 1000 ** 3 }],
+			['1.5T', { value: 1.5, unit: 'T', bytes: 1.5 * 1000 ** 4 }],
+			// case-insensitive
+			['1gb', { value: 1, unit: 'gb', bytes: 1000 ** 3 }],
+			['1.5 mib', { value: 1.5, unit: 'mib', bytes: 1.5 * 1024 ** 2 }],
+			// whitespace
+			[' 1.5 GB ', { value: 1.5, unit: 'GB', bytes: 1.5 * 1000 ** 3 }],
+		];
+
+		test('should parse valid byte strings', () => {
+			for (const [str, expected] of validTestCases) {
+				expect(parseBytes(str)).toEqual(expected);
+			}
+		});
+
+		const invalidTestCases = ['abc', '1.5XB', ''];
+
+		test('should return undefined for invalid strings', () => {
+			for (const str of invalidTestCases) {
+				expect(parseBytes(str)).toBeUndefined();
+			}
+		});
+	});
+});

package/src/strings/camelCase.ts

@@ -1,83 +1,78 @@
 // https://github.com/sindresorhus/camelcase/blob/master/index.js
 
 function preserveCamelCase(string: string) {
-  let isLastCharLower = false;
-  let isLastCharUpper = false;
-  let isLastLastCharUpper = false;
+	let isLastCharLower = false;
+	let isLastCharUpper = false;
+	let isLastLastCharUpper = false;
 
-  for (let i = 0; i < string.length; i++) {
-    const character = string[i];
+	for (let i = 0; i < string.length; i++) {
+		const character = string[i];
 
-    if (isLastCharLower && /[a-zA-Z]/.test(character) && character.toUpperCase() === character) {
-      string = string.slice(0, i) + '-' + string.slice(i);
-      isLastCharLower = false;
-      isLastLastCharUpper = isLastCharUpper;
-      isLastCharUpper = true;
-      i++;
-    } else if (
-      isLastCharUpper &&
-      isLastLastCharUpper &&
-      /[a-zA-Z]/.test(character) &&
-      character.toLowerCase() === character
-    ) {
-      string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
-      isLastLastCharUpper = isLastCharUpper;
-      isLastCharUpper = false;
-      isLastCharLower = true;
-    } else {
-      isLastCharLower = character.toLowerCase() === character && character.toUpperCase() !== character;
-      isLastLastCharUpper = isLastCharUpper;
-      isLastCharUpper = character.toUpperCase() === character && character.toLowerCase() !== character;
-    }
-  }
+		if (isLastCharLower && /[a-zA-Z]/.test(character) && character.toUpperCase() === character) {
+			string = string.slice(0, i) + '-' + string.slice(i);
+			isLastCharLower = false;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = true;
+			i++;
+		} else if (
+			isLastCharUpper
+			&& isLastLastCharUpper
+			&& /[a-zA-Z]/.test(character)
+			&& character.toLowerCase() === character
+		) {
+			string = string.slice(0, i - 1) + '-' + string.slice(i - 1);
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = false;
+			isLastCharLower = true;
+		} else {
+			isLastCharLower = character.toLowerCase() === character && character.toUpperCase() !== character;
+			isLastLastCharUpper = isLastCharUpper;
+			isLastCharUpper = character.toUpperCase() === character && character.toLowerCase() !== character;
+		}
+	}
 
-  return string;
+	return string;
 }
 
 export function pascalCase(input: string | string[]) {
-  return camelCase(input, { pascalCase: true });
+	return camelCase(input, { pascalCase: true });
 }
 
-export function camelCase(
-  input: string | string[],
-  options: { pascalCase: boolean } = {
-    pascalCase: false,
-  },
-) {
-  if (!(typeof input === 'string' || Array.isArray(input))) {
-    throw new TypeError('Expected the input to be `string | string[]`');
-  }
+export function camelCase(input: string | string[], options: { pascalCase: boolean } = { pascalCase: false }) {
+	if (!(typeof input === 'string' || Array.isArray(input))) {
+		throw new TypeError('Expected the input to be `string | string[]`');
+	}
 
-  const postProcess = (x: string) => (options.pascalCase ? x.charAt(0).toUpperCase() + x.slice(1) : x);
+	const postProcess = (x: string) => (options.pascalCase ? x.charAt(0).toUpperCase() + x.slice(1) : x);
 
-  if (Array.isArray(input)) {
-    input = input
-      .map((x) => x.trim())
-      .filter((x) => x.length)
-      .join('-');
-  } else {
-    input = input.trim();
-  }
+	if (Array.isArray(input)) {
+		input = input
+			.map((x) => x.trim())
+			.filter((x) => x.length)
+			.join('-');
+	} else {
+		input = input.trim();
+	}
 
-  if (input.length === 0) {
-    return '';
-  }
+	if (input.length === 0) {
+		return '';
+	}
 
-  if (input.length === 1) {
-    return options.pascalCase ? input.toUpperCase() : input.toLowerCase();
-  }
+	if (input.length === 1) {
+		return options.pascalCase ? input.toUpperCase() : input.toLowerCase();
+	}
 
-  const hasUpperCase = input !== input.toLowerCase();
+	const hasUpperCase = input !== input.toLowerCase();
 
-  if (hasUpperCase) {
-    input = preserveCamelCase(input);
-  }
+	if (hasUpperCase) {
+		input = preserveCamelCase(input);
+	}
 
-  input = input
-    .replace(/^[_.\- ]+/, '')
-    .toLowerCase()
-    .replace(/[_.\- ]+(\w|$)/g, (_, p1) => p1.toUpperCase())
-    .replace(/\d+(\w|$)/g, (m) => m.toUpperCase());
+	input = input
+		.replace(/^[_.\- ]+/, '')
+		.toLowerCase()
+		.replace(/[_.\- ]+(\w|$)/g, (_, p1) => p1.toUpperCase())
+		.replace(/\d+(\w|$)/g, (m) => m.toUpperCase());
 
-  return postProcess(input);
+	return postProcess(input);
 }

package/src/strings/formatBytes.ts

@@ -1,30 +1,51 @@
-/**
- * Format bytes as human-readable text.
- *
- * @param bytes Number of bytes.
- * @param si True to use metric (SI) units, aka powers of 1000. False to use
- *           binary (IEC), aka powers of 1024.
- * @param dp Number of decimal places to display.
- *
- * @return Formatted string.
- */
-export function formatBytes(bytes: number, si = false, dp = 1) {
-  const thresh = si ? 1000 : 1024;
-
-  if (Math.abs(bytes) < thresh) {
-    return `${bytes} B`;
-  }
-
-  const units = si
-    ? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
-    : ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
-  let u = -1;
-  const r = 10 ** dp;
-
-  do {
-    bytes /= thresh;
-    ++u;
-  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);
-
-  return bytes.toFixed(dp) + ' ' + units[u];
+type SIUnit = 'B' | 'kB' | 'MB' | 'GB' | 'TB' | 'PB' | 'EB' | 'ZB' | 'YB';
+type IECUnit = 'B' | 'KiB' | 'MiB' | 'GiB' | 'TiB' | 'PiB' | 'EiB' | 'ZiB' | 'YiB';
+type Unit = SIUnit | IECUnit;
+
+interface FormatBytesOptions {
+	/** True to use metric (SI) units (powers of 1000). Default is false (binary IEC, powers of 1024). */
+	si?: boolean;
+	/** Number of decimal places to display. Default is 1. */
+	dp?: number;
+	/** Force formatting to a specific unit. */
+	unit?: Unit;
+}
+
+export function formatBytes(bytes: number, options?: FormatBytesOptions): string;
+export function formatBytes(bytes: number, si?: boolean, dp?: number): string;
+export function formatBytes(bytes: number, optionsOrSi: boolean | FormatBytesOptions = false, dp = 1): string {
+	let options: FormatBytesOptions;
+	if (typeof optionsOrSi === 'boolean') {
+		options = { si: optionsOrSi, dp };
+	} else {
+		options = optionsOrSi || {};
+	}
+
+	const { si = false, dp: decimalPlaces = 1, unit: forceUnit } = options;
+	const thresh = si ? 1000 : 1024;
+	const units = si
+		? ['kB', 'MB', 'GB', 'TB', 'PB', 'EB', 'ZB', 'YB']
+		: ['KiB', 'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'];
+
+	if (Math.abs(bytes) < thresh && !forceUnit) {
+		return `${bytes} B`;
+	}
+
+	if (forceUnit && forceUnit !== 'B') {
+		const unitIndex = units.findIndex((u) => u.toLowerCase() === forceUnit.toLowerCase());
+		if (unitIndex !== -1) {
+			const value = bytes / Math.pow(thresh, unitIndex + 1);
+			return `${value.toFixed(decimalPlaces)} ${units[unitIndex]}`;
+		}
+	}
+
+	let u = -1;
+	const r = 10 ** decimalPlaces;
+
+	do {
+		bytes /= thresh;
+		++u;
+	} while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);
+
+	return `${bytes.toFixed(decimalPlaces)} ${units[u]}`;
 }

package/src/strings/parseBytes.ts

@@ -0,0 +1,66 @@
+const UnitMultipliers: Record<string, number> = {
+	B: 1,
+	// SI
+	K: 1000,
+	KB: 1000,
+	M: 1000 ** 2,
+	MB: 1000 ** 2,
+	G: 1000 ** 3,
+	GB: 1000 ** 3,
+	T: 1000 ** 4,
+	TB: 1000 ** 4,
+	P: 1000 ** 5,
+	PB: 1000 ** 5,
+	E: 1000 ** 6,
+	EB: 1000 ** 6,
+	Z: 1000 ** 7,
+	ZB: 1000 ** 7,
+	Y: 1000 ** 8,
+	YB: 1000 ** 8,
+	// IEC
+	KIB: 1024,
+	MIB: 1024 ** 2,
+	GIB: 1024 ** 3,
+	TIB: 1024 ** 4,
+	PIB: 1024 ** 5,
+	EIB: 1024 ** 6,
+	ZIB: 1024 ** 7,
+	YIB: 1024 ** 8,
+};
+
+type ParseBytesResult = {
+	bytes: number;
+	unit: string;
+	value: number;
+};
+
+export function parseBytes(str: string): ParseBytesResult | undefined {
+	if (typeof str !== 'string' || str.length === 0) {
+		return undefined;
+	}
+
+	const match = str.trim().match(/^([\d.]+)\s*([a-z]+)?$/i);
+	if (!match) {
+		return undefined;
+	}
+
+	const value = parseFloat(match[1]);
+	let unit = (match[2] || 'B').toUpperCase();
+	let multiplier = UnitMultipliers[unit];
+
+	// Handle cases like G -> GB
+	if (multiplier === undefined && unit.length === 1 && unit !== 'B') {
+		unit += 'B';
+		multiplier = UnitMultipliers[unit];
+	}
+
+	if (isNaN(value) || multiplier === undefined) {
+		return undefined;
+	}
+
+	return {
+		value,
+		unit: match[2] || 'B',
+		bytes: value * multiplier,
+	};
+}

package/src/strings/renderTemplate.test.ts

@@ -3,21 +3,14 @@ import { expect, test } from 'vitest';
 import { renderTemplate } from './renderTemplate';
 
 test('renderTemplate', () => {
-  const obj = {
-    name: 'wener',
-    authors: [
-      {
-        name: 'wener',
-      },
-    ],
-  };
-  for (const [k, v] of Object.entries({
-    'My name is ${name}': 'My name is wener',
-    'My name is ${  authors[0].name  }': 'My name is wener',
-  })) {
-    expect(renderTemplate(k, obj)).toBe(v);
-  }
-  expect(renderTemplate('My name is ${name}', (v) => v)).toBe('My name is name');
-  expect(renderTemplate('My name is ${name}', obj, 'common')).toBe('My name is ${name}');
-  expect(renderTemplate('My name is {{name}}', obj, 'common')).toBe('My name is wener');
+	const obj = { name: 'wener', authors: [{ name: 'wener' }] };
+	for (const [k, v] of Object.entries({
+		'My name is ${name}': 'My name is wener',
+		'My name is ${  authors[0].name  }': 'My name is wener',
+	})) {
+		expect(renderTemplate(k, obj)).toBe(v);
+	}
+	expect(renderTemplate('My name is ${name}', (v) => v)).toBe('My name is name');
+	expect(renderTemplate('My name is ${name}', obj, 'common')).toBe('My name is ${name}');
+	expect(renderTemplate('My name is {{name}}', obj, 'common')).toBe('My name is wener');
 });