@angular-wave/angular.ts 0.9.9 → 0.11.0

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/interface.d.ts

@@ -385,15 +385,6 @@ export interface StateDeclaration {
    * ```
    */
   parent?: string | StateDeclaration;
-  /**
-   * Gets the internal State object API
-   *
-   * Gets the *internal API* for a registered state.
-   *
-   * Note: the internal [[StateObject]] API is subject to change without notice
-   * @internal
-   */
-  $$state?: () => StateObject;
   /**
    * Resolve - a mechanism to asynchronously fetch data, participating in the Transition lifecycle
    *

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/template-factory.d.ts

@@ -21,7 +21,7 @@ export class TemplateFactoryProvider {
   $templateRequest: any;
   $http: import("../interface.ts").HttpService;
   $templateCache: ng.TemplateCacheService;
-  $injector: import("../core/di/internal-injector.js").InjectorService;
+  $injector: import("../interface.ts").InjectorService;
   /**
    * Forces the provider to use $http service directly
    * @param {boolean} value

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

@@ -78,16 +78,6 @@ export interface TransitionOptions {
    * @default `true`
    */
   supercede?: boolean;
-  /** @internal */
-  reloadState?: StateObject;
-  /** @internal
-   * If this transition is a redirect, this property should be the original Transition (which was redirected to this one)
-   */
-  redirectedFrom?: Transition;
-  /** @internal */
-  current?: () => Transition;
-  /** @internal */
-  source?: "sref" | "url" | "redirect" | "otherwise" | "unknown";
 }
 export interface TransitionHookOptions {
   current?: () => Transition;
@@ -298,10 +288,6 @@ export interface HookRegOptions {
  * Note: the Transition object only allows hooks to be registered before the Transition is started.
  */
 export interface IHookRegistry {
-  /** @internal place to store the hooks */
-  _registeredHooks: {
-    [key: string]: RegisteredHook[];
-  };
   /**
    * Registers a [[TransitionHookFn]], called *before a transition starts*.
    *
@@ -837,24 +823,6 @@ export interface IMatchingNodes {
   retained: PathNode[];
   entering: PathNode[];
 }
-/** @internal */
-export interface RegisteredHooks {
-  [key: string]: RegisteredHook[];
-}
-/** @internal */
-export interface PathTypes {
-  [key: string]: PathType;
-  to: PathType;
-  from: PathType;
-  exiting: PathType;
-  retained: PathType;
-  entering: PathType;
-}
-/** @internal */
-export interface PathType {
-  name: string;
-  scope: TransitionHookScope;
-}
 /**
  * Hook Criterion used to match a transition.
  *
@@ -866,15 +834,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/dom.d.ts

@@ -133,7 +133,7 @@ export function setIsolateScope(
  * Gets the controller instance for a given element, if exists. Defaults to "ngControllerController"
  *
  * @param {Element} element - The DOM element to get data from.
- * @param {string} [name] - The DOM element to get data from.
+ * @param {string} [name] - Controller name.
  * @returns {import("../core/scope/scope.js").Scope|undefined} - The retrieved data
  */
 export function getController(
@@ -198,11 +198,9 @@ export function cleanElementData(nodes: NodeListOf<Element> | Element[]): void;
 /**
  * Return instance of InjectorService attached to element
  * @param {Element} element
- * @returns {import('../core/di/internal-injector.js').InjectorService}
+ * @returns {ng.InjectorService}
  */
-export function getInjector(
-  element: Element,
-): import("../core/di/internal-injector.js").InjectorService;
+export function getInjector(element: Element): ng.InjectorService;
 /**
  * Creates a DOM element from an HTML string.
  * @param {string} htmlString - A string representing the HTML to parse. Must have only one root element.
@@ -240,6 +238,7 @@ export function domInsert(
   parentElement: any,
   afterElement: any,
 ): void;
+export function animatedomInsert(element: any, parent: any, after: any): void;
 /**
  * Returns the base href of the document.
  *

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/)