How can I handle TypedArrays generically when some of their signatures are incompatible?

Take the simple function bellow. This is trivial in JavaScript, but in TypeScript this produces an error because TypedArray.set is expecting the first parameter to be of type ArrayLike<number> & ArrayLike<bigint>.

<!-- language: lang-typescript -->

type TypedArray = Int8Array | Uint8Array | Uint8ClampedArray 
| Int16Array | Uint16Array
| Int32Array | Uint32Array 
| BigInt64Array | BigUInt64Array
| Float32Array | Float64Array

function expand<T extends TypedArray>(arr: T, elementCount: number): T {
    const constructor = arr.constructor as new (length: number) => T
    const result = new constructor(arr.length + elementCount)
    result.set(arr) //error
    return result
}

The only way for something like this to work is with generics. There is a longstanding open feature at microsoft/TypeScript#15402 to support some sort of supertype interface for typed arrays, with a comment that suggests defining a generic interface like:

interface TypedArr<T extends number | bigint> {
  readonly BYTES_PER_ELEMENT: number;
  readonly buffer: ArrayBufferLike;
  readonly byteLength: number;
  readonly byteOffset: number;
  /* ✂ ⋯ omitted for brevity ⋯ ✂ */
  join(separator?: string): string;
  keys(): IterableIterator<number>;
  lastIndexOf(searchElement: T, fromIndex?: number): number;
  readonly length: number;
  /* ✂ ⋯ omitted for brevity ⋯ ✂ */
  reverse(): this;
  set(array: ArrayLike<T>, offset?: number): void;
  slice(start?: number, end?: number): TypedArr<T>;
  /* ✂ ⋯ omitted for brevity ⋯ ✂ */
  valueOf(): TypedArr<T>;
  values(): IterableIterator<T>;
  [Symbol.iterator](): IterableIterator<T>;
  [index: number]: T;
}

and then you can use TypedArr<number> or TypedArr<bigint> to represent most of the functionality you needed in your union type:

function expand<T extends number | bigint>(arr: TypedArr<T>, elementCount: number): TypedArr<T> {
  const constructor = arr.constructor as new (length: number) => TypedArr<T>
  const result = new constructor(arr.length + elementCount);
  result.set(arr);
  return result;
}

declare const a64: BigInt64Array;
expand(a64, 3); // okay
declare const a32: Int32Array;
expand(a32, 4); // okay

This may or may not ever make it into the standard library, but even if it doesn't you can just define it yourself for your code base. That's not an optimal experience, but as workarounds go it's pretty good since it behaves the same either way.

Or, depending on your needs, you could make a type that captures only those pieces of TypedArray that you will use inside your function. Maybe like:

interface TypedArrLike extends ArrayLike<number | bigint> {
  set(array: ArrayLike<number | bigint>, offset?: number): void;
}

function expand<T extends TypedArrLike>(arr: T, elementCount: number): T {
  const constructor = arr.constructor as new (length: number) => T
  const result = new constructor(arr.length + elementCount)
  result.set(arr)
  return result
}

declare const a64: BigUint64Array;
expand(a64, 3); // okay
declare const a32: Int32Array;
expand(a32, 4); // okay

which produces a similar result without needing a huge interface.

Playground link to code