@angular-wave/angular.ts 0.18.0 → 0.19.0

package/@types/animations/queue/interface.d.ts

@@ -1,4 +1,5 @@
 import { AnimateRunner } from "../runner/animate-runner.js";
+import { AnimationEventData } from "../interface.ts";
 export type QueuePhase =
   | "start"
   | "close"
@@ -6,13 +7,9 @@ export type QueuePhase =
   | "progress"
   | "dom"
   | string;
-export interface QueueAnimationData {
-  addClass: string | null;
-  removeClass: string | null;
-  from: Record<string, any> | null;
-  to: Record<string, any> | null;
+export type QueueAnimationData = AnimationEventData & {
   [key: string]: any;
-}
+};
 export interface AnimateQueueService {
   on(
     event: string,
@@ -24,7 +21,7 @@ export interface AnimateQueueService {
     ) => void,
   ): void;
   off(
-    event: string,
+    event: string | Element,
     container?: Element,
     callback?: (
       el: Element,
@@ -48,3 +45,13 @@ export interface AnimateQueueService {
     domOperation?: () => void,
   ): AnimateRunner;
 }
+export type AnimateEventCallback = (
+  el: Element,
+  phase: QueuePhase,
+  data: QueueAnimationData,
+) => void;
+export interface CallbackRegistryEntry {
+  node: Element;
+  callback: AnimateEventCallback;
+}
+export type CallbackRegistry = Record<string, CallbackRegistryEntry[] | null>;

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

@@ -110,7 +110,7 @@ export class Attributes {
     * @returns {Function} Returns a deregistration function for this observer.
     */
   $observe<T>(key: string, fn: (value?: T) => any): Function;
-  _observers: any;
+  _observers: Record<string, any>;
   /**
    * Sets a special (non-standard) attribute on an element.
    *

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

@@ -2,11 +2,11 @@ export const DirectiveSuffix: "Directive";
 export class CompileProvider {
   static $inject: string[];
   /**
-   * @param {import('../../interface.ts').Provider} $provide
+   * @param {ng.ProvideService} $provide
    * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $sanitizeUriProvider
    */
   constructor(
-    $provide: import("../../interface.ts").Provider,
+    $provide: ng.ProvideService,
     $sanitizeUriProvider: import("../sanitize/sanitize-uri.js").SanitizeUriProvider,
   );
   /**
@@ -15,13 +15,13 @@ export class CompileProvider {
    * @param {string|Object} name Name of the directive in camel-case (i.e. `ngBind` which will match
    *    as `ng-bind`), or an object map of directives where the keys are the names and the values
    *    are the factories.
-   * @param {Function|Array} directiveFactory An injectable directive factory function. See the
+   * @param {Function|Array<Function>} directiveFactory An injectable directive factory function. See the
    *    {@link guide/directive directive guide} and the {@link $compile compile API} for more info.
    * @returns {CompileProvider} Self for chaining.
    */
   directive: (
     name: string | any,
-    directiveFactory: Function | any[],
+    directiveFactory: Function | Array<Function>,
   ) => CompileProvider;
   /**
    * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
@@ -101,13 +101,16 @@ export class CompileProvider {
    * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
    *
    * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|import('../sanitize/sanitize-uri.js').SanitizeUriProvider} Current RegExp if called without value or self for
+   * @returns {RegExp|import('../sanitize/sanitize-uri.js').SanitizeUriProvider | undefined} Current RegExp if called without value or self for
    *    chaining otherwise.
    */
   imgSrcSanitizationTrustedUrlList: (
     regexp?: RegExp | undefined,
-  ) => RegExp | import("../sanitize/sanitize-uri.js").SanitizeUriProvider;
-  strictComponentBindingsEnabled: (enabled: any) => boolean | this;
+  ) =>
+    | RegExp
+    | import("../sanitize/sanitize-uri.js").SanitizeUriProvider
+    | undefined;
+  strictComponentBindingsEnabled: (enabled: boolean) => boolean | this;
   /**
    * Defines the security context for DOM properties bound by ng-prop-*.
    *
@@ -129,15 +132,22 @@ export class CompileProvider {
         $exceptionHandler: ng.ExceptionHandlerService,
         $templateRequest: ng.TemplateRequestService,
         $parse: ng.ParseService,
-        $controller: any,
+        $controller: ng.ControllerService,
         $sce: ng.SceService,
         $animate: ng.AnimateService,
-      ) => (
-        compileNode: string | Element | Node | ChildNode | NodeList,
-        transcludeFn?: import("./interface.ts").TranscludeFn,
-        maxPriority?: number,
-        ignoreDirective?: string,
-        previousCompileContext?: any,
-      ) => import("./interface.ts").PublicLinkFn)
+      ) => ng.CompileService)
   )[];
 }
+export type BoundTranscludeFn = import("./interface.ts").BoundTranscludeFn;
+export type ChildTranscludeOrLinkFn =
+  import("./interface.ts").ChildTranscludeOrLinkFn;
+export type CloneAttachFn = import("./interface.ts").CloneAttachFn;
+export type CompileNodesFn = import("./interface.ts").CompileNodesFn;
+export type CompositeLinkFn = import("./interface.ts").CompositeLinkFn;
+export type NodeLinkFn = import("./interface.ts").NodeLinkFn;
+export type NodeLinkFnCtx = import("./interface.ts").NodeLinkFnCtx;
+export type PreviousCompileContext =
+  import("./interface.ts").PreviousCompileContext;
+export type PublicLinkFn = import("./interface.ts").PublicLinkFn;
+export type TranscludedNodes = import("./interface.ts").TranscludedNodes;
+export type InternalDirective = import("./interface.ts").InternalDirective;

package/@types/core/compile/interface.d.ts

@@ -1,8 +1,19 @@
 import type { Scope } from "../scope/scope.js";
 import type { NodeRef } from "../../shared/noderef.js";
-type TranscludedNodes = Node | Node[] | NodeList | null;
-type TranscludeFnCb = (clone?: TranscludedNodes, scope?: Scope | null) => void;
+export type TranscludedNodes = Node | Node[] | NodeList | null;
 export type ChildTranscludeOrLinkFn = TranscludeFn | PublicLinkFn;
+/**
+ * Callback used when transcluded content is cloned.
+ */
+export type CloneAttachFn = (
+  clone?: TranscludedNodes,
+  scope?: Scope | null,
+) => any;
+export interface TemplateLinkingFunctionOptions {
+  _parentBoundTranscludeFn?: BoundTranscludeFn | null;
+  transcludeControllers?: unknown;
+  _futureParentElement?: Node | Element | null | undefined;
+}
 /**
  * A function passed as the fifth argument to a `PublicLinkFn` link function.
  * It behaves like a linking function, with the `scope` argument automatically created
@@ -11,35 +22,56 @@ export type ChildTranscludeOrLinkFn = TranscludeFn | PublicLinkFn;
  * The function returns the DOM content to be injected (transcluded) into the directive.
  */
 export type TranscludeFn = {
-  (cb: TranscludeFnCb): void;
-  (scope: Scope, cb?: TranscludeFnCb): void;
-  _slots?: any;
+  /**
+   * $transclude(cloneAttachFn, futureParentElement?, slotName?)
+   * (no explicit scope passed)
+   */
+  (
+    cloneAttachFn: CloneAttachFn,
+    futureParentElement?: Node | Element | null,
+    slotName?: string | number,
+  ): TranscludedNodes | void;
+  /**
+   * $transclude(scope?, cloneAttachFn?, futureParentElement?, slotName?)
+   * (scope-first form)
+   */
+  (
+    scope?: Scope | null,
+    cloneAttachFn?: CloneAttachFn,
+    futureParentElement?: Node | Element | null,
+    slotName?: string | number,
+  ): TranscludedNodes | void;
+  /**
+   * Internal call path that threads link options.
+   */
+  (
+    scope?: Scope | null,
+    cloneAttachFn?: CloneAttachFn,
+    options?: TemplateLinkingFunctionOptions,
+  ): TranscludedNodes | void;
+  /** Slot transclusion functions (if the parent declared slots). */
+  _slots?: Record<string | number, TranscludeFn | null>;
+  /** Added by your `controllersBoundTransclude` wrapper. */
+  isSlotFilled?: (slotName: string | number) => boolean;
+  /** Internal: unwraps to the bound transclude when threaded through link options. */
+  _boundTransclude?: BoundTranscludeFn;
 };
-export type CloneAttachFn = (
-  clone: Node | Element | NodeList,
-  scope?: Scope,
-) => void;
 /**
- * A specialized version of `TranscludeFn` with the scope argument already bound.
- * This function requires no parameters and returns the same result as `TranscludeFn`.
+ * A specialized version of `TranscludeFn` with the parent scope already bound.
+ * Used internally to thread controller context and future parent elements.
  */
 export interface BoundTranscludeFn {
   (
-    scope?: Scope,
+    transcludedScope?: Scope | null,
     cloneAttachFn?: CloneAttachFn,
-    transcludeControllers?: unknown,
-    _futureParentElement?: Node | Element,
-    scopeToChild?: Scope,
-  ): Node | Element | NodeList;
-  _slots: Record<string, SlotTranscludeFn | null | undefined>;
+    controllers?: unknown,
+    futureParentElement?: Node | Element | null,
+    containingScope?: Scope,
+  ): TranscludedNodes | void;
+  _slots: Record<string | number, BoundTranscludeFn | null>;
+  _boundTransclude?: BoundTranscludeFn;
 }
-export type SlotTranscludeFn = (
-  scope?: Scope,
-  cloneAttachFn?: CloneAttachFn,
-  transcludeControllers?: unknown,
-  _futureParentElement?: Node | Element,
-  scopeToChild?: Scope,
-) => Node | Element | NodeList;
+export type SlotTranscludeFn = BoundTranscludeFn;
 /**
  * Represents a simple change in a watched value.
  */
@@ -53,8 +85,8 @@ export interface SimpleChange {
 export type PublicLinkFn = {
   (
     scope: Scope,
-    cloneConnectFn?: TranscludeFn,
-    options?: any,
+    cloneAttachFn?: CloneAttachFn,
+    options?: TemplateLinkingFunctionOptions,
   ): Element | Node | ChildNode | Node[];
   pre?: any;
   post?: any;
@@ -63,8 +95,8 @@ export type PublicLinkFn = {
  * Entry point for the `$compile` service.
  */
 export type CompileFn = (
-  compileNode: string | Element | Node | ChildNode | NodeList,
-  transcludeFn?: TranscludeFn,
+  compileNode: string | Element | Node | ChildNode | NodeList | null,
+  transcludeFn?: ChildTranscludeOrLinkFn | null,
   maxPriority?: number,
   ignoreDirective?: string,
   previousCompileContext?: any,
@@ -75,12 +107,46 @@ export type CompileFn = (
 export interface LinkFnMapping {
   index: number;
   nodeLinkFnCtx?: NodeLinkFnCtx;
-  childLinkFn?: CompositeLinkFn;
+  childLinkFn?: CompositeLinkFn | null;
 }
 /**
- * Function that compiles a list of nodes and returns a composite linking function.
+ * Compiles a node (or list of nodes) into a single composite link function.
+ *
+ * For each node in `nodeRefList`:
+ * 1) Collect and sort matching directives.
+ * 2) Apply directives to produce an optional node link function/context.
+ * 3) Recursively compile child nodes (unless a terminal directive stops recursion).
+ * 4) Return a composite link function that links all nodes (and their children) in order.
+ *
+ * Notes:
+ * - `transcludeFn` is the “thing passed down” to directives as `$transclude`. Depending on phase,
+ *   it may be a `TranscludeFn` (real transclusion function), a `PublicLinkFn` (compiled link fn),
+ *   or `null` (no transclusion).
+ * - `previousCompileContext` carries internal bookkeeping for replace/transclusion/templateUrl and
+ *   is only applied to the first node in a virtual group.
  */
-export type CompileNodesFn = () => CompositeLinkFn;
+export type CompileNodesFn = (
+  /**
+   * NodeRef wrapping either a single Node/Element or a list (e.g. NodeList/array-like).
+   */
+  nodeRefList: NodeRef | null,
+  /**
+   * Parent transclusion/link function passed down to directives and child compilation.
+   */
+  transcludeFn?: ChildTranscludeOrLinkFn,
+  /**
+   * If provided, only directives with `priority < maxPriority` are applied to the first node.
+   */
+  maxPriority?: number,
+  /**
+   * Normalized directive name to ignore on the first node (prevents re-applying the triggering directive).
+   */
+  ignoreDirective?: string,
+  /**
+   * Internal bookkeeping used across re-compilation passes (replace, element transclusion, templateUrl).
+   */
+  previousCompileContext?: PreviousCompileContext | null,
+) => CompositeLinkFn | null;
 export type ChildLinkFn = (
   scope: Scope,
   nodeRef: NodeRef,
@@ -90,7 +156,7 @@ export type ChildLinkFn = (
  * A function used to link a specific node.
  */
 export type NodeLinkFn = (
-  childLinkFn: ChildLinkFn | null,
+  childLinkFn: ChildLinkFn | CompositeLinkFn | null | undefined,
   scope: Scope,
   node: Node | Element,
   boundTranscludeFn: BoundTranscludeFn | null,
@@ -116,6 +182,115 @@ export type ApplyDirectivesToNodeFn = () => NodeLinkFn;
 export type CompositeLinkFn = (
   scope: Scope,
   $linkNode: NodeRef,
-  _parentBoundTranscludeFn?: Function,
+  _parentBoundTranscludeFn?: BoundTranscludeFn | null,
 ) => void;
-export {};
+/**
+ * Internal compile bookkeeping passed through compile/compileNodes/applyDirectivesToNode.
+ * Used to preserve state across re-compilation passes (replace, transclusion, templateUrl),
+ * and to coordinate virtual-group indexing.
+ */
+export interface PreviousCompileContext {
+  /** Index of the current node inside the parent NodeRef list (virtual group position). */
+  index?: number;
+  /** The parent NodeRef list that the current node belongs to (used when replaced nodes must be re-indexed). */
+  parentNodeRef?: NodeRef;
+  /**
+   * Mutable NodeRef pointing at the “current” compile node for this context.
+   * Updated when directives replace or element-transclude the node (e.g. comment anchor).
+   */
+  ctxNodeRef?: NodeRef;
+  /**
+   * When true, linking must create a fresh scope anchor because a parent replace+transclusion
+   * removed the element that would normally hold the transclusion scope.
+   * Consumed by `publicLinkFn` to do `scope.$parent?.$new()` in that edge case.
+   */
+  needsNewScope?: boolean;
+  /**
+   * True if an element-transcluding directive has been applied (transclude === "element").
+   * Affects how controllers/transclusion are resolved and how templateUrl linking re-attaches nodes.
+   */
+  hasElementTranscludeDirective?: boolean;
+  /**
+   * The directive that requested “non-terminal” (non-TLB) transclusion most recently.
+   * Used to detect and throw on multiple transclusion directives on the same element
+   * (except whitelisted ones like ngIf/ngRepeat).
+   */
+  _nonTlbTranscludeDirective?: ng.Directive | null;
+  /**
+   * A “future” parent element passed through transclusion/linking so that namespace detection
+   * and transcluded node insertion can use the correct DOM parent (especially with replace/element transclusion).
+   */
+  _futureParentElement?: Node | Element | null;
+  /**
+   * Map of directive-name -> directive definition for directives on this element that declare controllers.
+   * Carried forward so controllers can be instantiated once and then wired during linking.
+   */
+  _controllerDirectives?: Record<string, ng.Directive> | null;
+  /**
+   * The directive responsible for creating a new child scope on this element (scope: true).
+   * Carried forward so templates/directives can be marked to inherit scope correctly after replace/transclusion.
+   */
+  _newScopeDirective?: ng.Directive | null;
+  /**
+   * The directive responsible for creating an isolate scope on this element (scope: {}).
+   * Carried forward so template directives can be marked and so linking can create the isolate scope once.
+   */
+  _newIsolateScopeDirective?: ng.Directive | null;
+  /**
+   * The directive that provided the active template/templateUrl for this element.
+   * Used to prevent multiple template directives and to coordinate replace/templateUrl compilation passes.
+   */
+  _templateDirective?: ng.Directive | null;
+}
+/**
+ * An internal augmentation of a directive definition object (DDO) used by the compiler.
+ *
+ * This extends `ng.Directive` with fields that AngularTS attaches during directive registration
+ * and compilation (e.g. sorting metadata, binding caches, template bookkeeping).
+ */
+export interface InternalDirective extends ng.Directive {
+  /**
+   * Normalized directive name (camelCase), e.g. `ngIf`.
+   * Typically set during registration.
+   */
+  name: string;
+  /**
+   * Directive priority used to order directive application during compilation.
+   * Higher priorities run first.
+   */
+  priority?: number;
+  /**
+   * Registration index (used as a stable tiebreaker when priorities and names match).
+   */
+  index?: number;
+  /**
+   * Parsed bindings metadata for isolate scope and/or bindToController.
+   * Populated by the compiler to avoid re-parsing.
+   */
+  _bindings?: any;
+  /**
+   * Parsed isolate-scope binding definitions (e.g. `{ foo: '@', bar: '=' }` expanded form).
+   * Typically derived from `_bindings.isolateScope`.
+   */
+  _isolateBindings?: any;
+  /**
+   * Marks that this directive (or one it was merged into) requires an isolate scope.
+   * Used for bookkeeping across template/replace/transclusion compilation passes.
+   */
+  _isolateScope?: boolean;
+  /**
+   * Marks that this directive (or one it was merged into) requires a new child scope.
+   * Used for bookkeeping across template/replace/transclusion compilation passes.
+   */
+  _newScope?: boolean;
+  /**
+   * When an async `templateUrl` directive is converted into a derived sync directive,
+   * this points back to the original directive.
+   */
+  _originalDirective?: any;
+  /**
+   * Template namespace hint (e.g. `"svg"`), used when wrapping templates or compiling
+   * non-HTML content.
+   */
+  templateNamespace?: string;
+}

package/@types/core/controller/controller.d.ts

@@ -1,54 +1,46 @@
-export function identifierForController(controller: any, ident: any): string;
 /**
- * The {@link ng.$controller $controller service} is used by AngularTS to create new
- * controllers.
- *
- * This provider allows controller registration via the
- * {@link ng.$controllerProvider#register register} method.
+ * @param {string | InjectableController | undefined} controller
+ * @param {string} [ident]
+ * @returns {string|undefined}
  */
+export function identifierForController(
+  controller: string | InjectableController | undefined,
+  ident?: string,
+): string | undefined;
 export class ControllerProvider {
-  /**
-   * @type {Map<string, Function|Object>}
-   * @private
-   */
+  /** @type {Map<string, InjectableController>} @private */
   private controllers;
-  /**
-   * Check if a controller with a given name exists.
-   *
-   * @param {string} name Controller name to check.
-   * @returns {boolean} True if the controller exists, false otherwise.
-   */
+  /** @param {string} name @returns {boolean} */
   has(name: string): boolean;
   /**
-   * Register a controller.
-   *
-   * @param {string|Object} name Controller name, or an object map of controllers where the keys are
-   *    the names and the values are the constructors.
-   * @param {Function|Array} constructor Controller constructor function (optionally decorated with DI
-   *    annotations in the array notation).
+   * @param {string | Record<string, unknown>} name
+   * @param {unknown} [constructor]
    */
-  register(name: string | any, constructor: Function | any[]): void;
+  register(name: string | Record<string, unknown>, constructor?: unknown): void;
   /**
-   * $get method for dependency injection.
+   * @type {import("../../interface.ts").Injectable<($injector: ng.InjectorService) => ControllerService>}
    */
-  $get: (
-    | string
-    | ((
-        $injector: ng.InjectorService,
-      ) => import("./interface.ts").ControllerService)
-  )[];
+  $get: import("../../interface.ts").Injectable<
+    ($injector: ng.InjectorService) => ControllerService
+  >;
   /**
-   * Adds an identifier to the controller instance in the given locals' scope.
-   *
-   * @param {Object} locals The locals object containing the scope.
-   * @param {string} identifier The identifier to assign.
-   * @param {Object} instance The controller instance.
-   * @param {string} name The name of the controller.
+   * @param {ControllerLocals | undefined} locals
+   * @param {string} identifier
+   * @param {object} instance
+   * @param {string} name
    */
   addIdentifier(
-    locals: any,
+    locals: ControllerLocals | undefined,
     identifier: string,
-    instance: any,
+    instance: object,
     name: string,
   ): void;
 }
+export type ControllerConstructor =
+  import("../../interface.ts").ControllerConstructor;
+export type InjectableController =
+  import("../../interface.ts").Injectable<ControllerConstructor>;
+export type ControllerService = import("./interface.ts").ControllerService;
+export type ControllerLocals = import("./interface.ts").ControllerLocals;
+export type ControllerExpression =
+  import("./interface.ts").ControllerExpression;

package/@types/core/controller/interface.d.ts

@@ -1,6 +1,15 @@
+import { ControllerConstructor, Injectable } from "../../interface.ts";
+/**
+ * The minimal local definitions required by $controller(ctrl, locals) calls.
+ */
+export interface ControllerLocals {
+  $scope: ng.Scope;
+  $element: Element;
+}
 export type ControllerService = (
-  expression: string | Function | ng.AnnotatedFactory<any>,
-  locals?: Record<string, any>,
+  expression: ControllerExpression,
+  locals?: ControllerLocals,
   later?: boolean,
   ident?: string,
-) => object | (() => object);
+) => any | (() => any);
+export type ControllerExpression = string | Injectable<ControllerConstructor>;

package/@types/core/parse/interface.d.ts

@@ -19,7 +19,7 @@ export interface CompiledExpressionProps {
    * Assigns a value to a context.
    * If value is not provided, may return the getter.
    */
-  _assign?: (context: any, value: any) => any;
+  _assign?: (scope: ng.Scope, value: any, locals?: object) => any;
 }
 /**
  * Expression function with context and optional locals/assign.
@@ -28,7 +28,7 @@ export interface CompiledExpressionProps {
 export type CompiledExpressionFunction = (
   context?: Scope | typeof Proxy<Scope>,
   locals?: object,
-  assign?: any,
+  _assign?: any,
 ) => any;
 /**
  * A compiled expression that is both a function and includes expression metadata.