dojo
diff --git a/‎README.md
Copy file name to clipboard
+25-8Lines changed: 25 additions & 8 deletions b/‎README.md
Copy file name to clipboard
+25-8Lines changed: 25 additions & 8 deletions
diff --git a/‎src/Injector.ts
Copy file name to clipboard
+8-1Lines changed: 8 additions & 1 deletion b/‎src/Injector.ts
Copy file name to clipboard
+8-1Lines changed: 8 additions & 1 deletion
diff --git a/‎src/Registry.ts
Copy file name to clipboard
+26-14Lines changed: 26 additions & 14 deletions b/‎src/Registry.ts
Copy file name to clipboard
+26-14Lines changed: 26 additions & 14 deletions
diff --git a/‎src/RegistryHandler.ts
Copy file name to clipboard
+3-4Lines changed: 3 additions & 4 deletions b/‎src/RegistryHandler.ts
Copy file name to clipboard
+3-4Lines changed: 3 additions & 4 deletions
diff --git a/‎src/decorators/inject.ts
Copy file name to clipboard
+9-9Lines changed: 9 additions & 9 deletions b/‎src/decorators/inject.ts
Copy file name to clipboard
+9-9Lines changed: 9 additions & 9 deletions
diff --git a/‎src/interfaces.d.ts
Copy file name to clipboard
+15Lines changed: 15 additions & 0 deletions b/‎src/interfaces.d.ts
Copy file name to clipboard
+15Lines changed: 15 additions & 0 deletions
diff --git a/‎src/mixins/I18n.ts
Copy file name to clipboard
+4-1Lines changed: 4 additions & 1 deletion b/‎src/mixins/I18n.ts
Copy file name to clipboard
+4-1Lines changed: 4 additions & 1 deletion
diff --git a/‎src/mixins/Themed.ts
Copy file name to clipboard
+4-1Lines changed: 4 additions & 1 deletion b/‎src/mixins/Themed.ts
Copy file name to clipboard
+4-1Lines changed: 4 additions & 1 deletion
diff --git a/‎tests/unit/Container.ts
Copy file name to clipboard
+14-6Lines changed: 14 additions & 6 deletions b/‎tests/unit/Container.ts
Copy file name to clipboard
+14-6Lines changed: 14 additions & 6 deletions
diff --git a/‎tests/unit/Injector.ts
Copy file name to clipboard
+4-5Lines changed: 4 additions & 5 deletions b/‎tests/unit/Injector.ts
Copy file name to clipboard
+4-5Lines changed: 4 additions & 5 deletions
@@ -688,11 +688,14 @@ A main registry can be provided to the `projector`, which will be automatically
 import { Registry } from '@dojo/widget-core/Registry';
 
 import { MyWidget } from './MyWidget';
-import { MyInjector } from './MyInjector';
+import { MyAppContext } from './MyAppContext';
 
 const registry = new Registry();
 registry.define('my-widget', MyWidget);
-registry.defineInjector('my-injector', MyInjector);
+registry.defineInjector('my-injector', (invalidator) => {
+	const appContext = new MyAppContext(invalidator);
+	return () => appContext;
+});
 // ... Mixin and create Projector ...
 
 projector.setProperties({ registry });
@@ -851,18 +854,32 @@ class MyClass extends WidgetBase {
 
 ### Containers & Injectors
 
-There is built-in support for side-loading/injecting values into sections of the widget tree and mapping them to a widget's properties. This is achieved by registering a `@dojo/widget-core/Injector` instance against a `registry` that is available to your application (i.e. set on the projector instance, `projector.setProperties({ registry })`).
+There is built-in support for side-loading/injecting values into sections of the widget tree and mapping them to a widget's properties. This is achieved by registering an injector factory with a `registry` and setting the registry as a property on the application's `projector` to ensure the registry instance is available to your application.
+
+Create a factory function for a function that returns the required `payload`.
+
+```ts
+registry.defineInjector('my-injector', () => {
+    return () => ({ foo: 'bar' });
+});
+```
 
-Create an `Injector` instance and pass the `payload` that needs to be injected to the constructor:
+The injector factory gets passed an `invalidator` function that can get called when something has changed that requires connected widgets to `invalidate`.
 
 ```ts
-const injector = new Injector({ foo: 'baz' });
-registry.defineInjector('my-injector', injector);
+registry.defineInjector('my-injector', (invalidator) => {
+    // This could be a store, but for this example it is simply an instance
+    // that accepts the `invalidator` and calls it when any of its internal
+    // state has changed.
+    const appContext = new AppContext(invalidator);
+    return () => appContext;
+});
+
 ```
 
-To connect the registered `injector` to a widget, we can use the `Container` HOC (higher order component) provided by `widget-core`. The `Container` accepts a widget `constructor`, `injector` label, and `getProperties` mapping function as arguments and returns a new class that returns the passed widget from its `render` function.
+To connect the registered `payload` to a widget, we can use the `Container` HOC (higher order component) provided by `widget-core`. The `Container` accepts a widget `constructor`, `injector` label, and `getProperties` mapping function as arguments and returns a new class that returns the passed widget from its `render` function.
 
-`getProperties` receives the `payload` from an `injector` and `properties` from the container HOC component. These are used to map into the wrapped widget's properties.
+`getProperties` receives the `payload` returned from the injector function and the `properties` passed to the container HOC component. These are used to map into the wrapped widget's properties.
 
 ```ts
 import { Container } from '@dojo/widget-core/Container';
 
@@ -7,19 +7,26 @@ export type InjectorEventMap = {
 
 export class Injector<T = any> extends Evented<InjectorEventMap> {
 	private _payload: T;
+	private _invalidator: undefined | (() => void);
 
 	constructor(payload: T) {
 		super();
 		this._payload = payload;
 	}
 
+	public setInvalidator(invalidator: () => void) {
+		this._invalidator = invalidator;
+	}
+
 	public get(): T {
 		return this._payload;
 	}
 
 	public set(payload: T): void {
 		this._payload = payload;
-		this.emit({ type: 'invalidate' });
+		if (this._invalidator) {
+			this._invalidator();
+		}
 	}
 }
 
 
@@ -3,8 +3,14 @@ import Map from '@dojo/shim/Map';
 import Symbol from '@dojo/shim/Symbol';
 import { EventObject } from '@dojo/core/interfaces';
 import { Evented } from '@dojo/core/Evented';
-import { Constructor, RegistryLabel, WidgetBaseConstructor, WidgetBaseInterface } from './interfaces';
-import { Injector } from './Injector';
+import {
+	Constructor,
+	InjectorFactory,
+	InjectorItem,
+	RegistryLabel,
+	WidgetBaseConstructor,
+	WidgetBaseInterface
+} from './interfaces';
 
 export type WidgetBaseConstructorFunction = () => Promise<WidgetBaseConstructor>;
 
@@ -23,9 +29,8 @@ export const WIDGET_BASE_TYPE = Symbol('Widget Base');
 
 export interface RegistryEventObject extends EventObject<RegistryLabel> {
 	action: string;
-	item: WidgetBaseConstructor | Injector;
+	item: WidgetBaseConstructor | InjectorFactory;
 }
-
 /**
  * Widget Registry Interface
  */
@@ -58,17 +63,17 @@ export interface RegistryInterface {
 	 * Define an Injector against a label
 	 *
 	 * @param label The label of the injector to register
-	 * @param registryItem The injector to define
+	 * @param registryItem The injector factory
 	 */
-	defineInjector(label: RegistryLabel, registryItem: Injector): void;
+	defineInjector(label: RegistryLabel, injectorFactory: InjectorFactory): void;
 
 	/**
 	 * Return an Injector registry item for the given label, null if an entry doesn't exist
 	 *
 	 * @param label The label of the injector to return
 	 * @returns The RegistryItem for the widgetLabel, `null` if no entry exists
 	 */
-	getInjector<T extends Injector>(label: RegistryLabel): T | null;
+	getInjector<T>(label: RegistryLabel): InjectorItem<T> | null;
 
 	/**
 	 * Returns a boolean if an injector for the label exists
@@ -112,12 +117,12 @@ export class Registry extends Evented<{}, RegistryLabel, RegistryEventObject> im
 	 */
 	private _widgetRegistry: Map<RegistryLabel, RegistryItem> | undefined;
 
-	private _injectorRegistry: Map<RegistryLabel, Injector> | undefined;
+	private _injectorRegistry: Map<RegistryLabel, InjectorItem> | undefined;
 
 	/**
 	 * Emit loaded event for registry label
 	 */
-	private emitLoadedEvent(widgetLabel: RegistryLabel, item: WidgetBaseConstructor | Injector): void {
+	private emitLoadedEvent(widgetLabel: RegistryLabel, item: WidgetBaseConstructor | InjectorItem): void {
 		this.emit({
 			type: widgetLabel,
 			action: 'loaded',
@@ -152,7 +157,7 @@ export class Registry extends Evented<{}, RegistryLabel, RegistryEventObject> im
 		}
 	}
 
-	public defineInjector(label: RegistryLabel, item: Injector): void {
+	public defineInjector(label: RegistryLabel, injectorFactory: InjectorFactory): void {
 		if (this._injectorRegistry === undefined) {
 			this._injectorRegistry = new Map();
 		}
@@ -161,8 +166,15 @@ export class Registry extends Evented<{}, RegistryLabel, RegistryEventObject> im
 			throw new Error(`injector has already been registered for '${label.toString()}'`);
 		}
 
-		this._injectorRegistry.set(label, item);
-		this.emitLoadedEvent(label, item);
+		const invalidator = new Evented();
+
+		const injectorItem: InjectorItem = {
+			injector: injectorFactory(() => invalidator.emit({ type: 'invalidate' })),
+			invalidator
+		};
+
+		this._injectorRegistry.set(label, injectorItem);
+		this.emitLoadedEvent(label, injectorItem);
 	}
 
 	public get<T extends WidgetBaseInterface = WidgetBaseInterface>(label: RegistryLabel): Constructor<T> | null {
@@ -201,12 +213,12 @@ export class Registry extends Evented<{}, RegistryLabel, RegistryEventObject> im
 		return null;
 	}
 
-	public getInjector<T extends Injector>(label: RegistryLabel): T | null {
+	public getInjector<T>(label: RegistryLabel): InjectorItem<T> | null {
 		if (!this._injectorRegistry || !this.hasInjector(label)) {
 			return null;
 		}
 
-		return this._injectorRegistry.get(label) as T;
+		return this._injectorRegistry.get(label)!;
 	}
 
 	public has(label: RegistryLabel): boolean {
 
@@ -1,9 +1,8 @@
 import { Map } from '@dojo/shim/Map';
 import { Evented } from '@dojo/core/Evented';
 import { EventObject } from '@dojo/core/interfaces';
-import { Constructor, RegistryLabel, WidgetBaseInterface } from './interfaces';
+import { Constructor, InjectorFactory, InjectorItem, RegistryLabel, WidgetBaseInterface } from './interfaces';
 import { Registry, RegistryEventObject, RegistryItem } from './Registry';
-import { Injector } from './Injector';
 
 export type RegistryHandlerEventMap = {
 	invalidate: EventObject<'invalidate'>;
@@ -40,7 +39,7 @@ export class RegistryHandler extends Evented<RegistryHandlerEventMap> {
 		this._registry.define(label, widget);
 	}
 
-	public defineInjector(label: RegistryLabel, injector: Injector): void {
+	public defineInjector(label: RegistryLabel, injector: InjectorFactory): void {
 		this._registry.defineInjector(label, injector);
 	}
 
@@ -59,7 +58,7 @@ export class RegistryHandler extends Evented<RegistryHandlerEventMap> {
 		return this._get(label, globalPrecedence, 'get', this._registryWidgetLabelMap);
 	}
 
-	public getInjector<T extends Injector>(label: RegistryLabel, globalPrecedence: boolean = false): T | null {
+	public getInjector<T>(label: RegistryLabel, globalPrecedence: boolean = false): InjectorItem<T> | null {
 		return this._get(label, globalPrecedence, 'getInjector', this._registryInjectorLabelMap);
 	}
 
 
@@ -1,14 +1,13 @@
 import WeakMap from '@dojo/shim/WeakMap';
 import { WidgetBase } from './../WidgetBase';
 import { handleDecorator } from './handleDecorator';
-import { Injector } from './../Injector';
 import { beforeProperties } from './beforeProperties';
-import { RegistryLabel } from './../interfaces';
+import { InjectorItem, RegistryLabel } from './../interfaces';
 
 /**
  * Map of instances against registered injectors.
  */
-const registeredInjectorsMap: WeakMap<WidgetBase, Injector[]> = new WeakMap();
+const registeredInjectorsMap: WeakMap<WidgetBase, InjectorItem[]> = new WeakMap();
 
 /**
  * Defines the contract requires for the get properties function
@@ -44,21 +43,22 @@ export interface InjectConfig {
 export function inject({ name, getProperties }: InjectConfig) {
 	return handleDecorator((target, propertyKey) => {
 		beforeProperties(function(this: WidgetBase & { own: Function }, properties: any) {
-			const injector = this.registry.getInjector(name);
-			if (injector) {
+			const injectorItem = this.registry.getInjector(name);
+			if (injectorItem) {
+				const { injector, invalidator } = injectorItem;
 				const registeredInjectors = registeredInjectorsMap.get(this) || [];
 				if (registeredInjectors.length === 0) {
 					registeredInjectorsMap.set(this, registeredInjectors);
 				}
-				if (registeredInjectors.indexOf(injector) === -1) {
+				if (registeredInjectors.indexOf(injectorItem) === -1) {
 					this.own(
-						injector.on('invalidate', () => {
+						invalidator.on('invalidate', () => {
 							this.invalidate();
 						})
 					);
-					registeredInjectors.push(injector);
+					registeredInjectors.push(injectorItem);
 				}
-				return getProperties(injector.get(), properties);
+				return getProperties(injector(), properties);
 			}
 		})(target);
 	});
 
@@ -231,6 +231,21 @@ export interface VNodeProperties {
  */
 export type RegistryLabel = string | symbol;
 
+export type InjectorPayload = () => any;
+
+/**
+ * Factory that returns an injector function
+ */
+export type InjectorFactory = (invalidator: () => void) => InjectorPayload;
+
+/**
+ * The injector item created for a registered Injector factory
+ */
+export interface InjectorItem<T = any> {
+	injector: () => T;
+	invalidator: Evented;
+}
+
 /**
  * Base widget properties
  */
 
@@ -87,7 +87,10 @@ export interface I18nMixin {
 
 export function registerI18nInjector(localeData: LocaleData, registry: Registry): Injector {
 	const injector = new Injector(localeData);
-	registry.defineInjector(INJECTOR_KEY, injector);
+	registry.defineInjector(INJECTOR_KEY, (invalidator) => {
+		injector.setInvalidator(invalidator);
+		return () => injector.get();
+	});
 	return injector;
 }
 
 
@@ -82,7 +82,10 @@ function createThemeClassesLookup(classes: ClassNames[]): ClassNames {
  */
 export function registerThemeInjector(theme: any, themeRegistry: Registry): Injector {
 	const themeInjector = new Injector(theme);
-	themeRegistry.defineInjector(INJECTED_THEME_KEY, themeInjector);
+	themeRegistry.defineInjector(INJECTED_THEME_KEY, (invalidator) => {
+		themeInjector.setInvalidator(invalidator);
+		return () => themeInjector.get();
+	});
 	return themeInjector;
 }
 
 
@@ -4,7 +4,6 @@ import { v, w } from '../../src/d';
 import { WidgetBase } from '../../src/WidgetBase';
 import { Container } from './../../src/Container';
 import { Registry } from './../../src/Registry';
-import { Injector } from './../../src/Injector';
 import { ProjectorMixin } from './../../src/mixins/Projector';
 
 interface TestWidgetProperties {
@@ -29,7 +28,7 @@ function getProperties(toInject: any, properties: any) {
 }
 
 const registry = new Registry();
-const injector = new Injector({});
+const injector = () => () => ({});
 registry.defineInjector('test-state-1', injector);
 registry.define('test-widget', TestWidget);
 
@@ -95,9 +94,18 @@ registerSuite('mixins/Container', {
 			assert.strictEqual(renderResult.widgetConstructor, 'test-widget');
 		},
 		'Container should always render but not invalidate parent when properties have not changed'() {
+			class TestInvalidate {
+				invalidator: any;
+			}
+			const testInvalidate = new TestInvalidate();
+			const testInvalidateInjector = (invalidator: any) => {
+				testInvalidate.invalidator = invalidator;
+				return () => {};
+			};
 			let renderCount = 0;
+			registry.defineInjector('test-always-render', testInvalidateInjector);
 			class Child extends WidgetBase<{ foo: string }> {}
-			class ContainerClass extends Container(Child, 'test-state-1', { getProperties }) {
+			class ContainerClass extends Container(Child, 'test-always-render', { getProperties }) {
 				render() {
 					renderCount++;
 					return super.render();
@@ -114,13 +122,13 @@ registerSuite('mixins/Container', {
 			projector.append();
 			renderCount = 0;
 
-			injector.set({});
+			testInvalidate.invalidator();
 			assert.strictEqual(renderCount, 1);
 
-			injector.set({});
+			testInvalidate.invalidator();
 			assert.strictEqual(renderCount, 2);
 
-			injector.set({});
+			testInvalidate.invalidator();
 			assert.strictEqual(renderCount, 3);
 		}
 	}
 
@@ -1,5 +1,6 @@
 const { registerSuite } = intern.getInterface('object');
 const { assert } = intern.getPlugin('chai');
+import { stub } from 'sinon';
 
 import { Injector } from './../../src/Injector';
 
@@ -10,14 +11,12 @@ registerSuite('Injector', {
 		assert.strictEqual(injector.get(), payload);
 	},
 	set() {
-		let invalidateCalled = false;
 		const payload = {};
 		const injector = new Injector(payload);
+		const invalidatorStub = stub();
+		injector.setInvalidator(invalidatorStub);
 		assert.strictEqual(injector.get(), payload);
-		injector.on('invalidate', () => {
-			invalidateCalled = true;
-		});
 		injector.set({});
-		assert.isTrue(invalidateCalled);
+		assert.isTrue(invalidatorStub.calledOnce);
 	}
 });
Original file line number	Diff line number	Diff line change
`@@ -7,19 +7,26 @@ export type InjectorEventMap = {`
`7`	`7`
`8`	`8`	`export class Injector<T = any> extends Evented<InjectorEventMap> {`
`9`	`9`	`private _payload: T;`
	`10`	`+ private _invalidator: undefined \| (() => void);`
`10`	`11`
`11`	`12`	`constructor(payload: T) {`
`12`	`13`	`super();`
`13`	`14`	`this._payload = payload;`
`14`	`15`	`}`
`15`	`16`
	`17`	`+ public setInvalidator(invalidator: () => void) {`
	`18`	`+ this._invalidator = invalidator;`
	`19`	`+ }`
	`20`	`+`
`16`	`21`	`public get(): T {`
`17`	`22`	`return this._payload;`
`18`	`23`	`}`
`19`	`24`
`20`	`25`	`public set(payload: T): void {`
`21`	`26`	`this._payload = payload;`
`22`		`- this.emit({ type: 'invalidate' });`
	`27`	`+ if (this._invalidator) {`
	`28`	`+ this._invalidator();`
	`29`	`+ }`
`23`	`30`	`}`
`24`	`31`	`}`
`25`	`32`
Original file line number	Diff line number	Diff line change
`@@ -1,9 +1,8 @@`
`1`	`1`	`import { Map } from '@dojo/shim/Map';`
`2`	`2`	`import { Evented } from '@dojo/core/Evented';`
`3`	`3`	`import { EventObject } from '@dojo/core/interfaces';`
`4`		`-import { Constructor, RegistryLabel, WidgetBaseInterface } from './interfaces';`
	`4`	`+import { Constructor, InjectorFactory, InjectorItem, RegistryLabel, WidgetBaseInterface } from './interfaces';`
`5`	`5`	`import { Registry, RegistryEventObject, RegistryItem } from './Registry';`
`6`		`-import { Injector } from './Injector';`
`7`	`6`
`8`	`7`	`export type RegistryHandlerEventMap = {`
`9`	`8`	`invalidate: EventObject<'invalidate'>;`
`@@ -40,7 +39,7 @@ export class RegistryHandler extends Evented<RegistryHandlerEventMap> {`
`40`	`39`	`this._registry.define(label, widget);`
`41`	`40`	`}`
`42`	`41`
`43`		`- public defineInjector(label: RegistryLabel, injector: Injector): void {`
	`42`	`+ public defineInjector(label: RegistryLabel, injector: InjectorFactory): void {`
`44`	`43`	`this._registry.defineInjector(label, injector);`
`45`	`44`	`}`
`46`	`45`
`@@ -59,7 +58,7 @@ export class RegistryHandler extends Evented<RegistryHandlerEventMap> {`
`59`	`58`	`return this._get(label, globalPrecedence, 'get', this._registryWidgetLabelMap);`
`60`	`59`	`}`
`61`	`60`
`62`		`- public getInjector<T extends Injector>(label: RegistryLabel, globalPrecedence: boolean = false): T \| null {`
	`61`	`+ public getInjector<T>(label: RegistryLabel, globalPrecedence: boolean = false): InjectorItem<T> \| null {`
`63`	`62`	`return this._get(label, globalPrecedence, 'getInjector', this._registryInjectorLabelMap);`
`64`	`63`	`}`
`65`	`64`