@angular-wave/angular.ts 0.0.34 → 0.0.36

package/{types → types-back}/index.d.ts

@@ -16,6 +16,7 @@ export as namespace ng;
 export = angular;
 
 import ng = angular;
+import { Obj } from "./router";
 
 ///////////////////////////////////////////////////////////////////////////////
 // ng module (angular.js)
@@ -104,7 +105,7 @@ declare namespace angular {
      * @param directiveFactory An injectable directive factory function.
      */
     directive<
-      TScope extends IScope = IScope,
+      TScope extends Scope = Scope,
       TElement extends JQLite = JQLite,
       TAttributes extends IAttributes = IAttributes,
       TController extends IDirectiveController = IController,
@@ -115,7 +116,7 @@ declare namespace angular {
       >,
     ): IModule;
     directive<
-      TScope extends IScope = IScope,
+      TScope extends Scope = Scope,
       TElement extends JQLite = JQLite,
       TAttributes extends IAttributes = IAttributes,
       TController extends IDirectiveController = IController,
@@ -380,14 +381,34 @@ declare namespace angular {
    * $rootScope - $rootScopeProvider - service in module ng
    * see https://docs.angularjs.org/api/ng/type/$rootScope.Scope and https://docs.angularjs.org/api/ng/service/$rootScope
    */
-  interface IScope {
+  class Scope {
+    $id: number;
+    $parent: Scope | null;
+    $root: Scope | null;
+    $$destroyed: boolean;
+    $$isolateBindings: any;
+    $$phase: any;
+
+    $$watchers?: any[];
+    $$nextSibling: Scope | null;
+    $$prevSibling: Scope | null;
+    $$childHead: Scope | null;
+    $$childTail: Scope | null;
+    $$ChildScope: Scope | null;
+    $$watchersCount: number;
+    $$digestWatchIndex: number;
+    $$suspended: boolean;
+
+    $$listeners: Object;
+    $$listenerCount: Object;
+
     $apply(): any;
-    $apply(exp: string): any;
-    $apply(exp: (scope: IScope) => any): any;
+    $apply(expr: string): any;
+    $apply(expr: (scope: Scope) => any): any;
 
     $applyAsync(): any;
     $applyAsync(exp: string): any;
-    $applyAsync(exp: (scope: IScope) => any): any;
+    $applyAsync(exp: (scope: Scope) => any): any;
 
     /**
      * Dispatches an event name downwards to all child scopes (and their children) notifying the registered $rootScope.Scope listeners.
@@ -400,6 +421,11 @@ declare namespace angular {
      * @param args Optional one or more arguments which will be passed onto the event listeners.
      */
     $broadcast(name: string, ...args: any[]): IAngularEvent;
+    private beginPhase(number): void;
+    private clearPhase(): void;
+    private $$postDigest(): void;
+    private incrementWatchersCount(number): void;
+    private decrementListenerCount(number, string): void;
     $destroy(): void;
     $digest(): void;
 
@@ -486,14 +512,14 @@ declare namespace angular {
 
     $eval(): any;
     $eval(expression: string, locals?: Object): any;
-    $eval(expression: (scope: IScope) => any, locals?: Object): any;
+    $eval(expression: (scope: Scope) => any, locals?: Object): any;
 
     $evalAsync(): void;
     $evalAsync(expression: string, locals?: Object): void;
-    $evalAsync(expression: (scope: IScope) => void, locals?: Object): void;
+    $evalAsync(expression: (scope: Scope) => void, locals?: Object): void;
 
     // Defaults to false by the implementation checking strategy
-    $new(isolate?: boolean, parent?: IScope): IScope;
+    $new(isolate?: boolean, parent?: Scope): Scope;
 
     /**
      * Listens on events of a given type. See $emit for discussion of event life cycle.
@@ -515,55 +541,46 @@ declare namespace angular {
     ): () => void;
     $watch<T>(
       watchExpression: string,
-      listener?: (newValue: T, oldValue: T, scope: IScope) => any,
+      listener?: (newValue: T, oldValue: T, scope: Scope) => any,
       objectEquality?: boolean,
     ): () => void;
     $watch(
-      watchExpression: (scope: IScope) => any,
+      watchExpression: (scope: Scope) => any,
       listener?: string,
       objectEquality?: boolean,
     ): () => void;
     $watch<T>(
-      watchExpression: (scope: IScope) => T,
-      listener?: (newValue: T, oldValue: T, scope: IScope) => any,
+      watchExpression: (scope: Scope) => T,
+      listener?: (newValue: T, oldValue: T, scope: Scope) => any,
       objectEquality?: boolean,
     ): () => void;
 
     $watchCollection<T>(
       watchExpression: string,
-      listener: (newValue: T, oldValue: T, scope: IScope) => any,
+      listener: (newValue: T, oldValue: T, scope: Scope) => any,
     ): () => void;
     $watchCollection<T>(
-      watchExpression: (scope: IScope) => T,
-      listener: (newValue: T, oldValue: T, scope: IScope) => any,
+      watchExpression: (scope: Scope) => T,
+      listener: (newValue: T, oldValue: T, scope: Scope) => any,
     ): () => void;
 
     $watchGroup(
       watchExpressions: any[],
-      listener: (newValue: any, oldValue: any, scope: IScope) => any,
+      listener: (newValue: any, oldValue: any, scope: Scope) => any,
     ): () => void;
     $watchGroup(
-      watchExpressions: Array<{ (scope: IScope): any }>,
-      listener: (newValue: any, oldValue: any, scope: IScope) => any,
+      watchExpressions: Array<{ (scope: Scope): any }>,
+      listener: (newValue: any, oldValue: any, scope: Scope) => any,
     ): () => void;
-
-    $parent: IScope;
-    $root: IScope;
-    $id: number;
-
-    // Hidden members
-    $$isolateBindings: any;
-    $$phase: any;
-    $$destroyed: boolean;
   }
 
-  interface IRootScopeService extends IScope {}
+  interface IRootScopeService extends Scope {}
 
   /**
    * $scope for ngRepeat directive.
    * see https://docs.angularjs.org/api/ng/directive/ngRepeat
    */
-  interface IRepeatScope extends IScope {
+  interface IRepeatScope extends Scope {
     /**
      * iterator offset of the repeated element (0..length-1).
      */
@@ -599,11 +616,11 @@ declare namespace angular {
     /**
      * the scope on which the event was $emit-ed or $broadcast-ed.
      */
-    targetScope: IScope;
+    targetScope: Scope;
     /**
      * the scope that is currently handling the event. Once the event propagates through the scope hierarchy, this property is set to null.
      */
-    currentScope: IScope;
+    currentScope: Scope;
     /**
      * name of the event.
      */
@@ -913,8 +930,8 @@ declare namespace angular {
   ///////////////////////////////////////////////////////////////////////////
   interface IParseService {
     (
-      expression: string,
-      interceptorFn?: (value: any, scope: IScope, locals: any) => any,
+      expression: string | ((scope: Scope) => any),
+      interceptorFn?: (value: any, scope: Scope, locals: any) => any,
       expensiveChecks?: boolean,
     ): ICompiledExpression;
   }
@@ -1457,7 +1474,7 @@ declare namespace angular {
 
   interface ICompileProvider extends IServiceProvider {
     directive<
-      TScope extends IScope = IScope,
+      TScope extends Scope = Scope,
       TElement extends JQLite = JQLite,
       TAttributes extends IAttributes = IAttributes,
       TController extends IDirectiveController = IController,
@@ -1468,7 +1485,7 @@ declare namespace angular {
       >,
     ): ICompileProvider;
     directive<
-      TScope extends IScope = IScope,
+      TScope extends Scope = Scope,
       TElement extends JQLite = JQLite,
       TAttributes extends IAttributes = IAttributes,
       TController extends IDirectiveController = IController,
@@ -1543,13 +1560,13 @@ declare namespace angular {
 
   interface ICloneAttachFunction {
     // Let's hint but not force cloneAttachFn's signature
-    (clonedElement?: JQLite, scope?: IScope): any;
+    (clonedElement?: JQLite, scope?: Scope): any;
   }
 
   // This corresponds to the "publicLinkFn" returned by $compile.
   interface ITemplateLinkingFunction {
     (
-      scope: IScope,
+      scope: Scope,
       cloneAttachFn?: ICloneAttachFunction,
       options?: ITemplateLinkingFunctionOptions,
     ): JQLite;
@@ -1573,7 +1590,7 @@ declare namespace angular {
   interface ITranscludeFunction {
     // If the scope is provided, then the cloneAttachFn must be as well.
     (
-      scope: IScope,
+      scope: Scope,
       cloneAttachFn: ICloneAttachFunction,
       futureParentElement?: JQLite,
       slotName?: string,
@@ -1601,7 +1618,7 @@ declare namespace angular {
    * The minimal local definitions required by $controller(ctrl, locals) calls.
    */
   interface IControllerLocals {
-    $scope: ng.IScope;
+    $scope: ng.Scope;
     $element: JQLite;
   }
 
@@ -2268,7 +2285,7 @@ declare namespace angular {
     | { [key: string]: IController };
 
   interface IDirectiveFactory<
-    TScope extends IScope = IScope,
+    TScope extends Scope = Scope,
     TElement extends JQLite = JQLite,
     TAttributes extends IAttributes = IAttributes,
     TController extends IDirectiveController = IController,
@@ -2281,7 +2298,7 @@ declare namespace angular {
   }
 
   interface IDirectiveLinkFn<
-    TScope extends IScope = IScope,
+    TScope extends Scope = Scope,
     TElement extends JQLite = JQLite,
     TAttributes extends IAttributes = IAttributes,
     TController extends IDirectiveController = IController,
@@ -2296,7 +2313,7 @@ declare namespace angular {
   }
 
   interface IDirectivePrePost<
-    TScope extends IScope = IScope,
+    TScope extends Scope = Scope,
     TElement extends JQLite = JQLite,
     TAttributes extends IAttributes = IAttributes,
     TController extends IDirectiveController = IController,
@@ -2310,7 +2327,7 @@ declare namespace angular {
   }
 
   interface IDirectiveCompileFn<
-    TScope extends IScope = IScope,
+    TScope extends Scope = Scope,
     TElement extends JQLite = JQLite,
     TAttributes extends IAttributes = IAttributes,
     TController extends IDirectiveController = IController,
@@ -2332,7 +2349,7 @@ declare namespace angular {
   }
 
   interface IDirective<
-    TScope extends IScope = IScope,
+    TScope extends Scope = Scope,
     TElement extends JQLite = JQLite,
     TAttributes extends IAttributes = IAttributes,
     TController extends IDirectiveController = IController,

package/types-back/router/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Main entry point for angular 1.x build
+ */ /** */
+export * from "./interface";
+export * from "./services";
+export * from "./statebuilders/views";
+export * from "./stateProvider";
+import "./injectables";
+import "./directives/stateDirectives";
+import "./stateFilters";
+import "./directives/viewDirective";
+import "./viewScroll";
+declare const _default: "router";
+export default _default;
+import * as core from "./core/index";
+export { core };
+export * from "./core/index";

package/{types → types-back}/router/interface.d.ts

@@ -1,4 +1,3 @@
-/** @publicapi @module ng1 */ /** */
 import {
   StateDeclaration,
   _ViewDeclaration,

package/{types → types-back}/router/legacy/resolveService.d.ts

@@ -1,4 +1,3 @@
-/** @publicapi @module ng1 */ /** */
 import { Obj } from "../core";
 /** @hidden */
 export declare const resolveFactory: () => {

package/{types → types-back}/router/legacy/stateEvents.d.ts

@@ -1,4 +1,5 @@
-import { IAngularEvent } from "angular";
+import { IAngularEvent } from "../..";
+
 /**
  * An event broadcast on `$rootScope` when the state transition **begins**.
  *

package/types-back/router/services.d.ts

@@ -0,0 +1,15 @@
+import { IRootScopeService } from "../";
+import { ResolveContext, TypedMap } from "./core";
+import { StateProvider } from "./stateProvider";
+declare module "./core/lib/router" {
+  interface Router {
+    /** @hidden */
+    stateProvider: StateProvider;
+  }
+}
+export declare function watchDigests($rootScope: IRootScopeService): void;
+export declare namespace watchDigests {
+  var $inject: string[];
+}
+/** @hidden TODO: find a place to move this */
+export declare const getLocals: (ctx: ResolveContext) => TypedMap<any>;

package/{types → types-back}/router/stateFilters.d.ts

@@ -1,4 +1,3 @@
-/** @publicapi @module ng1 */ /** */
 import { StateService } from "./core";
 declare function $IsStateFilter($state: StateService): any;
 declare namespace $IsStateFilter {

package/{types → types-back}/router/stateProvider.d.ts

@@ -1,4 +1,3 @@
-/** @publicapi @module ng1 */ /** */
 import {
   BuilderFunction,
   StateRegistry,

package/{types → types-back}/router/statebuilders/onEnterExitRetain.d.ts

@@ -1,4 +1,3 @@
-/** @publicapi @module ng1 */ /** */
 import { StateObject, TransitionStateHookFn } from "../core";
 /**
  * This is a [[StateBuilder.builder]] function for angular1 `onEnter`, `onExit`,

package/e2e/unit.spec.ts

@@ -1,16 +0,0 @@
-import { test, expect } from '@playwright/test';
-
-test('unit tests contain no errors', async ({ page }) => {
-  await page.goto('/');
-
-  await page.content();
-  // on average 15-17 seconds
-  // TODO break these up
-  await page.waitForTimeout(20000);
-  //await page.screenshot({ path: 'errors-view.png' , fullPage: true });
-  // Expect a jasmine bar to contain 0 failures
-  console.log(await page.content());
-  await expect(page.locator('.jasmine-overall-result')).toHaveText(/0 failures/);
-  
-});
-

package/public/my_other_directive.html

@@ -1 +0,0 @@
-<div my-other-directive></div>

package/src/directive/if.md

@@ -1,80 +0,0 @@
-/\*\*
-
-- @ngdoc directive
-- @name ngIf
-- @restrict A
-- @multiElement
--
-- @description
-- The `ngIf` directive removes or recreates a portion of the DOM tree based on an
-- {expression}. If the expression assigned to `ngIf` evaluates to a false
-- value then the element is removed from the DOM, otherwise a clone of the
-- element is reinserted into the DOM.
--
-- `ngIf` differs from `ngShow` and `ngHide` in that `ngIf` completely removes and recreates the
-- element in the DOM rather than changing its visibility via the `display` css property. A common
-- case when this difference is significant is when using css selectors that rely on an element's
-- position within the DOM, such as the `:first-child` or `:last-child` pseudo-classes.
--
-- Note that when an element is removed using `ngIf` its scope is destroyed and a new scope
-- is created when the element is restored. The scope created within `ngIf` inherits from
-- its parent scope using
-- [prototypal inheritance](https://github.com/angular/angular.js/wiki/Understanding-Scopes#javascript-prototypal-inheritance).
-- An important implication of this is if `ngModel` is used within `ngIf` to bind to
-- a javascript primitive defined in the parent scope. In this case any modifications made to the
-- variable within the child scope will override (hide) the value in the parent scope.
--
-- Also, `ngIf` recreates elements using their compiled state. An example of this behavior
-- is if an element's class attribute is directly modified after it's compiled, using something like
-- jQuery's `.addClass()` method, and the element is later removed. When `ngIf` recreates the element
-- the added class will be lost because the original compiled state is used to regenerate the element.
--
-- Additionally, you can provide animations via the `ngAnimate` module to animate the `enter`
-- and `leave` effects.
--
-- @animations
-- | Animation | Occurs |
-- |----------------------------------|-------------------------------------|
-- | {@link ng.$animate#enter enter} | just after the `ngIf` contents change and a new DOM element is created and injected into the `ngIf` container |
-- | {@link ng.$animate#leave leave} | just before the `ngIf` contents are removed from the DOM |
--
-- @element ANY
-- @scope
-- @priority 600
-- @param {string} ngIf If the {@link guide/expression expression} is falsy then
--     the element is removed from the DOM tree. If it is truthy a copy of the compiled
--     element is added to the DOM tree.
--
-- @example
-  <example module="ngAnimate" deps="angular-animate.js" animations="true" name="ng-if">
-  <file name="index.html">
-  <label>Click me: <input type="checkbox" ng-model="checked" ng-init="checked=true" /></label><br/>
-  Show when checked:
-  <span ng-if="checked" class="animate-if">
-  This is removed when the checkbox is unchecked.
-  </span>
-  </file>
-  <file name="animations.css">
-  .animate-if {
-  background:white;
-  border:1px solid black;
-  padding:10px;
-  }
-
-       .animate-if.ng-enter, .animate-if.ng-leave {
-         transition:all cubic-bezier(0.250, 0.460, 0.450, 0.940) 0.5s;
-       }
-
-       .animate-if.ng-enter,
-       .animate-if.ng-leave.ng-leave-active {
-         opacity:0;
-       }
-
-       .animate-if.ng-leave,
-       .animate-if.ng-enter.ng-enter-active {
-         opacity:1;
-       }
-
-     </file>
-   </example>
-  */

package/test/build-test.html

@@ -1,14 +0,0 @@
-<!doctype html>
-<html ng-app>
-  <head>
-    <script src="../dist/angular-ts.umd.js"></script>
-  </head>
-  <body>
-    <div>
-      <label>Name:</label>
-      <input type="text" ng-model="yourName" placeholder="Enter a name here" />
-      <hr />
-      <h1>Hello {{yourName}}!</h1>
-    </div>
-  </body>
-</html>

package/test/mock-test.html

@@ -1,13 +0,0 @@
-<!doctype html>
-<html ng-app>
-  <head>
-    <script src="../dist/build/angular.js"></script>
-    <script src="../dist/build/angular-mocks.js"></script>
-  </head>
-  <body ng-init="val = true">
-    <button ng-click="val=!val">Click me</button> {{ val}}
-    <div>
-      <div ng-include="'/mock/interpolation'"></div>
-    </div>
-  </body>
-</html>

package/test/module-test.html

@@ -1,58 +0,0 @@
-<!doctype html>
-<html>
-  <head>
-    <script></script>
-    <script type="module" src="../src/index.js"></script>
-    <script>
-      document.addEventListener("DOMContentLoaded", () => {
-        var myApp = window.angular.module("test", ["ng.router"]);
-        myApp
-          .config(function ($stateProvider) {
-            $stateProvider
-              .state({ name: "top", url: "" })
-              .state({ name: "other", url: "/other/:id", template: "other" })
-              .state({
-                name: "other.detail",
-                url: "/detail",
-                template: "detail",
-              })
-              .state({
-                name: "contacts",
-                url: "/contacts",
-                template:
-                  '<a ng-sref=".item({ id: 5 })" class="item">Person</a> <ng-view></ng-view>',
-              })
-              .state({
-                name: "contacts.item",
-                url: "/{id:int}",
-                template:
-                  '<a ng-sref=".detail" class="item-detail">Detail</a> | <a ng-sref="^" class="item-parent">Parent</a> | <ng-view></ng-view>',
-              })
-              .state({
-                name: "contacts.item.detail",
-                url: "/{id}",
-                template:
-                  '<div class="title">Detail</div> | <a ng-sref="^" class="item-parent2">Item</a>',
-              });
-          })
-          .controller(
-            "TestController",
-            class {
-              constructor($q) {
-                const defer = $q.defer();
-                this.contact = defer.promise;
-                this.test = 1;
-                defer.resolve({ id: 6 });
-              }
-            },
-          );
-      });
-    </script>
-  </head>
-  <body ng-app="test">
-    <div ng-controller="TestController as $ctrl">
-      {{$ctrl.test}}
-      <a ng-sref="contacts.item.detail({ id: contact.id })">Details</a>
-    </div>
-  </body>
-</html>

package/types/router/locationServices.d.ts

@@ -1,50 +0,0 @@
-/** @publicapi @module ng1 */ /** */
-import { LocationConfig, LocationServices, Router } from "./core";
-import { ILocationService, ILocationProvider, IWindowService } from "../index";
-/**
- * Implements Router LocationServices and LocationConfig using Angular 1's $location service
- * @internalapi
- */
-export declare class Ng1LocationServices
-  implements LocationConfig, LocationServices
-{
-  private $locationProvider;
-  private $location;
-  private $sniffer;
-  private $browser;
-  private $window;
-  path: any;
-  search: any;
-  hash: any;
-  hashPrefix: any;
-  port: any;
-  protocol: any;
-  host: any;
-  private _baseHref;
-  private _urlListeners;
-  /**
-   * Applys ng1-specific path parameter encoding
-   *
-   * The Angular 1 `$location` service is a bit weird.
-   * It doesn't allow slashes to be encoded/decoded bi-directionally.
-   *
-   * See the writeup at https://github.com/angular-ui/ui-router/issues/2598
-   *
-   * This code patches the `path` parameter type so it encoded/decodes slashes as ~2F
-   *
-   * @param router
-   */
-  static monkeyPatchPathParameterType(router: Router): void;
-  constructor($locationProvider: ILocationProvider);
-  onChange(callback: Function): () => Function[];
-  html5Mode(): any;
-  baseHref(): any;
-  url(newUrl?: string, replace?: boolean, state?: any): string;
-  _runtimeServices(
-    $rootScope: any,
-    $location: ILocationService,
-    $sniffer: any,
-    $browser: any,
-    $window: IWindowService,
-  ): void;
-}