perf: delete pre-view-engine core, compiler, platform-browser, etc code (#14788)

After the introduction of the view engine, we can drop a lot of code that is not used any more.

This should reduce the size of the app bundles because a lot of this code was not being properly tree-shaken by today's tools even though it was dead code.
This commit is contained in:
Tobias Bosch
2017-02-27 23:08:19 -08:00
committed by Igor Minar
parent e58cb7ba08
commit 126fda2613
151 changed files with 1283 additions and 14864 deletions

View File

@ -10,9 +10,6 @@
* All channels used by angular's WebWorker components are listed here.
* You should not use these channels in your application code.
*/
export const RENDERER_CHANNEL = 'ng-Renderer';
export const EVENT_CHANNEL = 'ng-Events';
export const RENDERER_V2_CHANNEL = 'v2.ng-Renderer';
export const EVENT_V2_CHANNEL = 'v2.ng-Events';

View File

@ -143,5 +143,3 @@ export class Serializer {
};
}
}
export const ANIMATION_WORKER_PLAYER_PREFIX = 'AnimationPlayer.';

View File

@ -6,241 +6,15 @@
* found in the LICENSE file at https://angular.io/license
*/
import {AnimationPlayer, Injectable, RenderComponentType, Renderer, RendererFactoryV2, RendererTypeV2, RendererV2, RootRenderer} from '@angular/core';
import {Injectable, RenderComponentType, Renderer, RendererFactoryV2, RendererTypeV2, RendererV2, RootRenderer} from '@angular/core';
import {MessageBus} from '../shared/message_bus';
import {EVENT_CHANNEL, EVENT_V2_CHANNEL, RENDERER_CHANNEL, RENDERER_V2_CHANNEL} from '../shared/messaging_api';
import {EVENT_V2_CHANNEL, RENDERER_V2_CHANNEL} from '../shared/messaging_api';
import {RenderStore} from '../shared/render_store';
import {ANIMATION_WORKER_PLAYER_PREFIX, Serializer, SerializerTypes} from '../shared/serializer';
import {Serializer, SerializerTypes} from '../shared/serializer';
import {ServiceMessageBroker, ServiceMessageBrokerFactory} from '../shared/service_message_broker';
import {EventDispatcher} from '../ui/event_dispatcher';
@Injectable()
export class MessageBasedRenderer {
private _eventDispatcher: EventDispatcher;
constructor(
private _brokerFactory: ServiceMessageBrokerFactory, private _bus: MessageBus,
private _serializer: Serializer, private _renderStore: RenderStore,
private _rootRenderer: RootRenderer) {}
start(): void {
const broker = this._brokerFactory.createMessageBroker(RENDERER_CHANNEL);
this._bus.initChannel(EVENT_CHANNEL);
this._eventDispatcher = new EventDispatcher(this._bus.to(EVENT_CHANNEL), this._serializer);
const [RCT, RSO, P] = [
RenderComponentType,
SerializerTypes.RENDER_STORE_OBJECT,
SerializerTypes.PRIMITIVE,
];
const methods: any[][] = [
['renderComponent', this._renderComponent, RCT, P],
['selectRootElement', this._selectRootElement, RSO, P, P],
['createElement', this._createElement, RSO, RSO, P, P],
['createViewRoot', this._createViewRoot, RSO, RSO, P],
['createTemplateAnchor', this._createTemplateAnchor, RSO, RSO, P],
['createText', this._createText, RSO, RSO, P, P],
['projectNodes', this._projectNodes, RSO, RSO, RSO],
['attachViewAfter', this._attachViewAfter, RSO, RSO, RSO],
['detachView', this._detachView, RSO, RSO],
['destroyView', this._destroyView, RSO, RSO, RSO],
['setElementProperty', this._setElementProperty, RSO, RSO, P, P],
['setElementAttribute', this._setElementAttribute, RSO, RSO, P, P],
['setBindingDebugInfo', this._setBindingDebugInfo, RSO, RSO, P, P],
['setElementClass', this._setElementClass, RSO, RSO, P, P],
['setElementStyle', this._setElementStyle, RSO, RSO, P, P],
['invokeElementMethod', this._invokeElementMethod, RSO, RSO, P, P],
['setText', this._setText, RSO, RSO, P],
['listen', this._listen, RSO, RSO, P, P],
['listenGlobal', this._listenGlobal, RSO, P, P, P],
['listenDone', this._listenDone, RSO, RSO],
['animate', this._animate, RSO, RSO, P, P, P, P, P, P, P],
];
methods.forEach(([name, method, ...argTypes]: any[]) => {
broker.registerMethod(name, argTypes, method.bind(this));
});
this._bindAnimationPlayerMethods(broker);
}
private _bindAnimationPlayerMethods(broker: ServiceMessageBroker) {
const [P, RSO] = [SerializerTypes.PRIMITIVE, SerializerTypes.RENDER_STORE_OBJECT];
broker.registerMethod(
ANIMATION_WORKER_PLAYER_PREFIX + 'play', [RSO, RSO],
(player: AnimationPlayer, element: any) => player.play());
broker.registerMethod(
ANIMATION_WORKER_PLAYER_PREFIX + 'pause', [RSO, RSO],
(player: AnimationPlayer, element: any) => player.pause());
broker.registerMethod(
ANIMATION_WORKER_PLAYER_PREFIX + 'init', [RSO, RSO],
(player: AnimationPlayer, element: any) => player.init());
broker.registerMethod(
ANIMATION_WORKER_PLAYER_PREFIX + 'restart', [RSO, RSO],
(player: AnimationPlayer, element: any) => player.restart());
broker.registerMethod(
ANIMATION_WORKER_PLAYER_PREFIX + 'destroy', [RSO, RSO],
(player: AnimationPlayer, element: any) => {
player.destroy();
this._renderStore.remove(player);
});
broker.registerMethod(
ANIMATION_WORKER_PLAYER_PREFIX + 'finish', [RSO, RSO],
(player: AnimationPlayer, element: any) => player.finish());
broker.registerMethod(
ANIMATION_WORKER_PLAYER_PREFIX + 'getPosition', [RSO, RSO],
(player: AnimationPlayer, element: any) => player.getPosition());
broker.registerMethod(
ANIMATION_WORKER_PLAYER_PREFIX + 'onStart', [RSO, RSO, P],
(player: AnimationPlayer, element: any) =>
this._listenOnAnimationPlayer(player, element, 'onStart'));
broker.registerMethod(
ANIMATION_WORKER_PLAYER_PREFIX + 'onDone', [RSO, RSO, P],
(player: AnimationPlayer, element: any) =>
this._listenOnAnimationPlayer(player, element, 'onDone'));
broker.registerMethod(
ANIMATION_WORKER_PLAYER_PREFIX + 'setPosition', [RSO, RSO, P],
(player: AnimationPlayer, element: any, position: number) => player.setPosition(position));
}
private _renderComponent(renderComponentType: RenderComponentType, rendererId: number) {
const renderer = this._rootRenderer.renderComponent(renderComponentType);
this._renderStore.store(renderer, rendererId);
}
private _selectRootElement(renderer: Renderer, selector: string, elId: number) {
this._renderStore.store(renderer.selectRootElement(selector, null), elId);
}
private _createElement(renderer: Renderer, parentElement: any, name: string, elId: number) {
this._renderStore.store(renderer.createElement(parentElement, name, null), elId);
}
private _createViewRoot(renderer: Renderer, hostElement: any, elId: number) {
const viewRoot = renderer.createViewRoot(hostElement);
if (this._renderStore.serialize(hostElement) !== elId) {
this._renderStore.store(viewRoot, elId);
}
}
private _createTemplateAnchor(renderer: Renderer, parentElement: any, elId: number) {
this._renderStore.store(renderer.createTemplateAnchor(parentElement, null), elId);
}
private _createText(renderer: Renderer, parentElement: any, value: string, elId: number) {
this._renderStore.store(renderer.createText(parentElement, value, null), elId);
}
private _projectNodes(renderer: Renderer, parentElement: any, nodes: any[]) {
renderer.projectNodes(parentElement, nodes);
}
private _attachViewAfter(renderer: Renderer, node: any, viewRootNodes: any[]) {
renderer.attachViewAfter(node, viewRootNodes);
}
private _detachView(renderer: Renderer, viewRootNodes: any[]) {
renderer.detachView(viewRootNodes);
}
private _destroyView(renderer: Renderer, hostElement: any, viewAllNodes: any[]) {
renderer.destroyView(hostElement, viewAllNodes);
for (let i = 0; i < viewAllNodes.length; i++) {
this._renderStore.remove(viewAllNodes[i]);
}
}
private _setElementProperty(
renderer: Renderer, renderElement: any, propertyName: string, propertyValue: any) {
renderer.setElementProperty(renderElement, propertyName, propertyValue);
}
private _setElementAttribute(
renderer: Renderer, renderElement: any, attributeName: string, attributeValue: string) {
renderer.setElementAttribute(renderElement, attributeName, attributeValue);
}
private _setBindingDebugInfo(
renderer: Renderer, renderElement: any, propertyName: string, propertyValue: string) {
renderer.setBindingDebugInfo(renderElement, propertyName, propertyValue);
}
private _setElementClass(
renderer: Renderer, renderElement: any, className: string, isAdd: boolean) {
renderer.setElementClass(renderElement, className, isAdd);
}
private _setElementStyle(
renderer: Renderer, renderElement: any, styleName: string, styleValue: string) {
renderer.setElementStyle(renderElement, styleName, styleValue);
}
private _invokeElementMethod(
renderer: Renderer, renderElement: any, methodName: string, args: any[]) {
renderer.invokeElementMethod(renderElement, methodName, args);
}
private _setText(renderer: Renderer, renderNode: any, text: string) {
renderer.setText(renderNode, text);
}
private _listen(renderer: Renderer, renderElement: any, eventName: string, unlistenId: number) {
const unregisterCallback = renderer.listen(
renderElement, eventName, (event: any) => this._eventDispatcher.dispatchRenderEvent(
renderElement, null, eventName, event));
this._renderStore.store(unregisterCallback, unlistenId);
}
private _listenGlobal(
renderer: Renderer, eventTarget: string, eventName: string, unlistenId: number) {
const unregisterCallback = renderer.listenGlobal(
eventTarget, eventName, (event: any) => this._eventDispatcher.dispatchRenderEvent(
null, eventTarget, eventName, event));
this._renderStore.store(unregisterCallback, unlistenId);
}
private _listenDone(renderer: Renderer, unlistenCallback: Function) { unlistenCallback(); }
private _animate(
renderer: Renderer, element: any, startingStyles: any, keyframes: any[], duration: number,
delay: number, easing: string, previousPlayers: number[], playerId: any) {
let normalizedPreviousPlayers: AnimationPlayer[];
if (previousPlayers && previousPlayers.length) {
normalizedPreviousPlayers =
previousPlayers.map(playerId => this._renderStore.deserialize(playerId));
}
const player = renderer.animate(
element, startingStyles, keyframes, duration, delay, easing, normalizedPreviousPlayers);
this._renderStore.store(player, playerId);
}
private _listenOnAnimationPlayer(player: AnimationPlayer, element: any, phaseName: string) {
const onEventComplete =
() => { this._eventDispatcher.dispatchAnimationEvent(player, phaseName, element); };
// there is no need to register a unlistener value here since the
// internal player callbacks are removed when the player is destroyed
if (phaseName == 'onDone') {
player.onDone(() => onEventComplete());
} else {
player.onStart(() => onEventComplete());
}
}
}
@Injectable()
export class MessageBasedRendererV2 {
private _eventDispatcher: EventDispatcher;

View File

@ -6,15 +6,15 @@
* found in the LICENSE file at https://angular.io/license
*/
import {Injectable, RenderComponentType, Renderer, RendererFactoryV2, RendererTypeV2, RendererV2, RootRenderer, ViewEncapsulation, ɵAnimationKeyframe as AnimationKeyframe, ɵAnimationPlayer as AnimationPlayer, ɵAnimationStyles as AnimationStyles, ɵRenderDebugInfo as RenderDebugInfo} from '@angular/core';
import {Injectable, RenderComponentType, Renderer, RendererFactoryV2, RendererTypeV2, RendererV2, RootRenderer, ViewEncapsulation} from '@angular/core';
import {ListWrapper} from '../../facade/collection';
import {isPresent} from '../../facade/lang';
import {ClientMessageBroker, ClientMessageBrokerFactory, FnArg, UiArguments} from '../shared/client_message_broker';
import {MessageBus} from '../shared/message_bus';
import {EVENT_CHANNEL, EVENT_V2_CHANNEL, RENDERER_CHANNEL, RENDERER_V2_CHANNEL} from '../shared/messaging_api';
import {EVENT_V2_CHANNEL, RENDERER_V2_CHANNEL} from '../shared/messaging_api';
import {RenderStore} from '../shared/render_store';
import {ANIMATION_WORKER_PLAYER_PREFIX, Serializer, SerializerTypes} from '../shared/serializer';
import {Serializer, SerializerTypes} from '../shared/serializer';
export class NamedEventEmitter {
private _listeners: Map<string, Function[]>;
@ -49,275 +49,6 @@ export class NamedEventEmitter {
}
}
@Injectable()
export class WebWorkerRootRenderer implements RootRenderer {
globalEvents = new NamedEventEmitter();
private _messageBroker: ClientMessageBroker;
private _componentRenderers = new Map<string, WebWorkerRenderer>();
constructor(
messageBrokerFactory: ClientMessageBrokerFactory, bus: MessageBus,
private _serializer: Serializer, public renderStore: RenderStore) {
this._messageBroker = messageBrokerFactory.createMessageBroker(RENDERER_CHANNEL);
bus.initChannel(EVENT_CHANNEL);
const source = bus.from(EVENT_CHANNEL);
source.subscribe({next: (message: any) => this._dispatchEvent(message)});
throw new Error(
'RootRenderer is no longer supported. Please use the `RendererFactoryV2` instead!');
}
private _dispatchEvent(message: {[key: string]: any}): void {
const element: WebWorkerRenderNode =
this._serializer.deserialize(message['element'], SerializerTypes.RENDER_STORE_OBJECT);
const playerData = message['animationPlayer'];
if (playerData) {
const phaseName = message['phaseName'];
const player: AnimationPlayer =
this._serializer.deserialize(playerData, SerializerTypes.RENDER_STORE_OBJECT);
element.animationPlayerEvents.dispatchEvent(player, phaseName);
} else {
const eventName = message['eventName'];
const target = message['eventTarget'];
const event = message['event'];
if (target) {
this.globalEvents.dispatchEvent(eventNameWithTarget(target, eventName), event);
} else {
element.events.dispatchEvent(eventName, event);
}
}
}
renderComponent(componentType: RenderComponentType): Renderer {
let result = this._componentRenderers.get(componentType.id);
if (!result) {
result = new WebWorkerRenderer(this, componentType);
this._componentRenderers.set(componentType.id, result);
const id = this.renderStore.allocateId();
this.renderStore.store(result, id);
this.runOnService('renderComponent', [
new FnArg(componentType, RenderComponentType),
new FnArg(result, SerializerTypes.RENDER_STORE_OBJECT),
]);
}
return result;
}
runOnService(fnName: string, fnArgs: FnArg[]) {
const args = new UiArguments(fnName, fnArgs);
this._messageBroker.runOnService(args, null);
}
allocateNode(): WebWorkerRenderNode {
const result = new WebWorkerRenderNode();
const id = this.renderStore.allocateId();
this.renderStore.store(result, id);
return result;
}
allocateId(): number { return this.renderStore.allocateId(); }
destroyNodes(nodes: any[]) {
for (let i = 0; i < nodes.length; i++) {
this.renderStore.remove(nodes[i]);
}
}
}
export class WebWorkerRenderer implements Renderer {
constructor(
private _rootRenderer: WebWorkerRootRenderer, private _componentType: RenderComponentType) {}
private _runOnService(fnName: string, fnArgs: FnArg[]) {
const fnArgsWithRenderer = [new FnArg(this, SerializerTypes.RENDER_STORE_OBJECT), ...fnArgs];
this._rootRenderer.runOnService(fnName, fnArgsWithRenderer);
}
selectRootElement(selectorOrNode: string, debugInfo?: RenderDebugInfo): any {
const node = this._rootRenderer.allocateNode();
this._runOnService('selectRootElement', [
new FnArg(selectorOrNode),
new FnArg(node, SerializerTypes.RENDER_STORE_OBJECT),
]);
return node;
}
createElement(parentElement: any, name: string, debugInfo?: RenderDebugInfo): any {
const node = this._rootRenderer.allocateNode();
this._runOnService('createElement', [
new FnArg(parentElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(name),
new FnArg(node, SerializerTypes.RENDER_STORE_OBJECT),
]);
return node;
}
createViewRoot(hostElement: any): any {
const viewRoot = this._componentType.encapsulation === ViewEncapsulation.Native ?
this._rootRenderer.allocateNode() :
hostElement;
this._runOnService('createViewRoot', [
new FnArg(hostElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(viewRoot, SerializerTypes.RENDER_STORE_OBJECT),
]);
return viewRoot;
}
createTemplateAnchor(parentElement: any, debugInfo?: RenderDebugInfo): any {
const node = this._rootRenderer.allocateNode();
this._runOnService('createTemplateAnchor', [
new FnArg(parentElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(node, SerializerTypes.RENDER_STORE_OBJECT),
]);
return node;
}
createText(parentElement: any, value: string, debugInfo?: RenderDebugInfo): any {
const node = this._rootRenderer.allocateNode();
this._runOnService('createText', [
new FnArg(parentElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(value),
new FnArg(node, SerializerTypes.RENDER_STORE_OBJECT),
]);
return node;
}
projectNodes(parentElement: any, nodes: any[]) {
this._runOnService('projectNodes', [
new FnArg(parentElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(nodes, SerializerTypes.RENDER_STORE_OBJECT),
]);
}
attachViewAfter(node: any, viewRootNodes: any[]) {
this._runOnService('attachViewAfter', [
new FnArg(node, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(viewRootNodes, SerializerTypes.RENDER_STORE_OBJECT),
]);
}
detachView(viewRootNodes: any[]) {
this._runOnService(
'detachView', [new FnArg(viewRootNodes, SerializerTypes.RENDER_STORE_OBJECT)]);
}
destroyView(hostElement: any, viewAllNodes: any[]) {
this._runOnService('destroyView', [
new FnArg(hostElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(viewAllNodes, SerializerTypes.RENDER_STORE_OBJECT),
]);
this._rootRenderer.destroyNodes(viewAllNodes);
}
setElementProperty(renderElement: any, propertyName: string, propertyValue: any) {
this._runOnService('setElementProperty', [
new FnArg(renderElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(propertyName),
new FnArg(propertyValue),
]);
}
setElementAttribute(renderElement: any, attributeName: string, attributeValue: string) {
this._runOnService('setElementAttribute', [
new FnArg(renderElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(attributeName),
new FnArg(attributeValue),
]);
}
setBindingDebugInfo(renderElement: any, propertyName: string, propertyValue: string) {
this._runOnService('setBindingDebugInfo', [
new FnArg(renderElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(propertyName),
new FnArg(propertyValue),
]);
}
setElementClass(renderElement: any, className: string, isAdd: boolean) {
this._runOnService('setElementClass', [
new FnArg(renderElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(className),
new FnArg(isAdd),
]);
}
setElementStyle(renderElement: any, styleName: string, styleValue: string) {
this._runOnService('setElementStyle', [
new FnArg(renderElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(styleName),
new FnArg(styleValue),
]);
}
invokeElementMethod(renderElement: any, methodName: string, args?: any[]) {
this._runOnService('invokeElementMethod', [
new FnArg(renderElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(methodName),
new FnArg(args),
]);
}
setText(renderNode: any, text: string) {
this._runOnService('setText', [
new FnArg(renderNode, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(text),
]);
}
listen(renderElement: WebWorkerRenderNode, name: string, callback: Function): Function {
renderElement.events.listen(name, callback);
const unlistenCallbackId = this._rootRenderer.allocateId();
this._runOnService('listen', [
new FnArg(renderElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(name),
new FnArg(unlistenCallbackId),
]);
return () => {
renderElement.events.unlisten(name, callback);
this._runOnService('listenDone', [new FnArg(unlistenCallbackId)]);
};
}
listenGlobal(target: string, name: string, callback: Function): Function {
this._rootRenderer.globalEvents.listen(eventNameWithTarget(target, name), callback);
const unlistenCallbackId = this._rootRenderer.allocateId();
this._runOnService('listenGlobal', [
new FnArg(target),
new FnArg(name, null),
new FnArg(unlistenCallbackId),
]);
return () => {
this._rootRenderer.globalEvents.unlisten(eventNameWithTarget(target, name), callback);
this._runOnService('listenDone', [new FnArg(unlistenCallbackId)]);
};
}
animate(
renderElement: any, startingStyles: AnimationStyles, keyframes: AnimationKeyframe[],
duration: number, delay: number, easing: string,
previousPlayers: AnimationPlayer[] = []): AnimationPlayer {
const playerId = this._rootRenderer.allocateId();
const previousPlayerIds: number[] =
previousPlayers.map(player => this._rootRenderer.renderStore.serialize(player));
this._runOnService('animate', [
new FnArg(renderElement, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(startingStyles),
new FnArg(keyframes),
new FnArg(duration),
new FnArg(delay),
new FnArg(easing),
new FnArg(previousPlayerIds),
new FnArg(playerId),
]);
const player = new _AnimationWorkerRendererPlayer(this._rootRenderer, renderElement);
this._rootRenderer.renderStore.store(player, playerId);
return player;
}
}
function eventNameWithTarget(target: string, eventName: string): string {
return `${target}:${eventName}`;
@ -583,103 +314,4 @@ export class WebWorkerRendererV2 implements RendererV2 {
}
}
export class AnimationPlayerEmitter {
private _listeners: Map<AnimationPlayer, {[phaseName: string]: Function[]}>;
private _getListeners(player: AnimationPlayer, phaseName: string): Function[] {
if (!this._listeners) {
this._listeners = new Map<AnimationPlayer, {[phaseName: string]: Function[]}>();
}
let phaseMap = this._listeners.get(player);
if (!phaseMap) {
this._listeners.set(player, phaseMap = {});
}
let phaseFns = phaseMap[phaseName];
if (!phaseFns) {
phaseFns = phaseMap[phaseName] = [];
}
return phaseFns;
}
listen(player: AnimationPlayer, phaseName: string, callback: Function) {
this._getListeners(player, phaseName).push(callback);
}
unlisten(player: AnimationPlayer) { this._listeners.delete(player); }
dispatchEvent(player: AnimationPlayer, phaseName: string) {
const listeners = this._getListeners(player, phaseName);
for (let i = 0; i < listeners.length; i++) {
listeners[i]();
}
}
}
export class WebWorkerRenderNode {
events = new NamedEventEmitter();
animationPlayerEvents = new AnimationPlayerEmitter();
}
class _AnimationWorkerRendererPlayer {
public parentPlayer: AnimationPlayer = null;
private _destroyed: boolean = false;
private _started: boolean = false;
constructor(private _rootRenderer: WebWorkerRootRenderer, private _renderElement: any) {}
private _runOnService(fnName: string, fnArgs: FnArg[]) {
if (!this._destroyed) {
const fnArgsWithRenderer = [
new FnArg(this, SerializerTypes.RENDER_STORE_OBJECT),
new FnArg(this._renderElement, SerializerTypes.RENDER_STORE_OBJECT), ...fnArgs
];
this._rootRenderer.runOnService(ANIMATION_WORKER_PLAYER_PREFIX + fnName, fnArgsWithRenderer);
}
}
onStart(fn: () => void): void {
this._renderElement.animationPlayerEvents.listen(this, 'onStart', fn);
this._runOnService('onStart', []);
}
onDone(fn: () => void): void {
this._renderElement.animationPlayerEvents.listen(this, 'onDone', fn);
this._runOnService('onDone', []);
}
onDestroy(fn: () => void): void {
this._renderElement.animationPlayerEvents.listen(this, 'onDestroy', fn);
this._runOnService('onDestroy', []);
}
hasStarted(): boolean { return this._started; }
init(): void { this._runOnService('init', []); }
play(): void {
this._started = true;
this._runOnService('play', []);
}
pause(): void { this._runOnService('pause', []); }
restart(): void { this._runOnService('restart', []); }
finish(): void { this._runOnService('finish', []); }
destroy(): void {
if (!this._destroyed) {
this._renderElement.animationPlayerEvents.unlisten(this);
this._runOnService('destroy', []);
this._rootRenderer.renderStore.remove(this);
this._destroyed = true;
}
}
reset(): void { this._runOnService('reset', []); }
setPosition(p: number): void { this._runOnService('setPosition', [new FnArg(p)]); }
getPosition(): number { return 0; }
}
export class WebWorkerRenderNode { events = new NamedEventEmitter(); }

View File

@ -16,7 +16,7 @@ import {PostMessageBus, PostMessageBusSink, PostMessageBusSource} from './web_wo
import {RenderStore} from './web_workers/shared/render_store';
import {Serializer} from './web_workers/shared/serializer';
import {ServiceMessageBrokerFactory, ServiceMessageBrokerFactory_} from './web_workers/shared/service_message_broker';
import {WebWorkerRendererFactoryV2, WebWorkerRootRenderer} from './web_workers/worker/renderer';
import {WebWorkerRendererFactoryV2} from './web_workers/worker/renderer';
import {WorkerDomAdapter} from './web_workers/worker/worker_adapter';
@ -63,8 +63,6 @@ export function setupWebWorker(): void {
{provide: DOCUMENT, useValue: null},
{provide: ClientMessageBrokerFactory, useClass: ClientMessageBrokerFactory_},
{provide: ServiceMessageBrokerFactory, useClass: ServiceMessageBrokerFactory_},
WebWorkerRootRenderer,
{provide: RootRenderer, useExisting: WebWorkerRootRenderer},
WebWorkerRendererFactoryV2,
{provide: RendererFactoryV2, useExisting: WebWorkerRendererFactoryV2},
{provide: ON_WEB_WORKER, useValue: true},

View File

@ -8,7 +8,7 @@
import {CommonModule, ɵPLATFORM_WORKER_UI_ID as PLATFORM_WORKER_UI_ID} from '@angular/common';
import {ErrorHandler, Injectable, InjectionToken, Injector, NgZone, PLATFORM_ID, PLATFORM_INITIALIZER, PlatformRef, Provider, RendererFactoryV2, RootRenderer, Testability, createPlatformFactory, isDevMode, platformCore, ɵAPP_ID_RANDOM_PROVIDER as APP_ID_RANDOM_PROVIDER} from '@angular/core';
import {AnimationDriver, DOCUMENT, EVENT_MANAGER_PLUGINS, EventManager, HAMMER_GESTURE_CONFIG, HammerGestureConfig, ɵBROWSER_SANITIZATION_PROVIDERS as BROWSER_SANITIZATION_PROVIDERS, ɵBrowserDomAdapter as BrowserDomAdapter, ɵBrowserGetTestability as BrowserGetTestability, ɵDomEventsPlugin as DomEventsPlugin, ɵDomRendererFactoryV2 as DomRendererFactoryV2, ɵDomRootRenderer as DomRootRenderer, ɵDomRootRenderer_ as DomRootRenderer_, ɵDomSharedStylesHost as DomSharedStylesHost, ɵHammerGesturesPlugin as HammerGesturesPlugin, ɵKeyEventsPlugin as KeyEventsPlugin, ɵSharedStylesHost as SharedStylesHost, ɵWebAnimationsDriver as WebAnimationsDriver, ɵgetDOM as getDOM} from '@angular/platform-browser';
import {DOCUMENT, EVENT_MANAGER_PLUGINS, EventManager, HAMMER_GESTURE_CONFIG, HammerGestureConfig, ɵBROWSER_SANITIZATION_PROVIDERS as BROWSER_SANITIZATION_PROVIDERS, ɵBrowserDomAdapter as BrowserDomAdapter, ɵBrowserGetTestability as BrowserGetTestability, ɵDomEventsPlugin as DomEventsPlugin, ɵDomRendererFactoryV2 as DomRendererFactoryV2, ɵDomSharedStylesHost as DomSharedStylesHost, ɵHammerGesturesPlugin as HammerGesturesPlugin, ɵKeyEventsPlugin as KeyEventsPlugin, ɵSharedStylesHost as SharedStylesHost, ɵgetDOM as getDOM} from '@angular/platform-browser';
import {ON_WEB_WORKER} from './web_workers/shared/api';
import {ClientMessageBrokerFactory, ClientMessageBrokerFactory_} from './web_workers/shared/client_message_broker';
@ -17,7 +17,7 @@ import {PostMessageBus, PostMessageBusSink, PostMessageBusSource} from './web_wo
import {RenderStore} from './web_workers/shared/render_store';
import {Serializer} from './web_workers/shared/serializer';
import {ServiceMessageBrokerFactory, ServiceMessageBrokerFactory_} from './web_workers/shared/service_message_broker';
import {MessageBasedRenderer, MessageBasedRendererV2} from './web_workers/ui/renderer';
import {MessageBasedRendererV2} from './web_workers/ui/renderer';
/**
@ -54,7 +54,6 @@ export const WORKER_UI_STARTABLE_MESSAGING_SERVICE =
export const _WORKER_UI_PLATFORM_PROVIDERS: Provider[] = [
{provide: NgZone, useFactory: createNgZone, deps: []},
MessageBasedRenderer,
MessageBasedRendererV2,
{
provide: WORKER_UI_STARTABLE_MESSAGING_SERVICE,
@ -71,14 +70,11 @@ export const _WORKER_UI_PLATFORM_PROVIDERS: Provider[] = [
{provide: EVENT_MANAGER_PLUGINS, useClass: HammerGesturesPlugin, multi: true},
{provide: HAMMER_GESTURE_CONFIG, useClass: HammerGestureConfig},
APP_ID_RANDOM_PROVIDER,
{provide: DomRootRenderer, useClass: DomRootRenderer_},
{provide: RootRenderer, useExisting: DomRootRenderer},
DomRendererFactoryV2,
{provide: RendererFactoryV2, useExisting: DomRendererFactoryV2},
{provide: SharedStylesHost, useExisting: DomSharedStylesHost},
{provide: ServiceMessageBrokerFactory, useClass: ServiceMessageBrokerFactory_},
{provide: ClientMessageBrokerFactory, useClass: ClientMessageBrokerFactory_},
{provide: AnimationDriver, useFactory: _resolveDefaultAnimationDriver, deps: []},
Serializer,
{provide: ON_WEB_WORKER, useValue: false},
RenderStore,
@ -158,7 +154,3 @@ function spawnWebWorker(uri: string, instance: WebWorkerInstance): void {
instance.init(webWorker, bus);
}
function _resolveDefaultAnimationDriver(): AnimationDriver {
return getDOM().supportsWebAnimation() ? new WebAnimationsDriver() : AnimationDriver.NOOP;
}