@angular-wave/angular.ts 0.9.9 → 0.10.0

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

@@ -0,0 +1,15 @@
+/**
+ * ngWorker directive factory
+ * Usage: <div ng-worker="workerName" data-params="{{ expression }}" data-on-result="callback($result)"></div>
+ */
+export function ngWorkerDirective(
+  $worker: any,
+  $parse: any,
+  $log: any,
+): {
+  restrict: string;
+  link(scope: any, element: any, attrs: any): void;
+};
+export namespace ngWorkerDirective {
+  let $inject: string[];
+}

package/@types/interface.d.ts

@@ -256,7 +256,7 @@ export interface DirectivePrePost {
 export type DirectiveLinkFn = (
   scope: Scope,
   element: HTMLElement,
-  attrs: Attributes,
+  attrs: Attributes & Record<string, any>,
   controller?: TController,
   transclude?: (...args: any[]) => any,
 ) => void;
@@ -264,9 +264,9 @@ export type DirectiveLinkFn = (
  * A compile function used to prepare directives before linking.
  */
 export type DirectiveCompileFn = (
-  templateElement: HTMLElement,
-  templateAttributes: Attributes,
-  transclude: (...args: any[]) => any,
+  templateElement?: HTMLElement,
+  templateAttributes?: Attributes & Record<string, any>,
+  transclude?: (...args: any[]) => any,
 ) => void | DirectiveLinkFn | DirectivePrePost;
 /**
  * Defines the structure of an AngularTS directive.
@@ -275,7 +275,7 @@ export type DirectiveCompileFn = (
 export interface Directive {
   /** Optional name (usually inferred) */
   name?: string;
-  /** Restrict option: 'A' and/or 'E'. Defaults to 'EA' */
+  /** Restrict option: 'A' and/or 'E'. Defaults to 'EA' if not defined */
   restrict?: string;
   /** Compile function for the directive */
   compile?: DirectiveCompileFn;

package/@types/namespace.d.ts

@@ -52,13 +52,17 @@ import {
   LinkFnMapping as TLinkFnMapping,
   CompositeLinkFn as TCompositeLinkFn,
 } from "./core/compile/inteface.ts";
+import {
+  WorkerConnection as TWorkerConnection,
+  WorkerConfig as TWorkerConfig,
+} from "./services/worker/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
   }
   export namespace ng {
     type Angular = TAngular;
-    type Attributes = TAttributes;
+    type Attributes = TAttributes & Record<string, any>;
     type Directive = TDirective;
     type DirectiveFactory = TDirectiveFactory;
     type Component = TComponent;
@@ -101,5 +105,7 @@ declare global {
     type ErrorHandlingConfig = TErrorHandlingConfig;
     type WindowService = Window;
     type DocumentService = Document;
+    type WorkerConfig = TWorkerConfig;
+    type WorkerConnection = TWorkerConnection;
   }
 }

package/@types/router/directives/view-directive.d.ts

@@ -134,5 +134,5 @@ export namespace $ViewDirectiveFill {
  * });
  * ```
  */
-/** @type {import("../../interface.js").AnnotatedDirectiveFactory} */
-export let ngView: import("../../interface.js").AnnotatedDirectiveFactory;
+/** @type {import("../../interface.ts").AnnotatedDirectiveFactory} */
+export let ngView: import("../../interface.ts").AnnotatedDirectiveFactory;

package/@types/router/path/path-utils.d.ts

@@ -37,13 +37,13 @@ export class PathUtils {
    * @param {PathNode[]} fromPath
    * @param {PathNode[]} toPath
    * @param {boolean} [reloadState]
-   * @returns {import("../transition/interface.js").TreeChanges}
+   * @returns {import("../transition/interface.ts").TreeChanges}
    */
   static treeChanges(
     fromPath: PathNode[],
     toPath: PathNode[],
     reloadState?: boolean,
-  ): import("../transition/interface.js").TreeChanges;
+  ): import("../transition/interface.ts").TreeChanges;
   /**
    * Returns a new path which is: the subpath of the first path which matches the second path.
    *

package/@types/router/state/state-object.d.ts

@@ -1,4 +1,4 @@
-/** @typedef {import('./interface.js').StateDeclaration} StateDeclaration */
+/** @typedef {import('./interface.ts').StateDeclaration} StateDeclaration */
 /**
  * Internal representation of a ng-router state.
  *
@@ -12,9 +12,9 @@
  */
 export class StateObject implements StateDeclaration {
   /**
-   * @param {import('./interface.js').StateDeclaration} config
+   * @param {import('./interface.ts').StateDeclaration} config
    */
-  constructor(config: import("./interface.js").StateDeclaration);
+  constructor(config: import("./interface.ts").StateDeclaration);
   name: any;
   navigable: any;
   /** @type {?StateObject} */
@@ -24,9 +24,9 @@ export class StateObject implements StateDeclaration {
   includes: any;
   $$state: () => this;
   /**
-   * @type {import('./interface.js').StateDeclaration}
+   * @type {import('./interface.ts').StateDeclaration}
    */
-  self: import("./interface.js").StateDeclaration;
+  self: import("./interface.ts").StateDeclaration;
   __stateObjectCache: {
     nameGlob: Glob;
   };
@@ -79,5 +79,5 @@ export namespace StateObject {
   /** Predicate which returns true if the object is an internal [[StateObject]] object */
   function isState(obj: any): boolean;
 }
-export type StateDeclaration = import("./interface.js").StateDeclaration;
+export type StateDeclaration = import("./interface.ts").StateDeclaration;
 import { Glob } from "../glob/glob.js";

package/@types/router/state/state-service.d.ts

@@ -27,7 +27,7 @@ export class StateProvider {
    *
    * @deprecated This is a passthrough through to [[Router.current]]
    */
-  get current(): import("./interface.js").StateDeclaration;
+  get current(): import("./interface.ts").StateDeclaration;
   /**
    * The current [[StateObject]] (an internal API)
    *
@@ -134,9 +134,9 @@ export class StateProvider {
   decorator(name: string, func: object): object;
   /**
    *
-   * @param {import("./interface.js").StateDeclaration} definition
+   * @param {import("./interface.ts").StateDeclaration} definition
    */
-  state(definition: import("./interface.js").StateDeclaration): this;
+  state(definition: import("./interface.ts").StateDeclaration): this;
   /**
    * Handler for when [[transitionTo]] is called with an invalid state.
    *

package/@types/router/transition/hook-builder.d.ts

@@ -45,4 +45,4 @@ export class HookBuilder {
    */
   getMatchingHooks(hookType: any, treeChanges: any, transition: any): any;
 }
-import { TransitionHookPhase } from "./interface.js";
+import { TransitionHookPhase } from "./transition-hook.js";

package/@types/router/transition/interface.d.ts

@@ -5,6 +5,7 @@ import { StateObject } from "../state/state-object.js";
 import { PathNode } from "../path/path-node.js";
 import { TargetState } from "../state/target-state.js";
 import { RegisteredHook } from "./hook-registry.js";
+import { TransitionHookScope } from "./transition-hook.js";
 /**
  * The TransitionOptions object can be used to change the behavior of a transition.
  *
@@ -866,15 +867,3 @@ export interface PathType {
  * Or, `true` to always match
  */
 export type HookMatchCriterion = string | IStateMatch | boolean;
-declare enum TransitionHookPhase {
-  CREATE = 0,
-  BEFORE = 1,
-  RUN = 2,
-  SUCCESS = 3,
-  ERROR = 4,
-}
-declare enum TransitionHookScope {
-  TRANSITION = 0,
-  STATE = 1,
-}
-export { TransitionHookPhase, TransitionHookScope };

package/@types/router/transition/transition-hook.d.ts

@@ -1,3 +1,34 @@
+/**
+ * Enum representing the different phases of a transition hook.
+ */
+export type TransitionHookPhase = number;
+/**
+ * Enum representing the different phases of a transition hook.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const TransitionHookPhase: Readonly<{
+  CREATE: 0;
+  BEFORE: 1;
+  RUN: 2;
+  SUCCESS: 3;
+  ERROR: 4;
+}>;
+/**
+ * Enum representing the scope in which a transition hook operates.
+ */
+export type TransitionHookScope = number;
+/**
+ * Enum representing the scope in which a transition hook operates.
+ *
+ * @readonly
+ * @enum {number}
+ */
+export const TransitionHookScope: Readonly<{
+  TRANSITION: 0;
+  STATE: 1;
+}>;
 export class TransitionHook {
   /**
    * Chains together an array of TransitionHooks.

package/@types/router/transition/transition-service.d.ts

@@ -117,4 +117,4 @@ export class TransitionProvider {
   _registerCoreTransitionHooks(): void;
 }
 import { Transition } from "./transition.js";
-import { TransitionHookPhase } from "./interface.js";
+import { TransitionHookPhase } from "./transition-hook.js";

package/@types/router/transition/transition.d.ts

@@ -47,7 +47,7 @@ export class Transition implements IHookRegistry {
   _targetState: import("../state/target-state.js").TargetState;
   _options: any;
   $id: number;
-  _treeChanges: import("./interface.js").TreeChanges;
+  _treeChanges: import("./interface.ts").TreeChanges;
   onStart: any;
   onBefore: any;
   onSuccess: any;
@@ -251,7 +251,7 @@ export class Transition implements IHookRegistry {
     pathname: any,
   ):
     | import("../path/path-node.js").PathNode[]
-    | import("./interface.js").TreeChanges;
+    | import("./interface.ts").TreeChanges;
   /**
    * Creates a new transition that is a redirection of the current one.
    *

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

@@ -1,4 +1,4 @@
-/** @typedef {import('../../interface.js').ServiceProvider} ServiceProvider
+/** @typedef {import('../../interface.ts').ServiceProvider} ServiceProvider
 
 /**
  * Configurable provider for an injectable event bus
@@ -182,4 +182,4 @@ export const EventBus: PubSub;
  * /**
  * Configurable provider for an injectable event bus
  */
-export type ServiceProvider = import("../../interface.js").ServiceProvider;
+export type ServiceProvider = import("../../interface.ts").ServiceProvider;

package/@types/services/sse/interface.d.ts

@@ -2,15 +2,41 @@
  * Configuration object for SSE
  */
 export interface SseConfig {
+  /** Include cookies/credentials when connecting */
   withCredentials?: boolean;
+  /** Custom headers (Note: EventSource doesn't natively support headers; handled at app level if needed) */
   headers?: Record<string, string>;
+  /** Called when the connection is successfully opened */
   onOpen?: (event: Event) => void;
+  /** Called when a message event is received */
   onMessage?: (data: any, event: MessageEvent) => void;
+  /** Called on connection error */
   onError?: (err: Event) => void;
+  /** Transform raw SSE message data (default: JSON.parse if possible) */
   transformMessage?: (data: string) => any;
+  /** Optional query parameters appended to the URL */
   params?: Record<string, any>;
+  /** Called when the connection is being re-established */
+  onReconnect?: (attempt: number) => void;
+  /** Delay in milliseconds before attempting to reconnect (default: 1000ms) */
+  retryDelay?: number;
+  /** Maximum number of reconnect attempts (default: Infinity) */
+  maxRetries?: number;
+  /** Heartbeat timeout in milliseconds; reconnect if no message within this time */
+  heartbeatTimeout?: number;
+}
+/**
+ * Managed SSE connection object returned by $sse.
+ * Provides a safe way to close the connection and stop reconnection attempts.
+ */
+export interface SseConnection {
+  /** Manually close the SSE connection and stop all reconnect attempts */
+  close(): void;
+  /** Manually restart the SSE connection */
+  connect(): void;
 }
 /**
  * $sse service type
+ * Returns a managed SSE connection that automatically reconnects when needed.
  */
-export type SseService = (url: string, config?: SseConfig) => EventSource;
+export type SseService = (url: string, config?: SseConfig) => SseConnection;

package/@types/services/sse/sse.d.ts

@@ -5,10 +5,10 @@
  *   const source = $sse('/events', {
  *     onMessage: (data) => console.log(data),
  *     onError: (err) => console.error(err),
- *     withCredentials: true
+ *     retryDelay: 2000,
+ *     heartbeatTimeout: 10000,
  *   });
  *
- *   // later:
  *   source.close();
  */
 export class SseProvider {
@@ -21,6 +21,7 @@ export class SseProvider {
    * Returns the $sse service function
    * @returns {ng.SseService}
    */
-  $get: () => ng.SseService;
+  $get: any[];
+  $log: import("../log/interface.ts").LogService;
   #private;
 }

package/@types/services/worker/interface.d.ts

@@ -0,0 +1,12 @@
+export interface WorkerConfig {
+  onMessage?: (data: any, event: MessageEvent) => void;
+  onError?: (err: ErrorEvent) => void;
+  autoRestart?: boolean;
+  autoTerminate?: boolean;
+  transformMessage?: (data: any) => any;
+}
+export interface WorkerConnection {
+  post(data: any): void;
+  terminate(): void;
+  restart(): void;
+}

package/@types/services/worker/worker.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Worker Provider
+ *
+ * Usage:
+ *   const worker = $worker('./math.worker.js', {
+ *     onMessage: (data) => console.log('Result:', data),
+ *     onError: (err) => console.error('Worker error:', err),
+ *     autoTerminate: false,
+ *     transformMessage: (d) => d,
+ *   });
+ *
+ *   worker.post({ action: 'fib', n: 20 });
+ *   worker.terminate();
+ */
+export class WorkerProvider {
+  /**
+   * @type {ng.LogService}
+   */
+  $log: ng.LogService;
+  /**
+   * Optional provider-level defaults
+   * @type {ng.WorkerConfig}
+   */
+  defaults: ng.WorkerConfig;
+  /**
+   * Returns the $worker service function
+   * @returns {ng.WorkerService}
+   */
+  $get: any[];
+  #private;
+}

package/@types/shared/url-utils/url-utils.d.ts

@@ -1,20 +1,20 @@
 /**
- * @param {import("./interface.js").ResolvableUrl} url
- * @return {import("./interface.js").ParsedUrl}
+ * @param {import("./interface.ts").ResolvableUrl} url
+ * @return {import("./interface.ts").ParsedUrl}
  */
 export function urlResolve(
-  url: import("./interface.js").ResolvableUrl,
-): import("./interface.js").ParsedUrl;
+  url: import("./interface.ts").ResolvableUrl,
+): import("./interface.ts").ParsedUrl;
 /**
  * Parse a request URL and determine whether this is a same-origin request as the application
  * document.
  *
- * @param {import("./interface.js").ResolvableUrl} requestUrl The url of the request as a string that will be resolved
+ * @param {import("./interface.ts").ResolvableUrl} requestUrl The url of the request as a string that will be resolved
  * or a parsed URL object.
  * @returns {boolean} Whether the request is for the same origin as the application document.
  */
 export function urlIsSameOrigin(
-  requestUrl: import("./interface.js").ResolvableUrl,
+  requestUrl: import("./interface.ts").ResolvableUrl,
 ): boolean;
 /**
  * Parse a request URL and determine whether it is same-origin as the current document base URL.
@@ -22,12 +22,12 @@ export function urlIsSameOrigin(
  * Note: The base URL is usually the same as the document location (`location.href`) but can
  * be overriden by using the `<base>` tag.
  *
- * @param {import("./interface.js").ResolvableUrl} requestUrl The url of the request as a string that will be resolved
+ * @param {import("./interface.ts").ResolvableUrl} requestUrl The url of the request as a string that will be resolved
  * or a parsed URL object.
  * @returns {boolean} Whether the URL is same-origin as the document base URL.
  */
 export function urlIsSameOriginAsBaseUrl(
-  requestUrl: import("./interface.js").ResolvableUrl,
+  requestUrl: import("./interface.ts").ResolvableUrl,
 ): boolean;
 /**
  * Create a function that can check a URL's origin against a list of allowed/trusted origins.
@@ -35,25 +35,25 @@ export function urlIsSameOriginAsBaseUrl(
  *
  * @param {string[]} trustedOriginUrls - A list of URLs (strings), whose origins are trusted.
  *
- * @returns {(url: import("./interface.js").ResolvableUrl) => boolean } - A function that receives a URL (string or parsed URL object) and returns
+ * @returns {(url: import("./interface.ts").ResolvableUrl) => boolean } - A function that receives a URL (string or parsed URL object) and returns
  *     whether it is of an allowed origin.
  */
 export function urlIsAllowedOriginFactory(
   trustedOriginUrls: string[],
-): (url: import("./interface.js").ResolvableUrl) => boolean;
+): (url: import("./interface.ts").ResolvableUrl) => boolean;
 /**
  * Determine if two URLs share the same origin.
  *
- * @param {import("./interface.js").ResolvableUrl} url1 - First URL to compare as a string or a normalized URL in the form of
+ * @param {import("./interface.ts").ResolvableUrl} url1 - First URL to compare as a string or a normalized URL in the form of
  *     a dictionary object returned by `urlResolve()`.
- * @param {import("./interface.js").ResolvableUrl} url2 - Second URL to compare as a string or a normalized URL in the form
+ * @param {import("./interface.ts").ResolvableUrl} url2 - Second URL to compare as a string or a normalized URL in the form
  *     of a dictionary object returned by `urlResolve()`.
  *
  * @returns {boolean} - True if both URLs have the same origin, and false otherwise.
  */
 export function urlsAreSameOrigin(
-  url1: import("./interface.js").ResolvableUrl,
-  url2: import("./interface.js").ResolvableUrl,
+  url1: import("./interface.ts").ResolvableUrl,
+  url2: import("./interface.ts").ResolvableUrl,
 ): boolean;
 /**
  * Removes a trailing hash ('#') from the given URL if it exists.

package/README.md

@@ -1,6 +1,6 @@
 ## AngularTS
 
-![Build status](https://github.com/angular-qave/angular.ts/actions/workflows/ci.yml/badge.svg)
+![Build status](https://github.com/angular-wave/angular.ts/actions/workflows/ci.yml/badge.svg)
 [![stats](https://data.jsdelivr.com/v1/package/npm/@angular-wave/angular.ts/badge?style=rounded)](https://www.jsdelivr.com/package/npm/@angular-wave/angular.ts)
 
 This project preserves, modernises and expands the original [AngularJS](https://angularjs.org/)