iSharkFly-Docs/angular-docs-cn
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(upgrade): remove unused variables (#40045)

Browse Source 
This commit removes a couple of unused variables.

PR Close #40045
This commit is contained in:
George Kalpakas 2020-12-10 19:13:31 +02:00 committed by Alex Rickabaugh
parent 76e3de253c
commit 61376d5a6e
2 changed files with 94 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
packages/upgrade/src/dynamic/src/upgrade_adapter.ts
View File

@ -505,7 +505,6 @@ export class UpgradeAdapter {
const delayApplyExps: Function[] = []; const delayApplyExps: Function[] = [];
let original$applyFn: Function; let original$applyFn: Function;
let rootScopePrototype: any; let rootScopePrototype: any;
let rootScope: IRootScopeService;
const upgradeAdapter = this; const upgradeAdapter = this;
const ng1Module = this.ng1Module = angularModule(this.idPrefix, modules); const ng1Module = this.ng1Module = angularModule(this.idPrefix, modules);
const platformRef = platformBrowserDynamic(); const platformRef = platformBrowserDynamic();
@ -533,7 +532,7 @@ export class UpgradeAdapter {
} else { } else {
throw new Error('Failed to find \'$apply\' on \'$rootScope\'!'); throw new Error('Failed to find \'$apply\' on \'$rootScope\'!');
} }
return rootScope = rootScopeDelegate; return rootScopeDelegate;
} }
]); ]);
if (ng1Injector.has($$TESTABILITY)) { if (ng1Injector.has($$TESTABILITY)) {

189
packages/upgrade/static/src/upgrade_module.ts
View File

@ -170,111 +170,108 @@ export class UpgradeModule {
const INIT_MODULE_NAME = UPGRADE_MODULE_NAME + '.init'; const INIT_MODULE_NAME = UPGRADE_MODULE_NAME + '.init';
// Create an ng1 module to bootstrap // Create an ng1 module to bootstrap
const initModule = angularModule(INIT_MODULE_NAME, [])
angularModule(INIT_MODULE_NAME, [])
.constant(UPGRADE_APP_TYPE_KEY, UpgradeAppType.Static) .constant(UPGRADE_APP_TYPE_KEY, UpgradeAppType.Static)
.value(INJECTOR_KEY, this.injector) .value(INJECTOR_KEY, this.injector)
.factory( .factory(
LAZY_MODULE_REF, LAZY_MODULE_REF, [INJECTOR_KEY, (injector: Injector) => ({injector} as LazyModuleRef)])
[INJECTOR_KEY, (injector: Injector) => ({injector} as LazyModuleRef)])
.config([ .config([
$PROVIDE, $INJECTOR, $PROVIDE, $INJECTOR,
($provide: IProvideService, $injector: IInjectorService) => { ($provide: IProvideService, $injector: IInjectorService) => {
if ($injector.has($$TESTABILITY)) { if ($injector.has($$TESTABILITY)) {
$provide.decorator($$TESTABILITY, [ $provide.decorator($$TESTABILITY, [
$DELEGATE, $DELEGATE,
(testabilityDelegate: ITestabilityService) => { (testabilityDelegate: ITestabilityService) => {
const originalWhenStable: Function = testabilityDelegate.whenStable; const originalWhenStable: Function = testabilityDelegate.whenStable;
const injector = this.injector; const injector = this.injector;
// Cannot use arrow function below because we need the context // Cannot use arrow function below because we need the context
const newWhenStable = function(callback: Function) { const newWhenStable = function(callback: Function) {
originalWhenStable.call(testabilityDelegate, function() { originalWhenStable.call(testabilityDelegate, function() {
const ng2Testability: Testability = injector.get(Testability); const ng2Testability: Testability = injector.get(Testability);
if (ng2Testability.isStable()) { if (ng2Testability.isStable()) {
callback(); callback();
} else { } else {
ng2Testability.whenStable( ng2Testability.whenStable(
newWhenStable.bind(testabilityDelegate, callback)); newWhenStable.bind(testabilityDelegate, callback));
} }
});
};
testabilityDelegate.whenStable = newWhenStable;
return testabilityDelegate;
}
]);
}
if ($injector.has($INTERVAL)) {
$provide.decorator($INTERVAL, [
$DELEGATE,
(intervalDelegate: IIntervalService) => {
// Wrap the $interval service so that setInterval is called outside NgZone,
// but the callback is still invoked within it. This is so that $interval
// won't block stability, which preserves the behavior from AngularJS.
let wrappedInterval =
(fn: Function, delay: number, count?: number, invokeApply?: boolean,
...pass: any[]) => {
return this.ngZone.runOutsideAngular(() => {
return intervalDelegate((...args: any[]) => {
// Run callback in the next VM turn - $interval calls
// $rootScope.$apply, and running the callback in NgZone will
// cause a '$digest already in progress' error if it's in the
// same vm turn.
setTimeout(() => {
this.ngZone.run(() => fn(...args));
});
}, delay, count, invokeApply, ...pass);
}); });
}; };
testabilityDelegate.whenStable = newWhenStable; (wrappedInterval as any)['cancel'] = intervalDelegate.cancel;
return testabilityDelegate; return wrappedInterval;
} }
]); ]);
}
}
])
.run([
$INJECTOR,
($injector: IInjectorService) => {
this.$injector = $injector;
// Initialize the ng1 $injector provider
setTempInjectorRef($injector);
this.injector.get($INJECTOR);
// Put the injector on the DOM, so that it can be "required"
angularElement(element).data!(controllerKey(INJECTOR_KEY), this.injector);
// Wire up the ng1 rootScope to run a digest cycle whenever the zone settles
// We need to do this in the next tick so that we don't prevent the bootup stabilizing
setTimeout(() => {
const $rootScope = $injector.get('$rootScope');
const subscription = this.ngZone.onMicrotaskEmpty.subscribe(() => {
if ($rootScope.$$phase) {
if (isDevMode()) {
console.warn(
'A digest was triggered while one was already in progress. This may mean that something is triggering digests outside the Angular zone.');
}
return $rootScope.$evalAsync();
} }
if ($injector.has($INTERVAL)) { return $rootScope.$digest();
$provide.decorator($INTERVAL, [ });
$DELEGATE, $rootScope.$on('$destroy', () => {
(intervalDelegate: IIntervalService) => { subscription.unsubscribe();
// Wrap the $interval service so that setInterval is called outside NgZone, });
// but the callback is still invoked within it. This is so that $interval }, 0);
// won't block stability, which preserves the behavior from AngularJS. }
let wrappedInterval = ]);
(fn: Function, delay: number, count?: number, invokeApply?: boolean,
...pass: any[]) => {
return this.ngZone.runOutsideAngular(() => {
return intervalDelegate((...args: any[]) => {
// Run callback in the next VM turn - $interval calls
// $rootScope.$apply, and running the callback in NgZone will
// cause a '$digest already in progress' error if it's in the
// same vm turn.
setTimeout(() => {
this.ngZone.run(() => fn(...args));
});
}, delay, count, invokeApply, ...pass);
});
};
(wrappedInterval as any)['cancel'] = intervalDelegate.cancel;
return wrappedInterval;
}
]);
}
}
])
.run([
$INJECTOR,
($injector: IInjectorService) => {
this.$injector = $injector;
// Initialize the ng1 $injector provider
setTempInjectorRef($injector);
this.injector.get($INJECTOR);
// Put the injector on the DOM, so that it can be "required"
angularElement(element).data!(controllerKey(INJECTOR_KEY), this.injector);
// Wire up the ng1 rootScope to run a digest cycle whenever the zone settles
// We need to do this in the next tick so that we don't prevent the bootup
// stabilizing
setTimeout(() => {
const $rootScope = $injector.get('$rootScope');
const subscription = this.ngZone.onMicrotaskEmpty.subscribe(() => {
if ($rootScope.$$phase) {
if (isDevMode()) {
console.warn(
'A digest was triggered while one was already in progress. This may mean that something is triggering digests outside the Angular zone.');
}
return $rootScope.$evalAsync();
}
return $rootScope.$digest();
});
$rootScope.$on('$destroy', () => {
subscription.unsubscribe();
});
}, 0);
}
]);
const upgradeModule = angularModule(UPGRADE_MODULE_NAME, [INIT_MODULE_NAME].concat(modules)); const upgradeModule = angularModule(UPGRADE_MODULE_NAME, [INIT_MODULE_NAME].concat(modules));