Type improvements

Author: Anatoly Ostrovsky

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

@@ -26,7 +26,7 @@ export class CompileProvider {
   /**
    * @param {string|Object} name Name of the component in camelCase (i.e. `myComp` which will match `<my-comp>`),
    *    or an object map of components where the keys are the names and the values are the component definition objects.
-   * @param {import("../../interface.js").ComponentOptions} options Component definition object (a simplified
+   * @param {import("../../interface.js").Component} options Component definition object (a simplified
    *    {directive definition object}),
    *    with the following properties (all optional):
    *
@@ -69,7 +69,7 @@ export class CompileProvider {
    */
   component: (
     name: string | any,
-    options: import("../../interface.js").ComponentOptions,
+    options: import("../../interface.js").Component,
   ) => CompileProvider;
   /**
    * Retrieves or overrides the default regular expression that is used for determining trusted safe

@types/core/di/ng-module.d.ts

@@ -74,12 +74,12 @@ export class NgModule {
   run(block: import("../../interface.ts").Injectable<any>): NgModule;
   /**
    * @param {string} name
-   * @param {import("../../interface.ts").ComponentOptions} options
+   * @param {import("../../interface.ts").Component} options
    * @returns {NgModule}
    */
   component(
     name: string,
-    options: import("../../interface.ts").ComponentOptions,
+    options: import("../../interface.ts").Component,
   ): NgModule;
   /**
    * @param {string} name

@types/directive/http/http.d.ts

@@ -12,35 +12,35 @@ export function getEventNameForElement(element: Element): EventType;
  * Handles DOM manipulation based on a swap strategy and server-rendered HTML.
  *
  * @param {string} html - The HTML string returned from the server.
- * @param {import("../../interface.ts").SwapModeType} swap
+ * @param {import("./interface.ts").SwapModeType} swap
  * @param {Element} target - The target DOM element to apply the swap to.
- * @param {import('../../core/scope/scope.js').Scope} scope
- * @param {import('../../core/compile/compile.js').CompileFn} $compile
+ * @param {ng.Scope} scope
+ * @param {ng.CompileService} $compile
  */
 export function handleSwapResponse(
   html: string,
-  swap: import("../../interface.ts").SwapModeType,
+  swap: import("./interface.ts").SwapModeType,
   target: Element,
-  scope: import("../../core/scope/scope.js").Scope,
-  $compile: import("../../core/compile/compile.js").CompileFn,
+  scope: ng.Scope,
+  $compile: ng.CompileService,
 ): void;
 /**
  * Creates an HTTP directive factory that supports GET, DELETE, POST, PUT.
  *
  * @param {"get" | "delete" | "post" | "put"} method - HTTP method to use.
  * @param {string} attrName - Attribute name containing the URL.
- * @returns {import('../../interface.ts').DirectiveFactory}
+ * @returns {ng.DirectiveFactory}
  */
 export function createHttpDirective(
   method: "get" | "delete" | "post" | "put",
   attrName: string,
-): import("../../interface.ts").DirectiveFactory;
-/** @type {import('../../interface.ts').DirectiveFactory} */
-export const ngGetDirective: import("../../interface.ts").DirectiveFactory;
-/** @type {import('../../interface.ts').DirectiveFactory} */
-export const ngDeleteDirective: import("../../interface.ts").DirectiveFactory;
-/** @type {import('../../interface.ts').DirectiveFactory} */
-export const ngPostDirective: import("../../interface.ts").DirectiveFactory;
-/** @type {import('../../interface.ts').DirectiveFactory} */
-export const ngPutDirective: import("../../interface.ts").DirectiveFactory;
+): ng.DirectiveFactory;
+/** @type {ng.DirectiveFactory} */
+export const ngGetDirective: ng.DirectiveFactory;
+/** @type {ng.DirectiveFactory} */
+export const ngDeleteDirective: ng.DirectiveFactory;
+/** @type {ng.DirectiveFactory} */
+export const ngPostDirective: ng.DirectiveFactory;
+/** @type {ng.DirectiveFactory} */
+export const ngPutDirective: ng.DirectiveFactory;
 export type EventType = "click" | "change" | "submit";

@types/directive/http/interface.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Possible values for `data-swap` attribute
+ */
+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;

@types/index.d.ts

@@ -32,13 +32,24 @@ 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";
 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>;
@@ -64,6 +75,7 @@ declare global {
     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;

@types/interface.d.ts

@@ -176,7 +176,7 @@ export interface Controller {
 /**
  * Defines a component's configuration object (a simplified directive definition object).
  */
-export interface ComponentOptions {
+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
@@ -392,33 +392,6 @@ export interface NgModelController {
   /** Current value shown in the view */
   $viewValue: any;
 }
-/**
- * Possible values for `data-swap` attribute
- */
-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 RootElementService extends Element {}
 /**
  * The minimal local definitions required by $controller(ctrl, locals) calls.