TypeScript Stack Overflow Answers

Selected technical solutions from my Stack Overflow history. These focus on inference, generics, overloads, and class typing — not a vote leaderboard.

class AClass {
    constructor(...args: [a: number] | [a: string, b: number]) {}
}
type t = ConstructorParameters<typeof AClass>;

Object.seal(myObject);
for (const prop of Object.iterateKeys(myObject)) {
    // prop is keyof typeof myObject only if sealed
}

static create<T extends new (...args: any) => any>(
    this: T,
    ...args: ConstructorParameters<T>
) {
    return new this(...args) as InstanceType<T>;
}

function mixin<M extends object>(
    src: new (...args: any) => any,
    dst: M
): asserts src is new (...args: any) => unknown & M {
    Object.assign(src.prototype, dst);
}

const props = defineProps<{
    onEvent: (() => string) | Array<() => string>
}>();

type MakeFunctionAsync<T extends (...args: any[]) => any> =
    (...args: ReadonlyArrayItems<Parameters<T>>) => Promise<ReturnType<T>>;

type Foo<T> = MakeFunctionAsync<typeof foo<T>>;

type AddName<T, Name extends string> = {
    [K in keyof T as K extends string ? `${K}${Name}` : never]: T[K]
};

import CompChild from './Comp.vue';
const $comps = useTemplateRef('$comps');

function myFunction<const T extends any[]>(param: {
    args: T;
    method: (...args: NoInfer<T>) => void;
}): void {}

class CanUpcase<T extends object> {
    upcase(propertyName: KeysOfType<T, string>) {
        return (this[propertyName] as string).toUpperCase();
    }
}
class User extends CanUpcase<User> {
    name = '';
}

function register<K extends PropertyKey, T extends {}, P extends PropertyDescriptor>(
    this: T, p: K, attributes: P
): asserts this is T & { [p in K]: P['value'] } {
    Object.defineProperty(this, p, attributes);
}

type Args = {
    [K in keyof IListState]: [key: K, value: IListState[K]]
}[keyof IListState];

exportParameter<N extends string>(name: N, value: string) {
    const param = new StringParameter(this, name, { parameterName: name, stringValue: value });
    return this as this & BaseStack<{ [k in N]: typeof param }>;
}

defineProps<{
    data: Record<string, T[]>,
    component: Component<T>,
    labelFn: (length: number, date: Date) => string
}>();

function useModel<T extends typeof BaseApiModel, M extends Methods>(
    model: T,
    method: M,
    options?: M extends 'get' ? { id?: number; params?: QueryFilterParams } : never
) {}

const all_ingredients = drinks.flatMap(drink =>
    Object.entries(drink)
        .filter(([k, v]) => k.startsWith('ingredient') && v)
        .map(([, v]) => v)
);

interface Animal {
    legs: number;
    age: number;
    tail: number;
    eyes: number;
}
interface Tiger extends Animal {
    color: 'stripes' | 'black';
}

class TypedMap extends Map {
    #keyType;
    constructor(keyType, entries = []) {
        super();
        this.#keyType = keyType;
        for (const [k, v] of entries) this.set(k, v);
    }
}

function out(ids: string[], params?: ApiParams): Promise<string[]>;
function out(params: ApiParams, params2?: ApiParams): Promise<BaseSchema>;
async function out(param1: string[] | ApiParams, param2: ApiParams = {}) {
    return 1 as any;
}
return out;

checkedValue?: TCheckedValue | true;
uncheckedValue?: TUncheckedValue | false;