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"
                     }
                 }
             }

src/main/ts/di/Annotations.ts +24 -11

             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) {
+                dependencies<D extends (keyof S)[]>(...deps: D) {
-                    return <M extends keyof T>(target: any, memberName: M, descriptor: TypedPropertyDescriptor<S[K]> ) => {
+                    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> {
+            const builder = new Builder<Box<Bar>, { bar: Bar; foo: Foo; obj: object }>();
-                setValue(value: T);
-            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")
+                constructor(value: T) {
-            export class Box<T> implements Injector<T> {
+                    this._value = value;
-                private _value: T;
                 @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"
                 ]
             }

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"]
                 }
             }

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