@angular/core 20.0.0-next.0 → 20.0.0-next.2

package/navigation_types.d-u4EOrrdZ.d.ts

@@ -0,0 +1,121 @@
+/**
+ * @license Angular v20.0.0-next.2
+ * (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.0",
+  "version": "20.0.0-next.2",
   "description": "Angular - the core framework",
   "author": "angular",
   "license": "MIT",
@@ -21,6 +21,10 @@
       "types": "./index.d.ts",
       "default": "./fesm2022/core.mjs"
     },
+    "./primitives/di": {
+      "types": "./primitives/di/index.d.ts",
+      "default": "./fesm2022/primitives/di.mjs"
+    },
     "./primitives/event-dispatch": {
       "types": "./primitives/event-dispatch/index.d.ts",
       "default": "./fesm2022/primitives/event-dispatch.mjs"
@@ -42,9 +46,15 @@
     "tslib": "^2.3.0"
   },
   "peerDependencies": {
+    "@angular/compiler": "20.0.0-next.2",
     "rxjs": "^6.5.3 || ^7.4.0",
     "zone.js": "~0.15.0"
   },
+  "peerDependenciesMeta": {
+    "@angular/compiler": {
+      "optional": true
+    }
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/angular/angular.git",

package/primitives/di/index.d.ts

@@ -0,0 +1,91 @@
+/**
+ * @license Angular v20.0.0-next.2
+ * (c) 2010-2025 Google LLC. https://angular.io/
+ * License: MIT
+ */
+
+/**
+ * @description
+ *
+ * Represents a type that a Component or other object is instances of.
+ *
+ * An example of a `Type` is `MyCustomComponent` class, which in JavaScript is represented by
+ * the `MyCustomComponent` constructor function.
+ *
+ * @publicApi
+ */
+declare const Type: FunctionConstructor;
+interface Type<T> extends Function {
+    new (...args: any[]): T;
+}
+
+/**
+ * Information about how a type or `InjectionToken` interfaces with the DI system.
+ *
+ * At a minimum, this includes a `factory` which defines how to create the given type `T`, possibly
+ * requesting injection of other types if necessary.
+ *
+ * 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.
+ */
+interface ɵɵInjectableDeclaration<T> {
+    /**
+     * Specifies that the given type belongs to a particular injector:
+     */
+    providedIn: Type<any> | 'root' | 'platform' | 'any' | null;
+    /**
+     * The token to which this definition belongs.
+     *
+     * Note that this may not be the same as the type that the `factory` will create.
+     */
+    token: unknown;
+    /**
+     * Factory method to execute to create an instance of the injectable.
+     */
+    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;
+}
+/**
+ * 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 {
+    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 { type InjectionToken, type Injector, NOT_FOUND, type NotFound, NotFoundError, getCurrentInjector, isNotFound, setCurrentInjector, type ɵɵInjectableDeclaration };