@angular-wave/angular.ts 0.0.51 → 0.0.52

package/types/directive/select/select.d.ts

@@ -0,0 +1,79 @@
+export function selectDirective(): {
+    restrict: string;
+    require: string[];
+    controller: typeof SelectController;
+    priority: number;
+    link: {
+        pre: (scope: any, element: any, attr: any, ctrls: any) => void;
+        post: (scope: any, element: any, attrs: any, ctrls: any) => void;
+    };
+};
+export const optionDirective: (string | (($interpolate: any) => {
+    restrict: string;
+    priority: number;
+    compile(element: any, attr: any): (scope: any, element: any, attr: any) => void;
+}))[];
+declare function SelectController($element: any, $scope: any): void;
+declare class SelectController {
+    constructor($element: any, $scope: any);
+    selectValueMap: {};
+    ngModelCtrl: {
+        $setViewValue: () => void;
+        $render: () => void;
+    };
+    multiple: boolean;
+    unknownOption: JQLite;
+    hasEmptyOption: boolean;
+    emptyOption: any;
+    renderUnknownOption: (val: any) => void;
+    updateUnknownOption: (val: any) => void;
+    generateUnknownOptionValue: (val: any) => string;
+    removeUnknownOption: () => void;
+    selectEmptyOption: () => void;
+    unselectEmptyOption: () => void;
+    readValue: () => any;
+    writeValue: (value: any) => void;
+    addOption: (value: any, element: any) => void;
+    removeOption: (value: any) => void;
+    hasOption: (value: any) => boolean;
+    /**
+     * @ngdoc method
+     * @name select.SelectController#$hasEmptyOption
+     *
+     * @description
+     *
+     * Returns `true` if the select element currently has an empty option
+     * element, i.e. an option that signifies that the select is empty / the selection is null.
+     *
+     */
+    $hasEmptyOption: () => boolean;
+    /**
+     * @ngdoc method
+     * @name select.SelectController#$isUnknownOptionSelected
+     *
+     * @description
+     *
+     * Returns `true` if the select element's unknown option is selected. The unknown option is added
+     * and automatically selected whenever the select model doesn't match any option.
+     *
+     */
+    $isUnknownOptionSelected: () => boolean;
+    /**
+     * @ngdoc method
+     * @name select.SelectController#$isEmptyOptionSelected
+     *
+     * @description
+     *
+     * Returns `true` if the select element has an empty option and this empty option is currently
+     * selected. Returns `false` if the select element has no empty option or it is not selected.
+     *
+     */
+    $isEmptyOptionSelected: () => boolean;
+    selectUnknownOrEmptyOption: (value: any) => void;
+    registerOption: (optionScope: any, optionElement: any, optionAttrs: any, interpolateValueFn: any, interpolateTextFn: any) => void;
+}
+declare namespace SelectController {
+    let $inject: string[];
+}
+import { JQLite } from "../../shared/jqlite/jqlite";
+export {};

package/types/router/directives/state-directives.d.ts

@@ -0,0 +1,31 @@
+export function $StateRefDirective($stateService: any, $timeout: any, $stateRegistry: any, $transitions: any): {
+    restrict: string;
+    require: string[];
+    link: (scope: any, element: any, attrs: any, ngSrefActive: any) => void;
+};
+export namespace $StateRefDirective {
+    let $inject: string[];
+}
+export function $StateRefDynamicDirective($state: any, $timeout: any, $stateRegistry: any, $transitions: any): {
+    restrict: string;
+    require: string[];
+    link: (scope: any, element: any, attrs: any, ngSrefActive: any) => void;
+};
+export namespace $StateRefDynamicDirective {
+    let $inject_1: string[];
+    export { $inject_1 as $inject };
+}
+/**
+ *
+ * @param {*} $state
+ * @param {*} $routerGlobals
+ * @param {*} $interpolate
+ * @param {*} $stateRegistry
+ * @param {*} $transitions
+ * @returns {import("../../types").Directive}
+ */
+export function $StateRefActiveDirective($state: any, $routerGlobals: any, $interpolate: any, $stateRegistry: any, $transitions: any): import("../../types").Directive;
+export namespace $StateRefActiveDirective {
+    let $inject_2: string[];
+    export { $inject_2 as $inject };
+}

package/src/core/document.spec.js

@@ -1,52 +0,0 @@
-import { publishExternalAPI } from "../public";
-import { createInjector } from "../injector";
-import { JQLite } from "../shared/jqlite/jqlite";
-
-describe("$document", () => {
-  let $document, $httpBackend, $http, $$isDocumentHidden;
-
-  beforeEach(() => {
-    publishExternalAPI();
-    var injector = createInjector(["ng"]);
-    $document = injector.get("$document");
-    $httpBackend = injector.get("$httpBackend");
-    $http = injector.get("$http");
-    $$isDocumentHidden = injector.get("$$isDocumentHidden");
-  });
-
-  it("should inject $document", () => {
-    expect($document).toEqual(JQLite(window.document));
-  });
-});
-
-describe("$$isDocumentHidden", () => {
-  let $rootScope;
-
-  beforeEach(() => {
-    publishExternalAPI();
-    var injector = createInjector(["ng"]);
-    $rootScope = injector.get("$rootScope");
-  });
-
-  it("should listen on the visibilitychange event", () => {
-    let doc;
-
-    const spy = spyOn(window.document, "addEventListener").and.callThrough();
-
-    () => {
-      expect(spy.calls.mostRecent().args[0]).toBe("visibilitychange");
-      expect(spy.calls.mostRecent().args[1]).toEqual(jasmine.any(Function));
-      expect($$isDocumentHidden()).toBeFalsy(); // undefined in browsers that don't support visibility
-    };
-  });
-
-  it("should remove the listener when the $rootScope is destroyed", () => {
-    const spy = spyOn(window.document, "removeEventListener").and.callThrough();
-
-    () => {
-      $rootScope.$destroy();
-      expect(spy.calls.mostRecent().args[0]).toBe("visibilitychange");
-      expect(spy.calls.mostRecent().args[1]).toEqual(jasmine.any(Function));
-    };
-  });
-});