@wener/utils 1.1.50 → 1.1.53

package/src/browsers/download.ts

@@ -1,3 +1,5 @@
+import type { Bytes } from '../io/types';
+
 /**
  * Trigger browser download
  * @param filename download as filename
@@ -6,42 +8,42 @@
  * @param raw if true, data is treated as raw data, not url
  */
 export async function download(filename: string, data: any, { type = 'application/octet-stream', raw = false } = {}) {
-  const a = document.createElement('a');
-  let closer: () => void = () => null;
-  try {
-    a.download = filename;
+	const a = document.createElement('a');
+	let closer: () => void = () => null;
+	try {
+		a.download = filename;
 
-    // url or data url
-    if (typeof data === 'string' && /^(https?:|data:)/.test(data) && !raw) {
-      a.href = data;
-      // 只有 same-origin 才能 download
-      if (/^https?:/.test(data)) {
-        if (new URL(data).origin !== location.origin) {
-          // 非同源
-          a.href = '';
-          data = await fetch(data).then((res) => res.blob());
-        }
-      }
-    } else if (typeof data === 'string') {
-      data = new TextEncoder().encode(data);
-    }
+		// url or data url
+		if (typeof data === 'string' && /^(https?:|data:)/.test(data) && !raw) {
+			a.href = data;
+			// 只有 same-origin 才能 download
+			if (/^https?:/.test(data)) {
+				if (new URL(data).origin !== location.origin) {
+					// 非同源
+					a.href = '';
+					data = await fetch(data).then((res) => res.blob());
+				}
+			}
+		} else if (typeof data === 'string') {
+			data = new TextEncoder().encode(data);
+		}
 
-    if (data instanceof Uint8Array) {
-      data = new Blob([data], { type });
-    }
-    {
-      if (data instanceof File || data instanceof Blob || data instanceof MediaSource) {
-        a.href = URL.createObjectURL(data);
-        closer = () => {
-          URL.revokeObjectURL(a.href);
-        };
-      } else {
-        console.error(`invalid download data`, data);
-        throw new Error(`can not download ${data && Object.getPrototypeOf(data)}`);
-      }
-      a.click();
-    }
-  } finally {
-    closer();
-  }
+		if (data instanceof Uint8Array) {
+			data = new Blob([data as Bytes], { type });
+		}
+		{
+			if (data instanceof File || data instanceof Blob || data instanceof MediaSource) {
+				a.href = URL.createObjectURL(data);
+				closer = () => {
+					URL.revokeObjectURL(a.href);
+				};
+			} else {
+				console.error(`invalid download data`, data);
+				throw new Error(`can not download ${data && Object.getPrototypeOf(data)}`);
+			}
+			a.click();
+		}
+	} finally {
+		closer();
+	}
 }

package/src/browsers/getFileFromDataTransfer.ts

@@ -1,41 +1,41 @@
 export function getFileFromDataTransfer(dataTransfer?: DataTransfer | null): { file?: File; name?: string } {
-  if (!dataTransfer) {
-    return {};
-  }
+	if (!dataTransfer) {
+		return {};
+	}
 
-  const items: DataTransferItemList = dataTransfer.items ?? [];
+	const items: DataTransferItemList = dataTransfer.items ?? [];
 
-  if (items.length >= 2 && items[0].kind === 'string' && items[1].kind === 'file') {
-    // name, file
-    const text = dataTransfer.getData('text');
-    const file = items[1].getAsFile() ?? dataTransfer.files?.item(0);
-    if (!file) {
-      console.error(`no file ${text}`, items[1]);
-      return {};
-    }
+	if (items.length >= 2 && items[0].kind === 'string' && items[1].kind === 'file') {
+		// name, file
+		const text = dataTransfer.getData('text');
+		const file = items[1].getAsFile() ?? dataTransfer.files?.item(0);
+		if (!file) {
+			console.error(`no file ${text}`, items[1]);
+			return {};
+		}
 
-    // let type = file.type;
-    // // fix type
-    // type = type;
-    // // NOTE paste file can not parse by libs
-    // if (type !== file.type) {
-    //   const blob = file.slice(0, file.size);
-    //   file = new File([blob], text, {type});
-    // }
+		// let type = file.type;
+		// // fix type
+		// type = type;
+		// // NOTE paste file can not parse by libs
+		// if (type !== file.type) {
+		//   const blob = file.slice(0, file.size);
+		//   file = new File([blob], text, {type});
+		// }
 
-    return { file, name: text };
-  } else if (items[0].kind === 'file') {
-    const file = items[0].getAsFile();
-    if (!file) {
-      console.error(`no file`, items[0]);
-      return {};
-    }
-    return { file, name: file.name };
-  } else {
-    console.debug(
-      `file item not match`,
-      Array.from(items).map((v) => ({ type: v.type, kind: v.kind })),
-    );
-  }
-  return {};
+		return { file, name: text };
+	} else if (items[0].kind === 'file') {
+		const file = items[0].getAsFile();
+		if (!file) {
+			console.error(`no file`, items[0]);
+			return {};
+		}
+		return { file, name: file.name };
+	} else {
+		console.debug(
+			`file item not match`,
+			Array.from(items).map((v) => ({ type: v.type, kind: v.kind })),
+		);
+	}
+	return {};
 }

package/src/browsers/loaders.ts

@@ -1,65 +1,65 @@
 function load(
-  el: HTMLScriptElement | HTMLLinkElement,
-  resolve: (v: any) => void,
-  reject: (v: any) => void,
-  options: { attributes: Record<string, string> } | undefined,
+	el: HTMLScriptElement | HTMLLinkElement,
+	resolve: (v: any) => void,
+	reject: (v: any) => void,
+	options: { attributes: Record<string, string> } | undefined,
 ) {
-  el.onload = () => {
-    resolve(el);
-  };
-  el.onerror = (e) => {
-    el.remove();
-    reject(e);
-  };
-  const { attributes = {} } = options || {};
-  Object.entries(attributes).forEach(([k, v]) => {
-    el.setAttribute(k, v);
-  });
+	el.onload = () => {
+		resolve(el);
+	};
+	el.onerror = (e) => {
+		el.remove();
+		reject(e);
+	};
+	const { attributes = {} } = options || {};
+	Object.entries(attributes).forEach(([k, v]) => {
+		el.setAttribute(k, v);
+	});
 
-  document.head.appendChild(el);
+	document.head.appendChild(el);
 }
 
 export function loadScripts(
-  src: string[],
-  options?: { attributes: Record<string, string> },
+	src: string[],
+	options?: { attributes: Record<string, string> },
 ): Promise<HTMLScriptElement[]>;
 export function loadScripts(src: string, options?: { attributes: Record<string, string> }): Promise<HTMLScriptElement>;
 
 export function loadScripts(
-  src: string | string[],
-  options?: { attributes: Record<string, string> },
+	src: string | string[],
+	options?: { attributes: Record<string, string> },
 ): Promise<HTMLScriptElement | HTMLScriptElement[]> {
-  if (Array.isArray(src)) {
-    return Promise.resolve().then(async () => {
-      const all = [];
-      for (const s of src) {
-        all.push(await loadScripts(s));
-      }
-      return all;
-    });
-  }
-  // todo quote ?
-  const $ele = document.querySelector(`script[src="${src}"]`) as HTMLScriptElement;
-  if ($ele) {
-    return Promise.resolve($ele);
-  }
-  return new Promise((resolve, reject) => {
-    const el = document.createElement('script');
-    el.src = src;
-    load(el, resolve, reject, options);
-  });
+	if (Array.isArray(src)) {
+		return Promise.resolve().then(async () => {
+			const all = [];
+			for (const s of src) {
+				all.push(await loadScripts(s));
+			}
+			return all;
+		});
+	}
+	// todo quote ?
+	const $ele = document.querySelector(`script[src="${src}"]`) as HTMLScriptElement;
+	if ($ele) {
+		return Promise.resolve($ele);
+	}
+	return new Promise((resolve, reject) => {
+		const el = document.createElement('script');
+		el.src = src;
+		load(el, resolve, reject, options);
+	});
 }
 
 export function loadStyles(href: string, options?: { attributes: Record<string, string> }): Promise<HTMLLinkElement> {
-  const $ele = document.querySelector(`link[href="${href}"]`) as HTMLLinkElement;
-  if ($ele) {
-    return Promise.resolve($ele);
-  }
+	const $ele = document.querySelector(`link[href="${href}"]`) as HTMLLinkElement;
+	if ($ele) {
+		return Promise.resolve($ele);
+	}
 
-  return new Promise((resolve, reject) => {
-    const el = document.createElement('link');
-    el.rel = 'stylesheet';
-    el.href = href;
-    load(el, resolve, reject, options);
-  });
+	return new Promise((resolve, reject) => {
+		const el = document.createElement('link');
+		el.rel = 'stylesheet';
+		el.href = href;
+		load(el, resolve, reject, options);
+	});
 }

package/src/crypto/base.ts

@@ -2,7 +2,7 @@
  * hex string
  */
 export function hex(s: Uint8Array | ArrayBuffer) {
-  return Array.from(new Uint8Array(s))
-    .map((v) => v.toString(16).padStart(2, '0'))
-    .join('');
+	return Array.from(new Uint8Array(s))
+		.map((v) => v.toString(16).padStart(2, '0'))
+		.join('');
 }

package/src/crypto/getNodeCrypto.ts

@@ -1,5 +1,5 @@
 // import type * as NodeCrypto from 'node:crypto';
-import { getGlobalThis } from '../runtime/getGlobalThis';
+import { getGlobalThis } from '../web/getGlobalThis';
 
 let nodeCrypto;
 // globalThis.process?.release?.name
@@ -17,6 +17,6 @@ let nodeCrypto;
 //   } catch (e) {}
 // }
 export function getNodeCrypto() {
-  nodeCrypto ||= getGlobalThis().crypto;
-  return nodeCrypto;
+	nodeCrypto ||= getGlobalThis().crypto;
+	return nodeCrypto;
 }

package/src/crypto/hashing.test.ts

@@ -2,68 +2,54 @@ import { assert, beforeAll, expect, test } from 'vitest';
 import { ArrayBuffers } from '../io/ArrayBuffers';
 import { polyfillCrypto } from '../server/polyfill/polyfillCrypto';
 import { isUUID } from '../validations/isUUID';
+import { _randomUUID } from '../web/randomUUID';
 import { hex } from './base';
 import { hmac, sha1, sha256, sha384, sha512 } from './hashing';
 import { md5 } from './md5';
-import { _randomUUID } from './randomUUID';
 
 beforeAll(async () => {
-  await polyfillCrypto();
+	await polyfillCrypto();
 });
 
 test('sha', async () => {
-  expect(hex(await sha1(''))).toBe('da39a3ee5e6b4b0d3255bfef95601890afd80709');
-  expect(await sha1('', 'hex')).toBe('da39a3ee5e6b4b0d3255bfef95601890afd80709');
-  expect(ArrayBuffers.toString(await sha1(''), 'base64')).toBe('2jmj7l5rSw0yVb/vlWAYkK/YBwk=');
-  expect(await sha1('', 'base64')).toBe('2jmj7l5rSw0yVb/vlWAYkK/YBwk=');
+	expect(hex(await sha1('', 'buffer'))).toBe('da39a3ee5e6b4b0d3255bfef95601890afd80709');
+	expect(await sha1('', 'hex')).toBe('da39a3ee5e6b4b0d3255bfef95601890afd80709');
+	expect(ArrayBuffers.toString(await sha1('', 'buffer'), 'base64')).toBe('2jmj7l5rSw0yVb/vlWAYkK/YBwk=');
+	expect(await sha1('', 'base64')).toBe('2jmj7l5rSw0yVb/vlWAYkK/YBwk=');
 
-  expect(await sha1('', 'hex')).toBe('da39a3ee5e6b4b0d3255bfef95601890afd80709');
-  expect(hex(await sha1('abc'))).toBe('a9993e364706816aba3e25717850c26c9cd0d89d');
-  expect(hex(await sha256(''))).toBe('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
-  expect(hex(await sha384(''))).toBe(
-    '38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b',
-  );
-  expect(hex(await sha512(''))).toBe(
-    'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e',
-  );
+	expect(await sha1('', 'hex')).toBe('da39a3ee5e6b4b0d3255bfef95601890afd80709');
+	expect(hex(await sha1('abc', 'buffer'))).toBe('a9993e364706816aba3e25717850c26c9cd0d89d');
+	expect(hex(await sha256('', 'buffer'))).toBe('e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855');
+	expect(hex(await sha384('', 'buffer'))).toBe(
+		'38b060a751ac96384cd9327eb1b1e36a21fdb71114be07434c0cc7bf63f6e1da274edebfe76f65fbd51ad2f14898b95b',
+	);
+	expect(hex(await sha512('', 'buffer'))).toBe(
+		'cf83e1357eefb8bdf1542850d66d8007d620e4050b5715dc83f4a921d36ce9ce47d0d13c5d85f2b0ff8318d2877eec2f63b931bd47417a81a538327af927da3e',
+	);
 
-  expect(md5('Hello')).toBe('8b1a9953c4611296a827abf8c47804d7');
+	expect(md5('Hello')).toBe('8b1a9953c4611296a827abf8c47804d7');
 });
 
 test('randomUUID', () => {
-  for (let i = 0; i < 20; i++) {
-    expect(isUUID(_randomUUID())).toBeTruthy();
-  }
+	for (let i = 0; i < 20; i++) {
+		expect(isUUID(_randomUUID())).toBeTruthy();
+	}
 });
 
 test('hmac', async () => {
-  let key = await crypto.subtle.importKey(
-    'raw',
-    new TextEncoder().encode('YourAccessKeySecret'),
-    {
-      name: 'HMAC',
-      hash: {
-        name: 'SHA-256',
-      },
-    },
-    false,
-    ['sign', 'verify'],
-  );
-  const out = hex(
-    await crypto.subtle.sign(
-      {
-        name: 'HMAC',
-        hash: {
-          name: 'SHA-256',
-        },
-      },
-      key,
-      new TextEncoder().encode(''),
-    ),
-  );
-  console.log(out);
-  const { createHmac } = await import('node:crypto');
-  let fromNode = createHmac('sha256', 'YourAccessKeySecret').update('').digest('hex');
-  assert.equal(out, fromNode);
-  assert.equal(out, await hmac('sha256', 'YourAccessKeySecret', '', 'hex'));
+	let key = await crypto.subtle.importKey(
+		'raw',
+		new TextEncoder().encode('YourAccessKeySecret'),
+		{ name: 'HMAC', hash: { name: 'SHA-256' } },
+		false,
+		['sign', 'verify'],
+	);
+	const out = hex(
+		await crypto.subtle.sign({ name: 'HMAC', hash: { name: 'SHA-256' } }, key, new TextEncoder().encode('')),
+	);
+	console.log(out);
+	const { createHmac } = await import('node:crypto');
+	let fromNode = createHmac('sha256', 'YourAccessKeySecret').update('').digest('hex');
+	assert.equal(out, fromNode);
+	assert.equal(out, await hmac('sha256', 'YourAccessKeySecret', '', 'hex'));
 });

package/src/crypto/hashing.ts

@@ -1,112 +1,112 @@
 import { ArrayBuffers } from '../io/ArrayBuffers';
 
-export function sha1(s: BinaryLike, o?: undefined): Promise<Buffer>;
-export function sha1(s: BinaryLike, o: 'hex' | 'base64'): Promise<string>;
+type HashEncoding = 'hex' | 'base64' | 'buffer';
+
+type HashFunction = {
+	(s: BinaryLike, o?: 'hex' | 'base64' | undefined): Promise<string>;
+	(s: BinaryLike, o: 'buffer'): Promise<ArrayBuffer>;
+};
+
+function createDigestFunction(a: string): HashFunction {
+	return (async (s: BinaryLike, o: HashEncoding = 'hex') => {
+		const buffer = await crypto.subtle.digest(a, binaryOf(s));
+		if (o === 'buffer') {
+			return buffer;
+		}
+		return ArrayBuffers.toString(buffer, o || 'hex');
+	}) as HashFunction;
+}
 
+export function sha1(s: BinaryLike, o?: undefined | 'buffer'): Promise<Buffer>;
+export function sha1(s: BinaryLike, o: 'hex' | 'base64'): Promise<string>;
 export function sha1(s: BinaryLike, o?: DigestOptions) {
-  return digestOf('SHA-1', s, o);
+	return digestOf('SHA-1', s, o);
 }
 
-export function sha256(s: BinaryLike, o?: undefined): Promise<Buffer>;
+export function sha256(s: BinaryLike, o?: undefined | 'buffer'): Promise<Buffer>;
 export function sha256(s: BinaryLike, o: 'hex' | 'base64'): Promise<string>;
 
 export function sha256(s: BinaryLike, o?: DigestOptions) {
-  return digestOf('SHA-256', s, o);
+	return digestOf('SHA-256', s, o);
 }
 
-export function sha384(s: BinaryLike, o?: undefined): Promise<Buffer>;
+export function sha384(s: BinaryLike, o?: undefined | 'buffer'): Promise<Buffer>;
 export function sha384(s: BinaryLike, o: 'hex' | 'base64'): Promise<string>;
 
 export function sha384(s: BinaryLike, o?: DigestOptions) {
-  return digestOf('SHA-384', s, o);
+	return digestOf('SHA-384', s, o);
 }
 
-export function sha512(s: BinaryLike, o?: undefined): Promise<Buffer>;
+export function sha512(s: BinaryLike, o?: undefined | 'buffer'): Promise<Buffer>;
 export function sha512(s: BinaryLike, o: 'hex' | 'base64'): Promise<string>;
 
 export function sha512(s: BinaryLike, o?: DigestOptions) {
-  return digestOf('SHA-512', s, o);
+	return digestOf('SHA-512', s, o);
 }
 
 function digestOf(a: string, s: BinaryLike, o?: DigestOptions) {
-  let buffer = crypto.subtle.digest(a, binaryOf(s));
-  return o ? buffer.then((v) => encode(v, o)) : buffer;
+	let buffer = crypto.subtle.digest(a, binaryOf(s));
+	if (o === 'buffer') {
+		return buffer;
+	}
+	return o ? buffer.then((v) => encode(v, o)) : buffer;
 }
 
-export type DigestOptions =
-  | 'hex'
-  | 'base64'
-  | {
-      encoding: 'hex' | 'base64';
-    };
+export type DigestOptions = 'hex' | 'base64' | 'buffer' | { encoding: 'hex' | 'base64' };
 
 type BinaryLike = string | BufferSource;
 
 function binaryOf(s: BinaryLike) {
-  // ArrayBuffer, TypedArray, DataView
-  if (typeof s === 'string') {
-    return new TextEncoder().encode(s);
-  }
-  //  ArrayBuffer, Buffer, TypedArray, DataView
-  return s;
+	// ArrayBuffer, TypedArray, DataView
+	if (typeof s === 'string') {
+		return new TextEncoder().encode(s);
+	}
+	//  ArrayBuffer, Buffer, TypedArray, DataView
+	return s;
 }
 
 function encode(buf: BufferSource, o?: DigestOptions) {
-  if (o) {
-    switch (o) {
-      case 'hex':
-      case 'base64':
-        return ArrayBuffers.toString(buf, o);
-    }
-  }
-  return buf;
+	if (o) {
+		switch (o) {
+			case 'hex':
+			case 'base64':
+				return ArrayBuffers.toString(buf, o);
+		}
+	}
+	return buf;
 }
 
 type StringEncoding = 'hex' | 'base64';
 type IsStringCoding<T> = T extends StringEncoding ? true : T extends { encoding: StringEncoding } ? true : false;
 
 export function hmac<O extends DigestOptions>(
-  hash: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512' | 'sha1' | 'sha256' | 'sha384' | 'sha512',
-  key: BinaryLike | CryptoKey,
-  data: BinaryLike,
-  o?: O,
+	hash: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512' | 'sha1' | 'sha256' | 'sha384' | 'sha512',
+	key: BinaryLike | CryptoKey,
+	data: BinaryLike,
+	o?: O,
 ): Promise<IsStringCoding<O> extends true ? string : Buffer>;
 
 export async function hmac(
-  hash: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512' | 'sha1' | 'sha256' | 'sha384' | 'sha512',
-  key: BinaryLike | CryptoKey,
-  data: BinaryLike,
-  o?: DigestOptions,
+	hash: 'SHA-1' | 'SHA-256' | 'SHA-384' | 'SHA-512' | 'sha1' | 'sha256' | 'sha384' | 'sha512',
+	key: BinaryLike | CryptoKey,
+	data: BinaryLike,
+	o?: DigestOptions,
 ) {
-  let ck =
-    key instanceof CryptoKey
-      ? key
-      : await crypto.subtle.importKey(
-          'raw',
-          binaryOf(key),
-          {
-            name: 'HMAC',
-            hash: {
-              name: normalizeHash(hash),
-            },
-          },
-          false,
-          ['sign'],
-        );
-  let buffer = await crypto.subtle.sign(
-    {
-      name: 'HMAC',
-      hash: {
-        name: hash,
-      },
-    },
-    ck,
-    binaryOf(data),
-  );
-
-  return encode(buffer, o);
+	let ck =
+		key instanceof CryptoKey
+			? key
+			: await crypto.subtle.importKey(
+					'raw',
+					binaryOf(key),
+					{ name: 'HMAC', hash: { name: normalizeHash(hash) } },
+					false,
+					['sign'],
+				);
+	let buffer = await crypto.subtle.sign({ name: 'HMAC', hash: { name: hash } }, ck, binaryOf(data));
+
+	return encode(buffer, o);
 }
 
 function normalizeHash(hash: string) {
-  return hash.replace(/^sha/i, 'SHA-');
+	return hash.replace(/^sha/i, 'SHA-');
 }

package/src/crypto/md5.bench.ts

@@ -3,29 +3,25 @@ import { bench, describe } from 'vitest';
 import { md5 } from './md5';
 
 describe('md5', () => {
-  const dataset = new Array(10000).fill(0).map((_, i) => String(Math.random() * i));
-  let iterations = 0;
-  bench(
-    'js',
-    function () {
-      iterations++;
-      md5(dataset[iterations % dataset.length]);
-    },
-    {
-      iterations: 10000,
-    },
-  );
+	const dataset = new Array(10000).fill(0).map((_, i) => String(Math.random() * i));
+	let iterations = 0;
+	bench(
+		'js',
+		function () {
+			iterations++;
+			md5(dataset[iterations % dataset.length]);
+		},
+		{ iterations: 10000 },
+	);
 
-  bench(
-    'native',
-    function () {
-      iterations++;
-      createHash('md5')
-        .update(dataset[iterations % dataset.length])
-        .digest('hex');
-    },
-    {
-      iterations: 10000,
-    },
-  );
+	bench(
+		'native',
+		function () {
+			iterations++;
+			createHash('md5')
+				.update(dataset[iterations % dataset.length])
+				.digest('hex');
+		},
+		{ iterations: 10000 },
+	);
 });

package/src/crypto/md5.test.ts

@@ -2,7 +2,7 @@ import { assert, describe, test } from 'vitest';
 import { md5 } from './md5';
 
 describe('md5', () => {
-  test('js', () => {
-    assert.equal(md5(''), 'd41d8cd98f00b204e9800998ecf8427e');
-  });
+	test('js', () => {
+		assert.equal(md5(''), 'd41d8cd98f00b204e9800998ecf8427e');
+	});
 });