@angular-wave/angular.ts 0.7.0-beta.0 → 0.7.1

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

@@ -1,6 +1,6 @@
 /**
  *
- * @param {string} ngRequired AngularJS expression. If it evaluates to `true`, it sets the
+ * @param {string} ngRequired AngularTS expression. If it evaluates to `true`, it sets the
  *                                `required` attribute to the element and adds the `required`
  *                                {@link ngModel.NgModelController#$validators `validator`}.
  *
@@ -9,7 +9,7 @@
  * It is most often used for {@link input `input`} and {@link select `select`} controls, but can also be
  * applied to custom controls.
  *
- * The directive sets the `required` attribute on the element if the AngularJS expression inside
+ * The directive sets the `required` attribute on the element if the AngularTS expression inside
  * `ngRequired` evaluates to true. A special directive for setting `required` is necessary because we
  * cannot use interpolation inside `required`. See the {@link guide/interpolation interpolation guide}
  * for more info.
@@ -24,11 +24,11 @@
 export const requiredDirective: (
   | string
   | ((
-      $parse: import("../../core/parse/parse.js").ParseService,
-    ) => import("../../types.js").Directive)
+      $parse: import("../../core/parse/interface.ts").ParseService,
+    ) => import("../../interface.ts").Directive)
 )[];
 /**
- * @param {String|RegExp} ngPattern AngularJS expression that must evaluate to a `RegExp` or a `String`
+ * @param {String|RegExp} ngPattern AngularTS expression that must evaluate to a `RegExp` or a `String`
  *                                      parsable into a `RegExp`, or a `RegExp` literal. See above for
  *                                      more details.
  *
@@ -39,7 +39,7 @@ export const requiredDirective: (
  *
  * The validator sets the `pattern` error key if the {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`}
  * does not match a RegExp which is obtained from the `ngPattern` attribute value:
- * - the value is an AngularJS expression:
+ * - the value is an AngularTS expression:
  *   - If the expression evaluates to a RegExp object, then this is used directly.
  *   - If the expression evaluates to a string, then it will be converted to a RegExp after wrapping it
  *     in `^` and `$` characters. For instance, `"abc"` will be converted to `new RegExp('^abc$')`.
@@ -69,11 +69,11 @@ export const requiredDirective: (
 export const patternDirective: (
   | string
   | ((
-      $parse: import("../../core/parse/parse.js").ParseService,
-    ) => import("../../types.js").Directive)
+      $parse: import("../../core/parse/interface.ts").ParseService,
+    ) => import("../../interface.ts").Directive)
 )[];
 /**
- * @param {string} ngMaxlength AngularJS expression that must evaluate to a `Number` or `String`
+ * @param {string} ngMaxlength AngularTS expression that must evaluate to a `Number` or `String`
  *                                 parsable into a `Number`. Used as value for the `maxlength`
  *                                 {@link ngModel.NgModelController#$validators validator}.
  *
@@ -83,7 +83,7 @@ export const patternDirective: (
  * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
  *
  * The validator sets the `maxlength` error key if the {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`}
- * is longer than the integer obtained by evaluating the AngularJS expression given in the
+ * is longer than the integer obtained by evaluating the AngularTS expression given in the
  * `ngMaxlength` attribute value.
  *
  * <div class="alert alert-info">
@@ -105,12 +105,12 @@ export const patternDirective: (
 export const maxlengthDirective: (
   | string
   | ((
-      $parse: import("../../core/parse/parse.js").ParseService,
-    ) => import("../../types.js").Directive)
+      $parse: import("../../core/parse/interface.ts").ParseService,
+    ) => import("../../interface.ts").Directive)
 )[];
 /**
  *
- * @param {string} ngMinlength AngularJS expression that must evaluate to a `Number` or `String`
+ * @param {string} ngMinlength AngularTS expression that must evaluate to a `Number` or `String`
  *                                 parsable into a `Number`. Used as value for the `minlength`
  *                                 {@link ngModel.NgModelController#$validators validator}.
  *
@@ -120,7 +120,7 @@ export const maxlengthDirective: (
  * It is most often used for text-based {@link input `input`} controls, but can also be applied to custom text-based controls.
  *
  * The validator sets the `minlength` error key if the {@link ngModel.NgModelController#$viewValue `ngModel.$viewValue`}
- * is shorter than the integer obtained by evaluating the AngularJS expression given in the
+ * is shorter than the integer obtained by evaluating the AngularTS expression given in the
  * `ngMinlength` attribute value.
  *
  * <div class="alert alert-info">

package/@types/filters/filter.d.ts

@@ -1,9 +1,4 @@
 /**
- * @returns {function(Array, string|Object|function(any, number, []):[], function(any, any):boolean|boolean, string?): Array}
+ * @returns {import('../interface.ts').FilterFn}
  */
-export function filterFilter(): (
-  arg0: any[],
-  arg1: string | any | ((arg0: any, arg1: number, arg2: []) => []),
-  arg2: (arg0: any, arg1: any) => boolean | boolean,
-  arg3: string | null,
-) => any[];
+export function filterFilter(): import("../interface.ts").FilterFn;

package/@types/filters/filters.d.ts

@@ -33,6 +33,6 @@ export function formatNumber(
   fractionSize: any,
 ): string;
 /**
- * @returns {function(Object, number?): Object}
+ * @returns {import('../interface.ts').FilterFn}
  */
-export function jsonFilter(): (arg0: any, arg1: number | null) => any;
+export function jsonFilter(): import("../interface.ts").FilterFn;

package/@types/filters/limit-to.d.ts

@@ -1,8 +1,4 @@
 /**
- * @returns {function(Array|ArrayLike|string|number, string|number, (string|number)?):Array|ArrayLike|string|number}
+ * @returns {import('../interface.ts').FilterFn}
  */
-export function limitToFilter(): (
-  arg0: any[] | ArrayLike<any> | string | number,
-  arg1: string | number,
-  arg2: (string | number) | null,
-) => any[] | ArrayLike<any> | string | number;
+export function limitToFilter(): import("../interface.ts").FilterFn;

package/@types/filters/order-by.d.ts

@@ -1,6 +1,7 @@
-export function orderByFilter(
-  $parse: any,
-): (array: any, sortPredicate: any, reverseOrder: any, compareFn: any) => any;
+/**
+ * @returns {import('../interface.ts').FilterFn}
+ */
+export function orderByFilter($parse: any): import("../interface.ts").FilterFn;
 export namespace orderByFilter {
   let $inject: string[];
 }

package/@types/injection-tokens.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Utility for mapping to service-names to providers
+ * @param {String[]} services
+ */
+export function provider(services: string[]): string[];
+/**
+ * A helper list of tokens matching the standard injectables that come predefined in the core `ng` module.
+ * These string tokens are commonly injected into services, directives, or components via `$inject`.
+ *
+ * Example:
+ * ```js
+ *
+ * myDirective.$inject = [
+ *   angular.$injectTokens.$animate,
+ *   angular.$injectTokens.$templateRequest,
+ * ];
+ * ```
+ * @type Readonly<Record<string, string>>
+ */
+export const $injectTokens: Readonly<Record<string, string>>;

package/@types/interface.d.ts

@@ -0,0 +1,302 @@
+import { Attributes } from "./core/compile/attributes.js";
+import { Scope } from "./core/scope/scope.js";
+/**
+ * A JavaScript expression represented as a string.
+ *
+ * Often used in interpolation bindings such as:
+ * `<span title="{{ attrBinding }}">{{ textBinding }}</span>`.
+ * Evaluated in the context of a {@link import('./core/scope/scope.js').Scope `scope`} object.
+ */
+export type Expression = string;
+/**
+ * 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.
+ *
+ * Example:
+ * ```ts
+ * ['dep1', 'dep2', function(dep1, dep2) { ... }]
+ * ```
+ */
+export type AnnotatedFactory = [...string[], (...args: any[]) => any];
+/**
+ * A factory that can be either a standalone function or a dependency-annotated array.
+ *
+ * The array form is used to support minification-safe dependency injection.
+ * See {@link AnnotatedFactory}.
+ */
+export type InjectableFactory = (...args: any[]) => any;
+export type Injectable = AnnotatedFactory | InjectableFactory;
+/**
+ * An object that defines how a service is constructed.
+ *
+ * It must define a `$get` property that provides the instance of the service,
+ * either as a plain factory function or as an {@link AnnotatedFactory}.
+ */
+export interface ServiceProvider {
+  $get: Injectable;
+}
+/**
+ * The API for registering different types of providers with the injector.
+ *
+ * This interface is used within AngularTS's `$provide` service to define
+ * services, factories, constants, values, decorators, etc.
+ */
+export interface Provider {
+  /**
+   * Register a service provider.
+   * @param name - The name of the service.
+   * @param provider - An object with a `$get` property that defines how the service is created.
+   */
+  provider(name: string, provider: ServiceProvider): ServiceProvider;
+  /**
+   * Register a factory function to create a service.
+   * @param name - The name of the service.
+   * @param factoryFn - A function (or annotated array) that returns the service instance.
+   */
+  factory(name: string, factoryFn: Injectable): ServiceProvider;
+  /**
+   * 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): ServiceProvider;
+  /**
+   * Register a fixed value as a service.
+   * @param name - The name of the service.
+   * @param val - The value to use.
+   */
+  value(name: string, val: any): ServiceProvider;
+  /**
+   * Register a constant value (available during config).
+   * @param name - The name of the constant.
+   * @param val - The constant value.
+   */
+  constant(name: string, val: any): void;
+  /**
+   * Register a decorator function to modify or replace an existing service.
+   * @param name - The name of the service to decorate.
+   * @param fn - A function that takes `$delegate` and returns a decorated service.
+   */
+  decorator(name: string, fn: Injectable): void;
+}
+/**
+ * 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.
+ */
+export type ControllerConstructor = (...args: any[]) => void | Controller;
+/**
+ * Describes the changes in component bindings during `$onChanges`.
+ */
+export interface ChangesObject<T = any> {
+  /** New value of the binding */
+  currentValue: T;
+  /** Whether this is the first change */
+  isFirstChange: () => boolean;
+}
+/**
+ * Mapping of binding property names to their change metadata.
+ */
+export type OnChangesObject = Record<string, ChangesObject>;
+/**
+ * AngularTS component lifecycle interface.
+ */
+export interface Controller {
+  /** Optional controller name (used in debugging) */
+  name?: string;
+  /** Called when the controller is initialized */
+  $onInit?: () => void;
+  /** Called when one-way bindings are updated */
+  $onChanges?: (changes: OnChangesObject) => void;
+  /** Called before the controller is destroyed */
+  $onDestroy?: () => void;
+  /** Called after the component is linked */
+  $postLink?: () => void;
+}
+/**
+ * Defines a component's configuration 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>;
+}
+/**
+ * A controller instance or object map used in directives.
+ */
+export type DirectiveController =
+  | Controller
+  | Controller[]
+  | {
+      [key: string]: Controller;
+    };
+/**
+ * Represents a controller used within directive link functions.
+ */
+export type TController = DirectiveController | NgModelController;
+/**
+ * Defines optional pre/post link functions in directive compile phase.
+ */
+export interface DirectivePrePost {
+  pre?: DirectiveLinkFn;
+  post?: DirectiveLinkFn;
+}
+/**
+ * A link function executed during directive linking.
+ */
+export type DirectiveLinkFn = (
+  scope: Scope,
+  element: HTMLElement,
+  attrs: Attributes,
+  controller?: TController,
+  transclude?: (...args: any[]) => any,
+) => void;
+/**
+ * A compile function used to prepare directives before linking.
+ */
+export type DirectiveCompileFn = (
+  templateElement: HTMLElement,
+  templateAttributes: Attributes,
+  transclude: (...args: any[]) => any,
+) => void | DirectiveLinkFn | DirectivePrePost;
+/**
+ * Defines the structure of an AngularTS directive.
+ */
+export interface Directive {
+  /** Optional name (usually inferred) */
+  name?: string;
+  /** Restrict option: 'A' and/or 'E'. Defaults to 'EA' */
+  restrict?: string;
+  /** Compile function for the directive */
+  compile?: DirectiveCompileFn;
+  /** Controller constructor or injectable string name */
+  controller?: string | Injectable | any;
+  /** Alias name for the controller in templates */
+  controllerAs?: string;
+  /** Whether to bind scope to controller */
+  bindToController?: boolean | Record<string, string>;
+  /** Link function(s) executed during linking */
+  link?: DirectiveLinkFn | DirectivePrePost;
+  /** Priority of the directive */
+  priority?: number;
+  /** Stops further directive processing if true */
+  terminal?: boolean;
+  /** Replaces the element with the template if true */
+  replace?: boolean;
+  /** Required controllers for the directive */
+  require?: string | string[] | Record<string, string>;
+  /** Scope configuration (`true`, `false`, or object for isolate scope) */
+  scope?: boolean | Record<string, string>;
+  /** Inline template */
+  template?: string | ((element: Element, attrs: Attributes) => string);
+  /** Template namespace (e.g., SVG, HTML) */
+  templateNamespace?: string;
+  /** Template URL for loading from server */
+  templateUrl?: string | ((element: Element, attrs: Attributes) => string);
+  /** Enables transclusion or configures named slots */
+  transclude?: boolean | "element" | Record<string, string>;
+  /** Internal hook for directive compilation state */
+  $$addStateInfo?: (...args: any[]) => any;
+}
+/**
+ * A factory function returning a directive definition.
+ */
+export type DirectiveFactory = (...args: any[]) => Directive | DirectiveLinkFn;
+/**
+ * Represents advanced transclusion functions used in directives.
+ */
+export interface TranscludeFunctionObject {
+  /** Transcludes content with a new scope */
+  transcludeWithScope(
+    scope: Scope,
+    cloneAttachFn: CloneAttachFunction,
+    element?: Element,
+    slotName?: string,
+  ): Element;
+  /** Transcludes content without creating a new scope */
+  transcludeWithoutScope(
+    cloneAttachFn?: CloneAttachFunction,
+    element?: Element,
+    slotName?: string,
+  ): Element;
+  /** Checks if a named slot is filled */
+  isSlotFilled(slotName: string): boolean;
+}
+/**
+ * Callback used when transcluded content is cloned.
+ */
+export type CloneAttachFunction = (
+  clonedElement?: Element,
+  scope?: Scope,
+) => any;
+/**
+ * Configuration for ngModel behavior.
+ */
+export interface NgModelOptions {
+  /** Space-separated event names that trigger updates */
+  updateOn?: string;
+  /** Delay in milliseconds or event-specific debounce times */
+  debounce?: number | Record<string, number>;
+  /** Whether to allow invalid values */
+  allowInvalid?: boolean;
+  /** Enables getter/setter style ngModel */
+  getterSetter?: boolean;
+  /** Timezone used for Date objects */
+  timezone?: string;
+  /** Time display format including seconds */
+  timeSecondsFormat?: string;
+  /** Whether to remove trailing :00 seconds */
+  timeStripZeroSeconds?: boolean;
+}
+/**
+ * Controller API for ngModel directive.
+ */
+export interface NgModelController {
+  /** Updates the view when the model changes */
+  $render(): void;
+  /** Sets the validity state of the control */
+  $setValidity(validationErrorKey: string, isValid: boolean): void;
+  /** Updates the model value */
+  $setViewValue(value: any, trigger?: string): void;
+  /** Marks the control as pristine */
+  $setPristine(): void;
+  /** Marks the control as dirty */
+  $setDirty(): void;
+  /** Re-validates the model */
+  $validate(): void;
+  /** Marks the control as touched */
+  $setTouched(): void;
+  /** Marks the control as untouched */
+  $setUntouched(): void;
+  /** Rolls back to previous view value */
+  $rollbackViewValue(): void;
+  /** Commits the current view value to the model */
+  $commitViewValue(): void;
+  /** Processes view-to-model transformations */
+  $processModelValue(): void;
+  /** Determines if value is considered empty */
+  $isEmpty(value: any): boolean;
+  /** Overrides the model options dynamically */
+  $overrideModelOptions(options: NgModelOptions): void;
+  /** Current value shown in the view */
+  $viewValue: any;
+}

package/@types/loader.d.ts

@@ -9,7 +9,9 @@ export class Angular {
   Cache: Map<number, any>;
   /** @type {import('./core/pubsub/pubsub.js').PubSub} */
   EventBus: import("./core/pubsub/pubsub.js").PubSub;
-  /** @type {string} */
+  /**
+   * @type {string} `version` from `package.json`
+   */
   version: string;
   /** @type {!Array<string|any>} */
   bootsrappedModules: Array<string | any>;
@@ -17,13 +19,14 @@ export class Angular {
   getInjector: typeof getInjector;
   getScope: typeof getScope;
   errorHandlingConfig: typeof errorHandlingConfig;
+  $injectTokens: Readonly<Record<string, string>>;
   /**
-   * Use this function to manually start up AngularJS application.
+   * Use this function to manually start up AngularTS application.
    *
    * AngularTS will detect if it has been loaded into the browser more than once and only allow the
    * first loaded script to be bootstrapped and will report a warning to the browser console for
    * each of the subsequent scripts. This prevents strange results in applications, where otherwise
-   * multiple instances of AngularJS try to work on the DOM.
+   * multiple instances of AngularTS try to work on the DOM.
    *   *
    * <div class="alert alert-warning">
    * **Note:** Do not bootstrap the app on an element with a directive that uses {@link ng.$compile#transclusion transclusion},
@@ -52,24 +55,19 @@ export class Angular {
    * </html>
    * ```
    *
-   * @param {string | Element | Document} element DOM element which is the root of AngularJS application.
+   * @param {string | Element | Document} element DOM element which is the root of AngularTS application.
    * @param {Array<String|any>} [modules] an array of modules to load into the application.
    *     Each item in the array should be the name of a predefined module or a (DI annotated)
    *     function that will be invoked by the injector as a `config` block.
    *     See: {@link angular.module modules}
-   * @param {AngularBootstrapConfig} [config] an object for defining configuration options for the application. The
-   *     following keys are supported:
-   *
-   * * `strictDi` - disable automatic function annotation for the application. This is meant to
-   *   assist in finding bugs which break minified code. Defaults to `false`.
-   *
-   * @returns {any} InjectorService - Returns the newly created injector for this app.
+   * @param {AngularBootstrapConfig} [config]
+   * @returns {import('./core/di/internal-injector.js').InjectorService} The created injector instance for this application.
    */
   bootstrap(
     element: string | Element | Document,
     modules?: Array<string | any>,
     config?: AngularBootstrapConfig,
-  ): any;
+  ): import("./core/di/internal-injector.js").InjectorService;
   $injector: import("./core/di/internal-injector.js").InjectorService;
   /**
    * @param {any[]} modules
@@ -86,13 +84,13 @@ export class Angular {
   init(element: Element | Document): void;
   /**
    *
-   * The `angular.module` is a global place for creating, registering and retrieving AngularJS
+   * The `angular.module` is a global place for creating, registering and retrieving AngularTS
    * modules.
-   * All modules (AngularJS core or 3rd party) that should be available to an application must be
+   * All modules (AngularTS core or 3rd party) that should be available to an application must be
    * registered using this mechanism.
    *
-   * Passing one argument retrieves an existing {@link import('./types.js').Module},
-   * whereas passing more than one argument creates a new {@link import('./types.js').Module}
+   * Passing one argument retrieves an existing {@link import('./interface.ts').Module},
+   * whereas passing more than one argument creates a new {@link import('./interface.ts').Module}
    *
    *
    * # Module
@@ -127,8 +125,8 @@ export class Angular {
    * @param {string} name The name of the module to create or retrieve.
    * @param {Array.<string>} [requires] If specified then new module is being created. If
    *        unspecified then the module is being retrieved for further configuration.
-   * @param {Array<any>|Function} [configFn] Optional configuration function for the module. Same as
-   *        {@link import('./types.js').Module#config Module#config()}.
+   * @param {Array<any>|Function} [configFn] Optional configuration function for the module that gets
+   *        passed to {@link NgModule.config NgModule.config()}.
    * @returns {NgModule} A newly registered module.
    */
   module(

package/@types/public.d.ts

@@ -1,10 +1,9 @@
 /**
- * Initializes `ng`, `animate`, `message`, `aria` and `router` modules.
- * @param {import('./loader').Angular} angular
- * @returns {import('./types.js').Module} `ng`module
+ * Initializes core `ng` module.
+ * @param {import('./loader.js').Angular} angular
+ * @returns {import('./core/di/ng-module.js').NgModule} `ng` module
  */
-export function publishExternalAPI(angular: any): import("./types.js").Module;
-/**
- * @type {string} `version` from `package.json`, injected by Rollup plugin
- */
-export const VERSION: string;
+export function publishExternalAPI(
+  angular: import("./loader.js").Angular,
+): import("./core/di/ng-module.js").NgModule;
+export const VERSION: "[VI]{version}[/VI]";

package/@types/router/common/glob.d.ts

@@ -1,3 +1,8 @@
+/** Returns true if the string has glob-like characters in it
+ *  @param {string} text
+ *  @returns {boolean}
+ */
+export function hasGlobs(text: string): boolean;
 /**
  * Matches state names using glob-like pattern strings.
  *
@@ -45,16 +50,28 @@
  * | `'**.X'`    | `'X'` , `'A.X'` , `'Z.Y.X'`                   | `'A'` , `'A.login.Z'`             |
  * | `'A.**.X'`  | `'A.X'` , `'A.B.X'` , `'A.B.C.X'`             | `'A'` , `'A.B.C'`                 |
  *
- * @packageDocumentation
  */
 export class Glob {
-  /** Returns true if the string has glob-like characters in it */
-  static is(text: any): boolean;
-  /** Returns a glob from the string, or null if the string isn't Glob-like */
-  static fromString(text: any): Glob;
-  constructor(text: any);
-  text: any;
-  glob: any;
+  /** Returns a glob from the string, or null if the string isn't Glob-like
+   * @param {string} text
+   * @returns {?Glob}
+   */
+  static fromString(text: string): Glob | null;
+  /**
+   * @param {string} text
+   */
+  constructor(text: string);
+  /**
+   * @type {string}
+   */
+  text: string;
+  /**
+   * @type {string[]}
+   */
+  glob: string[];
+  /**
+   * @type {RegExp}
+   */
   regexp: RegExp;
   matches(name: any): boolean;
 }