implab/implabjs-core Commit - r107:3725cefc8f98

Initial work on typescript support for the container configuration

cin -

r107:3725cefc8f98 ioc ts support

parent child

Context file:

r107:3725cefc8f98

Collapse all files

src/main/ts/di/Annotations.ts created 644 +11 0

@@ -0,0 +1,11
	1	import { Constructor } from "../interfaces";
	2
	3	export interface InjectOptions {
	4	lazy?: boolean;
	5	}
	6
	7	export function inject<I extends { [name in keyof I]: (v: any) => void } >(dependency: string) {
	8	return <M extends keyof I>(target: any, memberName: M, descriptor: TypedPropertyDescriptor<I[M]> ) => {
	9
	10	};
	11	}

src/test/ts/mock/Box.ts created 644 +18 0

@@ -0,0 +1,18
	1	import { inject } from "../di/Annotations";
	2
	3	export interface Injector<T> {
	4	setValue(value: T);
	5	}
	6
	7	export class Box<T> implements Injector<T> {
	8	private _value: T;
	9
	10	@inject<Injector<T>>("bar")
	11	setValue(value: T) {
	12	this._value = value;
	13	}
	14
	15	getValue() {
	16	return this._value;
	17	}
	18	}

src/test/ts/tests/ConfigurationBuilderTests.ts created 644 +36 0

@@ -0,0 +1,36
	1	import { Constructor } from "../interfaces";
	2	import { ActivationType } from "../di/interfaces";
	3
	4	namespace MyLib {
	5	interface Resolver<S> {
	6	<K extends keyof S>(name: K): S[K];
	7	<K extends keyof S>(lazy: K): (overrides?: {}) => S[K];
	8	}
	9
	10	interface RegistrationOptions<S> {
	11	activation?: ActivationType;
	12	services?: BuilderContext<S>;
	13	}
	14
	15	interface BuilderContext<S> {
	16	registerType<T extends Constructor, K extends string>(
	17	name: K,
	18	constructor: T,
	19	options?: RegistrationOptions<S>
	20	): BuilderContext<S & { K: T }>;
	21
	22	registerFactory<T, K extends string>(
	23	name: K,
	24	factory: (resolver: Resolver<S>) => T,
	25	options?: RegistrationOptions<S>
	26	): BuilderContext<S & { K: T }>;
	27
	28	registerInstance<T, K extends string>(
	29	name: K,
	30	instance: T,
	31	ownership?: boolean
	32	): BuilderContext<S & { K: T }>;
	33	}
	34	}
	35
	36	export = MyLib;

.settings/org.eclipse.buildship.core.prefs +11 0

@@ -1,2 +1,13
		1	arguments=
		2	auto.sync=false
		3	build.scans.enabled=false
		4	connection.gradle.distribution=GRADLE_DISTRIBUTION(WRAPPER)
1	connection.project.dir=	5	connection.project.dir=
2	eclipse.preferences.version=1	6	eclipse.preferences.version=1
		7	gradle.user.home=
		8	java.home=/usr/lib64/jvm/java
		9	jvm.arguments=
		10	offline.mode=false
		11	override.workspace.settings=true
		12	show.console.view=true
		13	show.executions.view=true

build.gradle +2 -2

             plugins {
-              id "org.implab.gradle-typescript" version "1.3.0"
+              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
                     if(symbols != 'none') {
                         sourceMap = true
-                        sourceRoot = "_src"
+                        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/Container.ts +3 -3

             import { ActivationContext } from "./ActivationContext";
             import { ValueDescriptor } from "./ValueDescriptor";
             import { ActivationError } from "./ActivationError";
             import { isDescriptor, ServiceMap } from "./interfaces";
             import { TraceSource } from "../log/TraceSource";
             import { Configuration } from "./Configuration";
             import { Cancellation } from "../Cancellation";
             const trace = TraceSource.get("@implab/core/di/ActivationContext");
             export class Container {
                 _services: ServiceMap;
                 _cache: object;
                 _cleanup: (() => void)[];
                 _root: Container;
                 _parent: Container;
                 constructor(parent?: Container) {
                     this._parent = parent;
                     this._services = parent ? Object.create(parent._services) : {};
                     this._cache = {};
                     this._cleanup = [];
                     this._root = parent ? parent.getRootContainer() : this;
                     this._services.container = new ValueDescriptor(this);
                 }
                 getRootContainer() {
                     return this._root;
                 }
                 getParent() {
                     return this._parent;
                 }
                 resolve(name: string, def?) {
                     trace.debug("resolve {0}", name);
                     const d = this._services[name];
                     if (d === undefined) {
                         if (arguments.length > 1)
                             return def;
                         else
                             throw new Error("Service '" + name + "' isn't found");
                     }
                     const context = new ActivationContext(this, this._services);
                     try {
                         return context.activate(d, name);
                     } catch (error) {
                         throw new ActivationError(name, context.getStack(), error);
                     }
                 }
                 /**
                  * @deprecated use resolve() method
                  */
                 getService() {
                     return this.resolve.apply(this, arguments);
                 }
                 register(nameOrCollection, service?) {
                     if (arguments.length === 1) {
                         const data = nameOrCollection;
                         for (const name in data)
                             this.register(name, data[name]);
                     } else {
                         if (!isDescriptor(service))
                             throw new Error("The service parameter must be a descriptor");
                         this._services[nameOrCollection] = service;
                     }
                     return this;
                 }
                 onDispose(callback) {
                     if (!(callback instanceof Function))
                         throw new Error("The callback must be a function");
                     this._cleanup.push(callback);
                 }
                 dispose() {
                     if (this._cleanup) {
                         for (const f of this._cleanup)
                             f();
                         this._cleanup = null;
                     }
                 }
                 /**
                  * @param{String|Object} config
                  *  The configuration of the contaier. Can be either a string or an object,
                  *  if the configuration is an object it's treated as a collection of
                  *  services which will be registed in the contaier.
                  *
                  * @param{Function} opts.contextRequire
                  *  The function which will be used to load a configuration or types for services.
                  *
                  */
                 async configure(config: string | object, opts?: any, ct = Cancellation.none) {
                     const c = new Configuration(this);
                     if (typeof (config) === "string") {
                         return c.loadConfiguration(config, opts && opts.contextRequire, ct);
                     } else {
                         return c.applyConfiguration(config, opts && opts.contextRequire, ct);
                     }
                 }
                 createChildContainer() {
                     return new Container(this);
                 }
-                has(id) {
+                has(id: string | number) {
                     return id in this._cache;
                 }
-                get(id) {
+                get(id: string | number) {
                     return this._cache[id];
                 }
-                store(id, value) {
+                store(id: string | number, value: any) {
                     return (this._cache[id] = value);
                 }
             }

src/tsconfig.json +2 0

             {
                 "compilerOptions": {
                     "moduleResolution": "node",
+                    "experimentalDecorators": true,
                     "noEmitOnError": true,
                     "listFiles": 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