implab/implabjs-core Commit - r109:f71c50acc9f9

working on di decorators

cin -

r109:f71c50acc9f9 ioc ts support

parent child

Context file:

r109:f71c50acc9f9

Collapse all files

src/test/ts/mock/config.ts created 644 0 0

NO CONTENT: new file 100644

build.gradle +2 0

                  compilerOptions {
                      types = []
                      declaration = true
+                     experimentalDecorators = true
+                     //strict = true
                      if(symbols != 'none') {
                          sourceMap = true

src/main/ts/di/Annotations.ts +25 -12

                  [k in keyof T]: Setter;
              };
+             type Compatible<T1, T2> = T1 extends T2 ? any : never;
+             type SetterType<T> = T extends (v: infer V) => void ? V : never;
+             type Tuple<T = any> = Parameters<(...args: T[]) => void>;
+             interface Newable<A extends Tuple, T> {
+                 new (...params: A): T;
+                 prototype: T;
+             }
+             type MapTuple<T, A extends (keyof T)[]> = { [K in keyof A] : K extends number ? T[ A[K] ] : A[K] };
              export class Builder<T, S> {
-                 provides(name: string) {
+                 provides() {
                      return <C extends Constructor<T>>(constructor: C) => {
                          return constructor;
                      };
                  }
                  inject<K extends keyof S>(dependency: K) {
-                     return <M extends keyof T>(target: any, memberName: M, descriptor: TypedPropertyDescriptor<Setter<S[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]>>>) => {
                      };
                  }
-                 prop<K extends keyof S>(dependency: K) {
-                     return <M extends keyof T>(target: any, memberName: M, descriptor: TypedPropertyDescriptor<S[K]> ) => {
+                 dependencies<D extends (keyof S)[]>(...deps: D) {
+                     return <C extends Constructor<T>>(constructor: MapTuple<S, D> extends ConstructorParameters<C> ? C : never) => {
+                         return constructor;
+                     } ;
+                 }
-                     };
+                 }
              }
-             export function inject<I extends Injector<I> >(dependency: string) {
-                 return <M extends keyof I>(target: any, memberName: M, descriptor: TypedPropertyDescriptor<I[M]> ) => {
-                 };
+             }

src/test/ts/mock/Bar.ts +8 -2

              export class Bar {
                  name = "bar";
-                 foo: Foo;
+                 foo: Foo | undefined;
-                 constructor(_opts) {
+                 constructor(_opts?: { foo?: Foo; }) {
                      if (_opts && _opts.foo)
                          this.foo = _opts.foo;
                  }
+                 getFoo() {
+                     if (this.foo === undefined)
+                         throw new Error("The foo isn't set");
+                     return this.foo;
+                 }
              }

src/test/ts/mock/Box.ts +18 -8

              import { Bar } from "./Bar";
              import { Foo } from "./Foo";
-             export interface Injector<T> {
-                 setValue(value: T);
+             }
+             const builder = new Builder<Box<Bar>, { bar: Bar; foo: Foo; obj: object }>();
-             const builder = new Builder<Box<any>, { bar: Bar; foo: Foo}>();
+             @builder.provides()
+             @builder.dependencies("bar")
+             export class Box<T> {
+                 private _value: T | undefined;
-             @builder.provides("barBox")
-             export class Box<T> implements Injector<T> {
-                 private _value: T;
+                 constructor(value: T) {
+                     this._value = value;
+                 }
                  @builder.inject("bar")
                  setValue(value: T) {
                      this._value = value;
                  }
+                 @builder.inject("foo")
+                 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/tsconfig.json +1 -1

              {
                  "extends": "../tsconfig",
                  "compilerOptions": {
-                     "rootDir": "ts",
+                     //"rootDir": "ts",
                      "baseUrl": ".",
                      "rootDirs": [
                          "ts",

src/tsconfig.json +1 0

                      "experimentalDecorators": true,
                      "noEmitOnError": true,
                      "listFiles": true,
+                     "strict": true,
                      "types": [],
                      "target": "ES5",
                      "lib": ["es5", "es2015.promise", "es2015.symbol", "es2015.iterable", "dom", "scripthost"]

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