@angular/core 20.0.0-next.1 → 20.0.0-next.3

package/navigation_types.d-u4EOrrdZ.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @license Angular v20.0.0-next.3
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+interface NavigationEventMap {
+    navigate: NavigateEvent;
+    navigatesuccess: Event;
+    navigateerror: ErrorEvent;
+    currententrychange: NavigationCurrentEntryChangeEvent;
+}
+interface NavigationResult {
+    committed: Promise<NavigationHistoryEntry>;
+    finished: Promise<NavigationHistoryEntry>;
+}
+declare class Navigation extends EventTarget {
+    entries(): NavigationHistoryEntry[];
+    readonly currentEntry: NavigationHistoryEntry | null;
+    updateCurrentEntry(options: NavigationUpdateCurrentEntryOptions): void;
+    readonly transition: NavigationTransition | null;
+    readonly canGoBack: boolean;
+    readonly canGoForward: boolean;
+    navigate(url: string, options?: NavigationNavigateOptions): NavigationResult;
+    reload(options?: NavigationReloadOptions): NavigationResult;
+    traverseTo(key: string, options?: NavigationOptions): NavigationResult;
+    back(options?: NavigationOptions): NavigationResult;
+    forward(options?: NavigationOptions): NavigationResult;
+    onnavigate: ((this: Navigation, ev: NavigateEvent) => any) | null;
+    onnavigatesuccess: ((this: Navigation, ev: Event) => any) | null;
+    onnavigateerror: ((this: Navigation, ev: ErrorEvent) => any) | null;
+    oncurrententrychange: ((this: Navigation, ev: NavigationCurrentEntryChangeEvent) => any) | null;
+    addEventListener<K extends keyof NavigationEventMap>(type: K, listener: (this: Navigation, ev: NavigationEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof NavigationEventMap>(type: K, listener: (this: Navigation, ev: NavigationEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+declare class NavigationTransition {
+    readonly navigationType: NavigationTypeString;
+    readonly from: NavigationHistoryEntry;
+    readonly finished: Promise<void>;
+}
+interface NavigationHistoryEntryEventMap {
+    dispose: Event;
+}
+declare class NavigationHistoryEntry extends EventTarget {
+    readonly key: string;
+    readonly id: string;
+    readonly url: string | null;
+    readonly index: number;
+    readonly sameDocument: boolean;
+    getState(): unknown;
+    ondispose: ((this: NavigationHistoryEntry, ev: Event) => any) | null;
+    addEventListener<K extends keyof NavigationHistoryEntryEventMap>(type: K, listener: (this: NavigationHistoryEntry, ev: NavigationHistoryEntryEventMap[K]) => any, options?: boolean | AddEventListenerOptions): void;
+    addEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof NavigationHistoryEntryEventMap>(type: K, listener: (this: NavigationHistoryEntry, ev: NavigationHistoryEntryEventMap[K]) => any, options?: boolean | EventListenerOptions): void;
+    removeEventListener(type: string, listener: EventListenerOrEventListenerObject, options?: boolean | EventListenerOptions): void;
+}
+type NavigationTypeString = 'reload' | 'push' | 'replace' | 'traverse';
+interface NavigationUpdateCurrentEntryOptions {
+    state: unknown;
+}
+interface NavigationOptions {
+    info?: unknown;
+}
+interface NavigationNavigateOptions extends NavigationOptions {
+    state?: unknown;
+    history?: 'auto' | 'push' | 'replace';
+}
+interface NavigationReloadOptions extends NavigationOptions {
+    state?: unknown;
+}
+declare class NavigationCurrentEntryChangeEvent extends Event {
+    constructor(type: string, eventInit?: NavigationCurrentEntryChangeEventInit);
+    readonly navigationType: NavigationTypeString | null;
+    readonly from: NavigationHistoryEntry;
+}
+interface NavigationCurrentEntryChangeEventInit extends EventInit {
+    navigationType?: NavigationTypeString | null;
+    from: NavigationHistoryEntry;
+}
+declare class NavigateEvent extends Event {
+    constructor(type: string, eventInit?: NavigateEventInit);
+    readonly navigationType: NavigationTypeString;
+    readonly canIntercept: boolean;
+    readonly userInitiated: boolean;
+    readonly hashChange: boolean;
+    readonly destination: NavigationDestination;
+    readonly signal: AbortSignal;
+    readonly formData: FormData | null;
+    readonly downloadRequest: string | null;
+    readonly info?: unknown;
+    intercept(options?: NavigationInterceptOptions): void;
+    scroll(): void;
+}
+interface NavigateEventInit extends EventInit {
+    navigationType?: NavigationTypeString;
+    canIntercept?: boolean;
+    userInitiated?: boolean;
+    hashChange?: boolean;
+    destination: NavigationDestination;
+    signal: AbortSignal;
+    formData?: FormData | null;
+    downloadRequest?: string | null;
+    info?: unknown;
+}
+interface NavigationInterceptOptions {
+    handler?: () => Promise<void>;
+    focusReset?: 'after-transition' | 'manual';
+    scroll?: 'after-transition' | 'manual';
+}
+declare class NavigationDestination {
+    readonly url: string;
+    readonly key: string | null;
+    readonly id: string | null;
+    readonly index: number;
+    readonly sameDocument: boolean;
+    getState(): unknown;
+}
+
+export { NavigateEvent as N, Navigation as a, NavigationCurrentEntryChangeEvent as b, NavigationHistoryEntry as c, type NavigationNavigateOptions as d, type NavigationOptions as e, type NavigationReloadOptions as f, type NavigationResult as g, NavigationTransition as h, type NavigationUpdateCurrentEntryOptions as i, type NavigationTypeString as j, type NavigationInterceptOptions as k, NavigationDestination as l };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@angular/core",
-  "version": "20.0.0-next.1",
+  "version": "20.0.0-next.3",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",
@@ -46,7 +46,7 @@
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
-    "@angular/compiler": "20.0.0-next.1",
+    "@angular/compiler": "20.0.0-next.3",
     "rxjs": "^6.5.3 || ^7.4.0",
     "zone.js": "~0.15.0"
   },

package/primitives/di/index.d.ts

@@ -1,54 +1,9 @@
 /**
- * @license Angular v20.0.0-next.1
+ * @license Angular v20.0.0-next.3
  * (c) 2010-2025 Google LLC. https://angular.io/
  * License: MIT
  */
 
-
-export declare function getCurrentInjector(): Injector | undefined | null;
-
-/**
- * A `Type` which has a `ɵprov: ɵɵInjectableDeclaration` static field.
- *
- * `InjectableType`s contain their own Dependency Injection metadata and are usable in an
- * `InjectorDef`-based `StaticInjector`.
- *
- * @publicApi
- */
-export declare interface InjectionToken<T> extends Type<T> {
-    ɵprov: ɵɵInjectableDeclaration<T>;
-}
-
-export declare interface Injector {
-    retrieve?<T>(token: InjectionToken<T>, options?: unknown): T | NotFound;
-}
-
-/**
- * Type guard for checking if an unknown value is a NotFound.
- */
-export declare function isNotFound(e: unknown): e is NotFound;
-
-/**
- * Value returned if the key-value pair couldn't be found in the context
- * hierarchy.
- */
-export declare const NOT_FOUND: unique symbol;
-
-/**
- * Type union of NotFound and NotFoundError.
- */
-export declare type NotFound = typeof NOT_FOUND | NotFoundError;
-
-/**
- * Error thrown when the key-value pair couldn't be found in the context
- * hierarchy. Context can be attached below.
- */
-export declare class NotFoundError extends Error {
-    constructor(message: string);
-}
-
-export declare function setCurrentInjector(injector: Injector | null | undefined): Injector | undefined | null;
-
 /**
  * @description
  *
@@ -60,24 +15,37 @@ export declare function setCurrentInjector(injector: Injector | null | undefined
  * @publicApi
  */
 declare const Type: FunctionConstructor;
-
-declare interface Type<T> extends Function {
+interface Type<T> extends Function {
     new (...args: any[]): T;
 }
 
 /**
- * Information about how a type or `InjectionToken` interfaces with the DI system.
+ * Information about how a type or `InjectionToken` interfaces with the DI
+ * system. This describes:
  *
- * At a minimum, this includes a `factory` which defines how to create the given type `T`, possibly
- * requesting injection of other types if necessary.
+ * 1. *How* the type is provided
+ *    The declaration must specify only one of the following:
+ *    - A `value` which is a predefined instance of the type.
+ *    - A `factory` which defines how to create the given type `T`, possibly
+ *      requesting injection of other types if necessary.
+ *    - Neither, in which case the type is expected to already be present in the
+ *      injector hierarchy. This is used for internal use cases.
  *
- * Optionally, a `providedIn` parameter specifies that the given type belongs to a particular
- * `Injector`, `NgModule`, or a special scope (e.g. `'root'`). A value of `null` indicates
- * that the injectable does not belong to any scope.
+ * 2. *Where* the type is stored (if it is stored)
+ *    - The `providedIn` parameter specifies which injector the type belongs to.
+ *    - The `token` is used as the key to store the type in the injector.
  */
-export declare interface ɵɵInjectableDeclaration<T> {
+interface ɵɵInjectableDeclaration<T> {
     /**
-     * Specifies that the given type belongs to a particular injector:
+     * Specifies that the given type belongs to a particular `Injector`,
+     * `NgModule`, or a special scope (e.g. `'root'`).
+     *
+     * `any` is deprecated and will be removed soon.
+     *
+     * A value of `null` indicates that the injectable does not belong to any
+     * scope, and won't be stored in any injector. For declarations with a
+     * factory, this will create a new instance of the type each time it is
+     * requested.
      */
     providedIn: Type<any> | 'root' | 'platform' | 'any' | null;
     /**
@@ -89,11 +57,50 @@ export declare interface ɵɵInjectableDeclaration<T> {
     /**
      * Factory method to execute to create an instance of the injectable.
      */
-    factory: (t?: Type<any>) => T;
+    factory?: (t?: Type<any>) => T;
     /**
      * In a case of no explicit injector, a location where the instance of the injectable is stored.
      */
-    value: T | undefined;
+    value?: T;
+}
+/**
+ * A `Type` which has a `ɵprov: ɵɵInjectableDeclaration` static field.
+ *
+ * `InjectableType`s contain their own Dependency Injection metadata and are usable in an
+ * `InjectorDef`-based `StaticInjector`.
+ *
+ * @publicApi
+ */
+interface InjectionToken<T> {
+    ɵprov: ɵɵInjectableDeclaration<T>;
+}
+
+/**
+ * Value returned if the key-value pair couldn't be found in the context
+ * hierarchy.
+ */
+declare const NOT_FOUND: unique symbol;
+/**
+ * Error thrown when the key-value pair couldn't be found in the context
+ * hierarchy. Context can be attached below.
+ */
+declare class NotFoundError extends Error {
+    readonly name: string;
+    constructor(message: string);
+}
+/**
+ * Type guard for checking if an unknown value is a NotFound.
+ */
+declare function isNotFound(e: unknown): e is NotFound;
+/**
+ * Type union of NotFound and NotFoundError.
+ */
+type NotFound = typeof NOT_FOUND | NotFoundError;
+
+interface Injector {
+    retrieve<T>(token: InjectionToken<T>, options?: unknown): T | NotFound;
 }
+declare function getCurrentInjector(): Injector | undefined | null;
+declare function setCurrentInjector(injector: Injector | null | undefined): Injector | undefined | null;
 
-export { }
+export { type InjectionToken, type Injector, NOT_FOUND, type NotFound, NotFoundError, getCurrentInjector, isNotFound, setCurrentInjector, type ɵɵInjectableDeclaration };