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

              plugins {
                id "org.implab.gradle-typescript" version "1.3.3"
                id "org.implab.gradle-hg"
                id "ivy-publish"
              }
              if (!symbols in ['local', 'pack', 'none'])
                  throw new Exception("The symbols property value is invalid: $symbols");
              if (!flavour in ['browser', 'node'])
                  throw new Exception("The flavour property value is invalid: $flavour");
              ext {
                  packageName = flavour == 'browser' ? "@$npmScope/$name-amd" : "@$npmScope/$name"
                  lint = project.hasProperty('lint') ? project.lint ?: true : false
              }
              sources {
                  amd {
                      typings {
                          srcDir main.output.typingsDir
                      }
                  }
                  cjs {
                      typings {
                          srcDir main.output.typingsDir
                      }
                  }
                  testAmd {
                      typings {
                          srcDir main.output.typingsDir
                          srcDir amd.output.typingsDir
                          srcDir test.output.typingsDir
                      }
                  }
                  testCjs {
                      typings {
                          srcDir main.output.typingsDir
                          srcDir cjs.output.typingsDir
                          srcDir test.output.typingsDir
                      }
                  }
              }
              typescript {
                  compilerOptions {
                      types = []
                      declaration = true
+                     experimentalDecorators = true
+                     //strict = true
                      if(symbols != 'none') {
                          sourceMap = true
                          sourceRoot = packageName
                      }
                      if (flavour == 'node') {
                          module = "commonjs"
                          target = "es2017"
                          lib = ["es2017", "dom", "scripthost"]
                      } else if (flavour == 'browser') {
                          module = "amd"
                          target = "es5"
                          lib = ["es5", "dom", "scripthost", "es2015.promise", "es2015.symbol", "es2015.iterable" ]
                      }
                  }
                  tscCmd = "$projectDir/node_modules/.bin/tsc"
                  tsLintCmd = "$projectDir/node_modules/.bin/tslint"
              	esLintCmd = "$projectDir/node_modules/.bin/eslint"
              }
              tasks.matching{ it.name =~ /^lint/ }.configureEach {
                  onlyIf { lint }
              }
              if (symbols == 'local') {
                  tasks.matching{ it.name =~ /^configureTs/ }.configureEach {
                      compilerOptions {
                          sourceRoot = "file://" + it.rootDir
                      }
                  }
              }
              task printVersion {
                  doLast {
                      println "packageName: $packageName";
                      println "version: $version";
                      println "flavour: $flavour";
                      println "target: $typescript.compilerOptions.target";
                      println "module: $typescript.compilerOptions.module";
                      println "lint: $lint";
                      println "symbols: $symbols";
                  }
              }
              npmPackMeta {
                  meta {
                      name = packageName
                  }
              }
              configureTsCjs {
                  dependsOn sources.main.output
                  compilerOptions {
                      types += [ "node" ]
                  }
              }
              configureTsAmd {
                  dependsOn sources.main.output
                  compilerOptions {
                      types += [ "requirejs", "dojo-typings" ]
                  }
              }
              test {
                  workingDir layout.buildDirectory.dir("test");
                  commandLine "node", "tests/index.js"
              }
              assemble {
                  if (flavour == 'browser') {
                      dependsOn sources.amd.output
                      from sources.amd.output.compiledDir
                      from sources.amd.resources
                  }
                  if (flavour == 'node') {
                      dependsOn sources.cjs.output
                      from sources.cjs.output.compiledDir
                      from sources.cjs.resources
                  }
              }
              assembleTest {
                  if (flavour == 'browser') {
                      dependsOn sources.amd.output, sources.testAmd.output
                      from sources.amd.output.compiledDir
                      from sources.testAmd.output.compiledDir
                      from sources.amd.resources
                      from sources.testAmd.resources
                  }
                  if (flavour == 'node') {
                      dependsOn sources.cjs.output, sources.testCjs.output
                      from sources.cjs.output.compiledDir
                      from sources.testCjs.output.compiledDir
                      from sources.cjs.resources
                      from sources.testCjs.resources
                  }
              }
              typings {
                  if (flavour == 'browser') {
                      dependsOn sources.amd.output
                      from sources.amd.output.typingsDir
                  }
                  if (flavour == 'node') {
                      dependsOn sources.cjs.output
                      from sources.cjs.output.typingsDir
                  }
              }
              task npmPackTypings(type: Copy) {
                  npmPackContents.dependsOn it
                  dependsOn sources.main.output
                  from sources.main.output.typingsDir
                  if (flavour == 'browser') {
                      dependsOn sources.amd.output
                      from sources.amd.output.typingsDir
                  }
                  if (flavour == 'node') {
                      dependsOn sources.cjs.output
                      from sources.cjs.output.typingsDir
                  }
                  into npm.packageDir
              }
              task npmPackSources(type: Copy) {
                  from sources.main.ts
                  if (symbols == 'pack') {
                     npmPackContents.dependsOn npmPackSources
                  }
                  if (flavour == 'browser') {
                      from sources.amd.ts
                  }
                  if (flavour == 'node') {
                      from sources.cjs.ts
                  }
                  into npm.packageDir.dir("_src")
              }
              task packJsTar(type: Tar) {
                  dependsOn assemble;
                  archiveBaseName = provider { packageName }
                  destinationDirectory = buildDir
                  archiveClassifier = provider { typescript.compilerOptions.module }
                  compression = Compression.GZIP
                  from(assemble.outputs)
                  doLast {
                      println archiveName;
                  }
              }
              task packTypingsTar(type: Tar) {
              }
              publishing {
                  publications {
                      local(IvyPublication) {
                          artifact(packJsTar) {
                              type = "js"
                          }
                      }
                  }
                  repositories {
                      ivy {
                          url "ivy-repo"
                      }
                  }
              }
  No newline at end of file

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

              import { Constructor } from "../interfaces";
              export interface InjectOptions {
                  lazy?: boolean;
              }
              type Setter<T = any> = (v: T) => void;
              type Injector<T> = {
                  [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

              import { Foo } from "./Foo";
              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 { Builder } from "../di/Annotations";
              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",
                          "../main/ts"
                      ]
                  },
                  "include" : [
                      "ts/**/*.ts"
                  ]
              }
  No newline at end of file

src/tsconfig.json +1 0

              {
                  "compilerOptions": {
                      "moduleResolution": "node",
                      "experimentalDecorators": true,
                      "noEmitOnError": true,
                      "listFiles": true,
+                     "strict": true,
                      "types": [],
                      "target": "ES5",
                      "lib": ["es5", "es2015.promise", "es2015.symbol", "es2015.iterable", "dom", "scripthost"]
                  }
              }
  No newline at end of file

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