@visulima/package 3.5.1 → 3.5.3

package/dist/packem_shared/{package-json-B2CLbuXK.d.mts → package-json-DvaC9k-3.d.cts}

@@ -423,52 +423,6 @@ type BuildTuple<L extends number, Fill = unknown, T extends readonly unknown[] =
 		? T
 		: BuildTuple<L, Fill, [...T, Fill]>;
 
-/**
-Returns the maximum value from a tuple of integers.
-
-Note:
-- Float numbers are not supported.
-
-@example
-```
-ArrayMax<[1, 2, 5, 3]>;
-//=> 5
-
-ArrayMax<[1, 2, 5, 3, 99, -1]>;
-//=> 99
-```
-*/
-type TupleMax<A extends number[], Result extends number = NegativeInfinity> = number extends A[number]
-	? never :
-	A extends [infer F extends number, ...infer R extends number[]]
-		? GreaterThan<F, Result> extends true
-			? TupleMax<R, F>
-			: TupleMax<R, Result>
-		: Result;
-
-/**
-Returns the minimum value from a tuple of integers.
-
-Note:
-- Float numbers are not supported.
-
-@example
-```
-ArrayMin<[1, 2, 5, 3]>;
-//=> 1
-
-ArrayMin<[1, 2, 5, 3, -5]>;
-//=> -5
-```
-*/
-type TupleMin<A extends number[], Result extends number = PositiveInfinity> = number extends A[number]
-	? never
-	: A extends [infer F extends number, ...infer R extends number[]]
-		? LessThan<F, Result> extends true
-			? TupleMin<R, F>
-			: TupleMin<R, Result>
-		: Result;
-
 /**
 Return a string representation of the given string or number.
 
@@ -663,85 +617,46 @@ type IsNumberLike<N> =
 				: false;
 
 /**
-Matches any primitive, `void`, `Date`, or `RegExp` value.
-*/
-type BuiltIns = Primitive | void | Date | RegExp;
-
-/**
-Matches non-recursive types.
-*/
-type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
-
-/**
-Returns the sum of two numbers.
-
-Note:
-- A or B can only support `-999` ~ `999`.
-- A and B can only be small integers, less than 1000.
-- If the result is negative, you can only get `number`.
+Returns the number with reversed sign.
 
 @example
 ```
-import type {Sum} from 'type-fest';
-
-Sum<111, 222>;
-//=> 333
-
-Sum<-111, 222>;
-//=> 111
+ReverseSign<-1>;
+//=> 1
 
-Sum<111, -222>;
-//=> number
+ReverseSign<1>;
+//=> -1
 
-Sum<PositiveInfinity, -9999>;
+ReverseSign<NegativeInfinity>
 //=> PositiveInfinity
 
-Sum<PositiveInfinity, NegativeInfinity>;
-//=> number
+ReverseSign<PositiveInfinity>
+//=> NegativeInfinity
 ```
+*/
+type ReverseSign<N extends number> =
+	// Handle edge cases
+	N extends 0 ? 0 : N extends PositiveInfinity ? NegativeInfinity : N extends NegativeInfinity ? PositiveInfinity :
+	// Handle negative numbers
+	`${N}` extends `-${infer P extends number}` ? P
+		// Handle positive numbers
+		: `-${N}` extends `${infer R extends number}` ? R : never;
 
-@category Numeric
+/**
+Matches any primitive, `void`, `Date`, or `RegExp` value.
 */
-// TODO: Support big integer and negative number.
-type Sum<A extends number, B extends number> = number extends A | B
-	? number
-	: [
-		IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
-		IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
-	] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-		And<IsEqual<R[0], true>, IsEqual<R[3], false>>,
-		And<IsEqual<R[2], true>, IsEqual<R[1], false>>
-		> extends true
-			? PositiveInfinity
-			: Or<
-			And<IsEqual<R[1], true>, IsEqual<R[2], false>>,
-			And<IsEqual<R[3], true>, IsEqual<R[0], false>>
-			> extends true
-				? NegativeInfinity
-				: true extends R[number]
-					? number
-					: ([IsNegative<A>, IsNegative<B>] extends infer R
-						? [false, false] extends R
-							? [...BuildTuple<A>, ...BuildTuple<B>]['length']
-							: [true, true] extends R
-								? number
-								: TupleMax<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Max_
-									? TupleMin<[NumberAbsolute<A>, NumberAbsolute<B>]> extends infer Min_ extends number
-										? Max_ extends A | B
-											? Subtract<Max_, Min_>
-											: number
-										: never
-									: never
-						: never) & number
-		: never;
+type BuiltIns = Primitive | void | Date | RegExp;
+
+/**
+Matches non-recursive types.
+*/
+type NonRecursiveType = BuiltIns | Function | (new (...arguments_: any[]) => unknown);
 
 /**
 Returns the difference between two numbers.
 
 Note:
 - A or B can only support `-999` ~ `999`.
-- If the result is negative, you can only get `number`.
 
 @example
 ```
@@ -754,7 +669,10 @@ Subtract<111, -222>;
 //=> 333
 
 Subtract<-111, 222>;
-//=> number
+//=> -333
+
+Subtract<18, 96>;
+//=> -78
 
 Subtract<PositiveInfinity, 9999>;
 //=> PositiveInfinity
@@ -765,38 +683,53 @@ Subtract<PositiveInfinity, PositiveInfinity>;
 
 @category Numeric
 */
-// TODO: Support big integer and negative number.
-type Subtract<A extends number, B extends number> = number extends A | B
-	? number
-	: [
-		IsEqual<A, PositiveInfinity>, IsEqual<A, NegativeInfinity>,
-		IsEqual<B, PositiveInfinity>, IsEqual<B, NegativeInfinity>,
-	] extends infer R extends [boolean, boolean, boolean, boolean]
-		? Or<
-		And<IsEqual<R[0], true>, IsEqual<R[2], false>>,
-		And<IsEqual<R[3], true>, IsEqual<R[1], false>>
-		> extends true
-			? PositiveInfinity
-			: Or<
-			And<IsEqual<R[1], true>, IsEqual<R[3], false>>,
-			And<IsEqual<R[2], true>, IsEqual<R[0], false>>
-			> extends true
-				? NegativeInfinity
-				: true extends R[number]
-					? number
-					: [IsNegative<A>, IsNegative<B>] extends infer R
-						? [false, false] extends R
-							? BuildTuple<A> extends infer R
-								? R extends [...BuildTuple<B>, ...infer R]
-									? R['length']
-									: number
-								: never
-							: LessThan<A, B> extends true
-								? number
-								: [false, true] extends R
-									? Sum<A, NumberAbsolute<B>>
-									: Subtract<NumberAbsolute<B>, NumberAbsolute<A>>
-						: never
+// TODO: Support big integer.
+type Subtract<A extends number, B extends number> =
+	// Handle cases when A or B is the actual "number" type
+	number extends A | B ? number
+		// Handle cases when A and B are both +/- infinity
+		: A extends B & (PositiveInfinity | NegativeInfinity) ? number
+			// Handle cases when A is - infinity or B is + infinity
+			: A extends NegativeInfinity ? NegativeInfinity : B extends PositiveInfinity ? NegativeInfinity
+				// Handle cases when A is + infinity or B is - infinity
+				: A extends PositiveInfinity ? PositiveInfinity : B extends NegativeInfinity ? PositiveInfinity
+					// Handle case when numbers are equal to each other
+					: A extends B ? 0
+						// Handle cases when A or B is 0
+						: A extends 0 ? ReverseSign<B> : B extends 0 ? A
+							// Handle remaining regular cases
+							: SubtractPostChecks<A, B>;
+
+/**
+Subtracts two numbers A and B, such that they are not equal and neither of them are 0, +/- infinity or the `number` type
+*/
+type SubtractPostChecks<A extends number, B extends number, AreNegative = [IsNegative<A>, IsNegative<B>]> =
+	AreNegative extends [false, false]
+		? SubtractPositives<A, B>
+		: AreNegative extends [true, true]
+			// When both numbers are negative we subtract the absolute values and then reverse the sign
+			? ReverseSign<SubtractPositives<NumberAbsolute<A>, NumberAbsolute<B>>>
+			// When the signs are different we can add the absolute values and then reverse the sign if A < B
+			: [...BuildTuple<NumberAbsolute<A>>, ...BuildTuple<NumberAbsolute<B>>] extends infer R extends unknown[]
+				? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length']
+				: never;
+
+/**
+Subtracts two positive numbers.
+*/
+type SubtractPositives<A extends number, B extends number> =
+	LessThan<A, B> extends true
+		// When A < B we can reverse the result of B - A
+		? ReverseSign<SubtractIfAGreaterThanB<B, A>>
+		: SubtractIfAGreaterThanB<A, B>;
+
+/**
+Subtracts two positive numbers A and B such that A > B.
+*/
+type SubtractIfAGreaterThanB<A extends number, B extends number> =
+	// This is where we always want to end up and do the actual subtraction
+	BuildTuple<A> extends [...BuildTuple<B>, ...infer R]
+		? R['length']
 		: never;
 
 /**
@@ -844,11 +777,89 @@ type PathsOptions = {
 	```
 	*/
 	bracketNotation?: boolean;
+
+	/**
+	Only include leaf paths in the output.
+
+	@default false
+
+	@example
+	```
+	type Post = {
+		id: number;
+		author: {
+			id: number;
+			name: {
+				first: string;
+				last: string;
+			};
+		};
+	};
+
+	type AllPaths = Paths<Post, {leavesOnly: false}>;
+	//=> 'id' | 'author' | 'author.id' | 'author.name' | 'author.name.first' | 'author.name.last'
+
+	type LeafPaths = Paths<Post, {leavesOnly: true}>;
+	//=> 'id' | 'author.id' | 'author.name.first' | 'author.name.last'
+	```
+
+	@example
+	```
+	type ArrayExample = {
+		array: Array<{foo: string}>;
+		tuple: [string, {bar: string}];
+	};
+
+	type AllPaths = Paths<ArrayExample, {leavesOnly: false}>;
+	//=> 'array' | `array.${number}` | `array.${number}.foo` | 'tuple' | 'tuple.0' | 'tuple.1' | 'tuple.1.bar'
+
+	type LeafPaths = Paths<ArrayExample, {leavesOnly: true}>;
+	//=> `array.${number}.foo` | 'tuple.0' | 'tuple.1.bar'
+	```
+	*/
+	leavesOnly?: boolean;
+
+	/**
+	Only include paths at the specified depth. By default all paths up to {@link PathsOptions.maxRecursionDepth | `maxRecursionDepth`} are included.
+
+	Note: Depth starts at `0` for root properties.
+
+	@default number
+
+	@example
+	```
+	type Post = {
+		id: number;
+		author: {
+			id: number;
+			name: {
+				first: string;
+				last: string;
+			};
+		};
+	};
+
+	type DepthZero = Paths<Post, {depth: 0}>;
+	//=> 'id' | 'author'
+
+	type DepthOne = Paths<Post, {depth: 1}>;
+	//=> 'author.id' | 'author.name'
+
+	type DepthTwo = Paths<Post, {depth: 2}>;
+	//=> 'author.name.first' | 'author.name.last'
+
+	type LeavesAtDepthOne = Paths<Post, {leavesOnly: true; depth: 1}>;
+	//=> 'author.id'
+	```
+	*/
+	depth?: number;
 };
 
 type DefaultPathsOptions = {
 	maxRecursionDepth: 10;
 	bracketNotation: false;
+	leavesOnly: false;
+	depth: number;
 };
 
 /**
@@ -897,6 +908,10 @@ type Paths<T, Options extends PathsOptions = {}> = _Paths<T, {
 	maxRecursionDepth: Options['maxRecursionDepth'] extends number ? Options['maxRecursionDepth'] : DefaultPathsOptions['maxRecursionDepth'];
 	// Set default bracketNotation to false
 	bracketNotation: Options['bracketNotation'] extends boolean ? Options['bracketNotation'] : DefaultPathsOptions['bracketNotation'];
+	// Set default leavesOnly to false
+	leavesOnly: Options['leavesOnly'] extends boolean ? Options['leavesOnly'] : DefaultPathsOptions['leavesOnly'];
+	// Set default depth to number
+	depth: Options['depth'] extends number ? Options['depth'] : DefaultPathsOptions['depth'];
 }>;
 
 type _Paths<T, Options extends Required<PathsOptions>> =
@@ -936,11 +951,30 @@ type InternalPaths<T, Options extends Required<PathsOptions>> =
 						) extends infer TranformedKey extends string | number ?
 						// 1. If style is 'a[0].b' and 'Key' is a numberlike value like 3 or '3', transform 'Key' to `[${Key}]`, else to `${Key}` | Key
 						// 2. If style is 'a.0.b', transform 'Key' to `${Key}` | Key
-							| TranformedKey
+							| ((Options['leavesOnly'] extends true
+								? MaxDepth extends 0
+									? TranformedKey
+									: T[Key] extends EmptyObject | readonly [] | NonRecursiveType | ReadonlyMap<unknown, unknown> | ReadonlySet<unknown>
+										? TranformedKey
+										: never
+								: TranformedKey
+							) extends infer _TransformedKey
+								// If `depth` is provided, the condition becomes truthy only when it reaches `0`.
+								// Otherwise, since `depth` defaults to `number`, the condition is always truthy, returning paths at all depths.
+								? 0 extends Options['depth']
+									? _TransformedKey
+									: never
+								: never)
 							| (
 								// Recursively generate paths for the current key
 								GreaterThan<MaxDepth, 0> extends true // Limit the depth to prevent infinite recursion
-									? _Paths<T[Key], {bracketNotation: Options['bracketNotation']; maxRecursionDepth: Subtract<MaxDepth, 1>}> extends infer SubPath
+									? _Paths<T[Key],
+									{
+										bracketNotation: Options['bracketNotation'];
+										maxRecursionDepth: Subtract<MaxDepth, 1>;
+										leavesOnly: Options['leavesOnly'];
+										depth: Subtract<Options['depth'], 1>;
+									}> extends infer SubPath
 										? SubPath extends string | number
 											? (
 												Options['bracketNotation'] extends true
@@ -1860,10 +1894,10 @@ type NormalizedReadResult = {
 };
 declare const findPackageJson: (cwd?: URL | string, options?: ReadOptions) => Promise<NormalizedReadResult>;
 declare const findPackageJsonSync: (cwd?: URL | string, options?: ReadOptions) => NormalizedReadResult;
-declare const writePackageJson: <T = PackageJson$1>(data: T, options?: WriteJsonOptions & {
+declare const writePackageJson: <T = PackageJson>(data: T, options?: WriteJsonOptions & {
     cwd?: URL | string;
 }) => Promise<void>;
-declare const writePackageJsonSync: <T = PackageJson$1>(data: T, options?: WriteJsonOptions & {
+declare const writePackageJsonSync: <T = PackageJson>(data: T, options?: WriteJsonOptions & {
     cwd?: URL | string;
 }) => void;
 declare const parsePackageJson: (packageFile: JsonObject | string, options?: {