@rsdoctor/utils 1.2.2 → 1.2.4-beta.0

package/compiled/connect/license

@@ -0,0 +1,25 @@
+(The MIT License)
+
+Copyright (c) 2010 Sencha Inc.
+Copyright (c) 2011 LearnBoost
+Copyright (c) 2011-2014 TJ Holowaychuk
+Copyright (c) 2015 Douglas Christopher Wilson
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/compiled/connect/package.json

@@ -0,0 +1 @@
+{"name":"connect","author":"TJ Holowaychuk <tj@vision-media.ca> (http://tjholowaychuk.com)","version":"3.7.0","license":"MIT","types":"index.d.ts","type":"commonjs"}

package/compiled/filesize/index.d.ts

@@ -0,0 +1,58 @@
+interface FileSizeOptionsBase {
+    base?: 10 | 2;
+    bits?: boolean;
+    exponent?: number;
+    fullform?: boolean;
+    fullforms?: string[];
+    locale?: string | boolean;
+    localeOptions?: Intl.DateTimeFormatOptions;
+    pad?: boolean;
+    precision?: number;
+    round?: number;
+    roundingMethod?: 'round' | 'floor' | 'ceil';
+    separator?: string;
+    spacer?: string;
+    standard?: 'si' | 'iec' | 'jedec';
+    symbols?: {};
+}
+
+interface FileSizeOptionsArray extends FileSizeOptionsBase {
+    output: 'array'
+}
+
+interface FileSizeOptionsExponent extends FileSizeOptionsBase {
+    output: 'exponent'
+}
+
+interface FileSizeOptionsObject extends FileSizeOptionsBase {
+    output: 'object'
+}
+
+interface FileSizeOptionsString extends FileSizeOptionsBase {
+    output: 'string'
+}
+
+interface FileSizeReturnObject {
+    value: string,
+    symbol: string,
+    exponent: number,
+    unit: string,
+}
+
+type FileSizeReturnArray = [ number, string ]
+
+type FileSizeOptionStringOrBase = FileSizeOptionsString | FileSizeOptionsBase;
+type FileSizeOptions = FileSizeOptionsArray | FileSizeOptionsExponent | FileSizeOptionsObject | FileSizeOptionStringOrBase | undefined
+type FileSizeReturnType<Options extends FileSizeOptions> =
+    Options extends FileSizeOptionsArray
+        ? FileSizeReturnArray
+        : Options extends FileSizeOptionsExponent
+        ? number
+        : Options extends FileSizeOptionsObject
+        ? FileSizeReturnObject
+        : string;
+
+declare function filesize<Options extends FileSizeOptions = undefined>(byteCount: number | string | bigint, options?: Options): FileSizeReturnType<Options> 
+declare function partial<Options extends FileSizeOptions = undefined>(options?: Options): (byteCount: number | string | bigint) => FileSizeReturnType<Options>
+
+export { filesize, partial };

package/compiled/filesize/index.js

@@ -0,0 +1,255 @@
+/******/ (() => { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	/* webpack/runtime/compat */
+/******/ 	
+/******/ 	if (typeof __nccwpck_require__ !== 'undefined') __nccwpck_require__.ab = __dirname + "/";
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// This entry need to be wrapped in an IIFE because it uses a non-standard name for the exports (exports).
+(() => {
+var exports = __webpack_exports__;
+/**
+ * filesize
+ *
+ * @copyright 2024 Jason Mulligan <jason.mulligan@avoidwork.com>
+ * @license BSD-3-Clause
+ * @version 10.1.6
+ */
+
+
+const ARRAY = "array";
+const BIT = "bit";
+const BITS = "bits";
+const BYTE = "byte";
+const BYTES = "bytes";
+const EMPTY = "";
+const EXPONENT = "exponent";
+const FUNCTION = "function";
+const IEC = "iec";
+const INVALID_NUMBER = "Invalid number";
+const INVALID_ROUND = "Invalid rounding method";
+const JEDEC = "jedec";
+const OBJECT = "object";
+const PERIOD = ".";
+const ROUND = "round";
+const S = "s";
+const SI = "si";
+const SI_KBIT = "kbit";
+const SI_KBYTE = "kB";
+const SPACE = " ";
+const STRING = "string";
+const ZERO = "0";
+const STRINGS = {
+	symbol: {
+		iec: {
+			bits: ["bit", "Kibit", "Mibit", "Gibit", "Tibit", "Pibit", "Eibit", "Zibit", "Yibit"],
+			bytes: ["B", "KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"]
+		},
+		jedec: {
+			bits: ["bit", "Kbit", "Mbit", "Gbit", "Tbit", "Pbit", "Ebit", "Zbit", "Ybit"],
+			bytes: ["B", "KB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"]
+		}
+	},
+	fullform: {
+		iec: ["", "kibi", "mebi", "gibi", "tebi", "pebi", "exbi", "zebi", "yobi"],
+		jedec: ["", "kilo", "mega", "giga", "tera", "peta", "exa", "zetta", "yotta"]
+	}
+};
+
+function filesize (arg, {
+	bits = false,
+	pad = false,
+	base = -1,
+	round = 2,
+	locale = EMPTY,
+	localeOptions = {},
+	separator = EMPTY,
+	spacer = SPACE,
+	symbols = {},
+	standard = EMPTY,
+	output = STRING,
+	fullform = false,
+	fullforms = [],
+	exponent = -1,
+	roundingMethod = ROUND,
+	precision = 0
+} = {}) {
+	let e = exponent,
+		num = Number(arg),
+		result = [],
+		val = 0,
+		u = EMPTY;
+
+	// Sync base & standard
+	if (standard === SI) {
+		base = 10;
+		standard = JEDEC;
+	} else if (standard === IEC || standard === JEDEC) {
+		base = 2;
+	} else if (base === 2) {
+		standard = IEC;
+	} else {
+		base = 10;
+		standard = JEDEC;
+	}
+
+	const ceil = base === 10 ? 1000 : 1024,
+		full = fullform === true,
+		neg = num < 0,
+		roundingFunc = Math[roundingMethod];
+
+	if (typeof arg !== "bigint" && isNaN(arg)) {
+		throw new TypeError(INVALID_NUMBER);
+	}
+
+	if (typeof roundingFunc !== FUNCTION) {
+		throw new TypeError(INVALID_ROUND);
+	}
+
+	// Flipping a negative number to determine the size
+	if (neg) {
+		num = -num;
+	}
+
+	// Determining the exponent
+	if (e === -1 || isNaN(e)) {
+		e = Math.floor(Math.log(num) / Math.log(ceil));
+
+		if (e < 0) {
+			e = 0;
+		}
+	}
+
+	// Exceeding supported length, time to reduce & multiply
+	if (e > 8) {
+		if (precision > 0) {
+			precision += 8 - e;
+		}
+
+		e = 8;
+	}
+
+	if (output === EXPONENT) {
+		return e;
+	}
+
+	// Zero is now a special case because bytes divide by 1
+	if (num === 0) {
+		result[0] = 0;
+		u = result[1] = STRINGS.symbol[standard][bits ? BITS : BYTES][e];
+	} else {
+		val = num / (base === 2 ? Math.pow(2, e * 10) : Math.pow(1000, e));
+
+		if (bits) {
+			val = val * 8;
+
+			if (val >= ceil && e < 8) {
+				val = val / ceil;
+				e++;
+			}
+		}
+
+		const p = Math.pow(10, e > 0 ? round : 0);
+		result[0] = roundingFunc(val * p) / p;
+
+		if (result[0] === ceil && e < 8 && exponent === -1) {
+			result[0] = 1;
+			e++;
+		}
+
+		u = result[1] = base === 10 && e === 1 ? bits ? SI_KBIT : SI_KBYTE : STRINGS.symbol[standard][bits ? BITS : BYTES][e];
+	}
+
+	// Decorating a 'diff'
+	if (neg) {
+		result[0] = -result[0];
+	}
+
+	// Setting optional precision
+	if (precision > 0) {
+		result[0] = result[0].toPrecision(precision);
+	}
+
+	// Applying custom symbol
+	result[1] = symbols[result[1]] || result[1];
+
+	if (locale === true) {
+		result[0] = result[0].toLocaleString();
+	} else if (locale.length > 0) {
+		result[0] = result[0].toLocaleString(locale, localeOptions);
+	} else if (separator.length > 0) {
+		result[0] = result[0].toString().replace(PERIOD, separator);
+	}
+
+	if (pad && round > 0) {
+		const i =  result[0].toString(),
+			x = separator || ((i.match(/(\D)/g) || []).pop() || PERIOD),
+			tmp = i.toString().split(x),
+			s = tmp[1] || EMPTY,
+			l = s.length,
+			n = round - l;
+
+		result[0] = `${tmp[0]}${x}${s.padEnd(l + n, ZERO)}`;
+	}
+
+	if (full) {
+		result[1] = fullforms[e] ? fullforms[e] : STRINGS.fullform[standard][e] + (bits ? BIT : BYTE) + (result[0] === 1 ? EMPTY : S);
+	}
+
+	// Returning Array, Object, or String (default)
+	return output === ARRAY ? result : output === OBJECT ? {
+		value: result[0],
+		symbol: result[1],
+		exponent: e,
+		unit: u
+	} : result.join(spacer);
+}
+
+// Partial application for functional programming
+function partial ({
+	bits = false,
+	pad = false,
+	base = -1,
+	round = 2,
+	locale = EMPTY,
+	localeOptions = {},
+	separator = EMPTY,
+	spacer = SPACE,
+	symbols = {},
+	standard = EMPTY,
+	output = STRING,
+	fullform = false,
+	fullforms = [],
+	exponent = -1,
+	roundingMethod = ROUND,
+	precision = 0
+} = {}) {
+	return arg => filesize(arg, {
+		bits,
+		pad,
+		base,
+		round,
+		locale,
+		localeOptions,
+		separator,
+		spacer,
+		symbols,
+		standard,
+		output,
+		fullform,
+		fullforms,
+		exponent,
+		roundingMethod,
+		precision
+	});
+}
+
+exports.filesize = filesize;
+exports.partial = partial;
+
+})();
+
+module.exports = __webpack_exports__;
+/******/ })()
+;

package/compiled/filesize/license

@@ -0,0 +1,28 @@
+Copyright (c) 2024, Jason Mulligan
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+  list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice,
+  this list of conditions and the following disclaimer in the documentation
+  and/or other materials provided with the distribution.
+
+* Neither the name of filesize nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

package/compiled/filesize/package.json

@@ -0,0 +1 @@
+{"name":"filesize","author":"Jason Mulligan <jason.mulligan@avoidwork.com>","version":"10.1.6","license":"BSD-3-Clause","types":"index.d.ts","type":"commonjs"}

package/dist/{type/build → build}/envinfo.d.ts

@@ -11,4 +11,3 @@ export declare function getGlobalNpmPackageVersion(pkg: string): Promise<string>
 export declare function getGlobalNpmPackageVersion(pkgs: string[]): Promise<string[]>;
 export declare function getGitBranch(): Promise<string>;
 export declare function getGitRepo(): Promise<string>;
-//# sourceMappingURL=envinfo.d.ts.map

package/dist/{type/build → build}/file/cache.d.ts

@@ -3,4 +3,3 @@ export declare function readFile(path: string): Promise<string>;
 export declare function readFileSync(path: string): string;
 export declare function readJSON<T extends Common.PlainObject>(path: string): Promise<T>;
 export declare function readJSONSync<T extends Common.PlainObject>(path: string): T;
-//# sourceMappingURL=cache.d.ts.map

package/dist/build/file/index.d.ts

@@ -0,0 +1,3 @@
+export * from './sharding';
+export * as fse from 'fs-extra/esm';
+export * as cache from './cache';

package/dist/{type/build → build}/file/sharding.d.ts

@@ -19,4 +19,3 @@ export declare class FileSharding {
         content: Buffer<ArrayBufferLike>;
     }[]>;
 }
-//# sourceMappingURL=sharding.d.ts.map

package/dist/{type/build → build}/index.d.ts

@@ -3,4 +3,3 @@ export * as Json from './json';
 export * as Server from './server';
 export * as EnvInfo from './envinfo';
 export * as Process from './process';
-//# sourceMappingURL=index.d.ts.map

package/dist/{type/build → build}/json.d.ts

@@ -1,4 +1,3 @@
 import { SDK } from '@rsdoctor/types';
 export declare function stringify<T, P = T extends undefined ? undefined : string>(json: T, replacer?: (this: any, key: string, value: any) => any, space?: string | number, cycle?: boolean): Promise<P>;
 export declare const readPackageJson: (file: string, readFile?: SDK.GetPackageFile) => SDK.PackageBasicData | undefined;
-//# sourceMappingURL=json.d.ts.map

package/dist/{type/build → build}/process.d.ts

@@ -1,3 +1,2 @@
 export declare function getMemoryUsage(): NodeJS.MemoryUsage;
 export declare function getMemoryUsageMessage(): string;
-//# sourceMappingURL=process.d.ts.map

package/dist/{type/build → build}/server.d.ts

@@ -12,4 +12,3 @@ export declare function createServer(port: number): Promise<{
     port: number;
     close(): Promise<void> | never;
 }>;
-//# sourceMappingURL=server.d.ts.map