@angular-wave/angular.ts 0.9.8 → 0.9.9

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

@@ -135,67 +135,10 @@ export class CompileProvider {
         $animate: any,
       ) => (
         compileNode: string | Element | Node | ChildNode | NodeList,
-        transcludeFn?: TranscludeFn,
+        transcludeFn?: import("./inteface.ts").TranscludeFn,
         maxPriority?: number,
         ignoreDirective?: string,
         previousCompileContext?: any,
-      ) => PublicLinkFn)
+      ) => import("./inteface.ts").PublicLinkFn)
   )[];
 }
-/**
- * A function passed as the fifth argument to a {@type PublicLinkFn} link function.
- * It behaves like a linking function, with the `scope` argument automatically created
- * as a new child of the transcluded parent scope.
- *
- * The function returns the DOM content to be injected (transcluded) into the directive.
- */
-export type TranscludeFn = (
-  clone?: Element | Node | ChildNode | NodeList | Node[],
-  scope?: import("../scope/scope.js").Scope,
-) => any;
-/**
- * A function passed as the fifth argument to a {@type PublicLinkFn} link function.
- * It behaves like a linking function, with the `scope` argument automatically created
- * as a new child of the transcluded parent scope.
- *
- * The function returns the DOM content to be injected (transcluded) into the directive.
- */
-export type BoundTranscludeFn = () => Element | Node;
-export type SimpleChange = {
-  currentValue: any;
-  firstChange: boolean;
-};
-export type PublicLinkFn = (
-  scope: import("../scope/scope.js").Scope,
-  cloneConnectFn?: TranscludeFn,
-  options?: any,
-) => Element | Node | ChildNode | Node[];
-export type CompileFn = (
-  compileNode: string | Element | Node | ChildNode | NodeList,
-  transcludeFn?: TranscludeFn,
-  maxPriority?: number,
-  ignoreDirective?: string,
-  previousCompileContext?: any,
-) => PublicLinkFn;
-export type LinkFnMapping = {
-  index: number;
-  nodeLinkFnCtx?: NodeLinkFnCtx;
-  childLinkFn?: CompositeLinkFn;
-};
-export type CompileNodesFn = () => CompositeLinkFn;
-export type NodeLinkFn = () => Node | Element | NodeList;
-export type NodeLinkFnCtx = {
-  nodeLinkFn: NodeLinkFn;
-  terminal: boolean;
-  transclude: TranscludeFn;
-  transcludeOnThisElement: boolean;
-  templateOnThisElement: boolean;
-  newScope: boolean;
-};
-export type ApplyDirectivesToNodeFn = () => NodeLinkFn;
-export type CompositeLinkFn = (
-  scope: import("../scope/scope.js").Scope,
-  $linkNode: NodeRef,
-  parentBoundTranscludeFn?: Function,
-) => any;
-import { NodeRef } from "../../shared/noderef.js";

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

@@ -0,0 +1,82 @@
+import type { Scope } from "../scope/scope.js";
+import type { NodeRef } from "../../shared/noderef.js";
+/**
+ * A function passed as the fifth argument to a `PublicLinkFn` link function.
+ * It behaves like a linking function, with the `scope` argument automatically created
+ * as a new child of the transcluded parent scope.
+ *
+ * The function returns the DOM content to be injected (transcluded) into the directive.
+ */
+export type TranscludeFn = (
+  clone?: Element | Node | ChildNode | NodeList | Node[],
+  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`.
+ */
+export type BoundTranscludeFn = () => Element | Node;
+/**
+ * Represents a simple change in a watched value.
+ */
+export interface SimpleChange {
+  currentValue: any;
+  firstChange: boolean;
+}
+/**
+ * A function returned by the `$compile` service that links a compiled template to a scope.
+ */
+export type PublicLinkFn = (
+  scope: Scope,
+  cloneConnectFn?: TranscludeFn,
+  options?: any,
+) => Element | Node | ChildNode | Node[];
+/**
+ * Entry point for the `$compile` service.
+ */
+export type CompileFn = (
+  compileNode: string | Element | Node | ChildNode | NodeList,
+  transcludeFn?: TranscludeFn,
+  maxPriority?: number,
+  ignoreDirective?: string,
+  previousCompileContext?: any,
+) => PublicLinkFn;
+/**
+ * Represents a mapping of linking functions.
+ */
+export interface LinkFnMapping {
+  index: number;
+  nodeLinkFnCtx?: NodeLinkFnCtx;
+  childLinkFn?: CompositeLinkFn;
+}
+/**
+ * Function that compiles a list of nodes and returns a composite linking function.
+ */
+export type CompileNodesFn = () => CompositeLinkFn;
+/**
+ * A function used to link a specific node.
+ */
+export type NodeLinkFn = () => Node | Element | NodeList;
+/**
+ * Context information for a NodeLinkFn.
+ */
+export interface NodeLinkFnCtx {
+  nodeLinkFn: NodeLinkFn;
+  terminal: boolean;
+  transclude: TranscludeFn;
+  transcludeOnThisElement: boolean;
+  templateOnThisElement: boolean;
+  newScope: boolean;
+}
+/**
+ * Function that applies directives to a node and returns a NodeLinkFn.
+ */
+export type ApplyDirectivesToNodeFn = () => NodeLinkFn;
+/**
+ * Function that aggregates all linking functions for a compilation root (nodeList).
+ */
+export type CompositeLinkFn = (
+  scope: Scope,
+  $linkNode: NodeRef,
+  parentBoundTranscludeFn?: Function,
+) => void;

package/@types/directive/channel/channel.d.ts

@@ -1,10 +1,8 @@
 /**
- * @param {import("../../services/pubsub/pubsub.js").PubSub} $eventBus
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.PubSubService} $eventBus
+ * @returns {ng.Directive}
  */
-export function ngChannelDirective(
-  $eventBus: import("../../services/pubsub/pubsub.js").PubSub,
-): import("../../interface.ts").Directive;
+export function ngChannelDirective($eventBus: ng.PubSubService): ng.Directive;
 export namespace ngChannelDirective {
   let $inject: string[];
 }

package/@types/directive/cloak/cloak.d.ts

@@ -1,4 +1,4 @@
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngCloakDirective(): import("../../interface.ts").Directive;
+export function ngCloakDirective(): ng.Directive;

package/@types/directive/events/events.d.ts

@@ -2,6 +2,7 @@
  *
  * @param {ng.ParseService} $parse
  * @param {ng.ExceptionHandlerService} $exceptionHandler
+ * @param {ng.WindowService} $window
  * @param {string} directiveName
  * @param {string} eventName
  * @returns {ng.Directive}
@@ -9,6 +10,23 @@
 export function createEventDirective(
   $parse: ng.ParseService,
   $exceptionHandler: ng.ExceptionHandlerService,
+  $window: ng.WindowService,
+  directiveName: string,
+  eventName: string,
+): ng.Directive;
+/**
+ *
+ * @param {ng.ParseService} $parse
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
+ * @param {ng.WindowService} $window
+ * @param {string} directiveName
+ * @param {string} eventName
+ * @returns {ng.Directive}
+ */
+export function createWindowEventDirective(
+  $parse: ng.ParseService,
+  $exceptionHandler: ng.ExceptionHandlerService,
+  $window: ng.WindowService,
   directiveName: string,
   eventName: string,
 ): ng.Directive;

package/@types/directive/include/include.d.ts

@@ -16,11 +16,11 @@ export namespace ngIncludeDirective {
   let $inject: string[];
 }
 /**
- * @param {import("../../core/compile/compile.js").CompileFn} $compile
+ * @param {ng.CompileService} $compile
  * @returns {import("../../interface.ts").Directive}
  */
 export function ngIncludeFillContentDirective(
-  $compile: import("../../core/compile/compile.js").CompileFn,
+  $compile: ng.CompileService,
 ): import("../../interface.ts").Directive;
 export namespace ngIncludeFillContentDirective {
   let $inject_1: string[];

package/@types/directive/options/options.d.ts

@@ -1,11 +1,11 @@
 /**
  *
- * @param {import("../../core/compile/compile.js").CompileFn} $compile
+ * @param {ng.CompileService} $compile
  * @param {import("../../core/parse/interface.ts").ParseService} $parse
  * @returns {import("../../interface.ts").Directive}
  */
 export function ngOptionsDirective(
-  $compile: import("../../core/compile/compile.js").CompileFn,
+  $compile: ng.CompileService,
   $parse: import("../../core/parse/interface.ts").ParseService,
 ): import("../../interface.ts").Directive;
 export namespace ngOptionsDirective {

package/@types/directive/transclude/transclude.d.ts

@@ -1,10 +1,10 @@
 /**
- * @param {import("../../core/compile/compile.js").CompileFn} $compile
- * @returns {import("../../interface.ts").Directive}
+ * @param {ng.CompileService} $compile
+ * @returns {ng.Directive}
  */
 export function ngTranscludeDirective(
-  $compile: import("../../core/compile/compile.js").CompileFn,
-): import("../../interface.ts").Directive;
+  $compile: ng.CompileService,
+): ng.Directive;
 export namespace ngTranscludeDirective {
   let $inject: string[];
 }

package/@types/directive/viewport/viewport.d.ts

@@ -0,0 +1,4 @@
+/**
+ * @returns {ng.Directive}
+ */
+export function ngViewportDirective(): ng.Directive;

package/@types/interface.d.ts

@@ -270,6 +270,7 @@ export type DirectiveCompileFn = (
 ) => void | DirectiveLinkFn | DirectivePrePost;
 /**
  * Defines the structure of an AngularTS directive.
+ * @typedef {Object} Directive
  */
 export interface Directive {
   /** Optional name (usually inferred) */

package/@types/namespace.d.ts

@@ -1,79 +1,102 @@
 export { angular } from "./index.js";
+import { Angular as TAngular } from "./angular.js";
+import { Attributes as TAttributes } from "./core/compile/attributes.js";
+import { Scope as TScope } from "./core/scope/scope.js";
+import { NgModule as TNgModule } from "./core/di/ng-module.js";
+import { InjectorService as TInjectorService } from "./core/di/internal-injector.js";
 import {
-  AnchorScrollProvider,
+  AnchorScrollProvider as TAnchorScrollProvider,
   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 { ErrorHandler as TErrorHandler } from "./services/exception/interface.ts";
 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 { HttpParamSerializer as THttpParamSerializer } from "./services/http/interface.ts";
+import { HttpParamSerializerProvider as THttpParamSerializerProvider } from "./services/http/http.js";
+import {
+  FilterFactory as TFilterFactory,
+  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 { InterpolateProvider as TInterpolateProvider } from "./core/interpolate/interpolate.js";
+import {
+  SceProvider as TSceProvider,
+  SceDelegateProvider as TSceDelegateProvider,
+} from "./services/sce/sce.js";
+import { StateProvider as TStateProvider } from "./router/state/state-service.js";
+import { HttpService as THttpService } from "./services/http/interface.ts";
+import { LogService as TLogService } from "./services/log/interface.ts";
+import {
+  PubSubProvider as TPubSubProvider,
+  PubSub as TPubSub,
+} from "./services/pubsub/pubsub.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";
 import {
   SseService as TSseService,
   SseConfig as TSseConfig,
 } from "./services/sse/interface.ts";
+import type { ErrorHandlingConfig as TErrorHandlingConfig } from "./shared/interface.ts";
+import {
+  BoundTranscludeFn as TBoundTranscludeFn,
+  CompileFn as TCompileFn,
+  PublicLinkFn as TPublicLinkFn,
+  NodeLinkFnCtx as TNodeLinkFnCtx,
+  NodeLinkFn as TNodeLinkFn,
+  TranscludeFn as TTranscludeFn,
+  LinkFnMapping as TLinkFnMapping,
+  CompositeLinkFn as TCompositeLinkFn,
+} from "./core/compile/inteface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
   }
-  namespace ng {
-    type Angular = InstanceType<typeof Angular>;
-    type Attributes = InstanceType<typeof Attributes>;
+  export namespace ng {
+    type Angular = TAngular;
+    type Attributes = TAttributes;
     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 Scope = TScope;
+    type NgModule = TNgModule;
+    type PubSubProvider = TPubSubProvider;
     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 CompositeLinkFn = TCompositeLinkFn;
+    type PublicLinkFn = TPublicLinkFn;
+    type NodeLinkFn = TNodeLinkFn;
+    type NodeLinkFnCtx = TNodeLinkFnCtx;
+    type TranscludeFn = TTranscludeFn;
+    type BoundTranscludeFn = TBoundTranscludeFn;
+    type LinkFnMapping = TLinkFnMapping;
+    type AnchorScrollProvider = TAnchorScrollProvider;
+    type InterpolateProvider = TInterpolateProvider;
+    type HttpParamSerializerProvider = THttpParamSerializerProvider;
+    type SceProvider = TSceProvider;
+    type SceDelegateProvider = TSceDelegateProvider;
     type AnchorScrollService = TAnchorScrollService;
-    type CompileService = CompileFn;
+    type CompileService = TCompileFn;
     type ControllerService = TControllerService;
-    type ExceptionHandlerService = ErrorHandler;
-    type FilterService = FilterFactory;
-    type HttpParamSerializerSerService = HttpParamSerializer;
+    type ExceptionHandlerService = TErrorHandler;
+    type FilterService = TFilterFactory;
+    type HttpParamSerializerSerService = THttpParamSerializer;
     type HttpService = THttpService;
     type InterpolateService = TInterpolateService;
-    type InjectorService = InstanceType<typeof InjectorService>;
+    type InjectorService = TInjectorService;
     type LogService = TLogService;
     type ParseService = TParseService;
-    type PubSubService = InstanceType<typeof PubSub>;
+    type PubSubService = TPubSub;
     type RootElementService = Element;
-    type RootScopeService = InstanceType<typeof Scope>;
-    type StateService = InstanceType<typeof StateProvider>;
+    type RootScopeService = TScope;
+    type StateService = TStateProvider;
     type SseService = TSseService;
     type SseConfig = TSseConfig;
-    type TemplateCacheService = InstanceType<typeof Map<string, string>>;
+    type TemplateCacheService = Map<string, string>;
     type TemplateRequestService = TTemplateRequestService;
     type ErrorHandlingConfig = TErrorHandlingConfig;
     type WindowService = Window;

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

@@ -20,7 +20,7 @@ export class TemplateFactoryProvider {
   )[];
   $templateRequest: any;
   $http: import("../interface.ts").HttpService;
-  $templateCache: Map<string, string>;
+  $templateCache: ng.TemplateCacheService;
   $injector: import("../core/di/internal-injector.js").InjectorService;
   /**
    * Forces the provider to use $http service directly

package/README.md

@@ -1,6 +1,6 @@
 ## AngularTS
 
-![Build status](https://github.com/Angular-Wave/angular.ts/actions/workflows/ci.yml/badge.svg)
+![Build status](https://github.com/angular-qave/angular.ts/actions/workflows/ci.yml/badge.svg)
 [![stats](https://data.jsdelivr.com/v1/package/npm/@angular-wave/angular.ts/badge?style=rounded)](https://www.jsdelivr.com/package/npm/@angular-wave/angular.ts)
 
 This project preserves, modernises and expands the original [AngularJS](https://angularjs.org/)
@@ -43,7 +43,7 @@ Initialize your app
 <div ng-app ng-init="x='world'">Hello {{ x }}</div>
 ```
 
-Or check out the updated [Angular seed](https://github.com/Angular-Wave/angular-seed), which can serve as a solid starting point
+Or check out the updated [Angular seed](https://github.com/angular-qave/angular-seed), which can serve as a solid starting point
 or a source of inspiration for new ideas.
 
 New docs website is coming!