New Case Study:See how Anthropic automated 95% of dependency reviews with Socket.Learn More →
Socket
Sign inDemoInstall
Socket
Sign inDemoInstall

@angular/upgrade

Package Overview
Dependencies
Maintainers
0
Versions
895
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

@angular/upgrade - npm Package Compare versions

Comparing version

20.0.0-next.1
to
20.0.0-next.2

angular1.d-DnOc0Rx9.d.ts
fesm2022/upgrade_helper-BOLCivYz.mjs
fesm2022/upgrade_helper-BOLCivYz.mjs.map

56

index.d.ts
/**
* @license Angular v20.0.0-next.1
* @license Angular v20.0.0-next.2
* (c) 2010-2025 Google LLC. https://angular.io/

@@ -7,42 +7,6 @@ * License: MIT

import { I as IRootScopeService, a as IInjectorService, b as IAngularBootstrapConfig } from './angular1.d-DnOc0Rx9.js';
export { V as VERSION } from './angular1.d-DnOc0Rx9.js';
import { Type, CompilerOptions, NgModuleRef, Injector } from '@angular/core';
import { CompilerOptions } from '@angular/core';
import { Injector } from '@angular/core';
import { NgModuleRef } from '@angular/core';
import { Type } from '@angular/core';
import { Version } from '@angular/core';
declare interface IAngularBootstrapConfig {
strictDi?: boolean;
}
declare interface IInjectorService {
get(key: string): any;
has(key: string): boolean;
}
declare interface IRootScopeService {
$new(isolate?: boolean): IScope;
$id: string;
$parent: IScope;
$root: IScope;
$watch(exp: Ng1Expression, fn?: (a1?: any, a2?: any) => void): Function;
$on(event: string, fn?: (event?: any, ...args: any[]) => void): Function;
$destroy(): any;
$apply(exp?: Ng1Expression): any;
$digest(): any;
$evalAsync(exp: Ng1Expression, locals?: any): void;
$on(event: string, fn?: (event?: any, ...args: any[]) => void): Function;
$$childTail: IScope;
$$childHead: IScope;
$$nextSibling: IScope;
$$phase: any;
[key: string]: any;
}
declare interface IScope extends IRootScopeService {
}
declare type Ng1Expression = string | Function;
/**

@@ -130,3 +94,3 @@ * Use `UpgradeAdapter` to allow AngularJS and Angular to coexist in a single application.

*/
export declare class UpgradeAdapter {
declare class UpgradeAdapter {
private ng2AppModule;

@@ -443,3 +407,2 @@ private compilerOptions?;

}
/**

@@ -452,3 +415,3 @@ * Use `UpgradeAdapterRef` to control a hybrid AngularJS / Angular application.

*/
export declare class UpgradeAdapterRef {
declare class UpgradeAdapterRef {
ng1RootScope: IRootScopeService;

@@ -472,7 +435,2 @@ ng1Injector: IInjectorService;

/**
* @publicApi
*/
export declare const VERSION: Version;
export { }
export { UpgradeAdapter, UpgradeAdapterRef };

10

package.json
{
"name": "@angular/upgrade",
"version": "20.0.0-next.1",
"version": "20.0.0-next.2",
"description": "Angular - the library for easing update from v1 to v2",

@@ -14,6 +14,6 @@ "author": "angular",

"peerDependencies": {
"@angular/core": "20.0.0-next.1",
"@angular/compiler": "20.0.0-next.1",
"@angular/platform-browser": "20.0.0-next.1",
"@angular/platform-browser-dynamic": "20.0.0-next.1"
"@angular/core": "20.0.0-next.2",
"@angular/compiler": "20.0.0-next.2",
"@angular/platform-browser": "20.0.0-next.2",
"@angular/platform-browser-dynamic": "20.0.0-next.2"
},

@@ -20,0 +20,0 @@ "repository": {

822

static/index.d.ts
/**
* @license Angular v20.0.0-next.1
* @license Angular v20.0.0-next.2
* (c) 2010-2025 Google LLC. https://angular.io/

@@ -7,112 +7,8 @@ * License: MIT

import { DoCheck } from '@angular/core';
import { ElementRef } from '@angular/core';
import { a as IInjectorService, c as IAugmentedJQuery, d as IDirective, e as IController, f as IScope, g as ILinkFn, S as SingleOrListOrMap, h as INgModelController } from '../angular1.d-DnOc0Rx9.js';
export { V as VERSION, i as getAngularJSGlobal, j as getAngularLib, s as setAngularJSGlobal, k as setAngularLib, l as ɵangular1 } from '../angular1.d-DnOc0Rx9.js';
import * as i0 from '@angular/core';
import { Injector } from '@angular/core';
import { NgModuleFactory } from '@angular/core';
import { NgModuleRef } from '@angular/core';
import { NgZone } from '@angular/core';
import { OnChanges } from '@angular/core';
import { OnDestroy } from '@angular/core';
import { OnInit } from '@angular/core';
import { PlatformRef } from '@angular/core';
import { SimpleChanges } from '@angular/core';
import { StaticProvider } from '@angular/core';
import { Type } from '@angular/core';
import { Version } from '@angular/core';
import { Type, StaticProvider, NgModuleRef, NgModuleFactory, OnInit, OnChanges, DoCheck, OnDestroy, ElementRef, Injector, SimpleChanges, NgZone, PlatformRef } from '@angular/core';
declare const $$TESTABILITY = "$$testability";
declare const $COMPILE = "$compile";
declare const $CONTROLLER = "$controller";
declare const $DELEGATE = "$delegate";
declare const $EXCEPTION_HANDLER = "$exceptionHandler";
declare const $HTTP_BACKEND = "$httpBackend";
declare const $INJECTOR = "$injector";
declare const $INTERVAL = "$interval";
declare const $PARSE = "$parse";
declare const $PROVIDE = "$provide";
declare const $ROOT_ELEMENT = "$rootElement";
declare const $ROOT_SCOPE = "$rootScope";
declare const $SCOPE = "$scope";
declare const $TEMPLATE_CACHE = "$templateCache";
declare const $TEMPLATE_REQUEST = "$templateRequest";
declare let angular: {
bootstrap: (e: Element, modules: (string | IInjectable)[], config?: IAngularBootstrapConfig) => IInjectorService;
module: (prefix: string, dependencies?: string[]) => IModule;
element: {
(e: string | Element | Document | IAugmentedJQuery): IAugmentedJQuery;
cleanData: (nodes: Node[] | NodeList) => void;
};
injector: (modules: Array<string | IInjectable>, strictDi?: boolean) => IInjectorService;
version: {
major: number;
};
resumeBootstrap: () => void;
getTestability: (e: Element) => ITestabilityService;
};
declare const bootstrap: typeof angular.bootstrap;
/**
* Clean the jqLite/jQuery data on the element and all its descendants.
* Equivalent to how jqLite/jQuery invoke `cleanData()` on an Element when removed:
* https://github.com/angular/angular.js/blob/2e72ea13fa98bebf6ed4b5e3c45eaf5f990ed16f/src/jqLite.js#L349-L355
* https://github.com/jquery/jquery/blob/6984d1747623dbc5e87fd6c261a5b6b1628c107c/src/manipulation.js#L182
*
* NOTE:
* `cleanData()` will also invoke the AngularJS `$destroy` DOM event on the element:
* https://github.com/angular/angular.js/blob/2e72ea13fa98bebf6ed4b5e3c45eaf5f990ed16f/src/Angular.js#L1932-L1945
*
* @param node The DOM node whose data needs to be cleaned.
*/
declare function cleanData(node: Node): void;
declare const COMPILER_KEY = "$$angularCompiler";
declare function controllerKey(name: string): string;
declare class Deferred<R> {
promise: Promise<R>;
resolve: (value: R | PromiseLike<R>) => void;
reject: (error?: any) => void;
constructor();
}
/**
* Destroy an AngularJS app given the app `$injector`.
*
* NOTE: Destroying an app is not officially supported by AngularJS, but try to do our best by
* destroying `$rootScope` and clean the jqLite/jQuery data on `$rootElement` and all
* descendants.
*
* @param $injector The `$injector` of the AngularJS app to destroy.
*/
declare function destroyApp($injector: IInjectorService): void;
declare function directiveNormalize(name: string): string;
declare type DirectiveRequireProperty = SingleOrListOrMap<string>;
declare type DirectiveTranscludeProperty = boolean | 'element' | {
[key: string]: string;
};
/**
* @description

@@ -165,3 +61,3 @@ *

*/
export declare function downgradeComponent(info: {
declare function downgradeComponent(info: {
component: Type<any>;

@@ -178,5 +74,2 @@ downgradedModule?: string;

declare const DOWNGRADED_MODULE_COUNT_KEY = "$$angularDowngradedModuleCount";
/**

@@ -242,3 +135,3 @@ * @description

*/
export declare function downgradeInjectable(token: any, downgradedModule?: string): Function;
declare function downgradeInjectable(token: any, downgradedModule?: string): Function;

@@ -358,4 +251,3 @@ /**

*/
export declare function downgradeModule<T>(moduleOrBootstrapFn: Type<T> | ((extraProviders: StaticProvider[]) => Promise<NgModuleRef<T>>)): string;
declare function downgradeModule<T>(moduleOrBootstrapFn: Type<T> | ((extraProviders: StaticProvider[]) => Promise<NgModuleRef<T>>)): string;
/**

@@ -477,380 +369,5 @@ * @description

*/
export declare function downgradeModule<T>(moduleOrBootstrapFn: NgModuleFactory<T>): string;
declare function downgradeModule<T>(moduleOrBootstrapFn: NgModuleFactory<T>): string;
declare const element: typeof angular.element;
/**
* Returns the current AngularJS global.
*
* @publicApi
*/
export declare function getAngularJSGlobal(): any;
/**
* @deprecated Use `getAngularJSGlobal` instead.
*
* @publicApi
*/
export declare function getAngularLib(): any;
declare function getDowngradedModuleCount($injector: IInjectorService): number;
declare const getTestability: typeof angular.getTestability;
declare function getTypeName(type: Type<any>): string;
declare function getUpgradeAppType($injector: IInjectorService): UpgradeAppType;
declare const GROUP_PROJECTABLE_NODES_KEY = "$$angularGroupProjectableNodes";
/**
* Glue the AngularJS `NgModelController` (if it exists) to the component
* (if it implements the needed subset of the `ControlValueAccessor` interface).
*/
declare function hookupNgModel(ngModel: INgModelController, component: any): void;
declare interface IAngularBootstrapConfig {
strictDi?: boolean;
}
declare interface IAnnotatedFunction extends Function {
$inject?: Function extends {
$inject?: string[];
} ? Ng1Token[] : ReadonlyArray<Ng1Token>;
}
declare interface IAttributes {
$observe(attr: string, fn: (v: string) => void): void;
[key: string]: any;
}
declare type IAugmentedJQuery = Node[] & {
on?: (name: string, fn: () => void) => void;
data?: (name: string, value?: any) => any;
text?: () => string;
inheritedData?: (name: string, value?: any) => any;
children?: () => IAugmentedJQuery;
contents?: () => IAugmentedJQuery;
parent?: () => IAugmentedJQuery;
empty?: () => void;
append?: (content: IAugmentedJQuery | string) => IAugmentedJQuery;
controller?: (name: string) => any;
isolateScope?: () => IScope;
injector?: () => IInjectorService;
triggerHandler?: (eventTypeOrObject: string | Event, extraParameters?: any[]) => IAugmentedJQuery;
remove?: () => void;
removeData?: () => void;
};
declare interface IBindingDestination {
[key: string]: any;
$onChanges?: (changes: SimpleChanges) => void;
}
declare interface ICacheObject {
put<T>(key: string, value?: T): T;
get(key: string): any;
}
declare interface ICloneAttachFunction {
(clonedElement: IAugmentedJQuery, scope: IScope): any;
}
declare interface ICompiledExpression {
(context: any, locals: any): any;
assign?: (context: any, value: any) => any;
}
declare interface ICompileService {
(element: Element | NodeList | Node[] | string, transclude?: Function): ILinkFn;
}
declare interface IComponent {
bindings?: {
[key: string]: string;
};
controller?: string | IInjectable;
controllerAs?: string;
require?: DirectiveRequireProperty;
template?: string | Function;
templateUrl?: string | Function;
transclude?: DirectiveTranscludeProperty;
}
declare type IController = string | IInjectable;
declare interface IControllerInstance extends IBindingDestination {
$doCheck?: () => void;
$onDestroy?: () => void;
$onInit?: () => void;
$postLink?: () => void;
}
declare interface IControllerService {
(controllerConstructor: IController, locals?: any, later?: any, ident?: any): any;
(controllerName: string, locals?: any): any;
}
declare interface IDirective {
compile?: IDirectiveCompileFn;
controller?: IController;
controllerAs?: string;
bindToController?: boolean | {
[key: string]: string;
};
link?: IDirectiveLinkFn | IDirectivePrePost;
name?: string;
priority?: number;
replace?: boolean;
require?: DirectiveRequireProperty;
restrict?: string;
scope?: boolean | {
[key: string]: string;
};
template?: string | Function;
templateUrl?: string | Function;
templateNamespace?: string;
terminal?: boolean;
transclude?: DirectiveTranscludeProperty;
}
declare interface IDirectiveCompileFn {
(templateElement: IAugmentedJQuery, templateAttributes: IAttributes, transclude: ITranscludeFunction): IDirectivePrePost;
}
declare interface IDirectiveLinkFn {
(scope: IScope, instanceElement: IAugmentedJQuery, instanceAttributes: IAttributes, controller: any, transclude: ITranscludeFunction): void;
}
declare interface IDirectivePrePost {
pre?: IDirectiveLinkFn;
post?: IDirectiveLinkFn;
}
declare interface IHttpBackendService {
(method: string, url: string, post?: any, callback?: Function, headers?: any, timeout?: number, withCredentials?: boolean): void;
}
declare type IInjectable = (Ng1Token | Function)[] | IAnnotatedFunction;
declare interface IInjectorService {
get(key: string): any;
has(key: string): boolean;
}
declare interface IIntervalService {
(func: Function, delay: number, count?: number, invokeApply?: boolean, ...args: any[]): Promise<any>;
cancel(promise: Promise<any>): boolean;
}
declare interface ILinkFn {
(scope: IScope, cloneAttachFn?: ICloneAttachFunction, options?: ILinkFnOptions): IAugmentedJQuery;
$$slots?: {
[slotName: string]: ILinkFn;
};
}
declare interface ILinkFnOptions {
parentBoundTranscludeFn?: Function;
transcludeControllers?: {
[key: string]: any;
};
futureParentElement?: Node;
}
declare interface IModule {
name: string;
requires: (string | IInjectable)[];
config(fn: IInjectable): IModule;
directive(selector: string, factory: IInjectable): IModule;
component(selector: string, component: IComponent): IModule;
controller(name: string, type: IInjectable): IModule;
factory(key: Ng1Token, factoryFn: IInjectable): IModule;
value(key: Ng1Token, value: any): IModule;
constant(token: Ng1Token, value: any): IModule;
run(a: IInjectable): IModule;
}
declare interface INgModelController {
$render(): void;
$isEmpty(value: any): boolean;
$setValidity(validationErrorKey: string, isValid: boolean): void;
$setPristine(): void;
$setDirty(): void;
$setUntouched(): void;
$setTouched(): void;
$rollbackViewValue(): void;
$validate(): void;
$commitViewValue(): void;
$setViewValue(value: any, trigger: string): void;
$viewValue: any;
$modelValue: any;
$parsers: Function[];
$formatters: Function[];
$validators: {
[key: string]: Function;
};
$asyncValidators: {
[key: string]: Function;
};
$viewChangeListeners: Function[];
$error: Object;
$pending: Object;
$untouched: boolean;
$touched: boolean;
$pristine: boolean;
$dirty: boolean;
$valid: boolean;
$invalid: boolean;
$name: string;
}
declare const injector: typeof angular.injector;
declare const INJECTOR_KEY = "$$angularInjector";
declare interface IParseService {
(expression: string): ICompiledExpression;
}
declare interface IProvider {
$get: IInjectable;
}
declare interface IProvideService {
provider(token: Ng1Token, provider: IProvider): IProvider;
factory(token: Ng1Token, factory: IInjectable): IProvider;
service(token: Ng1Token, type: IInjectable): IProvider;
value(token: Ng1Token, value: any): IProvider;
constant(token: Ng1Token, value: any): void;
decorator(token: Ng1Token, factory: IInjectable): void;
}
declare interface IRootScopeService {
$new(isolate?: boolean): IScope;
$id: string;
$parent: IScope;
$root: IScope;
$watch(exp: Ng1Expression, fn?: (a1?: any, a2?: any) => void): Function;
$on(event: string, fn?: (event?: any, ...args: any[]) => void): Function;
$destroy(): any;
$apply(exp?: Ng1Expression): any;
$digest(): any;
$evalAsync(exp: Ng1Expression, locals?: any): void;
$on(event: string, fn?: (event?: any, ...args: any[]) => void): Function;
$$childTail: IScope;
$$childHead: IScope;
$$nextSibling: IScope;
$$phase: any;
[key: string]: any;
}
declare interface IScope extends IRootScopeService {
}
declare function isFunction(value: any): value is Function;
declare function isNgModuleType(value: any): value is Type<unknown>;
declare interface ITemplateCacheService extends ICacheObject {
}
declare interface ITestabilityService {
findBindings(element: Element, expression: string, opt_exactMatch?: boolean): Element[];
findModels(element: Element, expression: string, opt_exactMatch?: boolean): Element[];
getLocation(): string;
setLocation(url: string): void;
whenStable(callback: Function): void;
}
declare interface ITranscludeFunction {
(scope: IScope, cloneAttachFn: ICloneAttachFunction): IAugmentedJQuery;
(cloneAttachFn?: ICloneAttachFunction): IAugmentedJQuery;
}
declare const LAZY_MODULE_REF = "$$angularLazyModuleRef";
declare interface LazyModuleRef {
injector?: Injector;
promise?: Promise<Injector>;
}
declare const module_: typeof angular.module;
declare type Ng1Expression = string | Function;
declare type Ng1Token = string;
declare const NG_ZONE_KEY = "$$angularNgZone";
declare function onError(e: any): void;
declare const REQUIRE_INJECTOR: string;
declare const REQUIRE_NG_MODEL = "?ngModel";
declare const resumeBootstrap: typeof angular.resumeBootstrap;
/**
* Resets the AngularJS global.
*
* Used when AngularJS is loaded lazily, and not available on `window`.
*
* @publicApi
*/
export declare function setAngularJSGlobal(ng: any): void;
/**
* @deprecated Use `setAngularJSGlobal` instead.
*
* @publicApi
*/
export declare function setAngularLib(ng: any): void;
declare type SingleOrListOrMap<T> = T | T[] | {
[key: string]: T;
};
/**
* Test two values for strict equality, accounting for the fact that `NaN !== NaN`.
*/
declare function strictEquals(val1: any, val2: any): boolean;
/**
* @fileoverview
* While Angular only uses Trusted Types internally for the time being,
* references to Trusted Types could leak into our public API, which would force
* anyone compiling against @angular/upgrade to provide the @types/trusted-types
* package in their compilation unit.
*
* Until https://github.com/microsoft/TypeScript/issues/30024 is resolved, we
* will keep Angular's public API surface free of references to Trusted Types.
* For internal and semi-private APIs that need to reference Trusted Types, the
* minimal type definitions for the Trusted Types API provided by this module
* should be used instead. They are marked as "declare" to prevent them from
* being renamed by compiler optimization.
*
* Adapted from
* https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/trusted-types/index.d.ts
* but restricted to the API surface used within Angular, mimicking the approach
* in packages/core/src/util/security/trusted_type_defs.ts.
*/
declare type TrustedHTML = string & {
__brand__: 'TrustedHTML';
};
declare const UPGRADE_APP_TYPE_KEY = "$$angularUpgradeAppType";
declare const UPGRADE_MODULE_NAME = "$$UpgradeModule";
declare const enum UpgradeAppType {
None = 0,
Dynamic = 1,
Static = 2,
Lite = 3
}
/**
* @description

@@ -895,3 +412,3 @@ *

*/
export declare class UpgradeComponent implements OnInit, OnChanges, DoCheck, OnDestroy {
declare class UpgradeComponent implements OnInit, OnChanges, DoCheck, OnDestroy {
private helper;

@@ -934,24 +451,2 @@ private $element;

declare class UpgradeHelper {
private name;
readonly $injector: IInjectorService;
readonly element: Element;
readonly $element: IAugmentedJQuery;
readonly directive: IDirective;
private readonly $compile;
private readonly $controller;
constructor(injector: Injector, name: string, elementRef: ElementRef, directive?: IDirective);
static getDirective($injector: IInjectorService, name: string): IDirective;
static getTemplate($injector: IInjectorService, directive: IDirective, fetchRemoteTemplate?: boolean, $element?: IAugmentedJQuery): string | TrustedHTML | Promise<string | TrustedHTML>;
buildController(controllerType: IController, $scope: IScope): any;
compileTemplate(template?: string | TrustedHTML): ILinkFn;
onDestroy($scope: IScope, controllerInstance?: any): void;
prepareTransclusion(): ILinkFn | undefined;
resolveAndBindRequiredControllers(controllerInstance: IControllerInstance | null): SingleOrListOrMap<IControllerInstance> | null;
private compileHtml;
private extractChildNodes;
private getDirectiveRequire;
private resolveRequire;
}
/**

@@ -1081,3 +576,3 @@ * @description

*/
export declare class UpgradeModule {
declare class UpgradeModule {
/** The bootstrap zone for the upgrade application */

@@ -1122,123 +617,200 @@ ngZone: NgZone;

declare function validateInjectionKey($injector: IInjectorService, downgradedModule: string, injectionKey: string, attemptedAction: string): void;
declare const $COMPILE = "$compile";
declare const $CONTROLLER = "$controller";
declare const $DELEGATE = "$delegate";
declare const $EXCEPTION_HANDLER = "$exceptionHandler";
declare const $HTTP_BACKEND = "$httpBackend";
declare const $INJECTOR = "$injector";
declare const $INTERVAL = "$interval";
declare const $PARSE = "$parse";
declare const $PROVIDE = "$provide";
declare const $ROOT_ELEMENT = "$rootElement";
declare const $ROOT_SCOPE = "$rootScope";
declare const $SCOPE = "$scope";
declare const $TEMPLATE_CACHE = "$templateCache";
declare const $TEMPLATE_REQUEST = "$templateRequest";
declare const $$TESTABILITY = "$$testability";
declare const COMPILER_KEY = "$$angularCompiler";
declare const DOWNGRADED_MODULE_COUNT_KEY = "$$angularDowngradedModuleCount";
declare const GROUP_PROJECTABLE_NODES_KEY = "$$angularGroupProjectableNodes";
declare const INJECTOR_KEY = "$$angularInjector";
declare const LAZY_MODULE_REF = "$$angularLazyModuleRef";
declare const NG_ZONE_KEY = "$$angularNgZone";
declare const UPGRADE_APP_TYPE_KEY = "$$angularUpgradeAppType";
declare const REQUIRE_INJECTOR: string;
declare const REQUIRE_NG_MODEL = "?ngModel";
declare const UPGRADE_MODULE_NAME = "$$UpgradeModule";
declare const constants_d_$$TESTABILITY: typeof $$TESTABILITY;
declare const constants_d_$COMPILE: typeof $COMPILE;
declare const constants_d_$CONTROLLER: typeof $CONTROLLER;
declare const constants_d_$DELEGATE: typeof $DELEGATE;
declare const constants_d_$EXCEPTION_HANDLER: typeof $EXCEPTION_HANDLER;
declare const constants_d_$HTTP_BACKEND: typeof $HTTP_BACKEND;
declare const constants_d_$INJECTOR: typeof $INJECTOR;
declare const constants_d_$INTERVAL: typeof $INTERVAL;
declare const constants_d_$PARSE: typeof $PARSE;
declare const constants_d_$PROVIDE: typeof $PROVIDE;
declare const constants_d_$ROOT_ELEMENT: typeof $ROOT_ELEMENT;
declare const constants_d_$ROOT_SCOPE: typeof $ROOT_SCOPE;
declare const constants_d_$SCOPE: typeof $SCOPE;
declare const constants_d_$TEMPLATE_CACHE: typeof $TEMPLATE_CACHE;
declare const constants_d_$TEMPLATE_REQUEST: typeof $TEMPLATE_REQUEST;
declare const constants_d_COMPILER_KEY: typeof COMPILER_KEY;
declare const constants_d_DOWNGRADED_MODULE_COUNT_KEY: typeof DOWNGRADED_MODULE_COUNT_KEY;
declare const constants_d_GROUP_PROJECTABLE_NODES_KEY: typeof GROUP_PROJECTABLE_NODES_KEY;
declare const constants_d_INJECTOR_KEY: typeof INJECTOR_KEY;
declare const constants_d_LAZY_MODULE_REF: typeof LAZY_MODULE_REF;
declare const constants_d_NG_ZONE_KEY: typeof NG_ZONE_KEY;
declare const constants_d_REQUIRE_INJECTOR: typeof REQUIRE_INJECTOR;
declare const constants_d_REQUIRE_NG_MODEL: typeof REQUIRE_NG_MODEL;
declare const constants_d_UPGRADE_APP_TYPE_KEY: typeof UPGRADE_APP_TYPE_KEY;
declare const constants_d_UPGRADE_MODULE_NAME: typeof UPGRADE_MODULE_NAME;
declare namespace constants_d {
export { constants_d_$$TESTABILITY as $$TESTABILITY, constants_d_$COMPILE as $COMPILE, constants_d_$CONTROLLER as $CONTROLLER, constants_d_$DELEGATE as $DELEGATE, constants_d_$EXCEPTION_HANDLER as $EXCEPTION_HANDLER, constants_d_$HTTP_BACKEND as $HTTP_BACKEND, constants_d_$INJECTOR as $INJECTOR, constants_d_$INTERVAL as $INTERVAL, constants_d_$PARSE as $PARSE, constants_d_$PROVIDE as $PROVIDE, constants_d_$ROOT_ELEMENT as $ROOT_ELEMENT, constants_d_$ROOT_SCOPE as $ROOT_SCOPE, constants_d_$SCOPE as $SCOPE, constants_d_$TEMPLATE_CACHE as $TEMPLATE_CACHE, constants_d_$TEMPLATE_REQUEST as $TEMPLATE_REQUEST, constants_d_COMPILER_KEY as COMPILER_KEY, constants_d_DOWNGRADED_MODULE_COUNT_KEY as DOWNGRADED_MODULE_COUNT_KEY, constants_d_GROUP_PROJECTABLE_NODES_KEY as GROUP_PROJECTABLE_NODES_KEY, constants_d_INJECTOR_KEY as INJECTOR_KEY, constants_d_LAZY_MODULE_REF as LAZY_MODULE_REF, constants_d_NG_ZONE_KEY as NG_ZONE_KEY, constants_d_REQUIRE_INJECTOR as REQUIRE_INJECTOR, constants_d_REQUIRE_NG_MODEL as REQUIRE_NG_MODEL, constants_d_UPGRADE_APP_TYPE_KEY as UPGRADE_APP_TYPE_KEY, constants_d_UPGRADE_MODULE_NAME as UPGRADE_MODULE_NAME };
}
/**
* @publicApi
* @fileoverview
* While Angular only uses Trusted Types internally for the time being,
* references to Trusted Types could leak into our public API, which would force
* anyone compiling against @angular/upgrade to provide the @types/trusted-types
* package in their compilation unit.
*
* Until https://github.com/microsoft/TypeScript/issues/30024 is resolved, we
* will keep Angular's public API surface free of references to Trusted Types.
* For internal and semi-private APIs that need to reference Trusted Types, the
* minimal type definitions for the Trusted Types API provided by this module
* should be used instead. They are marked as "declare" to prevent them from
* being renamed by compiler optimization.
*
* Adapted from
* https://github.com/DefinitelyTyped/DefinitelyTyped/blob/master/types/trusted-types/index.d.ts
* but restricted to the API surface used within Angular, mimicking the approach
* in packages/core/src/util/security/trusted_type_defs.ts.
*/
export declare const VERSION: Version;
type TrustedHTML = string & {
__brand__: 'TrustedHTML';
};
declare namespace ɵangular1 {
export {
setAngularLib,
getAngularLib,
setAngularJSGlobal,
getAngularJSGlobal,
Ng1Token,
Ng1Expression,
IAnnotatedFunction,
IInjectable,
SingleOrListOrMap,
IModule,
ICompileService,
ILinkFn,
ILinkFnOptions,
IRootScopeService,
IScope,
IAngularBootstrapConfig,
IDirective,
DirectiveRequireProperty,
DirectiveTranscludeProperty,
IDirectiveCompileFn,
IDirectivePrePost,
IDirectiveLinkFn,
IComponent,
IAttributes,
ITranscludeFunction,
ICloneAttachFunction,
IAugmentedJQuery,
IProvider,
IProvideService,
IParseService,
ICompiledExpression,
IHttpBackendService,
ICacheObject,
ITemplateCacheService,
IController,
IControllerService,
IInjectorService,
IIntervalService,
ITestabilityService,
INgModelController,
bootstrap,
module_,
element,
injector,
resumeBootstrap,
getTestability
}
interface IBindingDestination {
[key: string]: any;
$onChanges?: (changes: SimpleChanges) => void;
}
export { ɵangular1 }
interface IControllerInstance extends IBindingDestination {
$doCheck?: () => void;
$onDestroy?: () => void;
$onInit?: () => void;
$postLink?: () => void;
}
declare class UpgradeHelper {
private name;
readonly $injector: IInjectorService;
readonly element: Element;
readonly $element: IAugmentedJQuery;
readonly directive: IDirective;
private readonly $compile;
private readonly $controller;
constructor(injector: Injector, name: string, elementRef: ElementRef, directive?: IDirective);
static getDirective($injector: IInjectorService, name: string): IDirective;
static getTemplate($injector: IInjectorService, directive: IDirective, fetchRemoteTemplate?: boolean, $element?: IAugmentedJQuery): string | TrustedHTML | Promise<string | TrustedHTML>;
buildController(controllerType: IController, $scope: IScope): any;
compileTemplate(template?: string | TrustedHTML): ILinkFn;
onDestroy($scope: IScope, controllerInstance?: any): void;
prepareTransclusion(): ILinkFn | undefined;
resolveAndBindRequiredControllers(controllerInstance: IControllerInstance | null): SingleOrListOrMap<IControllerInstance> | null;
private compileHtml;
private extractChildNodes;
private getDirectiveRequire;
private resolveRequire;
}
declare namespace ɵconstants {
export {
$COMPILE,
$CONTROLLER,
$DELEGATE,
$EXCEPTION_HANDLER,
$HTTP_BACKEND,
$INJECTOR,
$INTERVAL,
$PARSE,
$PROVIDE,
$ROOT_ELEMENT,
$ROOT_SCOPE,
$SCOPE,
$TEMPLATE_CACHE,
$TEMPLATE_REQUEST,
$$TESTABILITY,
COMPILER_KEY,
DOWNGRADED_MODULE_COUNT_KEY,
GROUP_PROJECTABLE_NODES_KEY,
INJECTOR_KEY,
LAZY_MODULE_REF,
NG_ZONE_KEY,
UPGRADE_APP_TYPE_KEY,
REQUIRE_INJECTOR,
REQUIRE_NG_MODEL,
UPGRADE_MODULE_NAME
}
type upgrade_helper_d_IBindingDestination = IBindingDestination;
type upgrade_helper_d_IControllerInstance = IControllerInstance;
type upgrade_helper_d_UpgradeHelper = UpgradeHelper;
declare const upgrade_helper_d_UpgradeHelper: typeof UpgradeHelper;
declare namespace upgrade_helper_d {
export { type upgrade_helper_d_IBindingDestination as IBindingDestination, type upgrade_helper_d_IControllerInstance as IControllerInstance, upgrade_helper_d_UpgradeHelper as UpgradeHelper };
}
export { ɵconstants }
declare namespace ɵupgradeHelper {
export {
IBindingDestination,
IControllerInstance,
UpgradeHelper
}
declare function onError(e: any): void;
/**
* Clean the jqLite/jQuery data on the element and all its descendants.
* Equivalent to how jqLite/jQuery invoke `cleanData()` on an Element when removed:
* https://github.com/angular/angular.js/blob/2e72ea13fa98bebf6ed4b5e3c45eaf5f990ed16f/src/jqLite.js#L349-L355
* https://github.com/jquery/jquery/blob/6984d1747623dbc5e87fd6c261a5b6b1628c107c/src/manipulation.js#L182
*
* NOTE:
* `cleanData()` will also invoke the AngularJS `$destroy` DOM event on the element:
* https://github.com/angular/angular.js/blob/2e72ea13fa98bebf6ed4b5e3c45eaf5f990ed16f/src/Angular.js#L1932-L1945
*
* @param node The DOM node whose data needs to be cleaned.
*/
declare function cleanData(node: Node): void;
declare function controllerKey(name: string): string;
/**
* Destroy an AngularJS app given the app `$injector`.
*
* NOTE: Destroying an app is not officially supported by AngularJS, but try to do our best by
* destroying `$rootScope` and clean the jqLite/jQuery data on `$rootElement` and all
* descendants.
*
* @param $injector The `$injector` of the AngularJS app to destroy.
*/
declare function destroyApp($injector: IInjectorService): void;
declare function directiveNormalize(name: string): string;
declare function getTypeName(type: Type<any>): string;
declare function getDowngradedModuleCount($injector: IInjectorService): number;
declare function getUpgradeAppType($injector: IInjectorService): UpgradeAppType;
declare function isFunction(value: any): value is Function;
declare function isNgModuleType(value: any): value is Type<unknown>;
declare function validateInjectionKey($injector: IInjectorService, downgradedModule: string, injectionKey: string, attemptedAction: string): void;
declare class Deferred<R> {
promise: Promise<R>;
resolve: (value: R | PromiseLike<R>) => void;
reject: (error?: any) => void;
constructor();
}
export { ɵupgradeHelper }
interface LazyModuleRef {
injector?: Injector;
promise?: Promise<Injector>;
}
declare const enum UpgradeAppType {
None = 0,
Dynamic = 1,
Static = 2,
Lite = 3
}
/**
* Glue the AngularJS `NgModelController` (if it exists) to the component
* (if it implements the needed subset of the `ControlValueAccessor` interface).
*/
declare function hookupNgModel(ngModel: INgModelController, component: any): void;
/**
* Test two values for strict equality, accounting for the fact that `NaN !== NaN`.
*/
declare function strictEquals(val1: any, val2: any): boolean;
declare namespace ɵutil {
export {
onError,
cleanData,
controllerKey,
destroyApp,
directiveNormalize,
getTypeName,
getDowngradedModuleCount,
getUpgradeAppType,
isFunction,
isNgModuleType,
validateInjectionKey,
hookupNgModel,
strictEquals,
Deferred,
LazyModuleRef,
UpgradeAppType
}
type util_d_Deferred<R> = Deferred<R>;
declare const util_d_Deferred: typeof Deferred;
type util_d_LazyModuleRef = LazyModuleRef;
type util_d_UpgradeAppType = UpgradeAppType;
declare const util_d_UpgradeAppType: typeof UpgradeAppType;
declare const util_d_cleanData: typeof cleanData;
declare const util_d_controllerKey: typeof controllerKey;
declare const util_d_destroyApp: typeof destroyApp;
declare const util_d_directiveNormalize: typeof directiveNormalize;
declare const util_d_getDowngradedModuleCount: typeof getDowngradedModuleCount;
declare const util_d_getTypeName: typeof getTypeName;
declare const util_d_getUpgradeAppType: typeof getUpgradeAppType;
declare const util_d_hookupNgModel: typeof hookupNgModel;
declare const util_d_isFunction: typeof isFunction;
declare const util_d_isNgModuleType: typeof isNgModuleType;
declare const util_d_onError: typeof onError;
declare const util_d_strictEquals: typeof strictEquals;
declare const util_d_validateInjectionKey: typeof validateInjectionKey;
declare namespace util_d {
export { util_d_Deferred as Deferred, type util_d_LazyModuleRef as LazyModuleRef, util_d_UpgradeAppType as UpgradeAppType, util_d_cleanData as cleanData, util_d_controllerKey as controllerKey, util_d_destroyApp as destroyApp, util_d_directiveNormalize as directiveNormalize, util_d_getDowngradedModuleCount as getDowngradedModuleCount, util_d_getTypeName as getTypeName, util_d_getUpgradeAppType as getUpgradeAppType, util_d_hookupNgModel as hookupNgModel, util_d_isFunction as isFunction, util_d_isNgModuleType as isNgModuleType, util_d_onError as onError, util_d_strictEquals as strictEquals, util_d_validateInjectionKey as validateInjectionKey };
}
export { ɵutil }
export { }
export { UpgradeComponent, UpgradeModule, downgradeComponent, downgradeInjectable, downgradeModule, constants_d as ɵconstants, upgrade_helper_d as ɵupgradeHelper, util_d as ɵutil };

86

static/testing/index.d.ts
/**
* @license Angular v20.0.0-next.1
* @license Angular v20.0.0-next.2
* (c) 2010-2025 Google LLC. https://angular.io/

@@ -7,36 +7,32 @@ * License: MIT

import { Type } from '@angular/core';
/**
* A helper function to use when unit testing AngularJS services that depend upon downgraded Angular
* A helper function to use when unit testing Angular services that depend upon upgraded AngularJS
* services.
*
* This function returns an AngularJS module that is configured to wire up the AngularJS and Angular
* injectors without the need to actually bootstrap a hybrid application.
* This function returns an `NgModule` decorated class that is configured to wire up the Angular
* and AngularJS injectors without the need to actually bootstrap a hybrid application.
* This makes it simpler and faster to unit test services.
*
* Use the returned AngularJS module in a call to
* [`angular.mocks.module`](https://docs.angularjs.org/api/ngMock/function/angular.mock.module) to
* include this module in the unit test injector.
* Use the returned class as an "import" when configuring the `TestBed`.
*
* In the following code snippet, we are configuring the `$injector` with two modules:
* The AngularJS `ng1AppModule`, which is the AngularJS part of our hybrid application and the
* `Ng2AppModule`, which is the Angular part.
* In the following code snippet, we are configuring the TestBed with two imports.
* The `Ng2AppModule` is the Angular part of our hybrid application and the `ng1AppModule` is the
* AngularJS part.
*
* {@example upgrade/static/ts/full/module.spec.ts region='angularjs-setup'}
* {@example upgrade/static/ts/full/module.spec.ts region='angular-setup'}
*
* Once this is done we can get hold of services via the AngularJS `$injector` as normal.
* Services that are (or have dependencies on) a downgraded Angular service, will be instantiated as
* needed by the Angular root `Injector`.
* Once this is done we can get hold of services via the Angular `Injector` as normal.
* Services that are (or have dependencies on) an upgraded AngularJS service, will be instantiated
* as needed by the AngularJS `$injector`.
*
* In the following code snippet, `heroesService` is a downgraded Angular service that we are
* accessing from AngularJS.
* In the following code snippet, `HeroesService` is an Angular service that depends upon an
* AngularJS service, `titleCase`.
*
* {@example upgrade/static/ts/full/module.spec.ts region='angularjs-spec'}
* {@example upgrade/static/ts/full/module.spec.ts region='angular-spec'}
*
* <div class="docs-alert docs-alert-important">
*
* This helper is for testing services not components.
* This helper is for testing services not Components.
* For Component testing you must still bootstrap a hybrid app. See `UpgradeModule` or

@@ -60,3 +56,3 @@ * `downgradeModule` for more information.

* * Only call this helper once per spec.
* * Do not use `createAngularJSTestingModule` in the same spec as `createAngularTestingModule`.
* * Do not use `createAngularTestingModule` in the same spec as `createAngularJSTestingModule`.
*

@@ -74,36 +70,40 @@ * </div>

*
* @param angularModules a collection of Angular modules to include in the configuration.
* @param angularJSModules a collection of the names of AngularJS modules to include in the
* configuration.
* @param [strictDi] whether the AngularJS injector should have `strictDI` enabled.
*
* @publicApi
*/
export declare function createAngularJSTestingModule(angularModules: any[]): string;
declare function createAngularTestingModule(angularJSModules: string[], strictDi?: boolean): Type<any>;
/**
* A helper function to use when unit testing Angular services that depend upon upgraded AngularJS
* A helper function to use when unit testing AngularJS services that depend upon downgraded Angular
* services.
*
* This function returns an `NgModule` decorated class that is configured to wire up the Angular
* and AngularJS injectors without the need to actually bootstrap a hybrid application.
* This function returns an AngularJS module that is configured to wire up the AngularJS and Angular
* injectors without the need to actually bootstrap a hybrid application.
* This makes it simpler and faster to unit test services.
*
* Use the returned class as an "import" when configuring the `TestBed`.
* Use the returned AngularJS module in a call to
* [`angular.mocks.module`](https://docs.angularjs.org/api/ngMock/function/angular.mock.module) to
* include this module in the unit test injector.
*
* In the following code snippet, we are configuring the TestBed with two imports.
* The `Ng2AppModule` is the Angular part of our hybrid application and the `ng1AppModule` is the
* AngularJS part.
* In the following code snippet, we are configuring the `$injector` with two modules:
* The AngularJS `ng1AppModule`, which is the AngularJS part of our hybrid application and the
* `Ng2AppModule`, which is the Angular part.
*
* {@example upgrade/static/ts/full/module.spec.ts region='angular-setup'}
* {@example upgrade/static/ts/full/module.spec.ts region='angularjs-setup'}
*
* Once this is done we can get hold of services via the Angular `Injector` as normal.
* Services that are (or have dependencies on) an upgraded AngularJS service, will be instantiated
* as needed by the AngularJS `$injector`.
* Once this is done we can get hold of services via the AngularJS `$injector` as normal.
* Services that are (or have dependencies on) a downgraded Angular service, will be instantiated as
* needed by the Angular root `Injector`.
*
* In the following code snippet, `HeroesService` is an Angular service that depends upon an
* AngularJS service, `titleCase`.
* In the following code snippet, `heroesService` is a downgraded Angular service that we are
* accessing from AngularJS.
*
* {@example upgrade/static/ts/full/module.spec.ts region='angular-spec'}
* {@example upgrade/static/ts/full/module.spec.ts region='angularjs-spec'}
*
* <div class="docs-alert docs-alert-important">
*
* This helper is for testing services not Components.
* This helper is for testing services not components.
* For Component testing you must still bootstrap a hybrid app. See `UpgradeModule` or

@@ -127,3 +127,3 @@ * `downgradeModule` for more information.

* * Only call this helper once per spec.
* * Do not use `createAngularTestingModule` in the same spec as `createAngularJSTestingModule`.
* * Do not use `createAngularJSTestingModule` in the same spec as `createAngularTestingModule`.
*

@@ -141,10 +141,8 @@ * </div>

*
* @param angularJSModules a collection of the names of AngularJS modules to include in the
* configuration.
* @param [strictDi] whether the AngularJS injector should have `strictDI` enabled.
* @param angularModules a collection of Angular modules to include in the configuration.
*
* @publicApi
*/
export declare function createAngularTestingModule(angularJSModules: string[], strictDi?: boolean): Type<any>;
declare function createAngularJSTestingModule(angularModules: any[]): string;
export { }
export { createAngularJSTestingModule, createAngularTestingModule };
fesm2022/static.mjs

Sorry, the diff of this file is not supported yet

fesm2022/static.mjs.map

Sorry, the diff of this file is not supported yet

fesm2022/static/testing.mjs

Sorry, the diff of this file is not supported yet

fesm2022/static/testing.mjs.map

Sorry, the diff of this file is not supported yet

fesm2022/upgrade.mjs

Sorry, the diff of this file is not supported yet

fesm2022/upgrade.mjs.map

Sorry, the diff of this file is not supported yet