impair/index.d.ts

A framework for building React applications with OOP principles and a layered architecture.

import * as react from 'react';
import { ReactElement, FC, PropsWithChildren } from 'react';
import * as tsyringe from 'tsyringe';
import { InjectionToken, ValueProvider, ClassProvider, FactoryProvider, TokenProvider } from 'tsyringe';
export { delay, inject } from 'tsyringe';
export { enableTracking, pauseTracking, toRaw, toReadonly } from '@vue/reactivity';

type Constructor<T = any> = new (...args: any[]) => T;
type InstanceLifecycle = 'singleton' | 'transient' | 'container' | 'resolution';
type Provider<T = any> = ValueProvider<T> | ClassProvider<T> | FactoryProvider<T> | TokenProvider<T> | Constructor<T>;
type Registration<T = any> = {
    token: InjectionToken<T>;
    provider: Provider<T>;
    lifecycle: InstanceLifecycle;
};
type ProviderProps<P extends object> = {
    readonly provide: readonly (Constructor | Registration | [Constructor, InstanceLifecycle] | [InjectionToken, ClassProvider<any>['useClass']] | [InjectionToken, ClassProvider<any>['useClass'], InstanceLifecycle])[];
    props?: P;
};
interface RendererViewModel {
    render(): ReactElement | null;
}

declare function component<P>(component: FC<P>): FC<P>;
declare namespace component {
    var fromViewModel: <P extends object>(viewModel: Constructor<RendererViewModel>) => FC<P>;
}

declare function useService<T extends Constructor>(service: T): InstanceType<T>;
declare function useService<T>(token: InjectionToken): T;

declare function useViewModel<T extends Constructor, P extends object>(viewModel: T, props?: P): InstanceType<T>;

type Scope = 'resolution-scoped' | 'container-scoped';
declare function injectable<T extends Constructor>(): (t: T) => void;
declare function injectable<T extends Constructor>(scope: Scope): (t: T) => void;

declare function provide(registrations: ProviderProps<any>['provide']): <T extends Constructor>(target: T) => void;

declare const Props: InjectionToken;

declare function ServiceProvider<P extends object>({ provide, children, props, }: PropsWithChildren<ProviderProps<P>>): react.FunctionComponentElement<react.ProviderProps<tsyringe.DependencyContainer>>;

declare function derived(target: any, propertyKey: string, descriptor: PropertyDescriptor): any;

declare function state(target: any, propertyKey: string): any;
declare namespace state {
    var shallow: typeof shallowState;
    var atom: typeof atomState;
}
declare function shallowState(target: any, propertyKey: string): any;
declare function atomState(target: any, propertyKey: string): any;

declare function trigger(target: any, propertyKey: string): any;
declare namespace trigger {
    var async: (target: any, propertyKey: string) => any;
}

declare function untrack<T extends () => any>(fn: T): any;

declare function onDispose(target: any, propertyKey: string): void;

declare function onInit(target: any, propertyKey: string): void;

declare function onMount(target: any, propertyKey: string): void;

declare function onUnmount(target: any, propertyKey: string): void;

export { Props, ServiceProvider, component, derived, injectable, onDispose, onInit, onMount, onUnmount, provide, state, trigger, untrack, useService, useViewModel };
export type { Constructor, InstanceLifecycle, Provider, ProviderProps, Registration, RendererViewModel };