@halospv3/hce.shared-config 2.6.4 → 3.0.0-develop.2

package/src/utils/reflection/PropertyDescriptorMap.d.ts

@@ -0,0 +1,15 @@
+/**
+ * A variant of TypeScript's ES5 PropertyDescriptorMap with an extra generic
+ * parameter for omitting inherited keys.
+ * @template T The type described by the {@link PropertyDescriptorMap}.
+ * @template [__proto__=null]
+ * The `null` or the `object`-like `[[Prototype]]` of {@link T}.
+ * @since 3.0.0
+ */
+export type PropertyDescriptorMap<T, __proto__ extends object | null = null>
+  = __proto__ extends null
+    ? { [P0 in keyof T]: TypedPropertyDescriptor<T[P0]>; }
+    : Omit<
+      { [P0 in keyof T]: TypedPropertyDescriptor<T[P0]>; },
+      keyof { [P1 in keyof __proto__]: TypedPropertyDescriptor<__proto__[P1]> }
+    >;

package/src/utils/reflection/filterForGetters.ts

@@ -0,0 +1,59 @@
+import type {
+  BaseClassProto,
+  baseClassProto,
+  ClassLike,
+  ConstructorConstraint,
+  InstanceTypeOrSelf,
+  SuperClassLike,
+  WithProto,
+} from './inheritance.js';
+import type { InstancePropertyDescriptorMap } from './InstancePropertyDescriptorMap.js';
+import type { OwnGetterDescriptorMap } from './OwnGetterDescriptorMap.js';
+import type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.js';
+import type { PropertyDescriptorMap } from './PropertyDescriptorMap.js';
+
+export function filterForGetters<
+  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | typeof baseClassProto>>,
+>(
+  descriptorMap: InstancePropertyDescriptorMap<Class>,
+): Partial<OwnGetterDescriptorMap<
+  InstanceType<Class>,
+  Class['__proto__'] extends BaseClassProto ? null : InstanceTypeOrSelf<Class['__proto__']>
+>>;
+export function filterForGetters<
+  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+>(
+  descriptorMap: OwnPropertyDescriptorMap<Class>,
+): Partial<OwnGetterDescriptorMap<Class, Class['__proto__']>>;
+/**
+ * Iterates through the descriptors object, checking for property descriptors whose `get` is a function.
+ * Returns an {@link OwnGetterDescriptorMap} of the getters.
+ * If you want only own, non-inherited getters, you must filter sanitize the
+ * type the `descriptors` parameter yourself e.g. `Omit<Class, keyof
+ * SuperClass>`.
+ * @param descriptorMap An object like the return value of Object.getOwnPropertyDescriptors
+ * @template Class Any ClassLike type
+ * @template T Any `object`-like type.
+ * @template [__proto__=null] If {@link Class} is not {@link ClassLike}, the `__proto__` of {@link T}.
+ * @returns An {@link OwnGetterDescriptorMap}.
+ * @since 3.0.0
+ */
+export function filterForGetters<
+  T extends object,
+  __proto__ extends object | null = null,
+>(
+  descriptorMap: PropertyDescriptorMap<T, __proto__> | PropertyDescriptorMap<T>,
+): Partial<OwnGetterDescriptorMap<T, __proto__>> {
+  let getterDescriptorMap: Partial<OwnGetterDescriptorMap<T, __proto__>> = {};
+  for (const key in descriptorMap) {
+    const element = descriptorMap[key as keyof typeof descriptorMap];
+    if (typeof element.get === 'function') {
+      getterDescriptorMap = Object.assign(
+        getterDescriptorMap,
+        { [key]: element },
+      );
+    }
+  }
+
+  return getterDescriptorMap;
+}

package/src/utils/reflection/getOwnPropertyDescriptors.ts

@@ -0,0 +1,52 @@
+import type { InstanceOrStatic } from '../miscTypes.js';
+import type { BaseClassProto, ClassLike, ConstructorConstraint, SuperClassLike, WithProto } from './inheritance.js';
+import type { InstancePropertyDescriptorMap } from './InstancePropertyDescriptorMap.js';
+import type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.js';
+
+/**
+ * Get the property descriptors of the class or constructor similar to {@link Object.getOwnPropertyDescriptors}, but with more options--including recursion.
+ * @template {InstanceOrStatic} _InstanceOrStatic 'Instance' or 'Static'. Determines the return type.
+ * @param classDefinition A class or constructor, cast to {@link ClassLike}.
+ * @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.
+ * @template {ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>} Class
+ * The typeof {@link classDefinition}.
+ * {@link WithProto}<{@link SuperClassLike}> is necessary for walking the
+ * prototype chain for both Instance  and Static properties.
+ * If unspecified, the return type may be incorrect.
+ * @returns ({@link instanceOrStatic} === 'Instance') ? {@link InstancePropertyDescriptorMap<Class>}\
+ * : ({@link instanceOrStatic} === 'Static') ? {@link OwnPropertyDescriptorMap<Class>}\
+ * : never
+ * @throws {TypeError}
+ * @since 3.0.0
+ */
+export function getOwnPropertyDescriptors<
+  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  _InstanceOrStatic extends InstanceOrStatic,
+>(
+  classDefinition: Class,
+  instanceOrStatic: _InstanceOrStatic,
+): [_InstanceOrStatic] extends ['Instance']
+  ? InstancePropertyDescriptorMap<Class>
+  : [_InstanceOrStatic] extends ['Static']
+      ? OwnPropertyDescriptorMap<Class>
+      : never {
+  switch (instanceOrStatic) {
+    case 'Instance': {
+      return Object.getOwnPropertyDescriptors(classDefinition.prototype) as [Extract<typeof instanceOrStatic, 'Instance'>] extends ['Instance']
+        ? InstancePropertyDescriptorMap<Class>
+        : [_InstanceOrStatic] extends ['Static']
+            ? OwnPropertyDescriptorMap<Class>
+            : never;
+    }
+    case 'Static': {
+      return Object.getOwnPropertyDescriptors(classDefinition) as [Extract<typeof instanceOrStatic, 'Static'>] extends ['Instance']
+        ? InstancePropertyDescriptorMap<Class>
+        : [_InstanceOrStatic] extends ['Static']
+            ? OwnPropertyDescriptorMap<Class>
+            : never;
+    }
+    default: {
+      throw new TypeError('Argument `instanceOrStatic` must be "Instance" or "Static".');
+    }
+  }
+}

package/src/utils/reflection/getOwnPropertyDescriptorsRecursively.ts

@@ -0,0 +1,127 @@
+import type { Increment } from '../GracefulRecursion.js';
+import type { InstanceOrStatic, Integer } from '../miscTypes.js';
+import { getOwnPropertyDescriptors } from './getOwnPropertyDescriptors.js';
+import { getPrototypesChainOf } from './getPrototypeChainOf.js';
+import type {
+  BaseClass,
+  BaseClassProto,
+  ClassLike,
+  ConstructorConstraint,
+  ConstructorLike,
+  ProtoChainOfClass,
+  SuperClassLike,
+  WithProto,
+} from './inheritance.js';
+import type { InstanceTypeOrSelfPropertyDescriptorMap } from './InstanceTypeOrSelfPropertyDescriptorMap.js';
+import type { OwnPropertyDescriptorMap } from './OwnPropertyDescriptorMap.js';
+/* eslint-disable jsdoc/check-tag-names */
+/**
+ * JSDoc type imports
+ * @typedef {import('./getPrototypeOf.js').getPrototypeOf} getPrototypeOf
+ * @typedef {import('./listOwnGetters.js').listOwnGetters} listOwnGetters
+ * @typedef {import('./InstancePropertyDescriptorMap.js').InstancePropertyDescriptorMap} InstancePropertyDescriptorMap
+ */
+/* eslint-enable jsdoc/check-tag-names */
+
+/**
+ * A conditional wrapper for {@link InstanceTypeOrSelfPropertyDescriptorMap} and
+ * {@link OwnPropertyDescriptorMap}.
+ *
+ * If {@link _InstanceOrStatic} is 'Instance', {@link InstanceTypeOrSelfPropertyDescriptorMap}.\
+ * Else if {@link _InstanceOrStatic} is 'Static',
+ * {@link OwnPropertyDescriptorMap }.\
+ * Else, `never`.
+ * @template {ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>} Class
+ * A class definition cast to {@link ClassLike}.
+ * @template {InstanceOrStatic} _InstanceOrStatic
+ * 'Instance' or 'Static'. Determines the return type.
+ * @since 3.0.0
+ */
+export type RecursedPropertyDescriptorMap<
+  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,
+  _InstanceOrStatic extends InstanceOrStatic,
+> = [_InstanceOrStatic] extends ['Instance'] ? InstanceTypeOrSelfPropertyDescriptorMap<Class, Class['__proto__']>
+  : [_InstanceOrStatic] extends ['Static'] ? OwnPropertyDescriptorMap<Class>
+      : never;
+
+/**
+ * An
+ * ordered array of {@link OwnPropertyDescriptorMap} or
+ * {@link InstancePropertyDescriptorMap} starting with {@link classDefinition}
+ * and ending with a {@link BaseClass}.
+ * @template {ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>} Class
+ * @template {'Instance' | 'Static'} InstanceOrStatic
+ * @template {Integer<number>} [Limit=16]
+ * @template {Integer<number>} [CurrentLevel=0]
+ */
+export type RecursedPropertyDescriptorMapArray<
+  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,
+  InstanceOrStatic extends 'Instance' | 'Static',
+  Limit extends Integer<number> = 16,
+  CurrentLevel extends Integer<number> = 0,
+> = Class['__proto__'] extends BaseClassProto['__proto__'] | BaseClassProto['__proto__']['__proto__'] ? never
+  : Class['__proto__'] extends BaseClassProto ? [RecursedPropertyDescriptorMap<BaseClass<Class>, InstanceOrStatic>]
+    : Class['__proto__'] extends ConstructorLike<Class['__proto__']>
+      ? [
+          RecursedPropertyDescriptorMap<Class, InstanceOrStatic>,
+          ...RecursedPropertyDescriptorMapArray<
+            ClassLike<Exclude<Class['__proto__'], BaseClassProto> & WithProto<SuperClassLike | BaseClassProto>>,
+            InstanceOrStatic,
+            Limit,
+            Increment<CurrentLevel>
+          >,
+        ]
+      : never;
+/**
+ * Walks the class inheritance chain to get a PropertyDescriptorMap of each class.
+ *
+ * While you _can_ use this to get an array of getter names/keys, you should use {@link getPrototypeOf} and {@link listOwnGetters}, instead!
+ * @template Class Any class definition type-cast to {@link ClassLike}
+ * @template _InstanceOrStatic
+ * @param classDefinition Any class definition type-cast to {@link ClassLike}
+ * @param instanceOrStatic 'Instance' or 'Static'. Determines the return type.
+ * @returns An
+ * ordered array of {@link OwnPropertyDescriptorMap} or
+ * {@link InstancePropertyDescriptorMap} starting with {@link classDefinition}
+ * and ending with a {@link BaseClass}.
+ * @since 3.0.0
+ */
+export function getOwnPropertyDescriptorsRecursively<
+  // Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  _InstanceOrStatic extends InstanceOrStatic,
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-parameters
+  Limit extends Integer<number> = 16,
+>(
+  classDefinition: Class,
+  instanceOrStatic: _InstanceOrStatic,
+): RecursedPropertyDescriptorMapArray<Class, _InstanceOrStatic> {
+  const staticProtoChain: ProtoChainOfClass<Class> = getPrototypesChainOf(classDefinition, 'classes');
+  if (isSingleTuple(staticProtoChain)) {
+    return [
+      getOwnPropertyDescriptors(
+        staticProtoChain[0],
+        instanceOrStatic,
+      ) as RecursedPropertyDescriptorMap<Class, _InstanceOrStatic>,
+    ] as unknown as RecursedPropertyDescriptorMapArray<Class, _InstanceOrStatic, Limit>;
+  }
+
+  const recursedPropertyDescriptorMapArray = staticProtoChain.map(classDefinition =>
+    getOwnPropertyDescriptors(
+      classDefinition,
+      instanceOrStatic,
+    ),
+  );
+
+  return recursedPropertyDescriptorMapArray as RecursedPropertyDescriptorMapArray<Class, _InstanceOrStatic>;
+}
+
+/**
+ * Simple utility for single-tuple type assertion
+ * @template {T} T T in T[]
+ * @param array an array
+ * @returns array is [T]
+ */
+function isSingleTuple<T>(array: T[]): array is [T] {
+  return Array.isArray(array) && array.length === 1;
+}

package/src/utils/reflection/getPrototypeChainOf.ts

@@ -0,0 +1,85 @@
+/* eslint-disable jsdoc/no-defaults */
+import type { TupleIndices } from '../miscTypes.js';
+import { getPrototypeOf } from './getPrototypeOf.js';
+import {
+  baseClassProto,
+  type BaseClassProto,
+  type ClassLike,
+  type ConstructorConstraint,
+  type ProtoChainOfClass,
+  type ProtoChainOfClassInstance,
+  type SuperClassLike,
+  type WithProto,
+} from './inheritance.js';
+import { isConstructor } from './isConstructor.js';
+
+type ProtoChain<
+  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  ClassesOrInstances extends 'classes' | 'classInstances',
+> = [ClassesOrInstances] extends ['classInstances'] ? ProtoChainOfClassInstance<Class>
+  : [ClassesOrInstances] extends ['classes'] ? ProtoChainOfClass<Class>
+      : never;
+
+/**
+ * Iterate through the class and its base/super classes until an anonymous function is reached. This is the default superclass all classes extend.
+ * @template Class Any {@link ClassLike} type.
+ * @template ClassesOrInstances 'classes' or 'classInstances'
+ * @param classDefinition Any class type satisfying {@link Class}. This class (or its instance type) is included in the return value.
+ * @param [returnType='classes'] Determines return type. If 'classInstances', the return type is an array of the classes' `.prototype`. Else, the classes themselves are returned.
+ * @since 3.0.0
+ * @returns
+ * `returnType extends 'classInstances' ? ClassLike<T>[] : ClassLike<T>[].map(c => c.prototype)`
+ * Excludes default superclasses e.g. anonymous functions, native code.
+ */
+export function getPrototypesChainOf<
+  Class extends ClassLike<ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>>,
+  ClassesOrInstances extends 'classes' | 'classInstances',
+>(
+  classDefinition: Class,
+  returnType: ClassesOrInstances,
+): ProtoChain<Class, ClassesOrInstances> {
+  // class definitions or their respective .prototype; exclude default superclasses.
+  let current: ProtoChainOfClass<Class>[TupleIndices<ProtoChainOfClass<Class>>] = classDefinition as ProtoChainOfClass<Class>[0 extends TupleIndices<ProtoChainOfClass<Class>> ? 0 : never];
+  let parent: typeof current & WithProto<SuperClassLike | BaseClassProto> | object;
+  const returnValue = [] as unknown as
+  ProtoChain<Class, ClassesOrInstances>;
+  let index: TupleIndices<typeof returnValue> = 0 as TupleIndices<typeof returnValue>;
+
+  while (baseClassProto !== current) {
+    parent = getPrototypeOf<typeof current>(current);
+    // current is a Class symbol/constructor. Object.getOwnPropertyDescriptors on current will include static properties.
+    if (!isConstructor(current))
+      break;
+    if (returnType === 'classInstances') {
+      const instanceOfCurrent = current.prototype as InstanceType<typeof current>;
+
+      returnValue[index] = instanceOfCurrent as typeof returnValue[typeof index];
+    }
+    else {
+      returnValue[index] = current as typeof returnValue[typeof index];
+    }
+
+    /**
+     * Assign the super class to current.
+     * If the argument is a class, Reflect.getPrototypeOf method returns the
+     * superclass.
+     */
+    if (
+      isConstructor(parent)
+      && 'name' in parent
+      && typeof parent.name === 'string'
+      && '' !== parent.name // it's possible for a Function/Constructor to be anonymous...
+    ) {
+      current = parent as ProtoChainOfClass<Class>[TupleIndices<ProtoChainOfClass<Class>>];
+    }
+    else {
+      break;
+    }
+    index++;
+  }
+  return returnValue;
+  /*
+    assuming current is NugetProjectProperties...
+    Reflect.getPrototypeOf(current).name is 'MSBuildProjectProperties'
+   */
+}

package/src/utils/reflection/getPrototypeOf.ts

@@ -0,0 +1,12 @@
+import type { ProtoOrSuperClass, WithProto } from './inheritance.js';
+
+/**
+ * A nearly useless wrapper for {@link Reflect.getPrototypeOf}
+ * @param object An object with the internal `__proto__` property present in its type.
+ * @returns The `__proto__` of the `object` param.
+ */
+export function getPrototypeOf<
+  T extends WithProto<ProtoOrSuperClass>,
+>(object: T): T['__proto__'] {
+  return Reflect.getPrototypeOf(object) as T['__proto__'];
+}

package/src/utils/reflection/inheritance.ts

@@ -0,0 +1,262 @@
+import type { Increment } from '../GracefulRecursion.js';
+import type { Integer } from '../miscTypes.js';
+import type { FunctionLike } from './FunctionLike.js';
+import { getPrototypeOf } from './getPrototypeOf.js';
+import type { PropertyDescriptorMap } from './PropertyDescriptorMap.js';
+
+/**
+ * The `[[Prototype]]` (i.e. `__proto__`) of any base class.
+ * @since 3.0.0
+ */
+export type BaseClassProto = (() => object) & {
+  /** @example BaseClass.__proto__.__proto__.toString() === '[object Object]' */
+  ['__proto__']: ObjectConstructor['prototype'] & {
+    ['__proto__']: null;
+    constructor: ObjectConstructor;
+  };
+  constructor: IBaseClass;
+  length: 0;
+  name: '';
+};
+
+/**
+ * The `[[Prototype]]` of all base classes.
+ * @since 3.0.0
+ */
+export const baseClassProto = getPrototypeOf(Object as BaseClass<ObjectConstructor>);
+
+/**
+ * [INTERNAL]
+ * An interface representing for attaching base class properties to a class type.
+ * This kept separate from {@link BaseClass} so it can be used by {@link BaseClassProto}.
+ * @since 3.0.0
+ */
+interface IBaseClass {
+  /**
+   * Readable for compatibility reasons, but invisible and non-enumerable in Node.js runtime.
+   * @example BaseClass.__proto__.toString() === 'function () { [native code] }'
+   */
+  ['__proto__']: BaseClassProto;
+
+  constructor: FunctionConstructor & { name: 'Function' };
+}
+
+/**
+ * Type a class type as a base class.
+ * Note: is `Class & ...`
+ * @since 3.0.0
+ */
+export type BaseClass<Class extends ConstructorConstraint<Class>>
+  = IClass<Class> & IBaseClass;
+
+/**
+ * A type representing any unknown constructor.
+ * @since 3.0.0
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export type Constructor_Unknown = abstract new (...args: any[]) => any;
+
+/**
+ * The constraint for constructor types.
+ * This is intended for generic type constraints.
+ * For conditional return types, use `T extends Constructor<T>` instead.
+ * @template T Any newable constructor type
+ * @since 3.0.0
+ */
+export type ConstructorConstraint<T extends abstract new (...args: ConstructorParameters<T>) => InstanceType<T>> = abstract new (...arguments_: ConstructorParameters<T>) => InstanceType<T>;
+
+/**
+ * {@link T} is a class constructor or unknown constructor. Else, `never`.
+ *
+ * Consider using {@link ClassLike} where walking the inheritance chain is necessary.
+ * @template [T=Constructor_Unknown]
+ * @since 3.0.0
+ */
+export type ConstructorLike<T = Constructor_Unknown>
+  = T extends Constructor_Unknown
+    ? T extends ConstructorConstraint<T>
+      ? T & ConstructorConstraint<T>
+      : T & Constructor_Unknown
+    : never;
+
+/**
+ * A type representing unknown {@link ClassLike} types.
+ * @since 3.0.0
+ */
+export type ClassLike_Unknown
+= IClass<
+  Constructor_Unknown
+  & WithProto<SuperClassLike | BaseClassProto>
+>;
+
+/**
+ * A subset of {@link ProtoOrSuperClass} suitable for a class's `[[Prototype]]`
+ * @since 3.0.0
+ */
+export type SuperClassLike = BaseClass<Constructor_Unknown> | ClassLike_Unknown;
+
+/**
+ * A terrible type. Use it if you must, but prefer other types when possible.
+ *
+ * Covers most SuperClass/Prototype types.
+ * A class that does not extend another class will satisfy {@link BaseClass}.
+ *
+ * If a type extends {@link ProtoOrSuperClass} and is `null`, you cannot get the
+ * type's keys. See {@link ./OwnKeyOf.ts}.
+ * @template [T=ReturnType<typeof Reflect.getPrototypeOf>] `null` or an `object`-like type.
+ * @since 3.0.0
+ */
+export type ProtoOrSuperClass<T extends object | null = ReturnType<typeof Reflect.getPrototypeOf>>
+  = T extends null ? null
+    : T extends object
+      ? T extends ConstructorLike<T>
+        ? T extends ClassLike<T & WithProto<SuperClassLike | BaseClassProto>>
+          ? T extends BaseClass<T> ? ClassLike<BaseClass<T>>
+            : ClassLike<T>
+          : T extends BaseClass<T>
+            ? BaseClass<T>
+            : ConstructorLike<T>
+        : T extends FunctionLike<infer FunctionConstraint>
+          ? T extends FunctionConstraint
+            ? FunctionLike<T>
+            : T & FunctionLike<FunctionConstraint>
+          : T extends object
+            ? T & object
+            : never
+      : never;
+
+/**
+ * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of any `object`-like type.
+ * Not to be confused with the _instance_ `.prototype` chain!
+ * ```
+ * > util.isDeepStrictEqual(Object.getOwnPropertyDescriptors({}.__proto__), Object.getOwnPropertyDescriptors(Object.prototype))
+ * true
+ * ```
+ * @template Object0 Any type with its `[[Prototype]]` attached as a `__proto__` property. The type of `__proto__` must extend {@link ProtoOrSuperClass}.
+ * @template [Limit=16]
+ * The maximum depth of recursion.
+ * Affects the maximum length of the returned type.\
+ * CAUTION: Larger values will severely degrade performance.
+ * 50 or more will trigger infinite-or-near-infinite-recursion errors.
+ * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
+ * @since 3.0.0
+ */
+export type ProtoChainOfObject<
+  Object0 extends WithProto<ProtoOrSuperClass>,
+  Limit extends Integer<number> = 16,
+  CurrentLevel extends Integer<number> = 0,
+> = PropertyDescriptorMap<Object0['__proto__']> extends PropertyDescriptorMap<ObjectConstructor['prototype']>
+  ? [Object0]
+  : Object0['__proto__'] extends WithProto<ProtoOrSuperClass>
+    ? CurrentLevel extends Limit ? [Object0]
+      : [
+          Object0,
+          ...ProtoChainOfObject<Object0['__proto__'], Limit, Increment<CurrentLevel>>,
+        ]
+    : never;
+
+/**
+ * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of an object (particularly, a class).
+ * @template Class Any type with its `[[Prototype]]` attached as a `__proto__` property.
+ * The type of `__proto__` must extend {@link SuperClassLike} or {@link BaseClassProto}.
+ * @template [Limit=16]
+ * The maximum depth of recursion.
+ * Affects the maximum length of the returned type.\
+ * CAUTION: Larger values will severely degrade performance.
+ * 50 or more will trigger infinite-or-near-infinite-recursion errors.
+ * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
+ * @since 3.0.0
+ */
+export type ProtoChainOfClass<
+  Class extends WithProto<SuperClassLike | BaseClassProto>,
+  Limit extends Integer<number> = 16,
+  CurrentLevel extends Integer<number> = 0,
+> = Class['__proto__'] extends BaseClassProto ? [Class]
+  : Class['__proto__'] extends SuperClassLike
+    ? CurrentLevel extends Limit ? [Class]
+      : [
+          Class,
+          ...ProtoChainOfClass<Class['__proto__'], Limit, Increment<CurrentLevel>>,
+        ]
+    : never;
+
+/**
+ * The {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Inheritance_and_the_prototype_chain prototype chain} of a class instance.
+ * @template Class A constructor type with its `[[Prototype]]` attached as a `__proto__` property.
+ * @template [Limit=16]
+ * The maximum depth of recursion.
+ * Affects the maximum length of the returned type.\
+ * CAUTION: Larger values will severely degrade performance.
+ * 50 or more will trigger infinite-or-near-infinite-recursion errors.
+ * @template [CurrentLevel=0] (INTERNAL) The current depth of the prototype chain.
+ * @since 3.0.0
+ */
+export type ProtoChainOfClassInstance<
+  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,
+  Limit extends Integer<number> = 16,
+  CurrentLevel extends Integer<number> = 0,
+> = Class['__proto__'] extends BaseClassProto ? [InstanceType<Class>]
+  : Class['__proto__'] extends SuperClassLike
+    ? CurrentLevel extends Limit ? [InstanceType<Class>]
+      : [
+          InstanceType<Class>,
+          ...ProtoChainOfClassInstance<Class['__proto__'], Limit, Increment<CurrentLevel>>,
+        ]
+    : never;
+
+/**
+ * Augment a class type to expose properties not exposed by TypeScript by default.
+ * Note: is `Class & ...`
+ * @template Class The typeof any class. If the type is unknown, wrap it with {@link ConstructorConstraint}.
+ * @since 3.0.0
+ */
+// defined as `type` because interfaces cannot extend their generic parameters
+export type IClass<Class extends ConstructorConstraint<Class>>
+  = Class
+    & {
+      prototype: InstanceType<Class>;
+      name: ConstructorConstraint<Class>['name'];
+      length: ConstructorConstraint<Class>['length'];
+    };
+
+/**
+ * A more fleshed-out Class type.
+ *
+ * Note: is `Class & ...`
+ *
+ * In addition to the Constructor constraint, this type...
+ * - Sets the type of the immediate superclass.
+ * - Sets `prototype` to {@link InstanceType}
+ * @template Class The `typeof MyClass`. If this class extends a class, pass `typeof MySuperClass` to the generic argument {@link Class}.
+ * @example
+ * type Class_MyClass = ClassLike<typeof MyClass & WithProto<BaseClass<typeof MyBaseClass>>;
+ * @since 3.0.0
+ */
+export type ClassLike<
+  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,
+> = Class extends BaseClass<Class> ? Class
+  : Class['__proto__'] extends BaseClassProto ? BaseClass<Class>
+    : Class['__proto__'] extends ConstructorLike<Class['__proto__']>
+      ? IClass<Class> & WithProto<ConstructorLike<Class['__proto__']>>
+      // Here, __proto__ is retained via Class
+      : IClass<Class>;
+
+/**
+ * If {@link T} is a class or constructor, {@link InstanceType}<{@link T}>. Else, {@link T}.
+ * @template T `null` or any `object`-like type.
+ * @since 3.0.0
+ */
+export type InstanceTypeOrSelf<T extends object | null> = T extends ConstructorLike
+  ? T extends ConstructorLike<T>
+    ? InstanceType<T>
+    : T
+  : T;
+
+/**
+ * Interface for attaching a `__proto__` to an object e.g. `T0 & WithProto<T1>`
+ * @template __proto__ the type of the an object's `[[Prototype]]`.
+ * @since 3.0.0
+ */
+export interface WithProto<__proto__ extends ProtoOrSuperClass> {
+  ['__proto__']: __proto__;
+}