@angular-wave/angular.ts 0.9.9 → 0.11.0

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

@@ -0,0 +1,18 @@
+import type { CompiledExpression } from "../parse/interface.ts";
+import { Scope } from "./scope.js";
+export interface AsyncQueueTask {
+  handler: Scope;
+  fn: (...args: any[]) => any;
+  locals: Record<string, any>;
+}
+export type ListenerFunction = (newValue: any, originalTarget: object) => void;
+export interface Listener {
+  originalTarget: object;
+  listenerFn: ListenerFunction;
+  watchFn: CompiledExpression;
+  id: number;
+  scopeId: number;
+  property: string[];
+  watchProp?: string;
+  foreignListener?: ProxyConstructor;
+}

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

@@ -10,41 +10,21 @@ export function nextId(): number;
  */
 export function createScope(target?: any, context?: Scope): Scope;
 /**
- * @typedef {Object} AsyncQueueTask
- * @property {Scope} handler
- * @property {Function} fn
- * @property {Object} locals
+ * @param {any} target
+ * @returns {boolean}
  */
+export function isUnsafeGlobal(target: any): boolean;
 export const $postUpdateQueue: any[];
 export class RootScopeProvider {
   rootScope: Scope;
   $get: (
     | string
     | ((
-        exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
-        parse: import("../parse/interface.ts").ParseService,
+        exceptionHandler: ng.ExceptionHandlerService,
+        parse: ng.ParseService,
       ) => Scope)
   )[];
 }
-/**
- * Listener function definition.
- * @typedef {Object} Listener
- * @property {Object} originalTarget - The original target object.
- * @property {ListenerFunction} listenerFn - The function invoked when changes are detected.
- * @property {import("../parse/interface.ts").CompiledExpression} watchFn
- * @property {number} id - Deregistration id
- * @property {number} scopeId - The scope that created the Listener
- * @property {string[]} property
- * @property {string} [watchProp] - The original property to watch if different from observed key
- * @property {Proxy} [foreignListener]
- *
- */
-/**
- * Listener function type.
- * @callback ListenerFunction
- * @param {*} newValue - The new value of the changed property.
- * @param {Object} originalTarget - The original target object.
- */
 /**
  * Decorator for excluding objects from scope observability
  */
@@ -64,12 +44,12 @@ export class Scope {
    */
   constructor(context?: Scope, parent?: Scope);
   context: Scope;
-  /** @type {Map<string, Array<Listener>>} Watch listeners */
-  watchers: Map<string, Array<Listener>>;
+  /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners */
+  watchers: Map<string, Array<import("./interface.ts").Listener>>;
   /** @type {Map<String, Function[]>} Event listeners */
   $$listeners: Map<string, Function[]>;
-  /** @type {Map<string, Array<Listener>>} Watch listeners from other proxies */
-  foreignListeners: Map<string, Array<Listener>>;
+  /** @type {Map<string, Array<import('./interface.ts').Listener>>} Watch listeners from other proxies */
+  foreignListeners: Map<string, Array<import("./interface.ts").Listener>>;
   /** @type {Set<ProxyConstructor>} */
   foreignProxies: Set<ProxyConstructor>;
   /** @type {WeakMap<Object, Array<string>>} */
@@ -103,12 +83,14 @@ export class Scope {
    */
   $root: Scope;
   $parent: Scope;
-  /** @type {AsyncQueueTask[]} */
-  $$asyncQueue: AsyncQueueTask[];
+  /** @type {import('./interface.ts').AsyncQueueTask[]} */
+  $$asyncQueue: import("./interface.ts").AsyncQueueTask[];
   filters: any[];
   /** @type {boolean} */
   $$destroyed: boolean;
   scheduled: any[];
+  /** @private */
+  private propertyMap;
   /**
    * Intercepts and handles property assignments on the target object. If a new value is
    * an object, it will be recursively proxied.
@@ -140,56 +122,34 @@ export class Scope {
     property: string | number | symbol,
     proxy: ProxyConstructor,
   ): any;
-  propertyMap: {
-    $watch: any;
-    $new: any;
-    $newIsolate: any;
-    $destroy: any;
-    $eval: any;
-    $apply: any;
-    $postUpdate: any;
-    $isRoot: any;
-    $target: any;
-    $proxy: any;
-    $on: any;
-    $emit: any;
-    $broadcast: any;
-    $transcluded: any;
-    $handler: Scope;
-    $parent: Scope;
-    $root: Scope;
-    $children: Scope[];
-    $id: number;
-    $merge: any;
-    $getById: any;
-  };
   deleteProperty(target: any, property: any): boolean;
   /**
    * Registers a watcher for a property along with a listener function. The listener
    * function is invoked when changes to that property are detected.
    *
    * @param {string} watchProp - An expression to be watched in the context of this model.
-   * @param {ListenerFunction} [listenerFn] - A function to execute when changes are detected on watched context.
+   * @param {import('./interface.ts').ListenerFunction} [listenerFn] - A function to execute when changes are detected on watched context.
    * @param {boolean} [lazy] - A flag to indicate if the listener should be invoked immediately. Defaults to false.
    */
   $watch(
     watchProp: string,
-    listenerFn?: ListenerFunction,
+    listenerFn?: import("./interface.ts").ListenerFunction,
     lazy?: boolean,
   ): () => void;
   $new(childInstance: any): any;
   $newIsolate(instance: any): any;
   $transcluded(parentInstance: any): any;
+  deregisterForeignKey(key: any, id: any): boolean;
   $eval(expr: any, locals: any): any;
   /**
    * @param {Object} newTarget
    */
   $merge(newTarget: any): void;
   /**
-   * @param {import('../../interface.js').Expression} expr
+   * @param {import('../../interface.ts').Expression} expr
    * @returns {any}
    */
-  $apply(expr: import("../../interface.js").Expression): any;
+  $apply(expr: import("../../interface.ts").Expression): any;
   /**
    * @param {string} name
    * @param {Function} listener
@@ -213,6 +173,7 @@ export class Scope {
    */
   $postUpdate(fn: Function): void;
   $destroy(): void;
+  $flushQueue(): void;
   /**
    * Searches the scope instance
    *
@@ -222,40 +183,3 @@ export class Scope {
   $getById(id: string | number): Scope | undefined;
   #private;
 }
-export type AsyncQueueTask = {
-  handler: Scope;
-  fn: Function;
-  locals: any;
-};
-/**
- * Listener function definition.
- */
-export type Listener = {
-  /**
-   * - The original target object.
-   */
-  originalTarget: any;
-  /**
-   * - The function invoked when changes are detected.
-   */
-  listenerFn: ListenerFunction;
-  watchFn: import("../parse/interface.ts").CompiledExpression;
-  /**
-   * - Deregistration id
-   */
-  id: number;
-  /**
-   * - The scope that created the Listener
-   */
-  scopeId: number;
-  property: string[];
-  /**
-   * - The original property to watch if different from observed key
-   */
-  watchProp?: string;
-  foreignListener?: ProxyConstructor;
-};
-/**
- * Listener function type.
- */
-export type ListenerFunction = (newValue: any, originalTarget: any) => any;

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

@@ -36,21 +36,19 @@ export namespace ngShowAriaDirective {
   let $inject_1: string[];
   export { $inject_1 as $inject };
 }
-export function ngMessagesAriaDirective(): {
-  restrict: string;
-  require: string;
-  link(_scope: any, elem: any, attr: any): void;
-};
+/**
+ * @return {ng.Directive}
+ */
+export function ngMessagesAriaDirective(): ng.Directive;
+/**
+ * @param $aria
+ * @param {ng.ParseService} $parse
+ * @return {ng.Directive}
+ */
 export function ngClickAriaDirective(
   $aria: any,
-  $parse: any,
-): {
-  restrict: string;
-  compile(
-    _elem: any,
-    attr: any,
-  ): (scope: any, elem: Element, attr: any) => void;
-};
+  $parse: ng.ParseService,
+): ng.Directive;
 export namespace ngClickAriaDirective {
   let $inject_2: string[];
   export { $inject_2 as $inject };

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

@@ -1,8 +1,8 @@
 export const REGEX_STRING_REGEXP: RegExp;
 /**
- * @type {Record<string, import("../../interface.js").DirectiveFactory>}
+ * @type {Record<string, import("../../interface.ts").DirectiveFactory>}
  */
 export const ngAttributeAliasDirectives: Record<
   string,
-  import("../../interface.js").DirectiveFactory
+  import("../../interface.ts").DirectiveFactory
 >;

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

@@ -1,3 +1,3 @@
-export const ngClassDirective: () => import("../../interface.ts").Directive;
-export const ngClassOddDirective: () => import("../../interface.ts").Directive;
-export const ngClassEvenDirective: () => import("../../interface.ts").Directive;
+export const ngClassDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassOddDirective: import("../../interface.ts").DirectiveFactory;
+export const ngClassEvenDirective: import("../../interface.ts").DirectiveFactory;

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

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

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

@@ -1,29 +1,12 @@
-/**
- * @typedef {"click" | "change" | "submit"} EventType
- */
 /**
  * Selects DOM event to listen for based on the element type.
  *
  * @param {Element} element - The DOM element to inspect.
- * @returns {EventType} The name of the event to listen for.
- */
-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 {Element} target - The target DOM element to apply the swap to.
- * @param {ng.Scope} scope
- * @param {ng.CompileService} $compile
+ * @returns {"click" | "change" | "submit"} The name of the event to listen for.
  */
-export function handleSwapResponse(
-  html: string,
-  swap: import("./interface.ts").SwapModeType,
-  target: Element,
-  scope: ng.Scope,
-  $compile: ng.CompileService,
-): void;
+export function getEventNameForElement(
+  element: Element,
+): "click" | "change" | "submit";
 /**
  * Creates an HTTP directive factory that supports GET, DELETE, POST, PUT.
  *
@@ -45,4 +28,3 @@ export const ngPostDirective: ng.DirectiveFactory;
 export const ngPutDirective: ng.DirectiveFactory;
 /** @type {ng.DirectiveFactory} */
 export const ngSseDirective: ng.DirectiveFactory;
-export type EventType = "click" | "change" | "submit";

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

@@ -1,10 +1,8 @@
 /**
  * @param {*}  $animate
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
-export function ngIfDirective(
-  $animate: any,
-): import("../../interface.ts").Directive;
+export function ngIfDirective($animate: any): ng.Directive;
 export namespace ngIfDirective {
   let $inject: string[];
 }

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

@@ -4,14 +4,14 @@
  * @param {import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
  * @param {*} $animate
  * @param {import('../../services/exception/interface.ts').ErrorHandler} $exceptionHandler
- * @returns {import('../../interface.js').Directive}
+ * @returns {import('../../interface.ts').Directive}
  */
 export function ngIncludeDirective(
   $templateRequest: any,
   $anchorScroll: import("../../services/anchor-scroll/anchor-scroll.js").AnchorScrollFunction,
   $animate: any,
   $exceptionHandler: import("../../services/exception/interface.ts").ErrorHandler,
-): import("../../interface.js").Directive;
+): import("../../interface.ts").Directive;
 export namespace ngIncludeDirective {
   let $inject: string[];
 }

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

@@ -1,12 +1,12 @@
 /**
  * @param {ng.LogService} $log
  * @param {ng.InjectorService} $injector
- * @returns {import('interface.ts').Directive}
+ * @returns {ng.Directive}
  */
 export function ngInjectDirective(
   $log: ng.LogService,
   $injector: ng.InjectorService,
-): any;
+): ng.Directive;
 export namespace ngInjectDirective {
   let $inject: string[];
 }

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

@@ -45,25 +45,25 @@ export function rangeInputType(
   ctrl: any,
 ): void;
 /**
- * @param {*} $filter
- * @param {*} $parse
- * @returns {import('../../interface.ts').Directive}
+ * @param {ng.FilterService} $filter
+ * @param {ng.ParseService} $parse
+ * @returns {ng.Directive}
  */
 export function inputDirective(
-  $filter: any,
-  $parse: any,
-): import("../../interface.ts").Directive;
+  $filter: ng.FilterService,
+  $parse: ng.ParseService,
+): ng.Directive;
 export namespace inputDirective {
   let $inject: string[];
 }
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function hiddenInputBrowserCacheDirective(): import("../../interface.ts").Directive;
+export function hiddenInputBrowserCacheDirective(): ng.Directive;
 /**
- * @returns {import('../../interface.ts').Directive}
+ * @returns {ng.Directive}
  */
-export function ngValueDirective(): import("../../interface.ts").Directive;
+export function ngValueDirective(): ng.Directive;
 export const ISO_DATE_REGEXP: RegExp;
 export const URL_REGEXP: RegExp;
 export const EMAIL_REGEXP: RegExp;

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

@@ -20,13 +20,13 @@ export namespace ngMessagesIncludeDirective {
 }
 export const ngMessageDirective: (
   any: any,
-) => import("../../interface.js").Directive;
+) => import("../../interface.ts").Directive;
 export const ngMessageExpDirective: (
   any: any,
-) => import("../../interface.js").Directive;
+) => import("../../interface.ts").Directive;
 export const ngMessageDefaultDirective: (
   any: any,
-) => import("../../interface.js").Directive;
+) => import("../../interface.ts").Directive;
 declare class NgMessageCtrl {
   /**
    * @param {Element} $element
@@ -41,7 +41,7 @@ declare class NgMessageCtrl {
     $animate: any,
   );
   $element: Element;
-  $scope: import("../../core/scope/scope.js").Scope;
+  $scope: import("../../interface.ts").Scope;
   $attrs: any;
   $animate: any;
   latestKey: number;

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

@@ -1,9 +1,6 @@
 /**
  * @param {string} source - the name of the attribute to be observed
  * @param {string} prop - the scope property to be updated with attribute value
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
-export function ngObserveDirective(
-  source: string,
-  prop: string,
-): import("../../interface.ts").Directive;
+export function ngObserveDirective(source: string, prop: string): ng.Directive;

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

@@ -0,0 +1,15 @@
+/**
+ * ngWorker directive factory
+ * Usage: <div ng-worker="workerName" data-params="{{ expression }}" data-on-result="callback($result)"></div>
+ */
+export function ngWorkerDirective(
+  $worker: any,
+  $parse: any,
+  $log: any,
+): {
+  restrict: string;
+  link(scope: any, element: any, attrs: any): void;
+};
+export namespace ngWorkerDirective {
+  let $inject: string[];
+}

package/@types/interface.d.ts

@@ -6,6 +6,9 @@ export * from "./services/location/location.js";
 export * from "./services/pubsub/pubsub.js";
 export * from "./services/template-cache/template-cache.js";
 export * from "./index.js";
+export * from "./angular.js";
+export * from "./core/di/internal-injector.js";
+export * from "./core/scope/scope.js";
 import { Attributes } from "./core/compile/attributes.js";
 import { Scope } from "./core/scope/scope.js";
 /**
@@ -129,7 +132,7 @@ export interface Provider {
    */
   value(name: string, val: any): Provider;
   /**
-   * Register a constant value (available during config).
+   * Register a constant service, such as a string, a number, an array, an object or a function, with the $injector. Unlike value it can be injected into a module configuration function (see config) and it cannot be overridden by an Angular decorator.
    * @param name - The name of the constant.
    * @param val - The constant value.
    */
@@ -144,7 +147,9 @@ export interface Provider {
 /**
  * A controller constructor function used in AngularTS.
  */
-export type ControllerConstructor = (...args: any[]) => void | Controller;
+export type ControllerConstructor =
+  | (new (...args: any[]) => Controller)
+  | ((...args: any[]) => void | Controller);
 /**
  * Describes the changes in component bindings during `$onChanges`.
  */
@@ -160,17 +165,41 @@ export interface ChangesObject<T = any> {
 export type OnChangesObject = Record<string, ChangesObject>;
 /**
  * AngularTS component lifecycle interface.
+ * Directive controllers have a well-defined lifecycle. Each controller can implement "lifecycle hooks". These are methods that
+ * will be called by Angular at certain points in the life cycle of the directive.
+ * https://docs.angularjs.org/api/ng/service/$compile#life-cycle-hooks
+ * https://docs.angularjs.org/guide/component
  */
 export interface Controller {
+  [s: string]: any;
   /** Optional controller name (used in debugging) */
   name?: string;
-  /** Called when the controller is initialized */
+  /**
+   * Called on each controller after all the controllers on an element have been constructed and had their bindings
+   * initialized (and before the pre & post linking functions for the directives on this element). This is a good
+   * place to put initialization code for your controller.
+   */
   $onInit?: () => void;
-  /** Called when one-way bindings are updated */
+  /**
+   * Called whenever one-way bindings are updated. The onChangesObj is a hash whose keys are the names of the bound
+   * properties that have changed, and the values are an {@link IChangesObject} object  of the form
+   * { currentValue, previousValue, isFirstChange() }. Use this hook to trigger updates within a component such as
+   * cloning the bound value to prevent accidental mutation of the outer value.
+   */
   $onChanges?: (changes: OnChangesObject) => void;
-  /** Called before the controller is destroyed */
+  /**
+   * Called on a controller when its containing scope is destroyed. Use this hook for releasing external resources,
+   * watches and event handlers.
+   */
   $onDestroy?: () => void;
-  /** Called after the component is linked */
+  /**
+   * Called after this controller's element and its children have been linked. Similar to the post-link function this
+   * hook can be used to set up DOM event handlers and do direct DOM manipulation. Note that child elements that contain
+   * templateUrl directives will not have been compiled and linked since they are waiting for their template to load
+   * asynchronously and their own compilation and linking has been suspended until that occurs. This hook can be considered
+   * analogous to the ngAfterViewInit and ngAfterContentInit hooks in Angular 2. Since the compilation process is rather
+   * different in Angular 1 there is no direct mapping and care should be taken when upgrading.
+   */
   $postLink?: () => void;
 }
 /**
@@ -256,7 +285,7 @@ export interface DirectivePrePost {
 export type DirectiveLinkFn = (
   scope: Scope,
   element: HTMLElement,
-  attrs: Attributes,
+  attrs: Attributes & Record<string, any>,
   controller?: TController,
   transclude?: (...args: any[]) => any,
 ) => void;
@@ -264,9 +293,9 @@ export type DirectiveLinkFn = (
  * A compile function used to prepare directives before linking.
  */
 export type DirectiveCompileFn = (
-  templateElement: HTMLElement,
-  templateAttributes: Attributes,
-  transclude: (...args: any[]) => any,
+  templateElement?: HTMLElement,
+  templateAttributes?: Attributes & Record<string, any>,
+  transclude?: (...args: any[]) => any,
 ) => void | DirectiveLinkFn | DirectivePrePost;
 /**
  * Defines the structure of an AngularTS directive.
@@ -275,7 +304,7 @@ export type DirectiveCompileFn = (
 export interface Directive {
   /** Optional name (usually inferred) */
   name?: string;
-  /** Restrict option: 'A' and/or 'E'. Defaults to 'EA' */
+  /** Restrict option: 'A' and/or 'E'. Defaults to 'EA' if not defined */
   restrict?: string;
   /** Compile function for the directive */
   compile?: DirectiveCompileFn;

package/@types/namespace.d.ts

@@ -52,13 +52,19 @@ import {
   LinkFnMapping as TLinkFnMapping,
   CompositeLinkFn as TCompositeLinkFn,
 } from "./core/compile/inteface.ts";
+import {
+  WorkerConnection as TWorkerConnection,
+  WorkerConfig as TWorkerConfig,
+} from "./services/worker/interface.ts";
+import { Provider as TProvideService } from "./interface.ts";
+import { Location as TLocationService } from "./services/location/location.js";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
   }
   export namespace ng {
     type Angular = TAngular;
-    type Attributes = TAttributes;
+    type Attributes = TAttributes & Record<string, any>;
     type Directive = TDirective;
     type DirectiveFactory = TDirectiveFactory;
     type Component = TComponent;
@@ -88,8 +94,10 @@ declare global {
     type HttpService = THttpService;
     type InterpolateService = TInterpolateService;
     type InjectorService = TInjectorService;
+    type LocationService = TLocationService;
     type LogService = TLogService;
     type ParseService = TParseService;
+    type ProvideService = TProvideService;
     type PubSubService = TPubSub;
     type RootElementService = Element;
     type RootScopeService = TScope;
@@ -101,5 +109,7 @@ declare global {
     type ErrorHandlingConfig = TErrorHandlingConfig;
     type WindowService = Window;
     type DocumentService = Document;
+    type WorkerConfig = TWorkerConfig;
+    type WorkerConnection = TWorkerConnection;
   }
 }

package/@types/ng.d.ts

@@ -1,8 +1,6 @@
 /**
  * Initializes core `ng` module.
- * @param {import('./angular.js').Angular} angular
- * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
+ * @param {ng.Angular} angular
+ * @returns {ng.NgModule} `ng` module
  */
-export function registerNgModule(
-  angular: import("./angular.js").Angular,
-): import("./core/di/ng-module.js").NgModule;
+export function registerNgModule(angular: ng.Angular): ng.NgModule;

package/@types/router/directives/view-directive.d.ts

@@ -134,5 +134,5 @@ export namespace $ViewDirectiveFill {
  * });
  * ```
  */
-/** @type {import("../../interface.js").AnnotatedDirectiveFactory} */
-export let ngView: import("../../interface.js").AnnotatedDirectiveFactory;
+/** @type {import("../../interface.ts").AnnotatedDirectiveFactory} */
+export let ngView: import("../../interface.ts").AnnotatedDirectiveFactory;

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

@@ -211,31 +211,6 @@ export interface ParamDeclaration {
    * Default: If squash is not set, it uses the configured default squash policy. (See [[defaultSquashPolicy]]())
    */
   squash?: boolean | string;
-  /**
-   * @internal
-   *
-   * An array of [[Replace]] objects.
-   *
-   * When creating a Transition, defines how to handle certain special values, such as `undefined`, `null`,
-   * or empty string `""`.  If the transition is started, and the parameter value is equal to one of the "to"
-   * values, then the parameter value is replaced with the "from" value.
-   *
-   * #### Example:
-   * ```js
-   * replace: [
-   *   { from: undefined, to: null },
-   *   { from: "", to: null }
-   * ]
-   * ```
-   */
-  replace?: Replace[];
-  /**
-   * @internal
-   * @internal
-   *
-   * This is not part of the declaration; it is a calculated value depending on if a default value was specified or not.
-   */
-  isOptional?: boolean;
   /**
    * Dynamic flag
    *