Create providers

abstract.ts

export type Abstract<T = any> = abstract new (...params: any[]) => T;

constructor-abstract-parameters.ts

import { Abstract } from './abstract';
import { Type } from './type';

type MapToAbstract<T> = T extends [infer First, ...infer Rest]
  ? [Abstract<First> | string, ...MapToAbstract<Rest>]
  : [];

export type ConstructorAbstractParameters<T extends Type> = MapToAbstract<
  ConstructorParameters<T>
>;

constructor-type-parameters.ts

import { Type } from './type';

type MapToType<T> = T extends [infer First, ...infer Rest]
  ? [Type<First> | string, ...MapToType<Rest>]
  : [];

export type ConstructorTypeParameters<T extends Type> = MapToType<
  ConstructorParameters<T>
>;

create-constructor-provider.ts

import {
  Type,
  ConstructorTypeParameters,
  ConstructorAbstractParameters,
} from '@typescript-stack/shared-api-global';

export function createConstructorProvider<T extends Type>(
  constructor: T,
  dependencies: ConstructorTypeParameters<T> | ConstructorAbstractParameters<T>
) {
  return {
    provide: constructor,
    useFactory(...params: ConstructorParameters<T>) {
      return new constructor(...params);
    },
    deps: dependencies,
  };
}

create-replaceable-provider.ts

import {
  Type,
  Abstract,
  ConstructorTypeParameters,
  ConstructorAbstractParameters,
} from '@typescript-stack/shared-api-global';

export function createReplaceableProvider<A extends Abstract, T extends Type>(
  constructor: A,
  implementation: T,
  dependencies: ConstructorTypeParameters<T> | ConstructorAbstractParameters<T>
) {
  return {
    provide: constructor,
    useFactory(...params: ConstructorParameters<T>) {
      return new implementation(...params);
    },
    deps: dependencies,
  };
}

create-value-provider.ts

export function createValueProvider<K, T>(provide: K, useValue: T) {
  return { provide, useValue };
}

type.ts

export interface Type<T = any> extends NewableFunction {
	new (...params: any[]): T;
}