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