implab/implabjs-core Commit - r112:efce7387bfc8

Working on IoC container configuration

cin -

r112:efce7387bfc8 ioc ts support

parent child

Context file:

r112:efce7387bfc8

Collapse all files

src/main/ts/di/Annotations.ts +5 -1

             import { Constructor } from "../interfaces";
             export interface InjectOptions {
                 lazy?: boolean;
             }
             type Setter<T = any> = (v: T) => void;
             type Compatible<T1, T2> = T1 extends T2 ? any : never;
             type SetterType<T> = T extends (v: infer V) => void ? V : never;
             type ExtractService<K, S> = K extends keyof S ? S[K] : K;
             type ExtractDependency<D, S> = D extends { $dependency: infer K } ? D extends { lazy: true } ? () => ExtractService<K, S> : ExtractService<K, S> : VisitDependency<D, S>;
             type VisitDependency<D, S> = D extends {} ? { [K in keyof D]: ExtractDependency<D[K], S> } : D;
             export class Builder<T, S> {
                 consume<P extends any[]>(...args: P) {
                     return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
-                        // return constructor;
+                        return constructor as typeof constructor & { service: () => T };
                     };
                 }
                 inject<K extends keyof S>(dependency: K) {
                     // K = "bar"
                     // M = "setValue"
                     // S[K] = Bar
                     // T[M] = (value: string) => void
                     // P[m] = (value: V) => void
                     return <P, M extends keyof (T | P)>(target: P, memberName: M, descriptor: TypedPropertyDescriptor<Compatible<T[M], Setter<S[K]>>>) => {
                     };
                 }
+                cast<T2 extends T>(): Builder<T2, S> {
+                    return this as Builder<T2, S>;
                 }
+            }

src/test/ts/mock/Box.ts +1 -1

             import { config } from "./config";
             const service = config.build("barBox");
             @service.consume(config.dependency("bar"))
             export class Box<T> {
                 private _value: T | undefined;
                 constructor(value: T) {
                     this._value = value;
                 }
                 @service.inject("bar")
                 setValue(value: T) {
                     this._value = value;
                 }
                 setObj(value: object) {
                 }
                 getValue() {
                     if (this._value === undefined)
                         throw new Error("Trying to get a value from the empty box");
                     return this._value;
                 }
+            }
  No newline at end of file

src/test/ts/mock/config.ts +4 -3

             import { Foo } from "./Foo";
             import { Bar } from "./Bar";
             import { ActivationType } from "../di/interfaces";
             import { Builder } from "../di/Annotations";
             import { Box } from "./Box";
             interface RegistrationOptions {
                 activation?: ActivationType;
             }
             interface Dependency<K extends keyof any> {
                 $dependency: K;
                 lazy?: boolean;
             }
             interface Lazy<K extends keyof any> extends Dependency<K> {
                 lazy: true;
             }
             type PromiseOrValue<T> = T | PromiseLike<T>;
             interface ConfigBuilder<S> {
                 build<K extends keyof S, T = S[K]>(name: K): Builder<T, S>;
                 dependency<K extends keyof S>(name: K): Dependency<K>;
                 lazy<K extends keyof S>(name: K): Lazy<K>;
                 mapTo<K extends keyof S>(name: K, ctor: () => PromiseOrValue<new (...args: any[]) => S[K]>): ConfigBuilder<S>;
             }
             interface ContainerServices {
                 barBox: Box<Bar>;
                 foo: Foo;
                 bar: Bar;
                 password: string;
                 user: string;
                 timeout: number;
             }
             declare function load<M, C extends keyof M>(m: PromiseLike<M>, name: C): () => PromiseLike<M[C]>;
             const t = {
                 barBox: load(import("./Box"), "Box"),
                 foo: async () => (await import("./Bar")).Bar,
                 bar: Bar,
                 password: String,
                 user: String,
                 timeout: Number
             };
+            declare const bc: typeof Box;
+            const x = new bc();
             export declare const config: ConfigBuilder<ContainerServices>;
-            config
-                .mapTo("bar", )
-                .mapTo("barBox", ;

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages