implab/implabjs-core Commit - r128:882b53b2ba5b

working on fluent configuration

cin -

r128:882b53b2ba5b ioc ts support

parent child

Context file:

r128:882b53b2ba5b

Collapse all files

src/main/ts/di/fluent/RegistrationBuilder.ts created 644 +37 0

@@ -0,0 +1,37
	1	import { ServiceRecordBuilder, ExtractDependency, RegistrationVisitor } from "./interfaces";
	2	import { ActivationType } from "../interfaces";
	3
	4	export class RegistrationBuilder<T, S extends object> {
	5	private _activationType: ActivationType = "call";
	6
	7	private _overrides: { [m in keyof S]?: (...args: any) => void } \| undefined;
	8
	9
	10	override<K extends keyof S>(name: K, builder: S[K], raw: true): this;
	11	override<K extends keyof S>(name: K, builder: (t: ServiceRecordBuilder<S[K], S>) => void): this;
	12	override<K extends keyof S, V>(name: S[K] extends ExtractDependency<V, S> ? K : never, value: V): this;
	13	override<K extends keyof S>(name: K, builder: S[K] \| ((t: ServiceRecordBuilder<S[K], S>) => void), raw: boolean = false) {
	14	if (!this._overrides)
	15	this._overrides = {};
	16	if (raw) {
	17
	18	} else if (builder instanceof Function) {
	19
	20	} else {
	21
	22	}
	23	return this;
	24	}
	25
	26	activate(activation: ActivationType) {
	27	this._activationType = activation;
	28	return this;
	29	}
	30	inject<M extends keyof T, P extends any[]>(member: T[M] extends (...params: ExtractDependency<P, S>) => any ? M : never, ...params: P) {
	31	return this;
	32	}
	33
	34	visit(visitor: RegistrationVisitor<S>) {
	35
	36	}
	37	} No newline at end of file

src/main/ts/di/fluent/interfaces.ts +29 -7

             import { ActivationType } from "../interfaces";
             import { AnnotaionBuilder } from "../Annotations";
             import { LazyDependencyRegistration, DependencyRegistration } from "../Configuration";
-            import { PromiseOrValue } from "../../interfaces";
+            import { Container } from "../Container";
             export interface DependencyOptions<T> {
                 optional?: boolean;
                 [m in M]: AnnotaionBuilder<T, S>;
             };
-            export interface ServiceBuilder<T, S extends object> {
+            export interface ServiceRecordBuilder<T, S extends object> {
                 type<P extends any[], C extends new (...args: ExtractDependency<P, S>) => T>(
                     target: C, ...params: P): ConstructorBuilder<C, S>;
                 factory<P extends any[], F extends (...args: ExtractDependency<P, S>) => T>(
                     target: F, ...params: P): FactoryBuilder<F, S>;
-                wired<M extends keyof any>(module: PromiseOrValue<ServiceModule<T, S, M>>, m: M): RegistrationBuilder<T, S>;
+                wired<M extends keyof any>(module: ServiceModule<T, S, M>, m: M): RegistrationBuilder<T, S>;
-                wired(module: PromiseOrValue<ServiceModule<T, S>>): RegistrationBuilder<T, S>;
+                wired(module: ServiceModule<T, S>): RegistrationBuilder<T, S>;
+            }
+            export interface RegistrationVisitor<S extends object> {
+                visitDependency(): void;
+                visitObject(): void;
+                visitTypeRegistration(): void;
+                visitFactoryRegistration(): void;
+                visitBuilder<T>(builder: (t: ServiceRecordBuilder<T, S>) => void): void;
             }
             export interface RegistrationBuilder<T, S extends object> {
-                override<K extends keyof S>(name: K, builder: S[K] | ((t: ServiceBuilder<S[K], S>) => any)): this;
+                override<K extends keyof S>(name: K, builder: S[K], raw: true): this;
+                override<K extends keyof S>(name: K, builder: (t: ServiceRecordBuilder<S[K], S>) => void): this;
+                override<K extends keyof S, V>(name: S[K] extends ExtractDependency<V, S> ? K : never, value: V): this;
                 activate(activation: ActivationType): this;
                 inject<M extends keyof T, P extends any[]>(member: T[M] extends (...params: ExtractDependency<P, S>) => any ? M : never, ...params: P): this;
+                visit(visitor: RegistrationVisitor<S>): void;
             }
             export interface ConstructorBuilder<C extends new (...args: any[]) => any, S extends object> extends RegistrationBuilder<InstanceType<C>, S> {
             }
             export interface ConfigBuilder<S extends object, Y extends keyof S = keyof S> {
-                register<K extends Y>(name: K, builder: S[K] | ((t: ServiceBuilder<S[K], S>) => any)): ConfigBuilder<S, Exclude<Y, K>>;
+                register<K extends Y>(name: K, builder: (t: ServiceRecordBuilder<S[K], S>) => void | Promise<void>): ConfigBuilder<S, Exclude<Y, K>>;
+                register<K extends Y, V>(name: S[K] extends ExtractDependency<V, S> ? K : never, value: V): ConfigBuilder<S, Exclude<Y, K>>;
+                register<K extends Y>(name: K, value: S[K], raw: true): ConfigBuilder<S, Exclude<Y, K>>;
+                apply(container: Container<S>): Promise<void>;
             }
             interface ServicesDeclaration<S extends object> {
-                build<T>(this: void): ServiceBuilder<T, S>;
+                build<T>(this: void): ServiceRecordBuilder<T, S>;
                 annotate<T>(this: void): AnnotaionBuilder<T, S>;
                 dependency<K extends keyof S>(this: void, name: K, opts: LazyDependencyOptions<S[K]>): LazyDependencyRegistration<S, K>;

src/test/ts/mock/config.ts +5 -16

             import { configure, dependency, build } from "./services";
-            import { Foo } from "./Foo";
-            import { Bar } from "./Bar";
-            import { Box } from "./Box";
             export const config = configure()
-                .register("bar", s => s
+                .register("bar", async s => s.wired(await import("./Bar"), "service"))
-                    .wired(import("./Bar"), "service")
+                .register("box", s => import("./Box").then(m => s.wired(m)))
-                    .inject("setName", "heell")
-                .register("box", s => s.wired(import("./Box")))
                 .register("host", "example.com")
                 // .registerType("bar2", Bar, [{ foo: dependency("foo"), host: "" }]);
-                .register("bar2", s => s.type(Bar,
+                .register("bar2", async s => s.type((await import("./Bar")).Bar,
                     {
-                        foo: build().type(Foo)
+                        foo: build().type((await import("./Foo")).Foo)
                             .activate("context"),
-                        nested: { lazy: dependency("foo", {lazy: true}) },
+                        nested: { lazy: dependency("foo", { lazy: true }) },
                         host: dependency("host")
                     },
                     "")
                     .inject("setName", dependency("host"))
-                .register("box", s => s
-                    .type(Box, dependency("bar"))
-                    .activate("context")
                 );

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