@wener/utils 1.1.51 → 1.1.53

package/src/objects/set.ts

@@ -6,43 +6,43 @@ import { parseObjectPath, type ObjectKey, type ObjectPath } from './parseObjectP
  * {@link https://github.com/lukeed/dset dset}
  */
 export function set<T extends object, V>(obj: T, key: ObjectKey | ObjectPath, val: V, merging = true) {
-  const path = parseObjectPath(key);
-  let i = 0;
-  const len = path.length;
-  let current: any = obj;
-  let x, k;
-  while (i < len) {
-    k = path[i++];
-    if (k === '__proto__' || k === 'constructor' || k === 'prototype') break;
-    // noinspection PointlessArithmeticExpressionJS
-    current = current[k] =
-      i === len
-        ? merging
-          ? merge(current[k], val)
-          : val
-        : typeof (x = current[k]) === typeof path
-          ? x
-          : // @ts-expect-error hacky type check
-            path[i] * 0 !== 0 || !!~('' + path[i]).indexOf('.') // eslint-disable-line
-            ? {}
-            : [];
-  }
+	const path = parseObjectPath(key);
+	let i = 0;
+	const len = path.length;
+	let current: any = obj;
+	let x, k;
+	while (i < len) {
+		k = path[i++];
+		if (k === '__proto__' || k === 'constructor' || k === 'prototype') break;
+		// noinspection PointlessArithmeticExpressionJS
+		current = current[k] =
+			i === len
+				? merging
+					? merge(current[k], val)
+					: val
+				: typeof (x = current[k]) === typeof path
+					? x
+					: // @ts-expect-error hacky type check
+						path[i] * 0 !== 0 || !!~('' + path[i]).indexOf('.') // eslint-disable-line
+						? {}
+						: [];
+	}
 }
 
 export function merge(a: any, b: any) {
-  let k;
-  if (typeof a === 'object' && typeof b === 'object') {
-    if (Array.isArray(a) && Array.isArray(b)) {
-      for (k = 0; k < b.length; k++) {
-        a[k] = merge(a[k], b[k]);
-      }
-    } else {
-      for (k in b) {
-        if (k === '__proto__' || k === 'constructor' || k === 'prototype') break;
-        a[k] = merge(a[k], b[k]);
-      }
-    }
-    return a;
-  }
-  return b;
+	let k;
+	if (typeof a === 'object' && typeof b === 'object') {
+		if (Array.isArray(a) && Array.isArray(b)) {
+			for (k = 0; k < b.length; k++) {
+				a[k] = merge(a[k], b[k]);
+			}
+		} else {
+			for (k in b) {
+				if (k === '__proto__' || k === 'constructor' || k === 'prototype') break;
+				a[k] = merge(a[k], b[k]);
+			}
+		}
+		return a;
+	}
+	return b;
 }

package/src/schema/typebox/typebox.ts

@@ -3,32 +3,26 @@ import { Value } from '@sinclair/typebox/value';
 
 // works like zod parse
 export const Parse = <T extends TSchema>(T: T, value: unknown) =>
-  // run transform, get T
-  Value.Decode(
-    T,
-    // remove additional
-    Value.Clean(
-      T,
-      // add missing
-      Value.Default(
-        T,
-        // '1' -> 1
-        Value.Convert(T, value),
-      ),
-    ),
-  );
+	// run transform, get T
+	Value.Decode(
+		T,
+		// remove additional
+		Value.Clean(
+			T,
+			// add missing
+			Value.Default(
+				T,
+				// '1' -> 1
+				Value.Convert(T, value),
+			),
+		),
+	);
 
 export const SafeParse = <T extends TSchema>(T: T, value: unknown) => {
-  let out = Value.Clean(T, Value.Default(T, Value.Convert(T, value)));
-  if (Value.Check(T, out)) {
-    // decode 也会 check
-    return {
-      data: Value.Decode(T, out),
-      success: true,
-    };
-  }
-  return {
-    errors: Array.from(Value.Errors(T, [], value)),
-    success: false,
-  };
+	let out = Value.Clean(T, Value.Default(T, Value.Convert(T, value)));
+	if (Value.Check(T, out)) {
+		// decode 也会 check
+		return { data: Value.Decode(T, out), success: true };
+	}
+	return { errors: Array.from(Value.Errors(T, [], value)), success: false };
 };

package/src/scripts/getGenerateContext.ts

@@ -8,92 +8,92 @@ import { formatBytes } from '../strings/formatBytes';
 let _root: GenerateContext;
 
 export interface GenerateContext {
-  pkgDir: string;
-  rootDataDir: string;
-  rootCacheDir: string;
-  dataDir: string;
-  cacheDir: string;
-  srcDir: string;
-  cache: (url: string) => Promise<string>;
-  writeData: (path: string, content: string) => Promise<void>;
-  writeSrc: (path: string, content: string) => Promise<void>;
+	pkgDir: string;
+	rootDataDir: string;
+	rootCacheDir: string;
+	dataDir: string;
+	cacheDir: string;
+	srcDir: string;
+	cache: (url: string) => Promise<string>;
+	writeData: (path: string, content: string) => Promise<void>;
+	writeSrc: (path: string, content: string) => Promise<void>;
 }
 
 async function cache(dir: string, url: string): Promise<string> {
-  const key = path.basename(url);
-  await fs.mkdir(path.join(dir), { recursive: true });
-  const file = path.join(dir, key);
-  try {
-    await fs.stat(file);
-    console.info('[cache] hit', url);
-    return await fs.readFile(file, 'utf-8');
-  } catch (e) {}
-  console.info('[cache] miss', url);
-  const text = await fetch(url).then((v) => {
-    if (v.status >= 300) {
-      throw new Error(`[cache] fetch ${url} ${v.status} ${v.statusText}`);
-    }
-    return v.text();
-  });
-  const size = new Blob([text]).size;
-  console.info(`[cache] write ${file} ${formatBytes(size)} (${size})`);
-  await fs.writeFile(file, text);
-  return text;
+	const key = path.basename(url);
+	await fs.mkdir(path.join(dir), { recursive: true });
+	const file = path.join(dir, key);
+	try {
+		await fs.stat(file);
+		console.info('[cache] hit', url);
+		return await fs.readFile(file, 'utf-8');
+	} catch (e) {}
+	console.info('[cache] miss', url);
+	const text = await fetch(url).then((v) => {
+		if (v.status >= 300) {
+			throw new Error(`[cache] fetch ${url} ${v.status} ${v.statusText}`);
+		}
+		return v.text();
+	});
+	const size = new Blob([text]).size;
+	console.info(`[cache] write ${file} ${formatBytes(size)} (${size})`);
+	await fs.writeFile(file, text);
+	return text;
 }
 
 export function getGenerateContext(prefix?: string): MaybePromise<GenerateContext> {
-  if (prefix) {
-    return Promise.resolve(getGenerateContext()).then((c) => {
-      const cacheDir = path.resolve(c.cacheDir, prefix);
-      const dataDir = path.resolve(c.dataDir, prefix);
-      const srcDir = path.resolve(c.srcDir, prefix);
-      return {
-        ...c,
-        dataDir,
-        cacheDir,
-        srcDir,
-        cache: (url: string) => cache(cacheDir, url),
-        writeData: (file: string, content: string) => write(dataDir, file, content),
-        writeSrc: (file: string, content: string) => write(srcDir, file, content),
-      };
-    });
-  }
-  return (
-    _root ||
-    Promise.resolve().then(async () => {
-      const pkgDir = await getPackageDir();
-      Errors.BadRequest.check(pkgDir, 'pkgDir not found');
-      const dataDir = path.resolve(pkgDir, 'data');
-      const cacheDir = path.resolve(pkgDir, 'cache');
-      const srcDir = path.resolve(pkgDir, 'src');
-      await fs.mkdir(cacheDir, { recursive: true });
-      await fs.mkdir(dataDir, { recursive: true });
-      return (_root = Object.freeze({
-        pkgDir,
-        dataDir,
-        cacheDir,
-        srcDir,
-        rootCacheDir: cacheDir,
-        rootDataDir: dataDir,
-        cache: (url: string) => cache(cacheDir, url),
-        writeData: (file: string, content: string) => write(dataDir, file, content),
-        writeSrc: (file: string, content: string) => write(srcDir, file, content),
-      }));
-    })
-  );
+	if (prefix) {
+		return Promise.resolve(getGenerateContext()).then((c) => {
+			const cacheDir = path.resolve(c.cacheDir, prefix);
+			const dataDir = path.resolve(c.dataDir, prefix);
+			const srcDir = path.resolve(c.srcDir, prefix);
+			return {
+				...c,
+				dataDir,
+				cacheDir,
+				srcDir,
+				cache: (url: string) => cache(cacheDir, url),
+				writeData: (file: string, content: string) => write(dataDir, file, content),
+				writeSrc: (file: string, content: string) => write(srcDir, file, content),
+			};
+		});
+	}
+	return (
+		_root
+		|| Promise.resolve().then(async () => {
+			const pkgDir = await getPackageDir();
+			Errors.BadRequest.check(pkgDir, 'pkgDir not found');
+			const dataDir = path.resolve(pkgDir, 'data');
+			const cacheDir = path.resolve(pkgDir, 'cache');
+			const srcDir = path.resolve(pkgDir, 'src');
+			await fs.mkdir(cacheDir, { recursive: true });
+			await fs.mkdir(dataDir, { recursive: true });
+			return (_root = Object.freeze({
+				pkgDir,
+				dataDir,
+				cacheDir,
+				srcDir,
+				rootCacheDir: cacheDir,
+				rootDataDir: dataDir,
+				cache: (url: string) => cache(cacheDir, url),
+				writeData: (file: string, content: string) => write(dataDir, file, content),
+				writeSrc: (file: string, content: string) => write(srcDir, file, content),
+			}));
+		})
+	);
 }
 
 async function write(dir: string, file: string, content: string) {
-  const size = new Blob([content]).size;
-  const dst = path.join(dir, file);
-  let last;
-  try {
-    last = (await fs.stat(dst)).size;
-  } catch {}
-  console.info(
-    `[write] ${path.relative(_root.pkgDir, dir)} ${file} ${
-      last ? (last !== size ? `${formatBytes(last)} (${last}) -> ` : 'SAME SIZE ') : ''
-    }${formatBytes(size)} (${size})`,
-  );
-  await fs.writeFile(dst, content);
+	const size = new Blob([content]).size;
+	const dst = path.join(dir, file);
+	let last;
+	try {
+		last = (await fs.stat(dst)).size;
+	} catch {}
+	console.info(
+		`[write] ${path.relative(_root.pkgDir, dir)} ${file} ${
+			last ? (last !== size ? `${formatBytes(last)} (${last}) -> ` : 'SAME SIZE ') : ''
+		}${formatBytes(size)} (${size})`,
+	);
+	await fs.writeFile(dst, content);
 }

package/src/server/crypto/md5.ts

@@ -1,5 +1,5 @@
 import { createHash } from 'node:crypto';
 
 export function md5(input: Buffer | string) {
-  return createHash('md5').update(input).digest('hex') as string;
+	return createHash('md5').update(input).digest('hex') as string;
 }

package/src/server/fetch/createFetchWithProxyByNodeFetch.ts

@@ -2,40 +2,37 @@ import type { FetchLike } from '../../fetch';
 import { getGlobalThis } from '../../web/getGlobalThis';
 
 export function createFetchWithProxyByNodeFetch({
-  proxy,
-  fetch,
+	proxy,
+	fetch,
 }: { proxy?: string; fetch?: FetchLike } = {}): FetchLike {
-  const globalThis = getGlobalThis();
-  if (!proxy) {
-    return fetch || globalThis.fetch;
-  }
+	const globalThis = getGlobalThis();
+	if (!proxy) {
+		return fetch || globalThis.fetch;
+	}
 
-  let agent: any;
-  const Request = globalThis.Request;
-  let NodeRequest: any;
-  let NodeFetch: any;
-  return async (url, init?: RequestInit) => {
-    if (!agent) {
-      const { default: createHttpsProxyAgent } = await import('https-proxy-agent');
-      agent = (createHttpsProxyAgent as any)(proxy);
-    }
+	let agent: any;
+	const Request = globalThis.Request;
+	let NodeRequest: any;
+	let NodeFetch: any;
+	return async (url, init?: RequestInit) => {
+		if (!agent) {
+			const { default: createHttpsProxyAgent } = await import('https-proxy-agent');
+			agent = (createHttpsProxyAgent as any)(proxy);
+		}
 
-    // node-fetch 才可以，node v18 fetch 不支持
-    if (!NodeRequest) {
-      ({ Request: NodeRequest, default: NodeFetch } = await import('node-fetch'));
-    }
+		// node-fetch 才可以，node v18 fetch 不支持
+		if (!NodeRequest) {
+			({ Request: NodeRequest, default: NodeFetch } = await import('node-fetch'));
+		}
 
-    fetch ||= NodeFetch;
+		fetch ||= NodeFetch;
 
-    if (url instanceof Request) {
-      return (fetch as any)(new Request(url, { agent } as any));
-    }
-    if ((url as any) instanceof NodeRequest) {
-      return (fetch as any)(new NodeRequest(url, { agent } as any));
-    }
-    return (fetch as any)(url, {
-      ...init,
-      agent,
-    } as any);
-  };
+		if (url instanceof Request) {
+			return (fetch as any)(new Request(url, { agent } as any));
+		}
+		if ((url as any) instanceof NodeRequest) {
+			return (fetch as any)(new NodeRequest(url, { agent } as any));
+		}
+		return (fetch as any)(url, { ...init, agent } as any);
+	};
 }

package/src/server/fetch/createFetchWithProxyByUndici.ts

@@ -3,77 +3,71 @@ import { createFetchWith, type FetchLike } from '../../fetch';
 import { getGlobalThis } from '../../web/getGlobalThis';
 
 export function createFetchWithProxyByUndici({
-  proxy,
-  token: _token,
-  fetch,
-  undici,
+	proxy,
+	token: _token,
+	fetch,
+	undici,
 }: {
-  proxy?: string;
-  token?: string;
-  fetch?: FetchLike;
-  undici?: MaybePromise<{ fetch: any; ProxyAgent: any }>;
+	proxy?: string;
+	token?: string;
+	fetch?: FetchLike;
+	undici?: MaybePromise<{ fetch: any; ProxyAgent: any }>;
 } = {}): FetchLike {
-  if (!proxy) {
-    return fetch || globalThis.fetch;
-  }
+	if (!proxy) {
+		return fetch || globalThis.fetch;
+	}
 
-  if ((getGlobalThis() as any).Bun) {
-    return createFetchWith({
-      fetch,
-      onRequest: ({ url, req, next }) => {
-        return next(url, {
-          ...req,
-          // https://github.com/oven-sh/bun/issues/1829
-          proxy,
-        } as RequestInit);
-      },
-    });
-  }
+	if ((getGlobalThis() as any).Bun) {
+		return createFetchWith({
+			fetch,
+			onRequest: ({ url, req, next }) => {
+				return next(url, {
+					...req,
+					// https://github.com/oven-sh/bun/issues/1829
+					proxy,
+				} as RequestInit);
+			},
+		});
+	}
 
-  let agent: any;
-  // https://github.com/nodejs/undici/blob/main/docs/best-practices/proxy.md
-  return async (...args) => {
-    const init = (args[1] ||= {}) as RequestInit & {
-      duplex?: string;
-      dispatcher?: any;
-    };
-    {
-      const body = init.body;
-      if (typeof body === 'object' && body && (body instanceof ReadableStream || Symbol.asyncIterator in body)) {
-        // request.duplex must be set if request.body is ReadableStream or Async Iterables
-        init.duplex ||= 'half';
-      }
-    }
-    if (!agent) {
-      let uri = proxy;
-      let token = _token;
-      {
-        let u: URL | undefined;
-        try {
-          u = new URL(proxy);
-        } catch (e) {}
-        if (!token && u && (u.username || u.password)) {
-          token = `Basic ${btoa(`${u.username || ''}:${u.password}`)}`;
-          u.username = '';
-          u.password = '';
-          uri = u.toString();
-        }
-      }
-      // if in next use 'next/dist/compiled/undici'
-      undici ||= import('undici');
-      const mod = await undici;
-      const ProxyAgent = mod.ProxyAgent as new (_: any) => any;
-      fetch ||= mod.fetch as FetchLike;
-      // https://github.com/nodejs/undici/blob/main/docs/api/ProxyAgent.md
-      agent = new ProxyAgent({
-        uri,
-        token,
-      });
-      // https://github.com/nodejs/node/issues/43187#issuecomment-1134634174
-      // (global as any)[Symbol.for('undici.globalDispatcher.1')] = agent;
-      // fixme should unwrap error https://github.com/nodejs/undici/issues/1248
-    }
-    init.dispatcher = agent;
-    return await fetch!(...args);
-  };
+	let agent: any;
+	// https://github.com/nodejs/undici/blob/main/docs/best-practices/proxy.md
+	return async (...args) => {
+		const init = (args[1] ||= {}) as RequestInit & { duplex?: string; dispatcher?: any };
+		{
+			const body = init.body;
+			if (typeof body === 'object' && body && (body instanceof ReadableStream || Symbol.asyncIterator in body)) {
+				// request.duplex must be set if request.body is ReadableStream or Async Iterables
+				init.duplex ||= 'half';
+			}
+		}
+		if (!agent) {
+			let uri = proxy;
+			let token = _token;
+			{
+				let u: URL | undefined;
+				try {
+					u = new URL(proxy);
+				} catch (e) {}
+				if (!token && u && (u.username || u.password)) {
+					token = `Basic ${btoa(`${u.username || ''}:${u.password}`)}`;
+					u.username = '';
+					u.password = '';
+					uri = u.toString();
+				}
+			}
+			// if in next use 'next/dist/compiled/undici'
+			undici ||= import('undici');
+			const mod = await undici;
+			const ProxyAgent = mod.ProxyAgent as new (_: any) => any;
+			fetch ||= mod.fetch as FetchLike;
+			// https://github.com/nodejs/undici/blob/main/docs/api/ProxyAgent.md
+			agent = new ProxyAgent({ uri, token });
+			// https://github.com/nodejs/node/issues/43187#issuecomment-1134634174
+			// (global as any)[Symbol.for('undici.globalDispatcher.1')] = agent;
+			// fixme should unwrap error https://github.com/nodejs/undici/issues/1248
+		}
+		init.dispatcher = agent;
+		return await fetch!(...args);
+	};
 }

package/src/server/getPackageDir.ts

@@ -6,13 +6,13 @@ import path from 'node:path';
 // const __dirname = path.dirname(__filename);
 
 export function getPackageDir(currentDir: string = process.cwd()) {
-  while (!fs.existsSync(path.join(currentDir, 'package.json'))) {
-    currentDir = path.resolve(currentDir, '..');
-    if (currentDir === '/') {
-      return undefined;
-    }
-  }
-  return currentDir;
+	while (!fs.existsSync(path.join(currentDir, 'package.json'))) {
+		currentDir = path.resolve(currentDir, '..');
+		if (currentDir === '/') {
+			return undefined;
+		}
+	}
+	return currentDir;
 }
 
 function findUp() {}

package/src/server/polyfill/polyfillBrowser.test.ts

@@ -4,17 +4,17 @@ import { polyfillBrowser } from './polyfillBrowser';
 import { polyfillFetch } from './polyfillFetch';
 
 beforeAll(async () => {
-  // return false in nodejs18
-  polyfillFetch(nodeFetch);
-  expect(polyfillFetch()).toBeFalsy();
-  await polyfillBrowser();
+	// return false in nodejs18
+	polyfillFetch(nodeFetch);
+	expect(polyfillFetch()).toBeFalsy();
+	await polyfillBrowser();
 });
 
 test('polyfillBrowser', () => {
-  expect(fetch).toBeTruthy();
-  expect(window).toBeTruthy();
-  expect(document).toBeTruthy();
-  expect(crypto).toBeTruthy();
-  // not the same
-  expect(window).not.toBe(globalThis);
+	expect(fetch).toBeTruthy();
+	expect(window).toBeTruthy();
+	expect(document).toBeTruthy();
+	expect(crypto).toBeTruthy();
+	// not the same
+	expect(window).not.toBe(globalThis);
 });

package/src/server/polyfill/polyfillBrowser.ts

@@ -11,7 +11,7 @@ import { polyfillJsDom } from './polyfillJsDom';
  * - `crypto`
  */
 export async function polyfillBrowser() {
-  await polyfillCrypto();
-  await polyfillFetch();
-  await polyfillJsDom();
+	await polyfillCrypto();
+	await polyfillFetch();
+	await polyfillJsDom();
 }

package/src/server/polyfill/polyfillCrypto.ts

@@ -1,10 +1,10 @@
 import { getGlobalThis } from '../../web/getGlobalThis';
 
 export async function polyfillCrypto() {
-  const globalThis = getGlobalThis();
-  if ('crypto' in globalThis) {
-    return false;
-  }
-  (globalThis as any).crypto = (await import('node:crypto')).webcrypto as Crypto;
-  return true;
+	const globalThis = getGlobalThis();
+	if ('crypto' in globalThis) {
+		return false;
+	}
+	(globalThis as any).crypto = (await import('node:crypto')).webcrypto as Crypto;
+	return true;
 }

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));
 }