@angular-wave/angular.ts 0.7.0-beta.0 → 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/.husky/pre-commit

@@ -1,3 +1,5 @@
+make lint
+make check
 make types
 make pretty
 git add ./

package/@types/animations/animate-children-directive.d.ts

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

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

@@ -1,9 +1,9 @@
 /**
- * @returns {import('../types.js').Directive}
+ * @returns {import('../interface.ts').Directive}
  */
 export function ngAnimateSwapDirective(
   $animate: any,
-): import("../types.js").Directive;
+): import("../interface.ts").Directive;
 export namespace ngAnimateSwapDirective {
   let $inject: string[];
 }

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
@@ -168,7 +175,7 @@ export class AnimateProvider {
         off: any;
         /**
          *  Associates the provided element with a host parent element to allow the element to be animated even if it exists
-         *  outside of the DOM structure of the AngularJS application. By doing so, any animation triggered via `$animate` can be issued on the
+         *  outside of the DOM structure of the AngularTS application. By doing so, any animation triggered via `$animate` can be issued on the
          *  element despite being outside the realm of the application or within another application. Say for example if the application
          *  was bootstrapped on an element that is somewhere inside of the `<body>` tag, but we wanted to allow for an element to be situated
          *  as a direct child of `document.body`, then this can be achieved by pinning the element via `$animate.pin(element)`. Keep in mind

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

@@ -0,0 +1,17 @@
+export type RafScheduler = {
+  /**
+   * Schedules a list of functions to run on the next animation frame(s).
+   * @param tasks - The tasks to be scheduled.
+   */
+  (tasks: Array<() => void>): void;
+  /**
+   * Internal queue of scheduled task arrays.
+   */
+  queue: Array<Array<() => void>>;
+  /**
+   * Waits until the animation frame is quiet before running the provided function.
+   * Cancels any previous animation frame requests.
+   * @param fn - The function to run when the frame is quiet.
+   */
+  waitUntilQuiet(fn: () => void): void;
+};

package/@types/animations/raf-scheduler.d.ts

@@ -1,24 +1,37 @@
 /**
- * @typedef {Function} RafSchedulerFunction
- * @typedef {Object} RafSchedulerObject
- * @property {Function} waitUntilQuiet - Function to wait until the animation frame is quiet.
- * @typedef {RafSchedulerObject & RafSchedulerFunction} RafScheduler
+ * @typedef {import('./interface.js').RafScheduler} RafScheduler
+ * @typedef {import('../interface.js').ServiceProvider} ServiceProvider
  */
 /**
- * Creates a requestAnimationFrame scheduler.
+ * Service provider that creates a requestAnimationFrame-based scheduler.
+ * @implements {ServiceProvider}
  */
-export function RafSchedulerProvider(): void;
-export class RafSchedulerProvider {
+export class RafSchedulerProvider implements ServiceProvider {
   /**
-   * @returns {RafScheduler} The scheduler object.
+   * Internal task queue, where each item is an array of functions to run.
+   * @type {Array<Array<() => void>>}
    */
-  $get: () => RafScheduler;
-}
-export type RafSchedulerFunction = Function;
-export type RafSchedulerObject = {
+  queue: Array<Array<() => void>>;
+  /**
+   * ID of the currently scheduled animation frame (if any).
+   * Used for cancellation and tracking.
+   * @type {number|null}
+   */
+  cancelFn: number | null;
   /**
-   * - Function to wait until the animation frame is quiet.
+   * Processes the next batch of tasks in the animation frame.
+   * Executes the first group of functions in the queue, then
+   * schedules the next frame if needed.
    */
-  waitUntilQuiet: Function;
-};
-export type RafScheduler = RafSchedulerObject & RafSchedulerFunction;
+  nextTick(): void;
+  /**
+   * Returns the scheduler function.
+   * This function allows tasks to be queued for execution on future animation frames.
+   * It also has helper methods and state attached.
+   *
+   * @returns {RafScheduler} The scheduler function with `queue` and `waitUntilQuiet`.
+   */
+  $get(): RafScheduler;
+}
+export type RafScheduler = import("./interface.js").RafScheduler;
+export type ServiceProvider = import("../interface.js").ServiceProvider;

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,
@@ -18,7 +21,7 @@ export class Attributes {
   );
   $rootScope: import("../scope/scope.js").Scope;
   $animate: any;
-  $exceptionHandler: import("../exception-handler.js").ErrorHandler;
+  $exceptionHandler: import("../error-handler.ts").ErrorHandler;
   $sce: any;
   $attr: {};
   /** @type {import("../../shared/noderef.js").NodeRef} */

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

@@ -1,9 +1,14 @@
-export function CompileProvider(
-  $provide: any,
-  $$sanitizeUriProvider: any,
-): void;
+export const DirectiveSuffix: "Directive";
 export class CompileProvider {
-  constructor($provide: any, $$sanitizeUriProvider: any);
+  static $inject: string[];
+  /**
+   * @param {import('../../interface.js').Provider} $provide
+   * @param {import('../sanitize/sanitize-uri.js').SanitizeUriProvider} $$sanitizeUriProvider
+   */
+  constructor(
+    $provide: import("../../interface.js").Provider,
+    $$sanitizeUriProvider: import("../sanitize/sanitize-uri.js").SanitizeUriProvider,
+  );
   /**
    * Register a new directive with the compiler.
    *
@@ -75,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.
@@ -93,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-*.
@@ -120,7 +125,7 @@ export class CompileProvider {
         $interpolate: any,
         $exceptionHandler: import("../exception-handler.js").ErrorHandler,
         $templateRequest: any,
-        $parse: import("../parse/parse.js").ParseService,
+        $parse: import("../parse/interface.ts").ParseService,
         $controller: any,
         $rootScope: import("../scope/scope.js").Scope,
         $sce: any,
@@ -134,10 +139,6 @@ export class CompileProvider {
       ) => PublicLinkFn)
   )[];
 }
-export namespace CompileProvider {
-  let $inject: string[];
-}
-export const DirectiveSuffix: "Directive";
 /**
  * A function passed as the fifth argument to a {@type PublicLinkFn} link function.
  * It behaves like a linking function, with the `scope` argument automatically created
@@ -165,7 +166,7 @@ export type PublicLinkFn = (
   scope: import("../scope/scope.js").Scope,
   cloneConnectFn?: TranscludeFn,
   options?: any,
-) => Element | Node | ChildNode;
+) => Element | Node | ChildNode | Node[];
 export type CompileFn = (
   compileNode: string | Element | Node | ChildNode | NodeList,
   transcludeFn?: TranscludeFn,
@@ -175,13 +176,19 @@ export type CompileFn = (
 ) => PublicLinkFn;
 export type LinkFnMapping = {
   index: number;
-  nodeLinkFn?: NodeLinkFn;
+  nodeLinkFnCtx?: NodeLinkFnCtx;
   childLinkFn?: CompositeLinkFn;
 };
 export type CompileNodesFn = () => CompositeLinkFn;
-export type NodeLinkFn = (
-  childLinkFn: CompositeLinkFn,
-) => Node | Element | NodeList;
+export type NodeLinkFn = () => Node | Element | NodeList;
+export type NodeLinkFnCtx = {
+  nodeLinkFn: NodeLinkFn;
+  terminal: boolean;
+  transclude: TranscludeFn;
+  transcludeOnThisElement: boolean;
+  templateOnThisElement: boolean;
+  newScope: boolean;
+};
 export type ApplyDirectivesToNodeFn = () => NodeLinkFn;
 export type CompositeLinkFn = (
   scope: import("../scope/scope.js").Scope,

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

@@ -1,6 +1,6 @@
 export function identifierForController(controller: any, ident: any): any;
 /**
- * The {@link ng.$controller $controller service} is used by AngularJS to create new
+ * The {@link ng.$controller $controller service} is used by AngularTS to create new
  * controllers.
  *
  * This provider allows controller registration via the

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

@@ -1,6 +1,6 @@
 /**
  * Injector for providers
- * @extends AbstractInjector
+ * @extends {AbstractInjector}
  */
 export class ProviderInjector extends AbstractInjector {
   /**
@@ -8,10 +8,16 @@ 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
- * @extends AbstractInjector
+ * @extends {AbstractInjector}
  */
 export class InjectorService extends AbstractInjector {
   /**
@@ -21,7 +27,6 @@ export class InjectorService extends AbstractInjector {
    */
   constructor(strictDi: boolean, providerInjector: ProviderInjector);
   providerInjector: ProviderInjector;
-  factory(serviceName: any): any;
   /**
    *
    * @param {string} name
@@ -40,10 +45,11 @@ declare class AbstractInjector {
   cache: any;
   /** @type {boolean} */
   strictDi: boolean;
-  path: any[];
-  /** @type {Object.<string, import("../../types").Module>} */
+  /** @type {string[]} */
+  path: string[];
+  /** @type {Object.<string, import("./ng-module.js").NgModule>} */
   modules: {
-    [x: string]: any;
+    [x: string]: import("./ng-module.js").NgModule;
   };
   /**
    * Get a service by name.
@@ -68,7 +74,7 @@ declare class AbstractInjector {
    * @param {*} [self]
    * @param {Object} [locals]
    * @param {string} [serviceName]
-   * @returns
+   * @returns {*}
    */
   invoke(
     fn: Function | string | Array<any>,
@@ -90,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";
@@ -22,13 +21,13 @@ export class NgModule {
    */
   constructor(name: string, requires: Array<string>, configFn?: Function);
   /**
+   * Name of the current module.
    * @type {string}
-   * Name of the module.
    */
   name: string;
   /**
-   * Holds the list of modules which the injector will load before the current module is
-   * loaded.
+   * Array of module names that this module depends on.
+   * @type {string[]}
    */
   requires: string[];
   /**

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

@@ -0,0 +1,7 @@
+/**
+ * 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.
+ */
+export type ErrorHandler = (exception: Error, cause?: string) => void;

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

@@ -1,5 +1,5 @@
 /**
- * Handles uncaught exceptions thrown in AngularJS expressions.
+ * Handles uncaught exceptions thrown in AngularTS expressions.
  *
  * By default, this service delegates to `$log.error()`, logging the exception to the browser console.
  * You can override this behavior to provide custom exception handling—such as reporting errors
@@ -7,7 +7,7 @@
  *
  * ## Default Behavior
  *
- * Uncaught exceptions within AngularJS expressions are intercepted and passed to this service.
+ * Uncaught exceptions within AngularTS expressions are intercepted and passed to this service.
  * The default implementation logs the error using `$log.error(exception, cause)`.
  *
  * ## Custom Implementation
@@ -39,15 +39,10 @@
  * }
  * ```
  *
- * @see {@link angular.ErrorHandler AngularJS ErrorHandler}
+ * @see {@link angular.ErrorHandler AngularTS ErrorHandler}
  */
 /** @typedef {import('../services/log').LogService} LogService */
-/**
- * @callback ErrorHandler
- * @param {Error} exception - Exception associated with the error.
- * @param {string} [cause] - Optional information about the context in which the error was thrown.
- * @returns {void}
- */
+/** @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.
@@ -60,4 +55,4 @@ export class ExceptionHandlerProvider {
   $get: (string | (($log: LogService) => ErrorHandler))[];
 }
 export type LogService = any;
-export type ErrorHandler = (exception: Error, cause?: string) => void;
+export type ErrorHandler = import("./error-handler.ts").ErrorHandler;

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

@@ -1,8 +1,24 @@
-export function FilterProvider($provide: any): void;
+/**
+ * @param {import('../../interface.ts').Provider} $provide
+ */
+export function FilterProvider(
+  $provide: import("../../interface.ts").Provider,
+): void;
 export class FilterProvider {
-  constructor($provide: any);
-  register: (name: any, factory: any) => any;
-  $get: (string | (($injector: any) => (name: any) => any))[];
+  /**
+   * @param {import('../../interface.ts').Provider} $provide
+   */
+  constructor($provide: import("../../interface.ts").Provider);
+  register: (
+    name: string | Record<string, import("../../interface.ts").FilterFactory>,
+    factory: import("../../interface.ts").FilterFactory,
+  ) => import("../../interface.ts").ServiceProvider;
+  $get: (
+    | string
+    | ((
+        $injector: import("../../core/di/internal-injector.js").InjectorService,
+      ) => (name: any) => any)
+  )[];
 }
 export namespace FilterProvider {
   let $inject: string[];

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

@@ -3,9 +3,9 @@
  * Used for configuring the interpolation markup. Defaults to `{{` and `}}`.
  *
  * <div class="alert alert-danger">
- * This feature is sometimes used to mix different markup languages, e.g. to wrap an AngularJS
+ * This feature is sometimes used to mix different markup languages, e.g. to wrap an AngularTS
  * template within a Python Jinja template (or any other template language). Mixing templating
- * languages is **very dangerous**. The embedding template language will not safely escape AngularJS
+ * languages is **very dangerous**. The embedding template language will not safely escape AngularTS
  * expressions, so any user-controlled values in the template will cause Cross Site Scripting (XSS)
  * security bugs!
  * </div>
@@ -22,7 +22,7 @@ export class InterpolateProvider {
   $get: (
     | string
     | ((
-        $parse: import("../parse/parse.js").ParseService,
+        $parse: import("../parse/interface.ts").ParseService,
         $sce: any,
       ) => {
         (