cargdev/angular
1
0
Fork 0
Code Issues 5 Pull Requests Actions Packages Projects Releases Wiki Activity

refactor(ivy): migrate ɵɵ prefix back to Δ (#30362)

Browse Source 
Now that issues are resolved with Closure compiler, we can move back to our desired prefix of `Δ`.

PR Close #30362
This commit is contained in:
Ben Lesh
2019-05-09 11:47:25 -07:00
committed by Alex Rickabaugh
parent dbb150a9bd
commit cf86ed7b29
142 changed files with 6417 additions and 6453 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
packages/core/src/di/index.ts
View File

@ -14,11 +14,11 @@
export * from './metadata';
export {InjectFlags} from './interface/injector';
export {ɵɵdefineInjectable, defineInjectable, ɵɵdefineInjector, InjectableType, InjectorType} from './interface/defs';
export {ΔdefineInjectable, defineInjectable, ΔdefineInjector, InjectableType, InjectorType} from './interface/defs';
export {forwardRef, resolveForwardRef, ForwardRefFn} from './forward_ref';
export {Injectable, InjectableDecorator, InjectableProvider} from './injectable';
export {Injector} from './injector';
export {ɵɵinject, inject, INJECTOR} from './injector_compatibility';
export {Δinject, inject, INJECTOR} from './injector_compatibility';
export {ReflectiveInjector} from './reflective_injector';
export {StaticProvider, ValueProvider, ConstructorSansProvider, ExistingProvider, FactoryProvider, Provider, TypeProvider, ClassProvider} from './interface/provider';
export {ResolvedReflectiveFactory, ResolvedReflectiveProvider} from './reflective_provider';

6
packages/core/src/di/injectable.ts
View File

@ -9,7 +9,7 @@
import {Type} from '../interface/type';
import {TypeDecorator, makeDecorator} from '../util/decorators';
import {InjectableType, getInjectableDef, ɵɵInjectableDef, ɵɵdefineInjectable} from './interface/defs';
import {InjectableType, getInjectableDef, ΔInjectableDef, ΔdefineInjectable} from './interface/defs';
import {ClassSansProvider, ConstructorSansProvider, ExistingSansProvider, FactorySansProvider, StaticClassSansProvider, ValueSansProvider} from './interface/provider';
import {compileInjectable as render3CompileInjectable} from './jit/injectable';
import {convertInjectableProviderToFactory} from './util';
@ -80,7 +80,7 @@ export const Injectable: InjectableDecorator = makeDecorator(
*
* @publicApi
*/
export interface InjectableType<T> extends Type<T> { ngInjectableDef: ɵɵInjectableDef<T>; }
export interface InjectableType<T> extends Type<T> { ngInjectableDef: ΔInjectableDef<T>; }
/**
* Supports @Injectable() in JIT mode for Render2.
@ -89,7 +89,7 @@ function render2CompileInjectable(
injectableType: InjectableType<any>,
options: {providedIn?: Type<any>| 'root' | null} & InjectableProvider): void {
if (options && options.providedIn !== undefined && !getInjectableDef(injectableType)) {
injectableType.ngInjectableDef = ɵɵdefineInjectable({
injectableType.ngInjectableDef = ΔdefineInjectable({
providedIn: options.providedIn,
factory: convertInjectableProviderToFactory(injectableType, options),
});

4
packages/core/src/di/injection_token.ts
View File

@ -8,7 +8,7 @@
import {Type} from '../interface/type';
import {ɵɵdefineInjectable} from './interface/defs';
import {ΔdefineInjectable} from './interface/defs';
/**
* Creates a token that can be used in a DI Provider.
@ -67,7 +67,7 @@ export class InjectionToken<T> {
// We are using it to assign `-1` which is used to identify `Injector`.
(this as any).__NG_ELEMENT_ID__ = options;
} else if (options !== undefined) {
this.ngInjectableDef = ɵɵdefineInjectable({
this.ngInjectableDef = ΔdefineInjectable({
providedIn: options.providedIn || 'root',
factory: options.factory,
});

8
packages/core/src/di/injector.ts
View File

@ -11,8 +11,8 @@ import {stringify} from '../util/stringify';
import {resolveForwardRef} from './forward_ref';
import {InjectionToken} from './injection_token';
import {INJECTOR, NG_TEMP_TOKEN_PATH, NullInjector, THROW_IF_NOT_FOUND, USE_VALUE, catchInjectorError, formatError, ɵɵinject} from './injector_compatibility';
import {ɵɵdefineInjectable} from './interface/defs';
import {INJECTOR, NG_TEMP_TOKEN_PATH, NullInjector, THROW_IF_NOT_FOUND, USE_VALUE, catchInjectorError, formatError, Δinject} from './injector_compatibility';
import {ΔdefineInjectable} from './interface/defs';
import {InjectFlags} from './interface/injector';
import {ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, StaticProvider, ValueProvider} from './interface/provider';
import {Inject, Optional, Self, SkipSelf} from './metadata';
@ -88,9 +88,9 @@ export abstract class Injector {
}
/** @nocollapse */
static ngInjectableDef = ɵɵdefineInjectable({
static ngInjectableDef = ΔdefineInjectable({
providedIn: 'any' as any,
factory: () => ɵɵinject(INJECTOR),
factory: () => Δinject(INJECTOR),
});
/**

17
packages/core/src/di/injector_compatibility.ts
View File

@ -13,7 +13,7 @@ import {stringify} from '../util/stringify';
import {resolveForwardRef} from './forward_ref';
import {InjectionToken} from './injection_token';
import {Injector} from './injector';
import {getInjectableDef, ɵɵInjectableDef} from './interface/defs';
import {getInjectableDef, ΔInjectableDef} from './interface/defs';
import {InjectFlags} from './interface/injector';
import {ValueProvider} from './interface/provider';
import {Inject, Optional, Self, SkipSelf} from './metadata';
@ -107,10 +107,9 @@ export function injectInjectorOnly<T>(
* @see inject
* @codeGenApi
*/
export function ɵɵinject<T>(token: Type<T>| InjectionToken<T>): T;
export function ɵɵinject<T>(token: Type<T>| InjectionToken<T>, flags?: InjectFlags): T|null;
export function ɵɵinject<T>(token: Type<T>| InjectionToken<T>, flags = InjectFlags.Default): T|
null {
export function Δinject<T>(token: Type<T>| InjectionToken<T>): T;
export function Δinject<T>(token: Type<T>| InjectionToken<T>, flags?: InjectFlags): T|null;
export function Δinject<T>(token: Type<T>| InjectionToken<T>, flags = InjectFlags.Default): T|null {
return (_injectImplementation || injectInjectorOnly)(token, flags);
}
@ -138,7 +137,7 @@ export function ɵɵinject<T>(token: Type<T>| InjectionToken<T>, flags = InjectF
*
* @publicApi
*/
export const inject = ɵɵinject;
export const inject = Δinject;
/**
* Injects `root` tokens in limp mode.
@ -149,7 +148,7 @@ export const inject = ɵɵinject;
*/
export function injectRootLimpMode<T>(
token: Type<T>| InjectionToken<T>, notFoundValue: T | undefined, flags: InjectFlags): T|null {
const injectableDef: ɵɵInjectableDef<T>|null = getInjectableDef(token);
const injectableDef: ΔInjectableDef<T>|null = getInjectableDef(token);
if (injectableDef && injectableDef.providedIn == 'root') {
return injectableDef.value === undefined ? injectableDef.value = injectableDef.factory() :
injectableDef.value;
@ -186,9 +185,9 @@ export function injectArgs(types: (Type<any>| InjectionToken<any>| any[])[]): an
}
}
args.push(ɵɵinject(type !, flags));
args.push(Δinject(type !, flags));
} else {
args.push(ɵɵinject(arg));
args.push(Δinject(arg));
}
}
return args;

20
packages/core/src/di/interface/defs.ts
View File

@ -26,7 +26,7 @@ import {ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, S
*
* @publicApi
*/
export interface ɵɵInjectableDef<T> {
export interface ΔInjectableDef<T> {
/**
* Specifies that the given type belongs to a particular injector:
* - `InjectorType` such as `NgModule`,
@ -60,7 +60,7 @@ export interface ɵɵInjectableDef<T> {
*
* @publicApi
*/
export interface ɵɵInjectorDef<T> {
export interface ΔInjectorDef<T> {
factory: () => T;
// TODO(alxhub): Narrow down the type here once decorators properly change the return type of the
@ -131,21 +131,21 @@ export interface InjectorTypeWithProviders<T> {
*
* @publicApi
*/
export function ɵɵdefineInjectable<T>(opts: {
export function ΔdefineInjectable<T>(opts: {
providedIn?: Type<any>| 'root' | 'any' | null,
factory: () => T,
}): never {
return ({
providedIn: opts.providedIn as any || null, factory: opts.factory, value: undefined,
} as ɵɵInjectableDef<T>) as never;
} as ΔInjectableDef<T>) as never;
}
/**
* @deprecated in v8, delete after v10. This API should be used only be generated code, and that
* code should now use ɵɵdefineInjectable instead.
* code should now use ΔdefineInjectable instead.
* @publicApi
*/
export const defineInjectable = ɵɵdefineInjectable;
export const defineInjectable = ΔdefineInjectable;
/**
* Construct an `InjectorDef` which configures an injector.
@ -167,11 +167,11 @@ export const defineInjectable = ɵɵdefineInjectable;
*
* @publicApi
*/
export function ɵɵdefineInjector(options: {factory: () => any, providers?: any[], imports?: any[]}):
export function ΔdefineInjector(options: {factory: () => any, providers?: any[], imports?: any[]}):
never {
return ({
factory: options.factory, providers: options.providers || [], imports: options.imports || [],
} as ɵɵInjectorDef<any>) as never;
} as ΔInjectorDef<any>) as never;
}
/**
@ -179,7 +179,7 @@ export function ɵɵdefineInjector(options: {factory: () => any, providers?: any
*
* @param type type which may have `ngInjectableDef`
*/
export function getInjectableDef<T>(type: any): ɵɵInjectableDef<T>|null {
export function getInjectableDef<T>(type: any): ΔInjectableDef<T>|null {
return type && type.hasOwnProperty(NG_INJECTABLE_DEF) ? (type as any)[NG_INJECTABLE_DEF] : null;
}
@ -188,7 +188,7 @@ export function getInjectableDef<T>(type: any): ɵɵInjectableDef<T>|null {
*
* @param type type which may have `ngInjectorDef`
*/
export function getInjectorDef<T>(type: any): ɵɵInjectorDef<T>|null {
export function getInjectorDef<T>(type: any): ΔInjectorDef<T>|null {
return type && type.hasOwnProperty(NG_INJECTOR_DEF) ? (type as any)[NG_INJECTOR_DEF] : null;
}

12
packages/core/src/di/jit/environment.ts
View File

@ -7,8 +7,8 @@
*/
import {Type} from '../../interface/type';
import {ɵɵinject} from '../injector_compatibility';
import {getInjectableDef, getInjectorDef, ɵɵdefineInjectable, ɵɵdefineInjector} from '../interface/defs';
import {Δinject} from '../injector_compatibility';
import {getInjectableDef, getInjectorDef, ΔdefineInjectable, ΔdefineInjector} from '../interface/defs';
@ -18,10 +18,10 @@ import {getInjectableDef, getInjectorDef, ɵɵdefineInjectable, ɵɵdefineInject
* This should be kept up to date with the public exports of @angular/core.
*/
export const angularCoreDiEnv: {[name: string]: Function} = {
'ɵɵdefineInjectable': ɵɵdefineInjectable,
'ɵɵdefineInjector': ɵɵdefineInjector,
'ɵɵinject': ɵɵinject,
'ɵɵgetFactoryOf': getFactoryOf,
'ΔdefineInjectable': ΔdefineInjectable,
'ΔdefineInjector': ΔdefineInjector,
'Δinject': Δinject,
'ΔgetFactoryOf': getFactoryOf,
};
function getFactoryOf<T>(type: Type<any>): ((type: Type<T>| null) => T)|null {

8
packages/core/src/di/r3_injector.ts
View File

@ -14,8 +14,8 @@ import {stringify} from '../util/stringify';
import {resolveForwardRef} from './forward_ref';
import {InjectionToken} from './injection_token';
import {Injector} from './injector';
import {INJECTOR, NG_TEMP_TOKEN_PATH, NullInjector, THROW_IF_NOT_FOUND, USE_VALUE, catchInjectorError, injectArgs, setCurrentInjector, ɵɵinject} from './injector_compatibility';
import {InjectableType, InjectorType, InjectorTypeWithProviders, getInjectableDef, getInjectorDef, ɵɵInjectableDef} from './interface/defs';
import {INJECTOR, NG_TEMP_TOKEN_PATH, NullInjector, THROW_IF_NOT_FOUND, USE_VALUE, catchInjectorError, injectArgs, setCurrentInjector, Δinject} from './injector_compatibility';
import {InjectableType, InjectorType, InjectorTypeWithProviders, getInjectableDef, getInjectorDef, ΔInjectableDef} from './interface/defs';
import {InjectFlags} from './interface/injector';
import {ClassProvider, ConstructorProvider, ExistingProvider, FactoryProvider, StaticClassProvider, StaticProvider, TypeProvider, ValueProvider} from './interface/provider';
import {APP_ROOT} from './scope';
@ -366,7 +366,7 @@ export class R3Injector {
return record.value as T;
}
private injectableDefInScope(def: ɵɵInjectableDef<any>): boolean {
private injectableDefInScope(def: ΔInjectableDef<any>): boolean {
if (!def.providedIn) {
return false;
} else if (typeof def.providedIn === 'string') {
@ -423,7 +423,7 @@ export function providerToFactory(
if (isValueProvider(provider)) {
factory = () => resolveForwardRef(provider.useValue);
} else if (isExistingProvider(provider)) {
factory = () => ɵɵinject(resolveForwardRef(provider.useExisting));
factory = () => Δinject(resolveForwardRef(provider.useExisting));
} else if (isFactoryProvider(provider)) {
factory = () => provider.useFactory(...injectArgs(provider.deps || []));
} else {

4
packages/core/src/di/util.ts
View File

@ -10,7 +10,7 @@ import {Type} from '../interface/type';
import {ReflectionCapabilities} from '../reflection/reflection_capabilities';
import {getClosureSafeProperty} from '../util/property';
import {injectArgs, ɵɵinject} from './injector_compatibility';
import {injectArgs, Δinject} from './injector_compatibility';
import {ClassSansProvider, ConstructorSansProvider, ExistingSansProvider, FactorySansProvider, StaticClassSansProvider, ValueProvider, ValueSansProvider} from './interface/provider';
const USE_VALUE =
@ -32,7 +32,7 @@ export function convertInjectableProviderToFactory(
return () => valueProvider.useValue;
} else if ((provider as ExistingSansProvider).useExisting) {
const existingProvider = (provider as ExistingSansProvider);
return () => ɵɵinject(existingProvider.useExisting);
return () => Δinject(existingProvider.useExisting);
} else if ((provider as FactorySansProvider).useFactory) {
const factoryProvider = (provider as FactorySansProvider);
return () => factoryProvider.useFactory(...injectArgs(factoryProvider.deps || EMPTY_ARRAY));