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

package/.github/workflows/ci.yml

@@ -5,25 +5,58 @@ permissions:
 
 on:
   push:
-    branches: [main, master]
+    branches:
+      - master
   pull_request:
-    branches: [main, master]
+    branches:
+      - master
 
 jobs:
-  # 1. Lint check
-  lint:
+  setup:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+
       - uses: actions/setup-node@v4
         with:
           node-version: lts/*
+
+      - name: Cache node_modules and Playwright
+        uses: actions/cache@v4
+        with:
+          path: |
+            node_modules
+            ~/.cache/ms-playwright
+          key: deps-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
+          restore-keys: |
+            deps-${{ runner.os }}-
+
       - name: Install dependencies
         run: npm ci
+
+      - name: Install Playwright browsers
+        run: npx playwright install --with-deps
+
+  lint:
+    needs: setup
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: lts/*
+      - name: Restore node_modules cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            node_modules
+            ~/.cache/ms-playwright
+          key: deps-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
+          restore-keys: |
+            deps-${{ runner.os }}-
       - name: Run lint check
-        run: ./node_modules/.bin/eslint ./src
+        run: npx eslint ./src
 
-  # 2. TypeScript check
   typescript:
     needs: lint
     runs-on: ubuntu-latest
@@ -32,12 +65,18 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: lts/*
-      - name: Install dependencies
-        run: npm ci
+      - name: Restore node_modules cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            node_modules
+            ~/.cache/ms-playwright
+          key: deps-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
+          restore-keys: |
+            deps-${{ runner.os }}-
       - name: Run TypeScript check
-        run: ./node_modules/.bin/tsc
+        run: npx tsc
 
-  # 3. Playwright tests
   playwright:
     needs: typescript
     runs-on: ubuntu-latest
@@ -46,10 +85,15 @@ jobs:
       - uses: actions/setup-node@v4
         with:
           node-version: lts/*
-      - name: Install dependencies
-        run: npm ci
-      - name: Install Playwright Browsers
-        run: npx playwright install --with-deps
+      - name: Restore node_modules cache
+        uses: actions/cache@v4
+        with:
+          path: |
+            node_modules
+            ~/.cache/ms-playwright
+          key: deps-${{ runner.os }}-${{ hashFiles('package-lock.json') }}
+          restore-keys: |
+            deps-${{ runner.os }}-
       - name: Run Playwright tests
         run: npx playwright test
       - uses: actions/upload-artifact@v4

package/.github/workflows/gh-pages.yml

@@ -0,0 +1,75 @@
+# Sample workflow for building and deploying a Hugo site to GitHub Pages
+name: Deploy Hugo site to Pages
+
+on:
+  # Runs on pushes targeting the default branch
+  push:
+    branches: ["master"]
+
+  # Allows you to run this workflow manually from the Actions tab
+  workflow_dispatch:
+
+# Sets permissions of the GITHUB_TOKEN to allow deployment to GitHub Pages
+permissions:
+  contents: read
+  pages: write
+  id-token: write
+
+# Allow only one concurrent deployment, skipping runs queued between the run in-progress and latest queued.
+# However, do NOT cancel in-progress runs as we want to allow these production deployments to complete.
+concurrency:
+  group: "pages"
+  cancel-in-progress: false
+
+# Default to bash
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  # Build job
+  build:
+    runs-on: ubuntu-latest
+    env:
+      HUGO_VERSION: 0.146.0
+    steps:
+      - name: Install Hugo CLI
+        run: |
+          wget -O ${{ runner.temp }}/hugo.deb https://github.com/gohugoio/hugo/releases/download/v${HUGO_VERSION}/hugo_extended_${HUGO_VERSION}_linux-amd64.deb \
+          && sudo dpkg -i ${{ runner.temp }}/hugo.deb
+      - name: Install Dart Sass
+        run: sudo snap install dart-sass
+      - name: Checkout
+        uses: actions/checkout@v4
+        with:
+          submodules: recursive
+      - name: Setup Pages
+        id: pages
+        uses: actions/configure-pages@v5
+      - name: Install Node.js dependencies
+        run: cd docs && [[ -f package-lock.json || -f npm-shrinkwrap.json ]] && npm ci || true
+      - name: Build with Hugo
+        env:
+          HUGO_CACHEDIR: ${{ runner.temp }}/hugo_cache
+          HUGO_ENVIRONMENT: production
+        run: |
+          hugo \
+            --source docs \
+            --minify \
+            --baseURL "${{ steps.pages.outputs.base_url }}/"
+      - name: Upload artifact
+        uses: actions/upload-pages-artifact@v3
+        with:
+          path: ./docs/public
+
+  # Deployment job
+  deploy:
+    environment:
+      name: github-pages
+      url: ${{ steps.deployment.outputs.page_url }}
+    runs-on: ubuntu-latest
+    needs: build
+    steps:
+      - name: Deploy to GitHub Pages
+        id: deployment
+        uses: actions/deploy-pages@v4

package/@types/animations/animate.d.ts

@@ -1,6 +1,10 @@
-export function AnimateProvider($provide: any): void;
+/** @param {import('../interface.ts').Provider} $provide */
+export function AnimateProvider(
+  $provide: import("../interface.ts").Provider,
+): void;
 export class AnimateProvider {
-  constructor($provide: any);
+  /** @param {import('../interface.ts').Provider} $provide */
+  constructor($provide: import("../interface.ts").Provider);
   $$registeredAnimations: any;
   /**
    * Registers a new injectable animation factory function. The factory function produces the
@@ -34,10 +38,13 @@ export class AnimateProvider {
    * ```
    *
    * @param {string} name The name of the animation (this is what the class-based CSS value will be compared to).
-   * @param {Function} factory The factory function that will be executed to return the animation
+   * @param {import("../interface.ts").Injectable} factory The factory function that will be executed to return the animation
    *                           object.
    */
-  register: (name: string, factory: Function) => void;
+  register: (
+    name: string,
+    factory: import("../interface.ts").Injectable,
+  ) => void;
   /**
    * Sets and/or returns the custom filter function that is used to "filter" animations, i.e.
    * determine if an animation is allowed or not. When no filter is specified (the default), no

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

@@ -1,4 +1,7 @@
-export class Attributes {
+/**
+ * @implements {Record<string, any>}
+ */
+export class Attributes implements Record<string, any> {
   static $nonscope: boolean;
   /**
    * @param {import('../scope/scope.js').Scope} $rootScope
@@ -6,7 +9,7 @@ export class Attributes {
    * @param {import("../exception-handler.js").ErrorHandler} $exceptionHandler
    * @param {*} $sce
    * @param {import("../../shared/noderef.js").NodeRef} [nodeRef]
-   * @param {*} [attributesToCopy]
+   * @param {Object} [attributesToCopy]
    */
   constructor(
     $rootScope: import("../scope/scope.js").Scope,

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

@@ -3,11 +3,11 @@ export class CompileProvider {
   static $inject: string[];
   /**
    * @param {import('../../interface.js').Provider} $provide
-   * @param $$sanitizeUriProvider
+   * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $$sanitizeUriProvider
    */
   constructor(
     $provide: import("../../interface.js").Provider,
-    $$sanitizeUriProvider: any,
+    $$sanitizeUriProvider: import("../sanitize/sanitize-uri.js").SanitizeUriProvider,
   );
   /**
    * Register a new directive with the compiler.
@@ -80,12 +80,12 @@ export class CompileProvider {
    * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
    *
    * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|CompileProvider} Current RegExp if called without value or self for
+   * @returns {RegExp|import('../sanitize/sanitize-uri.js').SanitizeUriProvider} Current RegExp if called without value or self for
    *    chaining otherwise.
    */
   aHrefSanitizationTrustedUrlList: (
     regexp?: RegExp | undefined,
-  ) => RegExp | CompileProvider;
+  ) => RegExp | import("../sanitize/sanitize-uri.js").SanitizeUriProvider;
   /**
    * Retrieves or overrides the default regular expression that is used for determining trusted safe
    * urls during img[src] sanitization.
@@ -98,12 +98,12 @@ export class CompileProvider {
    * the absolute url is prefixed with `'unsafe:'` string and only then is it written into the DOM.
    *
    * @param {RegExp=} regexp New regexp to trust urls with.
-   * @returns {RegExp|CompileProvider} Current RegExp if called without value or self for
+   * @returns {RegExp|import('../sanitize/sanitize-uri.js').SanitizeUriProvider} Current RegExp if called without value or self for
    *    chaining otherwise.
    */
   imgSrcSanitizationTrustedUrlList: (
     regexp?: RegExp | undefined,
-  ) => RegExp | CompileProvider;
+  ) => RegExp | import("../sanitize/sanitize-uri.js").SanitizeUriProvider;
   strictComponentBindingsEnabled: (enabled: any) => boolean | this;
   /**
    * Defines the security context for DOM properties bound by ng-prop-*.

package/@types/core/di/injector.d.ts

@@ -20,5 +20,4 @@ export function annotate(
   strictDi?: boolean,
   name?: string,
 ): Array<string>;
-/** @type {String[]} Used only for error reporting of circular dependencies*/
-export const path: string[];
+import { InjectorService } from "./internal-injector.js";

package/@types/core/di/internal-injector.d.ts

@@ -8,6 +8,12 @@ export class ProviderInjector extends AbstractInjector {
    * @param {boolean} strictDi - Indicates if strict dependency injection is enforced.
    */
   constructor(cache: any, strictDi: boolean);
+  /**
+   * Factory method for creating services.
+   * @param {string} caller - The name of the caller requesting the service.
+   * @throws {Error} If the provider is unknown.
+   */
+  factory(caller: string): void;
 }
 /**
  * Injector for factories and services
@@ -21,11 +27,6 @@ export class InjectorService extends AbstractInjector {
    */
   constructor(strictDi: boolean, providerInjector: ProviderInjector);
   providerInjector: ProviderInjector;
-  /**
-   * @param {string} serviceName
-   * @returns {*}
-   */
-  factory(serviceName: string): any;
   /**
    *
    * @param {string} name
@@ -44,7 +45,8 @@ declare class AbstractInjector {
   cache: any;
   /** @type {boolean} */
   strictDi: boolean;
-  path: any[];
+  /** @type {string[]} */
+  path: string[];
   /** @type {Object.<string, import("./ng-module.js").NgModule>} */
   modules: {
     [x: string]: import("./ng-module.js").NgModule;
@@ -94,7 +96,8 @@ declare class AbstractInjector {
   /**
    * @abstract
    * @param {string} _serviceName
+   * @returns {any}
    */
-  factory(_serviceName: string): void;
+  factory(_serviceName: string): any;
 }
 export {};

package/@types/core/di/ng-module.d.ts

@@ -1,4 +1,3 @@
-export const PROVIDE_LITERAL: "$provide";
 export const INJECTOR_LITERAL: "$injector";
 export const COMPILE_LITERAL: "$compileProvider";
 export const ANIMATION_LITERAL: "$animateProvider";

package/@types/core/error-handler.d.ts

@@ -2,6 +2,6 @@
  * A callback type for handling errors.
  *
  * @param exception - The exception associated with the error.
- * @param cause - Optional information about the context in which the error was thrown.
+ * @param [cause] - Optional information about the context in which the error was thrown.
  */
 export type ErrorHandler = (exception: Error, cause?: string) => void;

package/@types/core/exception-handler.d.ts

@@ -42,7 +42,7 @@
  * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
  */
 /** @typedef {import('../services/log').LogService} LogService */
-/** @typedef {import("./error-handler.ts").ErrorHandler }  ErrorHandler */
+/** @typedef {import("./error-handler.ts").ErrorHandler}  ErrorHandler */
 /**
  * Provider for `$exceptionHandler` service. Delegates uncaught exceptions to `$log.error()` by default.
  * Can be overridden to implement custom error-handling logic.

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

@@ -1,7 +1,7 @@
 import type { DecoratedASTNode } from "./interpreter.js";
 import type { Scope } from "../scope/scope.js";
 /**
- * Describes metadata and behavior for a compiled AngularJS expression.
+ * Describes metadata and behavior for a compiled AngularTS expression.
  */
 export interface CompiledExpressionProps {
   /** Indicates if the expression is a literal. */
@@ -41,7 +41,7 @@ export interface CompiledExpressionProps {
  * Evaluates the compiled expression.
  */
 export type CompiledExpressionFunction = (
-  context: Scope,
+  context?: Scope,
   locals?: object,
   assign?: any,
 ) => any;
@@ -73,7 +73,7 @@ export interface CompiledExpressionHandlerMap {
  * @returns A compiled expression.
  */
 export type ParseService = (
-  expression: CompiledExpression | string | ((scope: Scope) => any),
+  expression?: CompiledExpression | string | ((scope: Scope) => any),
   interceptorFn?: (value: any, scope: Scope, locals: any) => any,
   expensiveChecks?: boolean,
 ) => CompiledExpression;

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

@@ -1,3 +1,19 @@
+/** @typedef {import('../../interface.js').ServiceProvider} ServiceProvider
+
+/**
+ * Configurable provider for an injectable event bus
+ * @implements {ServiceProvider}
+ */
+export class PubSubProvider implements ServiceProvider {
+  /**
+   * @type {PubSub}
+   */
+  eventBus: PubSub;
+  /**
+   * @returns {PubSub}
+   */
+  $get: () => PubSub;
+}
 export class PubSub {
   /**
    * Runs a function asynchronously.
@@ -162,3 +178,8 @@ export class PubSub {
   dispose(): void;
 }
 export const EventBus: PubSub;
+/**
+ * /**
+ * Configurable provider for an injectable event bus
+ */
+export type ServiceProvider = import("../../interface.js").ServiceProvider;

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

@@ -10,10 +10,7 @@ export class SceProvider {
    * Enables/disables SCE and returns the current value.
    */
   enabled: (value?: boolean | undefined, ...args: any[]) => boolean;
-  $get: (
-    | string
-    | (($parse: any, $sceDelegate: any, $exceptionHandler: any) => any)
-  )[];
+  $get: (string | (($parse: any, $sceDelegate: any) => any))[];
 }
 export namespace SCE_CONTEXTS {
   let HTML: string;
@@ -236,7 +233,7 @@ export class SceDelegateProvider {
   $get: (
     | string
     | ((
-        $injector: any,
+        $injector: import("../../core/di/internal-injector.js").InjectorService,
         $$sanitizeUri: any,
         $exceptionHandler: ErrorHandler,
       ) => {

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

@@ -119,10 +119,15 @@ export class Scope {
    * @param {Object} target - The target object.
    * @param {string} property - The name of the property being set.
    * @param {*} value - The new value being assigned to the property.
+   * @param {Proxy} proxy - The proxy intercepting property access
    * @returns {boolean} - Returns true to indicate success of the operation.
    */
-  set(target: any, property: string, value: any, proxy: any): boolean;
-  checkeListenersForAllKeys(value: any): void;
+  set(
+    target: any,
+    property: string,
+    value: any,
+    proxy: ProxyConstructor,
+  ): boolean;
   /**
    * Intercepts property access on the target object. It checks for specific
    * properties (`watch` and `sync`) and binds their methods. For other properties,
@@ -140,8 +145,6 @@ export class Scope {
   ): any;
   propertyMap: {
     $watch: any;
-    $watchGroup: any;
-    $watchCollection: any;
     $new: any;
     $newIsolate: any;
     $destroy: any;
@@ -161,16 +164,9 @@ export class Scope {
     $root: Scope;
     $children: Scope[];
     $id: number;
-    registerForeignKey: any;
-    notifyListener: any;
     $merge: any;
     $getById: any;
   };
-  /**
-   * @private
-   * @param {Listener[]} listeners
-   */
-  private scheduleListener;
   deleteProperty(target: any, property: any): boolean;
   /**
    * Registers a watcher for a property along with a listener function. The listener
@@ -185,24 +181,30 @@ export class Scope {
     listenerFn?: ListenerFunction,
     lazy?: boolean,
   ): () => void;
-  $watchGroup(watchArray: any, listenerFn: any): void;
-  $watchCollection(watchProp: any, listenerFn: any): () => void;
   $new(childInstance: any): any;
   $newIsolate(instance: any): any;
   $transcluded(parentInstance: any): any;
-  registerKey(key: any, listener: any): void;
-  registerForeignKey(key: any, listener: any): void;
-  deregisterKey(key: any, id: any): boolean;
-  deregisterForeignKey(key: any, id: any): boolean;
   $eval(expr: any, locals: any): any;
   $evalAsync(expr: any, locals: any): Promise<any>;
+  /**
+   * @param {Object} newTarget
+   */
   $merge(newTarget: any): void;
-  $apply(expr: any): any;
-  $on(name: any, listener: any): () => void;
+  /**
+   * @param {import('../../interface.js').Expression} expr
+   * @returns {any}
+   */
+  $apply(expr: import("../../interface.js").Expression): any;
+  /**
+   * @param {string} name
+   * @param {Function} listener
+   * @returns {(function(): void)|*}
+   */
+  $on(name: string, listener: Function): (() => void) | any;
   /**
    * @param {string} name
    * @param  {...any} args
-   * @returns
+   * @returns {void}
    */
   $emit(name: string, ...args: any[]): void;
   /**
@@ -211,24 +213,8 @@ export class Scope {
    * @returns {any}
    */
   $broadcast(name: string, ...args: any[]): any;
-  /**
-   * @private
-   * @returns {void}
-   */
-  private eventHelper;
-  /**
-   * @private
-   * @returns {boolean}
-   */
-  private isRoot;
   $postUpdate(fn: any): void;
   $destroy(): void;
-  /**
-   * Invokes the registered listener function with watched property changes.
-   *
-   * @param {Listener} listener - The property path that was changed.
-   */
-  notifyListener(listener: Listener, target: any): void;
   /**
    * Searches the scope instance
    *
@@ -236,6 +222,7 @@ export class Scope {
    * @returns {Scope|undefined}
    */
   $getById(id: string | number): Scope | undefined;
+  #private;
 }
 export type AsyncQueueTask = {
   handler: Scope;

package/@types/core/task-tracker-factory.d.ts

@@ -1,8 +1,11 @@
-export class TaskTrackerFactoryProvider {
-  $get: (
-    | string
-    | ((log: import("../services/log.js").LogService) => TaskTracker)
-  )[];
+/** @typedef {import('../interface.ts').ServiceProvider} ServiceProvider */
+/** @typedef {import('../interface.ts').AnnotatedFactory} AnnotatedFactory */
+/**
+ * @implements {ServiceProvider}
+ */
+export class TaskTrackerFactoryProvider implements ServiceProvider {
+  /** @type {AnnotatedFactory} */
+  $get: AnnotatedFactory;
 }
 /**
  * A factory function to create `TaskTracker` instances.
@@ -69,3 +72,5 @@ export class TaskTracker {
    */
   private getLastCallbackForType;
 }
+export type ServiceProvider = import("../interface.ts").ServiceProvider;
+export type AnnotatedFactory = import("../interface.ts").AnnotatedFactory;

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

@@ -46,7 +46,10 @@ export function ngClickAriaDirective(
   $parse: any,
 ): {
   restrict: string;
-  compile(elem: any, attr: any): (scope: any, elem: Element, attr: any) => void;
+  compile(
+    _elem: any,
+    attr: any,
+  ): (scope: any, elem: Element, attr: any) => void;
 };
 export namespace ngClickAriaDirective {
   let $inject_2: string[];

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

@@ -3,29 +3,15 @@
  * @param {*} $templateRequest
  * @param {import("../../services/anchor-scroll.js").AnchorScrollFunction} $anchorScroll
  * @param {*} $animate
- * @returns
+ * @param {import('../../core/error-handler.js').ErrorHandler} $exceptionHandler
+ * @returns {import('../../interface.js').Directive}
  */
 export function ngIncludeDirective(
   $templateRequest: any,
   $anchorScroll: import("../../services/anchor-scroll.js").AnchorScrollFunction,
   $animate: any,
-): {
-  restrict: string;
-  priority: number;
-  terminal: boolean;
-  transclude: string;
-  controller: () => void;
-  compile(
-    _element: any,
-    attr: any,
-  ): (
-    scope: any,
-    $element: any,
-    _$attr: any,
-    ctrl: any,
-    $transclude: any,
-  ) => void;
-};
+  $exceptionHandler: import("../../core/error-handler.js").ErrorHandler,
+): import("../../interface.js").Directive;
 export namespace ngIncludeDirective {
   let $inject: string[];
 }

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

@@ -12,7 +12,7 @@ export const ngOptionsDirective: (
         post: (
           scope: import("../../core/scope/scope.js").Scope,
           selectElement: HTMLSelectElement,
-          attr: any,
+          attr: import("../../core/compile/attributes.js").Attributes,
           ctrls: any,
         ) => void;
       };

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>>;