@angular-wave/angular.ts 0.9.3 → 0.9.5

package/@types/interface.d.ts

@@ -4,25 +4,24 @@ export * from "./services/log/log.js";
 export * from "./services/location/interface.ts";
 export * from "./services/location/location.js";
 export * from "./services/pubsub/pubsub.js";
-export * from "./services/template-cache/interface.ts";
 export * from "./services/template-cache/template-cache.js";
 export * from "./index.js";
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
-import { NgModule } from "./core/di/ng-module.js";
-import { PubSubProvider, PubSub } from "./services/pubsub/pubsub.js";
-import type { ErrorHandlingConfig as iErrorHandlingConfig } from "./shared/interface.ts";
-declare global {
-  interface Function {
-    $inject?: readonly string[] | undefined;
-  }
-  namespace ng {
-    type Scope = InstanceType<typeof Scope>;
-    type NgModule = InstanceType<typeof NgModule>;
-    type PubSubProvider = InstanceType<typeof PubSubProvider>;
-    type PubSub = InstanceType<typeof PubSub>;
-    type ErrorHandlingConfig = iErrorHandlingConfig;
-  }
+/**
+ * Configuration options for the AngularTS bootstrap process.
+ *
+ * @property strictDi - If `true`, disables automatic function annotation
+ * for the application. This helps identify code that breaks under minification.
+ * Defaults to `false`.
+ */
+export interface AngularBootstrapConfig {
+  /**
+   * Disable automatic function annotation for the application.
+   * This helps find bugs that would break under minified code.
+   * Defaults to `false`.
+   */
+  strictDi?: boolean;
 }
 /**
  * A JavaScript expression represented as a string, typically used in interpolation bindings.
@@ -40,26 +39,39 @@ export type ExpandoStore = {
   };
 };
 /**
- * A dependency-annotated factory array used by AngularTS DI system.
- *
- * It consists of zero or more dependency names (as strings), followed by
- * a factory function that takes those dependencies as arguments.
+ * Dependency-annotated factory array used by AngularTS DI system.
  *
  * Example:
- * ```ts
- * ['dep1', 'dep2', function(dep1, dep2) { ... }]
- * ```
+ * ['dep1', 'dep2', (dep1, dep2) => new MyController(dep1, dep2)]
+ */
+export type AnnotatedFactory<TFunction extends (...args: any[]) => any> = [
+  ...string[],
+  TFunction,
+];
+/**
+ * A class (constructor function) that can be instantiated.
  */
-export type AnnotatedFactory = [...string[], (...args: any[]) => any];
-export type InjectableFactory = (...args: any[]) => any;
-export type InjectableClass = new (...args: any[]) => any;
+export type InjectableClass<TInstance = any> = new (...args: any) => TInstance;
 /**
- * A factory that can be either a standalone function or a dependency-annotated array or a class (constructor function).
+ * A factory that can be:
+ * - a standalone function,
+ * - a dependency-annotated array,
+ * - or a class constructor.
  *
- * The array form is used to support minification-safe dependency injection.
- * See {@link AnnotatedFactory}.
+ * Parentheses are required around constructor types when used in unions.
  */
-export type Injectable = AnnotatedFactory | InjectableFactory | InjectableClass;
+export type Injectable<
+  T extends ((...args: any[]) => any) | (abstract new (...args: any[]) => any),
+> =
+  | AnnotatedFactory<
+      T extends abstract new (...args: any[]) => any
+        ? (...args: ConstructorParameters<T>) => InstanceType<T>
+        : T
+    >
+  | (T extends abstract new (...args: any[]) => any
+      ? InjectableClass<InstanceType<T>>
+      : never)
+  | T;
 /**
  * An object that defines how a service is constructed.
  *
@@ -67,7 +79,7 @@ export type Injectable = AnnotatedFactory | InjectableFactory | InjectableClass;
  * either as a plain factory function or as an {@link AnnotatedFactory}.
  */
 export interface ServiceProvider {
-  $get: Injectable;
+  $get: Injectable<any>;
 }
 /**
  * The API for registering different types of providers with the injector.
@@ -103,13 +115,13 @@ export interface Provider {
    * @param name - The name of the service.
    * @param factoryFn - A function (or annotated array) that returns the service instance.
    */
-  factory(name: string, factoryFn: Injectable): Provider;
+  factory(name: string, factoryFn: Injectable<any>): Provider;
   /**
    * Register a constructor function to create a service.
    * @param name - The name of the service.
    * @param constructor - A class or function to instantiate.
    */
-  service(name: string, constructor: Injectable): Provider;
+  service(name: string, constructor: Injectable<any>): Provider;
   /**
    * Register a fixed value as a service.
    * @param name - The name of the service.
@@ -129,14 +141,6 @@ export interface Provider {
    */
   decorator(name: string, fn: Function): Provider;
 }
-/**
- * A filter function takes an input and optional arguments, and returns a transformed value.
- */
-export type FilterFn = (input: any, ...args: any[]) => any;
-/**
- * A filter factory function that returns a FilterFn.
- */
-export type FilterFactory = (...args: any[]) => FilterFn;
 /**
  * A controller constructor function used in AngularTS.
  */
@@ -170,23 +174,61 @@ export interface Controller {
   $postLink?: () => void;
 }
 /**
- * Defines a component's configuration object.
+ * Defines a component's configuration object (a simplified directive definition object).
  */
-export interface ComponentOptions {
-  /** Controller function or injectable string reference */
-  controller?: string | Injectable;
-  /** Alias name for the controller in templates */
-  controllerAs?: string;
-  /** Inline HTML template */
-  template?: string | Injectable;
-  /** URL of the HTML template */
-  templateUrl?: string | Injectable;
-  /** Binding definitions (e.g., `@`, `=`, `<`) */
-  bindings?: Record<string, string>;
-  /** Enable transclusion or specify named slots */
-  transclude?: boolean | Record<string, string>;
-  /** Required controllers from other directives */
-  require?: Record<string, string>;
+export interface Component {
+  controller?: string | Injectable<ControllerConstructor> | undefined;
+  /**
+   * An identifier name for a reference to the controller. If present, the controller will be published to its scope under
+   * the specified name. If not present, this will default to '$ctrl'.
+   */
+  controllerAs?: string | undefined;
+  /**
+   * html template as a string or a function that returns an html template as a string which should be used as the
+   * contents of this component. Empty string by default.
+   * If template is a function, then it is injected with the following locals:
+   * $element - Current element
+   * $attrs - Current attributes object for the element
+   * Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)
+   */
+  template?: string | Injectable<(...args: any[]) => string> | undefined;
+  /**
+   * Path or function that returns a path to an html template that should be used as the contents of this component.
+   * If templateUrl is a function, then it is injected with the following locals:
+   * $element - Current element
+   * $attrs - Current attributes object for the element
+   * Use the array form to define dependencies (necessary if strictDi is enabled and you require dependency injection)
+   */
+  templateUrl?: string | Injectable<(...args: any[]) => string> | undefined;
+  /**
+   * Define DOM attribute binding to component properties. Component properties are always bound to the component
+   * controller and not to the scope.
+   */
+  bindings?:
+    | {
+        [boundProperty: string]: string;
+      }
+    | undefined;
+  /**
+   * Whether transclusion is enabled. Disabled by default.
+   */
+  transclude?:
+    | boolean
+    | {
+        [slot: string]: string;
+      }
+    | undefined;
+  /**
+   * Requires the controllers of other directives and binds them to this component's controller.
+   * The object keys specify the property names under which the required controllers (object values) will be bound.
+   * Note that the required controllers will not be available during the instantiation of the controller,
+   * but they are guaranteed to be available just before the $onInit method is executed!
+   */
+  require?:
+    | {
+        [controller: string]: string;
+      }
+    | undefined;
 }
 /**
  * A controller instance or object map used in directives.
@@ -237,7 +279,7 @@ export interface Directive {
   /** Compile function for the directive */
   compile?: DirectiveCompileFn;
   /** Controller constructor or injectable string name */
-  controller?: string | Injectable | any;
+  controller?: string | Injectable<any> | any;
   /** Alias name for the controller in templates */
   controllerAs?: string;
   /** Whether to bind scope to controller */
@@ -350,30 +392,11 @@ export interface NgModelController {
   /** Current value shown in the view */
   $viewValue: any;
 }
+export interface RootElementService extends Element {}
 /**
- * Possible values for `data-swap` attribute
+ * The minimal local definitions required by $controller(ctrl, locals) calls.
  */
-export declare const SwapMode: {
-  /** (default) Replaces the contents inside the element */
-  readonly innerHTML: "innerHTML";
-  /** Replaces the entire element, including the tag itself */
-  readonly outerHTML: "outerHTML";
-  /** Inserts plain text (without parsing HTML) */
-  readonly textContent: "textContent";
-  /** Inserts HTML immediately before the element itself */
-  readonly beforebegin: "beforebegin";
-  /** Inserts HTML inside the element, before its first child */
-  readonly afterbegin: "afterbegin";
-  /** Inserts HTML inside the element, after its last child */
-  readonly beforeend: "beforeend";
-  /** Inserts HTML immediately after the element itself */
-  readonly afterend: "afterend";
-  /** Removes the element entirely */
-  readonly delete: "delete";
-  /** Performs no insertion (no-op) */
-  readonly none: "none";
-};
-/**
- * Union type representing all possible DOM insertion modes.
- */
-export type SwapModeType = keyof typeof SwapMode;
+export interface ControllerLocals {
+  $scope: Scope;
+  $element: Element;
+}

package/@types/namespace.d.ts

@@ -0,0 +1,76 @@
+export * from "./index.js";
+import {
+  AnchorScrollProvider,
+  AnchorScrollService as TAnchorScrollService,
+} from "./services/anchor-scroll/anchor-scroll.js";
+import { ControllerService as TControllerService } from "./core/controller/interface.ts";
+import { ErrorHandler } from "./services/exception/interface.ts";
+import { Angular } from "./angular.js";
+import { Attributes } from "./core/compile/attributes.js";
+import { Scope } from "./core/scope/scope.js";
+import { NgModule } from "./core/di/ng-module.js";
+import { PubSubProvider, PubSub } from "./services/pubsub/pubsub.js";
+import type { ErrorHandlingConfig as TErrorHandlingConfig } from "./shared/interface.ts";
+import { InjectorService } from "./core/di/internal-injector.js";
+import { CompileFn } from "./core/compile/compile.js";
+import { ParseService as TParseService } from "./core/parse/interface.ts";
+import { TemplateRequestService as TTemplateRequestService } from "./services/template-request/interface.ts";
+import { HttpParamSerializer } from "./services/http/interface.ts";
+import { HttpParamSerializerProvider } from "./services/http/http.js";
+import { FilterFactory, FilterFn as TFilterFn } from "./filters/interface.ts";
+import { InterpolateService as TInterpolateService } from "./core/interpolate/interface.ts";
+import { InterpolateProvider } from "./core/interpolate/interpolate.js";
+import { SceDelegateProvider, SceProvider } from "./services/sce/sce.js";
+import {
+  Directive as TDirective,
+  DirectiveFactory as TDirectiveFactory,
+  Component as TComponent,
+  Controller as TController,
+} from "./interface.ts";
+import { StateProvider } from "./router/state/state-service.js";
+import { HttpService as THttpService } from "./services/http/interface.ts";
+import { LogService as TLogService } from "./services/log/interface.ts";
+declare global {
+  interface Function {
+    $inject?: readonly string[] | undefined;
+  }
+  namespace ng {
+    type Angular = InstanceType<typeof Angular>;
+    type Attributes = InstanceType<typeof Attributes>;
+    type Directive = TDirective;
+    type DirectiveFactory = TDirectiveFactory;
+    type Component = TComponent;
+    type Controller = TController;
+    type Scope = InstanceType<typeof Scope>;
+    type NgModule = InstanceType<typeof NgModule>;
+    type PubSubProvider = InstanceType<typeof PubSubProvider>;
+    type FilterFn = TFilterFn;
+    type AnchorScrollProvider = InstanceType<typeof AnchorScrollProvider>;
+    type InterpolateProvider = InstanceType<typeof InterpolateProvider>;
+    type HttpParamSerializerProvider = InstanceType<
+      typeof HttpParamSerializerProvider
+    >;
+    type SceProvider = InstanceType<typeof SceProvider>;
+    type SceDelegateProvider = InstanceType<typeof SceDelegateProvider>;
+    type AnchorScrollService = TAnchorScrollService;
+    type CompileService = CompileFn;
+    type ControllerService = TControllerService;
+    type ExceptionHandlerService = ErrorHandler;
+    type FilterService = FilterFactory;
+    type HttpParamSerializerSerService = HttpParamSerializer;
+    type HttpService = THttpService;
+    type InterpolateService = TInterpolateService;
+    type InjectorService = InstanceType<typeof InjectorService>;
+    type LogService = TLogService;
+    type ParseService = TParseService;
+    type PubSubService = InstanceType<typeof PubSub>;
+    type RootElementService = Element;
+    type RootScopeService = InstanceType<typeof Scope>;
+    type StateService = InstanceType<typeof StateProvider>;
+    type TemplateCacheService = InstanceType<typeof Map<string, string>>;
+    type TemplateRequestService = TTemplateRequestService;
+    type ErrorHandlingConfig = TErrorHandlingConfig;
+    type WindowService = Window;
+    type DocumentService = Document;
+  }
+}

package/@types/router/state/interface.d.ts

@@ -179,7 +179,7 @@ export interface ViewDeclaration {
    * }
    * ```
    */
-  componentProvider?: Injectable;
+  componentProvider?: Injectable<any>;
   /**
    * The view's controller function or name
    *
@@ -193,7 +193,7 @@ export interface ViewDeclaration {
    *
    * See: [[Ng1Controller]] for information about component-level router hooks.
    */
-  controller?: Injectable | string;
+  controller?: Injectable<any> | string;
   /**
    * A controller alias name.
    *
@@ -227,7 +227,7 @@ export interface ViewDeclaration {
    * }
    * ```
    */
-  controllerProvider?: Injectable;
+  controllerProvider?: Injectable<any>;
   /**
    * The scope variable name to use for resolve data.
    *
@@ -302,7 +302,7 @@ export interface ViewDeclaration {
    * }
    * ```
    */
-  templateProvider?: Injectable;
+  templateProvider?: Injectable<any>;
 }
 /**
  * The return value of a [[redirectTo]] function
@@ -517,7 +517,7 @@ export interface StateDeclaration {
   resolve?:
     | ResolveTypes[]
     | {
-        [key: string]: Injectable;
+        [key: string]: Injectable<any>;
       };
   /**
    * Sets the resolve policy defaults for all resolves on this state
@@ -740,7 +740,7 @@ export interface StateDeclaration {
    * });
    * ```
    */
-  onEnter?: TransitionStateHookFn | Injectable;
+  onEnter?: TransitionStateHookFn | Injectable<any>;
   /**
    * A state hook invoked when a state is being retained.
    *
@@ -767,7 +767,7 @@ export interface StateDeclaration {
    * });
    * ```
    */
-  onRetain?: TransitionStateHookFn | Injectable;
+  onRetain?: TransitionStateHookFn | Injectable<any>;
   /**
    * A state hook invoked when a state is being exited.
    *
@@ -794,7 +794,7 @@ export interface StateDeclaration {
    * });
    * ```
    */
-  onExit?: TransitionStateHookFn | Injectable;
+  onExit?: TransitionStateHookFn | Injectable<any>;
   /**
    * A function used to lazy load code
    *

package/@types/router/state-filters.d.ts

@@ -9,11 +9,11 @@
  * ```
  *
  * @param {import('./state/state-service.js').StateProvider} $state
- * @returns {import('../interface.ts').FilterFn}
+ * @returns {ng.FilterFn}
  */
 export function $IsStateFilter(
   $state: import("./state/state-service.js").StateProvider,
-): import("../interface.ts").FilterFn;
+): ng.FilterFn;
 export namespace $IsStateFilter {
   let $inject: string[];
 }
@@ -28,11 +28,11 @@ export namespace $IsStateFilter {
  * ```
  *
  * @param {import('./state/state-service.js').StateProvider} $state
- * @returns {import('../interface.ts').FilterFn}
+ * @returns {ng.FilterFn}
  */
 export function $IncludedByStateFilter(
   $state: import("./state/state-service.js").StateProvider,
-): import("../interface.ts").FilterFn;
+): ng.FilterFn;
 export namespace $IncludedByStateFilter {
   let $inject_1: string[];
   export { $inject_1 as $inject };

package/@types/router/template-factory.d.ts

@@ -12,15 +12,15 @@ export class TemplateFactoryProvider {
   $get: (
     | string
     | ((
-        $http: any,
-        $templateCache: import("../services/template-cache/interface.ts").TemplateCache,
+        $http: ng.HttpService,
+        $templateCache: ng.TemplateCacheService,
         $templateRequest: any,
         $injector: import("../core/di/internal-injector.js").InjectorService,
       ) => this)
   )[];
   $templateRequest: any;
-  $http: any;
-  $templateCache: import("../interface.ts").TemplateCache;
+  $http: import("../interface.ts").HttpService;
+  $templateCache: Map<string, string>;
   $injector: import("../core/di/internal-injector.js").InjectorService;
   /**
    * Forces the provider to use $http service directly
@@ -69,25 +69,25 @@ export class TemplateFactoryProvider {
   /**
    * Creates a template by invoking an injectable provider function.
    *
-   * @param {import('../interface.ts').Injectable} provider Function to invoke via `locals`
+   * @param {import('../interface.ts').Injectable<any>} provider Function to invoke via `locals`
    * @param {Function} params a function used to invoke the template provider
    * @param {import("./resolve/resolve-context.js").ResolveContext} context
    * @return {string|Promise.<string>} The template html as a string, or a promise
    * for that string.
    */
   fromProvider(
-    provider: import("../interface.ts").Injectable,
+    provider: import("../interface.ts").Injectable<any>,
     params: Function,
     context: import("./resolve/resolve-context.js").ResolveContext,
   ): string | Promise<string>;
   /**
    * Creates a component's template by invoking an injectable provider function.
    *
-   * @param {import('../interface.ts').Injectable} provider Function to invoke via `locals`
+   * @param {import('../interface.ts').Injectable<any>} provider Function to invoke via `locals`
    * @return {Promise<any>} The template html as a string: "<component-name input1='::$resolve.foo'></component-name>".
    */
   fromComponentProvider(
-    provider: import("../interface.ts").Injectable,
+    provider: import("../interface.ts").Injectable<any>,
     context: any,
   ): Promise<any>;
   /**

package/@types/router/transition/hook-builder.d.ts

@@ -12,8 +12,11 @@
  * in the Transition class, so we must also provide the Transition's _treeChanges)
  */
 export class HookBuilder {
-  constructor(transition: any);
-  transition: any;
+  /**
+   * @param {import("./transition.js").Transition} transition
+   */
+  constructor(transition: import("./transition.js").Transition);
+  transition: import("./transition.js").Transition;
   /**
    * @param {TransitionHookPhase} phase
    * @returns

package/@types/router/transition/hook-registry.d.ts

@@ -26,15 +26,24 @@ export function makeEvent(
  * The registration data for a registered transition hook
  */
 export class RegisteredHook {
+  /**
+   * @param {import("./transition-service.js").TransitionProvider} tranSvc
+   * @param eventType
+   * @param callback
+   * @param matchCriteria
+   * @param removeHookFromRegistry
+   * @param options
+   */
   constructor(
-    tranSvc: any,
+    tranSvc: import("./transition-service.js").TransitionProvider,
     eventType: any,
     callback: any,
     matchCriteria: any,
     removeHookFromRegistry: any,
     options?: {},
   );
-  tranSvc: any;
+  /** @type {import("./transition-service.js").TransitionProvider} */
+  tranSvc: import("./transition-service.js").TransitionProvider;
   eventType: any;
   callback: any;
   matchCriteria: any;

package/@types/router/transition/transition-service.d.ts

@@ -37,7 +37,6 @@ export class TransitionProvider {
   globals: import("../router.js").Router;
   $view: any;
   _deregisterHookFns: {};
-  _pluginapi: any;
   $get: (
     | string
     | ((
@@ -94,7 +93,11 @@ export class TransitionProvider {
     getErrorHandler?: () => (error: any) => any,
     synchronous?: boolean,
   ): void;
-  _getEvents(phase: any): any[];
+  /**
+   * @param {TransitionHookPhase} [phase]
+   * @return {any[]}
+   */
+  _getEvents(phase?: TransitionHookPhase): any[];
   /**
    * Adds a Path to be used as a criterion against a TreeChanges path
    *
@@ -114,3 +117,4 @@ export class TransitionProvider {
   _registerCoreTransitionHooks(): void;
 }
 import { Transition } from "./transition.js";
+import { TransitionHookPhase } from "./interface.js";

package/@types/router/transition/transition.d.ts

@@ -289,9 +289,9 @@ export class Transition implements IHookRegistry {
    *
    * @internal
    *
-   * @returns a promise for a successful transition.
+   * @returns {Promise} a promise for a successful transition.
    */
-  run(): any;
+  run(): Promise<any>;
   success: boolean;
   _error: any;
   /**

package/@types/router/view/view.d.ts

@@ -17,15 +17,8 @@
 export class ViewService {
   _ngViews: any[];
   _viewConfigs: any[];
-  _viewConfigFactories: {};
   _listeners: any[];
-  _pluginapi: {
-    _registeredUIView: (id: any) => undefined;
-    _registeredUIViews: () => any[];
-    _activeViewConfigs: () => any[];
-    _onSync: (listener: any) => () => any;
-  };
-  $get: (() => this)[];
+  $get: () => this;
   /**
    * @param {?import('../state/state-object.js').StateObject} context
    * @return {?import('../state/state-object.js').StateObject}

package/@types/router/view-scroll.d.ts

@@ -4,7 +4,9 @@ export class ViewScrollProvider {
   $get: (
     | string
     | ((
-        $anchorScroll: import("../services/anchor-scroll.js").AnchorScrollObject,
-      ) => import("../services/anchor-scroll.js").AnchorScrollObject | Function)
+        $anchorScroll: import("../services/anchor-scroll/anchor-scroll.js").AnchorScrollObject,
+      ) =>
+        | import("../services/anchor-scroll/anchor-scroll.js").AnchorScrollObject
+        | Function)
   )[];
 }

package/@types/services/{anchor-scroll.d.ts → anchor-scroll/anchor-scroll.d.ts}

@@ -13,8 +13,8 @@ export class AnchorScrollProvider {
   $get: (
     | string
     | ((
-        $location: import("../services/location/location.js").Location,
-        $rootScope: import("../core/scope/scope.js").Scope,
+        $location: import("../../services/location/location.js").Location,
+        $rootScope: import("../../core/scope/scope.js").Scope,
       ) => AnchorScrollFunction)
   )[];
 }

package/@types/services/exception/exception-handler.d.ts

@@ -42,7 +42,7 @@
  * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
  */
 /** @typedef {import('../log/interface.ts').LogService} LogService */
-/** @typedef {import("./interface.ts").Interface}  ErrorHandler */
+/** @typedef {import("./interface.ts").ErrorHandler}  ErrorHandler */
 /**
  * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.
  * Can be overridden to implement custom error-handling logic.
@@ -55,4 +55,4 @@ export class ExceptionHandlerProvider {
   $get: (string | (($log: LogService) => ErrorHandler))[];
 }
 export type LogService = import("../log/interface.ts").LogService;
-export type ErrorHandler = import("./interface.ts").Interface;
+export type ErrorHandler = import("./interface.ts").ErrorHandler;

package/@types/services/exception/interface.d.ts

@@ -4,4 +4,4 @@
  * @param exception - The exception associated with the error.
  * @param [cause] - Optional information about the context in which the error was thrown.
  */
-export type Interface = (exception: Error, cause?: string) => void;
+export type ErrorHandler = (exception: Error, cause?: string) => void;