##// END OF EJS Templates
implab » implabjs-core
RSS

Clone from http://hg.code.sf.net/p/implabjs/core

working on fluent configuration
working on fluent configuration
cin - - Load All Authors

File last commit:

r115:691199f665e0 ioc ts support
r128:882b53b2ba5b ioc ts support
Show More
ActivatableMixin.ts
89 lines | 2.7 KiB | video/mp2t | TypeScriptLexer
/ src / main / ts / components / ActivatableMixin.ts
History | Source | Raw |Copy content |Copy permalink
cin
changed the project structure
 r49 import { IActivationController, IActivatable, ICancellation } from "../interfaces";
import { AsyncComponent } from "./AsyncComponent";
import { Cancellation } from "../Cancellation";
import { TraceSource } from "../log/TraceSource";
type Constructor<T = {}> = new (...args: any[]) => T;
const log = TraceSource.get("@implab/core/components/ActivatableMixin");
export function ActivatableMixin<TBase extends Constructor<AsyncComponent>>(Base: TBase) {
return class extends Base implements IActivatable {
cin
corrected code to support ts strict mode...
 r115 _controller: IActivationController | undefined;
cin
changed the project structure
 r49
cin
corrected code to support ts strict mode...
 r115 _active = false;
cin
changed the project structure
 r49
isActive() {
return this._active;
}
cin
corrected code to support ts strict mode...
 r115 hasActivationController() {
return !!this._controller;
}
cin
changed the project structure
 r49 getActivationController() {
cin
corrected code to support ts strict mode...
 r115 if (!this._controller)
throw Error("Activation controller isn't set");
cin
changed the project structure
 r49 return this._controller;
}
setActivationController(controller: IActivationController) {
this._controller = controller;
}
async onActivating(ct: ICancellation) {
if (this._controller)
await this._controller.activating(this, ct);
}
async onActivated(ct: ICancellation) {
if (this._controller)
await this._controller.activated(this, ct);
}
activate(ct: ICancellation = Cancellation.none) {
return this.runOperation(this._activateAsync.bind(this), ct);
}
async _activateAsync(ct: ICancellation) {
if (this.isActive())
return;
await this.onActivating(ct);
this._active = true;
try {
await this.onActivated(ct);
} catch (e) {
log.error("Suppressed onActivated error: {0}", e);
}
}
async onDeactivating(ct: ICancellation) {
if (this._controller)
await this._controller.deactivating(this, ct);
}
async onDeactivated(ct: ICancellation) {
if (this._controller)
await this._controller.deactivated(this, ct);
}
deactivate(ct: ICancellation = Cancellation.none) {
return this.runOperation(this._deactivateAsync.bind(this), ct);
}
async _deactivateAsync(ct: ICancellation) {
if (!this.isActive())
return;
await this.onDeactivating(ct);
this._active = false;
try {
await this.onDeactivated(ct);
} catch (e) {
log.error("Suppressed onDeactivated error: {0}", e);
}
}
};
}
export const traceSource = log;