@augment-vir/core 32.1.0 → 32.2.1

package/dist/augments/type/primitive-type.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Matches any [primitive value](https://developer.mozilla.org/en-US/docs/Glossary/Primitive).
+ *
+ * Copied from the `Primitive` type in the `type-fest` package so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Primitive = null | undefined | string | number | boolean | symbol | bigint;

package/dist/augments/type/primitive-type.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/promisable.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Create a type that represents either the value or the value wrapped in `PromiseLike`.
+ *
+ * Copied from the `Promisable` type in the `type-fest` package so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Async
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Promisable<T> = T | PromiseLike<T>;

package/dist/augments/type/promisable.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/readonly-deep.d.ts

@@ -0,0 +1,30 @@
+import { type BuiltIns, type HasMultipleCallSignatures } from './built-in-type.js';
+type ReadonlyMapDeep<KeyType, ValueType> = {} & Readonly<ReadonlyMap<ReadonlyDeep<KeyType>, ReadonlyDeep<ValueType>>>;
+type ReadonlySetDeep<ItemType> = {} & Readonly<ReadonlySet<ReadonlyDeep<ItemType>>>;
+type ReadonlyObjectDeep<ObjectType extends object> = {
+    readonly [KeyType in keyof ObjectType]: ReadonlyDeep<ObjectType[KeyType]>;
+};
+/**
+ * Create a deeply immutable version of another type.
+ *
+ * Copied from the `ReadonlyDeep` type in the `type-fest` package so that this package's public
+ * types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type ReadonlyDeep<T> = T extends BuiltIns ? T : T extends new (...arguments_: any[]) => unknown ? T : T extends (...arguments_: any[]) => unknown ? {} extends ReadonlyObjectDeep<T> ? T : HasMultipleCallSignatures<T> extends true ? T : ((...arguments_: Parameters<T>) => ReturnType<T>) & ReadonlyObjectDeep<T> : T extends Readonly<ReadonlyMap<infer KeyType, infer ValueType>> ? ReadonlyMapDeep<KeyType, ValueType> : T extends Readonly<ReadonlySet<infer ItemType>> ? ReadonlySetDeep<ItemType> : T extends readonly [] | readonly [...never[]] ? readonly [] : T extends readonly [
+    infer U,
+    ...infer V
+] ? readonly [
+    ReadonlyDeep<U>,
+    ...ReadonlyDeep<V>
+] : T extends readonly [
+    ...infer U,
+    infer V
+] ? readonly [
+    ...ReadonlyDeep<U>,
+    ReadonlyDeep<V>
+] : T extends ReadonlyArray<infer ItemType> ? ReadonlyArray<ReadonlyDeep<ItemType>> : T extends object ? ReadonlyObjectDeep<T> : unknown;
+export {};

package/dist/augments/type/readonly-deep.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/readonly-keys-of.d.ts

@@ -0,0 +1,20 @@
+import { type IsAny, type IsEqual } from './type-checks.js';
+type IsReadonlyKeyOf<Type extends object, Key extends keyof Type> = IsAny<Type | Key> extends true ? never : Key extends unknown ? Type extends unknown ? IsEqual<{
+    [K in Key]: Type[Key];
+}, {
+    readonly [K in Key]: Type[Key];
+}> : never : never;
+/**
+ * Extract all readonly keys from the given type.
+ *
+ * Copied from the `ReadonlyKeysOf` type in the `type-fest` package so that this package's public
+ * types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type ReadonlyKeysOf<Type extends object> = Type extends unknown ? keyof {
+    [Key in keyof Type as IsReadonlyKeyOf<Type, Key> extends false ? never : Key]: never;
+} & keyof Type : never;
+export {};

package/dist/augments/type/readonly-keys-of.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/require-keys.d.ts

@@ -0,0 +1,47 @@
+import { type RequiredKeysOf } from '../object/required-keys.js';
+import { type If, type IfNotAnyOrNever } from './conditional-type.js';
+import { type Except } from './except.js';
+import { type IsAny, type IsNever } from './type-checks.js';
+/**
+ * Returns `true` if the given object type has at least one required key, otherwise `false`.
+ *
+ * Copied from the `HasRequiredKeys` type in `type-fest` v5.6 (built on {@link RequiredKeysOf}) so
+ * that this package's public types do not depend on `type-fest` (see the note in
+ * `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type HasRequiredKeys<BaseType extends object> = RequiredKeysOf<BaseType> extends never ? false : true;
+type RequireExactlyOneHelper<ObjectType, KeysType extends keyof ObjectType> = {
+    [Key in KeysType]: Required<Pick<ObjectType, Key>> & Partial<Record<Exclude<KeysType, Key>, never>>;
+}[KeysType] & Omit<ObjectType, KeysType>;
+/**
+ * Create a type that requires exactly one of the given keys and disallows the rest, while keeping
+ * the remaining (non-listed) keys as is.
+ *
+ * Copied from the `RequireExactlyOne` type in `type-fest` v5.6 so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type RequireExactlyOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever<KeysType>, never, RequireExactlyOneHelper<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
+type RequireAtLeastOneHelper<ObjectType, KeysType extends keyof ObjectType> = {
+    [Key in KeysType]-?: Required<Pick<ObjectType, Key>> & Partial<Pick<ObjectType, Exclude<KeysType, Key>>>;
+}[KeysType] & Except<ObjectType, KeysType>;
+/**
+ * Create a type that requires at least one of the given keys, while keeping the remaining
+ * (non-listed) keys as is.
+ *
+ * Copied from the `RequireAtLeastOne` type in `type-fest` v5.6 so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type RequireAtLeastOne<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever<KeysType>, never, RequireAtLeastOneHelper<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
+export {};

package/dist/augments/type/require-keys.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/require-one-or-none.d.ts

@@ -0,0 +1,18 @@
+import { type If, type IfNotAnyOrNever } from './conditional-type.js';
+import { type RequireExactlyOne } from './require-keys.js';
+import { type IsAny, type IsNever } from './type-checks.js';
+type RequireNone<KeysType extends PropertyKey> = Partial<Record<KeysType, never>>;
+type RequireOneOrNoneHelper<ObjectType, KeysType extends keyof ObjectType> = (RequireExactlyOne<ObjectType, KeysType> | RequireNone<KeysType>) & Omit<ObjectType, KeysType>;
+/**
+ * Create a type that requires exactly one of the given keys or none of the given keys, while
+ * keeping the remaining keys as is.
+ *
+ * Copied from the `RequireOneOrNone` type in `type-fest` v5.6 so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type RequireOneOrNone<ObjectType, KeysType extends keyof ObjectType = keyof ObjectType> = IfNotAnyOrNever<ObjectType, If<IsNever<KeysType>, ObjectType, RequireOneOrNoneHelper<ObjectType, If<IsAny<KeysType>, keyof ObjectType, KeysType>>>>;
+export {};

package/dist/augments/type/require-one-or-none.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/set-optional.d.ts

@@ -0,0 +1,19 @@
+import { type Except } from './except.js';
+import { type KeysOfUnion } from './keys-of-union.js';
+import { type Simplify } from './simplify.js';
+type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
+    [P in keyof T as Extract<P, Keys>]: T[P];
+};
+type _SetOptional<BaseType, Keys extends keyof BaseType> = BaseType extends unknown ? Simplify<Except<BaseType, Keys> & Partial<HomomorphicPick<BaseType, Keys>>> : never;
+/**
+ * Create a type that makes the given keys optional, while keeping the remaining keys as is.
+ *
+ * Copied from the `SetOptional` type in the `type-fest` package so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type SetOptional<BaseType, Keys extends keyof BaseType> = (BaseType extends (...arguments_: never) => any ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetOptional<BaseType, Keys>;
+export {};

package/dist/augments/type/set-optional.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/set-required.d.ts

@@ -0,0 +1,47 @@
+import { type If } from './conditional-type.js';
+import { type Except } from './except.js';
+import { type KeysOfUnion } from './keys-of-union.js';
+import { type OptionalKeysOf } from './optional-keys-of.js';
+import { type Simplify } from './simplify.js';
+import { type IsNever } from './type-checks.js';
+import { type UnknownArray } from './unknown-array.js';
+type HomomorphicPick<T, Keys extends KeysOfUnion<T>> = {
+    [P in keyof T as Extract<P, Keys>]: T[P];
+};
+type IsArrayReadonly<T extends UnknownArray> = If<IsNever<T>, false, T extends unknown[] ? false : true>;
+/** Remove the optional modifier from the specified keys in an array. */
+type SetArrayRequired<TArray extends UnknownArray, Keys, Counter extends any[] = [], Accumulator extends UnknownArray = []> = TArray extends unknown ? keyof TArray & `${number}` extends never ? [
+    ...Accumulator,
+    ...TArray
+] : TArray extends readonly [
+    (infer First)?,
+    ...infer Rest
+] ? '0' extends OptionalKeysOf<TArray> ? `${Counter['length']}` extends `${Keys & (string | number)}` ? SetArrayRequired<Rest, Keys, [
+    ...Counter,
+    any
+], [
+    ...Accumulator,
+    First
+]> : [
+    ...Accumulator,
+    ...TArray
+] : SetArrayRequired<Rest, Keys, [
+    ...Counter,
+    any
+], [
+    ...Accumulator,
+    TArray[0]
+]> : never : never;
+type _SetRequired<BaseType, Keys extends keyof BaseType> = BaseType extends UnknownArray ? SetArrayRequired<BaseType, Keys> extends infer ResultantArray ? If<IsArrayReadonly<BaseType>, Readonly<ResultantArray>, ResultantArray> : never : Simplify<Except<BaseType, Keys> & Required<HomomorphicPick<BaseType, Keys>>>;
+/**
+ * Create a type that makes the given keys required, while keeping the remaining keys as is.
+ *
+ * Copied from the `SetRequired` type in the `type-fest` package so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type SetRequired<BaseType, Keys extends keyof BaseType> = (BaseType extends (...arguments_: never) => any ? (...arguments_: Parameters<BaseType>) => ReturnType<BaseType> : unknown) & _SetRequired<BaseType, Keys>;
+export {};

package/dist/augments/type/set-required.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/simplify.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Flattens the type output to improve type hints shown in editors. Also transforms an interface
+ * into a type to aid with assignability.
+ *
+ * Copied from the `Simplify` type in the `type-fest` package so that this package's public types do
+ * not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Simplify<T> = {
+    [KeyType in keyof T]: T[KeyType];
+} & {};

package/dist/augments/type/simplify.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/subtract.d.ts

@@ -0,0 +1,177 @@
+import { type NegativeInfinity, type PositiveInfinity } from '../number/infinity.js';
+import { type If } from './conditional-type.js';
+import { type IsAny, type IsEqual, type IsNever } from './type-checks.js';
+import { type UnknownArray } from './unknown-array.js';
+type Numeric = number | bigint;
+type Zero = 0 | 0n;
+type Negative<T extends Numeric> = T extends Zero ? never : `${T}` extends `-${string}` ? T : never;
+type IsNegative<T extends Numeric> = T extends Negative<T> ? true : false;
+type ReverseSign<N extends number> = N extends 0 ? 0 : N extends PositiveInfinity ? NegativeInfinity : N extends NegativeInfinity ? PositiveInfinity : `${N}` extends `-${infer P extends number}` ? P : `-${N}` extends `${infer R extends number}` ? R : never;
+type StringToNumber<S extends string> = S extends `${infer N extends number}` ? N : S extends 'Infinity' ? PositiveInfinity : S extends '-Infinity' ? NegativeInfinity : never;
+type Absolute<N extends number | bigint> = N extends bigint ? `${N}` extends `-${infer Magnitude extends bigint}` ? Magnitude : N : `${N}` extends `-${infer Magnitude}` ? StringToNumber<Magnitude> : N;
+type IfNotAnyOrNever<T, IfNotAny, IfAny = any, IfNever = never> = If<IsAny<T>, IfAny, If<IsNever<T>, IfNever, IfNotAny>>;
+type DigitCharacter = '0' | '1' | '2' | '3' | '4' | '5' | '6' | '7' | '8' | '9';
+type DigitTupleOf<Digit extends DigitCharacter, Fill> = [
+    [
+    ],
+    [
+        Fill
+    ],
+    [
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ],
+    [
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill,
+        Fill
+    ]
+][Digit];
+type RepeatTupleTenTimes<Tuple extends UnknownArray> = [
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple,
+    ...Tuple
+];
+type BuildTupleDigitByDigit<Length extends string, Fill, Accumulator extends UnknownArray = []> = Length extends `${infer First extends DigitCharacter}${infer Rest}` ? BuildTupleDigitByDigit<Rest, Fill, [
+    ...RepeatTupleTenTimes<Accumulator>,
+    ...DigitTupleOf<First, Fill>
+]> : Accumulator;
+type BuildTuple<Length extends number, Fill> = number extends Length ? Fill[] : BuildTupleDigitByDigit<`${Length}`, Fill>;
+type TupleOf<Length extends number, Fill = unknown> = IfNotAnyOrNever<Length, BuildTuple<If<IsNegative<Length>, 0, Length>, Fill>, Fill[], [
+]>;
+type And<A extends boolean, B extends boolean> = A extends true ? B extends true ? true : false : false;
+type Or<A extends boolean, B extends boolean> = A extends true ? true : B extends true ? true : false;
+type StringToArray<S extends string, Result extends string[] = []> = string extends S ? never : S extends `${infer F}${infer R}` ? StringToArray<R, [
+    ...Result,
+    F
+]> : Result;
+type StringLength<S extends string> = string extends S ? never : StringToArray<S>['length'];
+type NumericString = '0123456789';
+type PositiveNumericCharacterGt<A extends string, B extends string> = NumericString extends `${infer HeadA}${A}${infer TailA}` ? NumericString extends `${infer HeadB}${B}${infer TailB}` ? HeadA extends `${HeadB}${infer _}${infer __}` ? true : false : never : never;
+type SameLengthPositiveNumericStringGt<A extends string, B extends string> = A extends `${infer FirstA}${infer RestA}` ? B extends `${infer FirstB}${infer RestB}` ? FirstA extends FirstB ? SameLengthPositiveNumericStringGt<RestA, RestB> : PositiveNumericCharacterGt<FirstA, FirstB> : never : false;
+type PositiveNumericStringGt<A extends string, B extends string> = A extends B ? false : [
+    TupleOf<StringLength<A>, 0>,
+    TupleOf<StringLength<B>, 0>
+] extends infer R extends [
+    readonly unknown[],
+    readonly unknown[]
+] ? R[0] extends [
+    ...R[1],
+    ...infer Remain extends readonly unknown[]
+] ? 0 extends Remain['length'] ? SameLengthPositiveNumericStringGt<A, B> : true : false : never;
+type GreaterThan<A extends number, B extends number> = A extends number ? B extends number ? number extends A | B ? boolean : [
+    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 ? true : Or<And<IsEqual<R[1], true>, IsEqual<R[3], false>>, And<IsEqual<R[2], true>, IsEqual<R[0], false>>> extends true ? false : true extends R[number] ? false : [
+    IsNegative<A>,
+    IsNegative<B>
+] extends infer R extends [
+    boolean,
+    boolean
+] ? [
+    true,
+    false
+] extends R ? false : [
+    false,
+    true
+] extends R ? true : [
+    false,
+    false
+] extends R ? PositiveNumericStringGt<`${A}`, `${B}`> : PositiveNumericStringGt<`${Absolute<B>}`, `${Absolute<A>}`> : never : never : never : never;
+type GreaterThanOrEqual<A extends number, B extends number> = number extends A | B ? boolean : A extends number ? B extends number ? A extends B ? true : GreaterThan<A, B> : never : never;
+type LessThan<A extends number, B extends number> = GreaterThanOrEqual<A, B> extends infer Result ? (Result extends true ? false : true) : never;
+type SubtractIfAGreaterThanB<A extends number, B extends number> = TupleOf<A> extends [
+    ...TupleOf<B>,
+    ...infer R
+] ? R['length'] : never;
+type SubtractPositives<A extends number, B extends number> = LessThan<A, B> extends true ? ReverseSign<SubtractIfAGreaterThanB<B, A>> : SubtractIfAGreaterThanB<A, B>;
+type SubtractPostChecks<A extends number, B extends number, AreNegative = [
+    IsNegative<A>,
+    IsNegative<B>
+]> = AreNegative extends [
+    false,
+    false
+] ? SubtractPositives<A, B> : AreNegative extends [
+    true,
+    true
+] ? ReverseSign<SubtractPositives<Absolute<A>, Absolute<B>>> : [
+    ...TupleOf<Absolute<A>>,
+    ...TupleOf<Absolute<B>>
+] extends infer R extends unknown[] ? LessThan<A, B> extends true ? ReverseSign<R['length']> : R['length'] : never;
+/**
+ * Returns the difference between two numbers. `A` or `B` can only support `-999` ~ `999`.
+ *
+ * Copied from the `Subtract` type in the `type-fest` package so that this package's public types do
+ * not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Number
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Subtract<A extends number, B extends number> = number extends A | B ? number : A extends B & (PositiveInfinity | NegativeInfinity) ? number : A extends NegativeInfinity ? NegativeInfinity : B extends PositiveInfinity ? NegativeInfinity : A extends PositiveInfinity ? PositiveInfinity : B extends NegativeInfinity ? PositiveInfinity : A extends B ? 0 : A extends 0 ? ReverseSign<B> : B extends 0 ? A : SubtractPostChecks<A, B>;
+export {};

package/dist/augments/type/subtract.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/tagged.d.ts

@@ -0,0 +1,30 @@
+declare const tag: unique symbol;
+/**
+ * The container object that holds a {@link Tagged} type's tags.
+ *
+ * Copied from the `TagContainer` type in the `type-fest` package so that this package's public
+ * types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type TagContainer<Token> = {
+    readonly [tag]: Token;
+};
+type Tag<Token extends PropertyKey, TagMetadata> = TagContainer<{
+    [K in Token]: TagMetadata;
+}>;
+/**
+ * Create a tagged type that can support multiple tags and per-tag metadata. Useful for creating
+ * distinct types that are not assignable to one another even though they share an underlying type.
+ *
+ * Copied from the `Tagged` type in the `type-fest` package so that this package's public types do
+ * not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type Tagged<Type, TagName extends PropertyKey, TagMetadata = never> = Type & Tag<TagName, TagMetadata>;
+export {};

package/dist/augments/type/tagged.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/type-checks.d.ts

@@ -0,0 +1,33 @@
+/**
+ * These type predicates are copied from `type-fest` v5.6 rather than imported from it. Owning them
+ * here keeps `@augment-vir` (and its consumers) decoupled from `type-fest`'s evolving internals:
+ * these utilities leak through the public `.d.ts` of downstream packages, so a `type-fest` upgrade
+ * could otherwise silently break consumers. These local copies use only built-in types so they
+ * never reference `type-fest`.
+ */
+type IsEqualHelper<A, B> = (<G>() => G extends (A & G) | G ? 1 : 2) extends <G>() => G extends (B & G) | G ? 1 : 2 ? true : false;
+/**
+ * Returns `true` if the two given types are exactly equal, otherwise `false`.
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type IsEqual<A, B> = [A] extends [B] ? [B] extends [A] ? IsEqualHelper<A, B> : false : false;
+/**
+ * Returns `true` if the given type is `never`, otherwise `false`.
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Returns `true` if the given type is `any`, otherwise `false`.
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type IsAny<T> = 0 extends 1 & NoInfer<T> ? true : false;
+export {};

package/dist/augments/type/type-checks.js

@@ -0,0 +1,8 @@
+/**
+ * These type predicates are copied from `type-fest` v5.6 rather than imported from it. Owning them
+ * here keeps `@augment-vir` (and its consumers) decoupled from `type-fest`'s evolving internals:
+ * these utilities leak through the public `.d.ts` of downstream packages, so a `type-fest` upgrade
+ * could otherwise silently break consumers. These local copies use only built-in types so they
+ * never reference `type-fest`.
+ */
+export {};

package/dist/augments/type/typed-array.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Matches any [typed
+ * array](https://developer.mozilla.org/docs/Web/JavaScript/Reference/Global_Objects/TypedArray),
+ * like `Uint8Array` or `Float64Array`.
+ *
+ * Copied from the `TypedArray` type in the `type-fest` package so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Array
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;

package/dist/augments/type/typed-array.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/undefined-to-optional.d.ts

@@ -0,0 +1,27 @@
+import { type IsUnknown } from './is-unknown.js';
+import { type Simplify } from './simplify.js';
+import { type IsAny } from './type-checks.js';
+type BaseKeyFilter<Type, Key extends keyof Type> = Key extends symbol ? never : Type[Key] extends symbol ? never : Type[Key] extends Record<string, unknown> ? Key : [(...arguments_: any[]) => any] extends [Type[Key]] ? never : Key;
+type FilterDefinedKeys<T extends object> = Exclude<{
+    [Key in keyof T]: IsAny<T[Key]> extends true ? Key : IsUnknown<T[Key]> extends true ? Key : undefined extends T[Key] ? never : T[Key] extends undefined ? never : BaseKeyFilter<T, Key>;
+}[keyof T], undefined>;
+type FilterOptionalKeys<T extends object> = Exclude<{
+    [Key in keyof T]: IsAny<T[Key]> extends true ? never : undefined extends T[Key] ? T[Key] extends undefined ? never : BaseKeyFilter<T, Key> : never;
+}[keyof T], undefined>;
+/**
+ * For an object `T`, if it has any properties that are a union with `undefined`, make those into
+ * optional properties instead.
+ *
+ * Copied from the internal `UndefinedToOptional` type in the `type-fest` package so that this
+ * package's public types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Object
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type UndefinedToOptional<T extends object> = Simplify<{
+    [Key in keyof Pick<T, FilterDefinedKeys<T>>]: T[Key];
+} & {
+    [Key in keyof Pick<T, FilterOptionalKeys<T>>]?: Exclude<T[Key], undefined>;
+}>;
+export {};

package/dist/augments/type/undefined-to-optional.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/union-member.d.ts

@@ -0,0 +1,14 @@
+import { type IsNever } from './type-checks.js';
+import { type UnionToIntersection } from './union-to-intersection.js';
+/**
+ * Returns a single member of the given union. Which member is returned is not guaranteed, but it is
+ * deterministic for a given union.
+ *
+ * Copied from the `UnionMember` type in the `type-fest` package so that this package's public types
+ * do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type UnionMember<T> = IsNever<T> extends true ? never : UnionToIntersection<T extends any ? () => T : never> extends () => infer R ? R : never;

package/dist/augments/type/union-member.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/union-to-intersection.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Convert a union type to an intersection type.
+ *
+ * Copied from the `UnionToIntersection` type in the `type-fest` package so that this package's
+ * public types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Type
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type UnionToIntersection<Union> = (Union extends unknown ? (distributedUnion: Union) => void : never) extends (mergedIntersection: infer Intersection) => void ? Intersection & Union : never;

package/dist/augments/type/union-to-intersection.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/union-to-tuple.d.ts

@@ -0,0 +1,21 @@
+import { type ExcludeExactly } from './exclude-exactly.js';
+import { type IsNever } from './type-checks.js';
+import { type UnionMember } from './union-member.js';
+import { type UnknownArray } from './unknown-array.js';
+type UnionToTupleHelper<Union, Accumulator extends UnknownArray = [], Member = UnionMember<Union>> = IsNever<Union> extends true ? Accumulator : UnionToTupleHelper<ExcludeExactly<Union, Member>, [
+    Member,
+    ...Accumulator
+]>;
+/**
+ * Convert a union type into an unordered tuple type of its elements. The order of the resulting
+ * tuple is not guaranteed.
+ *
+ * Copied from the `UnionToTuple` type in `type-fest` v5.6 so that this package's public types do
+ * not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Array
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type UnionToTuple<Union> = UnionToTupleHelper<Union> extends infer Result extends UnknownArray ? Result : never;
+export {};

package/dist/augments/type/union-to-tuple.js

@@ -0,0 +1 @@
+export {};

package/dist/augments/type/unknown-array.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Represents an array with `unknown` values. Any array can be assigned to this type.
+ *
+ * Copied from the `UnknownArray` type in the `type-fest` package so that this package's public
+ * types do not depend on `type-fest` (see the note in `type-checks.ts`).
+ *
+ * @category Array
+ * @category Package : @augment-vir/common
+ * @package [`@augment-vir/common`](https://www.npmjs.com/package/@augment-vir/common)
+ */
+export type UnknownArray = readonly unknown[];

package/dist/augments/type/unknown-array.js

@@ -0,0 +1 @@
+export {};