Time improvements

Author: tolyo

@types/core/compile/attributes.d.ts

@@ -1,6 +1,25 @@
+/**
+ * @extends {Record<string, any>}
+ */
 export class Attributes {
   static $nonscope: boolean;
   /**
+   * Creates an Attributes instance.
+   *
+   * There are two construction modes:
+   *
+   * 1. **Fresh instance** (no `attributesToCopy`):
+   *    - Used when compiling a DOM element for the first time.
+   *    - Initializes a new `$attr` map to track normalized → DOM attribute names.
+   *
+   * 2. **Clone instance** (`attributesToCopy` provided):
+   *    - Used when cloning attributes for directive linking / child scopes.
+   *    - Performs a shallow copy of all properties from the source Attributes object,
+   *      including `$attr`, normalized attribute values, and internal fields
+   *      (e.g. `$$observers`).
+   *    - `$attr` is intentionally **not reinitialized** in this case, because the
+   *      source object already contains the correct normalized → DOM attribute mapping.
+   *
    * @param {ng.AnimateService} $animate
    * @param {ng.ExceptionHandlerService} $exceptionHandler
    * @param {*} $sce
@@ -17,6 +36,10 @@ export class Attributes {
   _$animate: import("../../animations/interface.ts").AnimateService;
   _$exceptionHandler: import("../../services/exception/interface.ts").ExceptionHandler;
   _$sce: any;
+  /**
+   * A map of DOM element attribute names to the normalized name. This is needed
+   * to do reverse lookup from normalized name back to actual name.
+   */
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */
   $nodeRef: import("../../shared/noderef.js").NodeRef;
@@ -71,20 +94,21 @@ export class Attributes {
     attrName?: string | undefined,
   ): void;
   /**
+     * @template T
      * Observes an interpolated attribute.
      *
      * The observer function will be invoked once during the next `$digest` following
      * compilation. The observer is then invoked whenever the interpolated value
      * changes.
      *
      * @param {string} key Normalized key. (ie ngAttribute) .
-     * @param {any} fn Function that will be called whenever
+     * @param {(value?: T) => any} fn Function that will be called whenever
               the interpolated value of the attribute changes.
     *        See the {@link guide/interpolation#how-text-and-attribute-bindings-work Interpolation
     *        guide} for more info.
-    * @returns {function()} Returns a deregistration function for this observer.
+    * @returns {Function} Returns a deregistration function for this observer.
     */
-  $observe(key: string, fn: any): () => any;
+  $observe<T>(key: string, fn: (value?: T) => any): Function;
   $$observers: any;
   setSpecialAttr(element: any, attrName: any, value: any): void;
   /**

@types/core/scope/interface.d.ts

@@ -10,3 +10,29 @@ export interface Listener {
   watchProp?: string;
   foreignListener?: ProxyConstructor;
 }
+export interface ScopeEvent {
+  /**
+   * the scope on which the event was $emit-ed or $broadcast-ed.
+   */
+  targetScope: ng.Scope;
+  /**
+   * the scope that is currently handling the event. Once the event propagates through the scope hierarchy, this property is set to null.
+   */
+  currentScope: ng.Scope;
+  /**
+   * name of the event.
+   */
+  name: string;
+  /**
+   * calling stopPropagation function will cancel further event propagation (available only for events that were $emit-ed).
+   */
+  stopPropagation?(): void;
+  /**
+   * calling preventDefault sets defaultPrevented flag to true.
+   */
+  preventDefault(): void;
+  /**
+   * true if preventDefault was called.
+   */
+  defaultPrevented: boolean;
+}

@types/namespace.d.ts

@@ -5,6 +5,7 @@ import { Scope as TScope } from "./core/scope/scope.js";
 import {
   ListenerFn as TListenerFn,
   Listener as TListener,
+  ScopeEvent as TScopeEvent,
 } from "./core/scope/interface.ts";
 import { NgModule as TNgModule } from "./core/di/ng-module/ng-module.js";
 import { InjectorService as TInjectorService } from "./core/di/internal-injector.js";
@@ -107,6 +108,10 @@ import { StateObject as TStateObject } from "./router/state/state-object.js";
 import { StateRegistryProvider as TStateRegistryProvider } from "./router/state/state-registry.js";
 import { ViewScrollService as TViewScrollService } from "./router/scroll/interface.ts";
 import { HookRegistry } from "./router/transition/interface.ts";
+import {
+  SCEService as TSCEService,
+  SCEDelegateService as TSCEDelegateService,
+} from "./services/sce/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
@@ -166,6 +171,8 @@ declare global {
     type RouterService = TRouterProvider;
     type StateService = TStateProvider;
     type StateRegistryService = TStateRegistryProvider;
+    type SCEService = TSCEService;
+    type SCEDelegateService = TSCEDelegateService;
     type SseService = TSseService;
     type SseConfig = TSseConfig;
     type TransitionService = TransitionProvider & HookRegistry;
@@ -206,5 +213,6 @@ declare global {
     type AnchorScrollFunction = TAnchorScrollFunction;
     type AnchorScrollObject = TAnchorScrollObject;
     type InjectionTokens = typeof PublicInjectionTokens;
+    type ScopeEvent = TScopeEvent;
   }
 }

@types/services/sce/interface.d.ts

@@ -0,0 +1,25 @@
+export interface SCEService {
+  getTrusted(type: string, mayBeTrusted: any): any;
+  getTrustedCss(value: any): any;
+  getTrustedHtml(value: any): any;
+  getTrustedJs(value: any): any;
+  getTrustedResourceUrl(value: any): any;
+  getTrustedUrl(value: any): any;
+  parse(type: string, expression: string): (context: any, locals: any) => any;
+  parseAsCss(expression: string): (context: any, locals: any) => any;
+  parseAsHtml(expression: string): (context: any, locals: any) => any;
+  parseAsJs(expression: string): (context: any, locals: any) => any;
+  parseAsResourceUrl(expression: string): (context: any, locals: any) => any;
+  parseAsUrl(expression: string): (context: any, locals: any) => any;
+  trustAs(type: string, value: any): any;
+  trustAsHtml(value: any): any;
+  trustAsJs(value: any): any;
+  trustAsResourceUrl(value: any): any;
+  trustAsUrl(value: any): any;
+  isEnabled(): boolean;
+}
+export interface SCEDelegateService {
+  getTrusted(type: string, mayBeTrusted: any): any;
+  trustAs(type: string, value: any): any;
+  valueOf(value: any): any;
+}