@angular-wave/angular.ts 0.11.0 → 0.12.0

package/@types/interface.d.ts

@@ -1,3 +1,4 @@
+export * from "./animations/interface.ts";
 export * from "./services/http/interface.ts";
 export * from "./services/log/interface.ts";
 export * from "./services/log/log.js";
@@ -63,14 +64,13 @@ export type InjectableClass<TInstance = any> = new (...args: any) => TInstance;
  *
  * Parentheses are required around constructor types when used in unions.
  */
+type FactoryFunction<T> = T extends abstract new (...args: any[]) => any
+  ? (...args: ConstructorParameters<T>) => InstanceType<T>
+  : T;
 export type Injectable<
   T extends ((...args: any[]) => any) | (abstract new (...args: any[]) => any),
 > =
-  | AnnotatedFactory<
-      T extends abstract new (...args: any[]) => any
-        ? (...args: ConstructorParameters<T>) => InstanceType<T>
-        : T
-    >
+  | AnnotatedFactory<FactoryFunction<T>>
   | (T extends abstract new (...args: any[]) => any
       ? InjectableClass<InstanceType<T>>
       : never)
@@ -271,22 +271,22 @@ export type DirectiveController =
 /**
  * Represents a controller used within directive link functions.
  */
-export type TController = DirectiveController | NgModelController;
+export type TController<T> = DirectiveController | NgModelController | T;
 /**
  * Defines optional pre/post link functions in directive compile phase.
  */
 export interface DirectivePrePost {
-  pre?: DirectiveLinkFn;
-  post?: DirectiveLinkFn;
+  pre?: DirectiveLinkFn<any>;
+  post?: DirectiveLinkFn<any>;
 }
 /**
  * A link function executed during directive linking.
  */
-export type DirectiveLinkFn = (
+export type DirectiveLinkFn<T> = (
   scope: Scope,
   element: HTMLElement,
   attrs: Attributes & Record<string, any>,
-  controller?: TController,
+  controller?: TController<T>,
   transclude?: (...args: any[]) => any,
 ) => void;
 /**
@@ -296,12 +296,11 @@ export type DirectiveCompileFn = (
   templateElement?: HTMLElement,
   templateAttributes?: Attributes & Record<string, any>,
   transclude?: (...args: any[]) => any,
-) => void | DirectiveLinkFn | DirectivePrePost;
+) => void | DirectiveLinkFn<any> | DirectivePrePost;
 /**
  * Defines the structure of an AngularTS directive.
- * @typedef {Object} Directive
  */
-export interface Directive {
+export interface Directive<TController = any> {
   /** Optional name (usually inferred) */
   name?: string;
   /** Restrict option: 'A' and/or 'E'. Defaults to 'EA' if not defined */
@@ -315,7 +314,7 @@ export interface Directive {
   /** Whether to bind scope to controller */
   bindToController?: boolean | Record<string, string>;
   /** Link function(s) executed during linking */
-  link?: DirectiveLinkFn | DirectivePrePost;
+  link?: DirectiveLinkFn<TController> | DirectivePrePost;
   /** Priority of the directive */
   priority?: number;
   /** Stops further directive processing if true */
@@ -340,7 +339,7 @@ export interface Directive {
 }
 export type DirectiveFactoryFn = (
   ...args: any[]
-) => Directive | DirectiveLinkFn;
+) => Directive | DirectiveLinkFn<any>;
 export type AnnotatedDirectiveFactory = Array<string | DirectiveFactoryFn>;
 export type DirectiveFactory = DirectiveFactoryFn | AnnotatedDirectiveFactory;
 /**

package/@types/namespace.d.ts

@@ -2,7 +2,11 @@ export { angular } from "./index.js";
 import { Angular as TAngular } from "./angular.js";
 import { Attributes as TAttributes } from "./core/compile/attributes.js";
 import { Scope as TScope } from "./core/scope/scope.js";
-import { NgModule as TNgModule } from "./core/di/ng-module.js";
+import {
+  ListenerFn as TListenerFn,
+  Listener as TListener,
+} from "./core/scope/interface.ts";
+import { NgModule as TNgModule } from "./core/di/ng-module/ng-module.js";
 import { InjectorService as TInjectorService } from "./core/di/internal-injector.js";
 import {
   AnchorScrollProvider as TAnchorScrollProvider,
@@ -36,6 +40,7 @@ import {
   DirectiveFactory as TDirectiveFactory,
   Component as TComponent,
   Controller as TController,
+  Injectable as TInjectable,
 } from "./interface.ts";
 import {
   SseService as TSseService,
@@ -55,17 +60,23 @@ import {
 import {
   WorkerConnection as TWorkerConnection,
   WorkerConfig as TWorkerConfig,
-} from "./services/worker/interface.ts";
+} from "./directive/worker/interface.ts";
 import { Provider as TProvideService } from "./interface.ts";
 import { Location as TLocationService } from "./services/location/location.js";
+import { AnimateService as TAnimateService } from "./animations/interface.ts";
+import { StorageBackend as TStorageBackend } from "./services/storage/interface.ts";
+import { StreamConnectionConfig as TStreamConnectionConfig } from "./services/stream/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
   }
+  interface Window {
+    angular: TAngular;
+  }
   export namespace ng {
     type Angular = TAngular;
     type Attributes = TAttributes & Record<string, any>;
-    type Directive = TDirective;
+    type Directive<TController = any> = TDirective<TController>;
     type DirectiveFactory = TDirectiveFactory;
     type Component = TComponent;
     type Controller = TController;
@@ -86,6 +97,7 @@ declare global {
     type SceProvider = TSceProvider;
     type SceDelegateProvider = TSceDelegateProvider;
     type AnchorScrollService = TAnchorScrollService;
+    type AnimateService = TAnimateService;
     type CompileService = TCompileFn;
     type ControllerService = TControllerService;
     type ExceptionHandlerService = TErrorHandler;
@@ -107,9 +119,18 @@ declare global {
     type TemplateCacheService = Map<string, string>;
     type TemplateRequestService = TTemplateRequestService;
     type ErrorHandlingConfig = TErrorHandlingConfig;
-    type WindowService = Window;
+    type ListenerFn = TListenerFn;
+    type Listener = TListener;
     type DocumentService = Document;
+    type WindowService = Window;
     type WorkerConfig = TWorkerConfig;
     type WorkerConnection = TWorkerConnection;
+    type Injectable<
+      T extends
+        | ((...args: any[]) => any)
+        | (abstract new (...args: any[]) => any),
+    > = TInjectable<T>;
+    type StorageBackend = TStorageBackend;
+    type StreamConnectionConfig = TStreamConnectionConfig;
   }
 }

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

@@ -19,7 +19,7 @@ export class LogProvider {
    */
   private consoleLog;
   /**
-   * @returns {import("./interface.ts").LogService}
+   * @returns {ng.LogService}
    */
-  $get(): import("./interface.ts").LogService;
+  $get(): ng.LogService;
 }

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

@@ -24,85 +24,7 @@ export namespace SCE_CONTEXTS {
  * `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict
  * Contextual Escaping (SCE)} services to AngularTS.
  *
- * For an overview of this service and the functionnality it provides in AngularTS, see the main
- * page for {@link ng.$sce SCE}. The current page is targeted for developers who need to alter how
- * SCE works in their application, which shouldn't be needed in most cases.
- *
- * <div class="alert alert-danger">
- * AngularTS strongly relies on contextual escaping for the security of bindings: disabling or
- * modifying this might cause cross site scripting (XSS) vulnerabilities. For libraries owners,
- * changes to this service will also influence users, so be extra careful and document your changes.
- * </div>
- *
- * Typically, you would configure or override the {@link ng.$sceDelegate $sceDelegate} instead of
- * the `$sce` service to customize the way Strict Contextual Escaping works in AngularTS.  This is
- * because, while the `$sce` provides numerous shorthand methods, etc., you really only need to
- * override 3 core functions (`trustAs`, `getTrusted` and `valueOf`) to replace the way things
- * work because `$sce` delegates to `$sceDelegate` for these operations.
- *
- * Refer {@link ng.$sceDelegateProvider $sceDelegateProvider} to configure this service.
- *
- * The default instance of `$sceDelegate` should work out of the box with little pain.  While you
- * can override it completely to change the behavior of `$sce`, the common case would
- * involve configuring the {@link ng.$sceDelegateProvider $sceDelegateProvider} instead by setting
- * your own trusted and banned resource lists for trusting URLs used for loading AngularTS resources
- * such as templates.  Refer {@link ng.$sceDelegateProvider#trustedResourceUrlList
- * $sceDelegateProvider.trustedResourceUrlList} and {@link
- * ng.$sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider.bannedResourceUrlList}
- */
-/**
- *
- * The `$sceDelegateProvider` provider allows developers to configure the {@link ng.$sceDelegate
- * $sceDelegate service}, used as a delegate for {@link ng.$sce Strict Contextual Escaping (SCE)}.
- *
- * The `$sceDelegateProvider` allows one to get/set the `trustedResourceUrlList` and
- * `bannedResourceUrlList` used to ensure that the URLs used for sourcing AngularTS templates and
- * other script-running URLs are safe (all places that use the `$sce.RESOURCE_URL` context). See
- * {@link ng.$sceDelegateProvider#trustedResourceUrlList
- * $sceDelegateProvider.trustedResourceUrlList} and
- * {@link ng.$sceDelegateProvider#bannedResourceUrlList $sceDelegateProvider.bannedResourceUrlList},
- *
- * For the general details about this service in AngularTS, read the main page for {@link ng.$sce
- * Strict Contextual Escaping (SCE)}.
- *
- * **Example**:  Consider the following case. <a name="example"></a>
- *
- * - your app is hosted at url `http://myapp.example.com/`
- * - but some of your templates are hosted on other domains you control such as
- *   `http://srv01.assets.example.com/`, `http://srv02.assets.example.com/`, etc.
- * - and you have an open redirect at `http://myapp.example.com/clickThru?...`.
- *
- * Here is what a secure configuration for this scenario might look like:
- *
- * ```
- *  angular.module('myApp', []).config(function($sceDelegateProvider) {
- *    $sceDelegateProvider.trustedResourceUrlList([
- *      // Allow same origin resource loads.
- *      'self',
- *      // Allow loading from our assets domain.  Notice the difference between * and **.
- *      'http://srv*.assets.example.com/**'
- *    ]);
- *
- *    // The banned resource URL list overrides the trusted resource URL list so the open redirect
- *    // here is blocked.
- *    $sceDelegateProvider.bannedResourceUrlList([
- *      'http://myapp.example.com/clickThru**'
- *    ]);
- *  });
- * ```
- * Note that an empty trusted resource URL list will block every resource URL from being loaded, and will require
- * you to manually mark each one as trusted with `$sce.trustAsResourceUrl`. However, templates
- * requested by {@link ng.$templateRequest $templateRequest} that are present in
- * {@link ng.$templateCache $templateCache} will not go through this check. If you have a mechanism
- * to populate your templates in that cache at config time, then it is a good idea to remove 'self'
- * from the trusted resource URL lsit. This helps to mitigate the security impact of certain types
- * of issues, like for instance attacker-controlled `ng-includes`.
- */
-/**
- * `$sceDelegate` is a service that is used by the `$sce` service to provide {@link ng.$sce Strict
- * Contextual Escaping (SCE)} services to AngularTS.
- *
- * For an overview of this service and the functionnality it provides in AngularTS, see the main
+ * For an overview of this service and the functionality it provides in AngularTS, see the main
  * page for {@link ng.$sce SCE}. The current page is targeted for developers who need to alter how
  * SCE works in their application, which shouldn't be needed in most cases.
  *
@@ -179,7 +101,7 @@ export namespace SCE_CONTEXTS {
 export class SceDelegateProvider {
   /**
    *
-   * @param {Array=} trustedResourceUrlList When provided, replaces the trustedResourceUrlList with
+   * @param {Array=} value When provided, replaces the trustedResourceUrlList with
    *     the value provided.  This must be an array or null.  A snapshot of this array is used so
    *     further changes to the array are ignored.
    *     Follow {@link ng.$sce#resourceUrlPatternItem this link} for a description of the items
@@ -198,7 +120,7 @@ export class SceDelegateProvider {
    * its origin with other apps! It is a good idea to limit it to only your application's directory.
    * </div>
    */
-  trustedResourceUrlList: (value: any, ...args: any[]) => any[];
+  trustedResourceUrlList: (value?: any[] | undefined, ...args: any[]) => any[];
   /**
    *
    * @param {Array=} bannedResourceUrlList When provided, replaces the `bannedResourceUrlList` with
@@ -226,7 +148,7 @@ export class SceDelegateProvider {
     | string
     | ((
         $injector: ng.InjectorService,
-        $$sanitizeUri: any,
+        $$sanitizeUri: import("../../core/sanitize/interface.ts").SanitizerFn,
         $exceptionHandler: ng.ExceptionHandlerService,
       ) => {
         trustAs: (type: string, trustedValue: any) => any;

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

@@ -17,11 +17,7 @@ export class SseProvider {
    * @type {ng.SseConfig}
    */
   defaults: ng.SseConfig;
-  /**
-   * Returns the $sse service function
-   * @returns {ng.SseService}
-   */
-  $get: any[];
+  $get: (string | ((log: ng.LogService) => ng.SseService))[];
   $log: import("../log/interface.ts").LogService;
   #private;
 }

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

@@ -0,0 +1,5 @@
+export interface StorageBackend {
+  get(key: string): string | undefined;
+  set(key: string, value: string): void;
+  remove(key: string): void;
+}

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

@@ -0,0 +1,19 @@
+/**
+ * Creates a proxy that automatically persists an object's state
+ * into a storage backend whenever a property is set.
+ *
+ * @param {object} target - The object to wrap
+ * @param {string} key - The storage key
+ * @param {object} storage - Any storage-like object with getItem/setItem/removeItem
+ * @param {{serialize?: function, deserialize?: function}} [options] - Optional custom (de)serialization
+ * @returns {Proxy}
+ */
+export function createPersistentProxy(
+  target: object,
+  key: string,
+  storage: object,
+  options?: {
+    serialize?: Function;
+    deserialize?: Function;
+  },
+): ProxyConstructor;

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

@@ -0,0 +1,18 @@
+export interface StreamConnectionConfig {
+  /** Called when the connection opens */
+  onOpen?: (event: Event) => void;
+  /** Called when a message is received */
+  onMessage?: (data: any, event: Event) => void;
+  /** Called when an error occurs */
+  onError?: (err: any) => void;
+  /** Called when a reconnect attempt happens */
+  onReconnect?: (attempt: number) => void;
+  /** Delay between reconnect attempts in milliseconds */
+  retryDelay?: number;
+  /** Maximum number of reconnect attempts */
+  maxRetries?: number;
+  /** Timeout in milliseconds to detect heartbeat inactivity */
+  heartbeatTimeout?: number;
+  /** Function to transform incoming messages */
+  transformMessage?: (data: any) => any;
+}

package/@types/shared/dom.d.ts

@@ -99,9 +99,9 @@ export function deleteCacheData(element: Element, key: string): void;
  * Gets scope for a given element.
  *
  * @param {Element} element - The DOM element to get data from.
- * @returns {*} - The retrieved data for the given key or all data if no key is provided.
+ * @returns {ng.Scope} - The retrieved data for the given key or all data if no key is provided.
  */
-export function getScope(element: Element): any;
+export function getScope(element: Element): ng.Scope;
 /**
  * Set scope for a given element.
  *
@@ -233,10 +233,26 @@ export function emptyElement(element: Element): void;
  * @returns {boolean}
  */
 export function isRoot(element: Element): boolean;
+/**
+ * Inserts a DOM element before or at the beginning of a parent element.
+ *
+ * @param {HTMLElement | Element} element
+ *   The element to insert into the DOM.
+ *
+ * @param {HTMLElement | Element} parentElement
+ *   The parent element that will receive the inserted element.
+ *
+ * @param {HTMLElement | Element | null} [afterElement]
+ *   An optional sibling element — if present and valid, `element`
+ *   will be inserted after it. If omitted or invalid, `element`
+ *   is prepended to `parentElement`.
+ *
+ * @returns {void}
+ */
 export function domInsert(
-  element: any,
-  parentElement: any,
-  afterElement: any,
+  element: HTMLElement | Element,
+  parentElement: HTMLElement | Element,
+  afterElement?: HTMLElement | Element | null,
 ): void;
 export function animatedomInsert(element: any, parent: any, after: any): void;
 /**

package/@types/shared/strings.d.ts

@@ -49,10 +49,4 @@ export function splitOnDelim(delim: any): (str: any) => any;
  * ```
  */
 export function joinNeighborsR(acc: any, x: any): any;
-export function beforeAfterSubstr(char: any): (str: any) => any[];
-export const hostRegex: RegExp;
 export function stripLastPathElement(str: any): any;
-export function splitHash(str: any): any[];
-export function splitQuery(str: any): any[];
-export function splitEqual(str: any): any[];
-export function trimHashVal(str: any): any;

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

@@ -208,19 +208,6 @@ export function isNumberNaN(num: any): boolean;
  */
 export function inherit(parent: any, extra: any): any;
 export function hasCustomToString(obj: any): boolean;
-/**
- * @module angular
- * @function isElement
-
- * @function
- *
- * @description
- * Determines if a reference is a DOM element (or wrapped jQuery element).
- *
- * @param {*} node Reference to check.
- * @returns {boolean} True if `value` is a DOM element (or wrapped jQuery element).
- */
-export function isElement(node: any): boolean;
 /**
  * Returns a string appropriate for the type of node.
  *
@@ -488,7 +475,18 @@ export function toDebugString(obj: any): any;
  *         The resulting string key is in 'type:hashKey' format.
  */
 export function hashKey(obj: any): string;
-export function mergeClasses(a: any, b: any): any;
+/**
+ * Merges two class name values into a single space-separated string.
+ * Accepts strings, arrays of strings, or null/undefined values.
+ *
+ * @param {string | string[] | null | undefined} a - The first class name(s).
+ * @param {string | string[] | null | undefined} b - The second class name(s).
+ * @returns {string} A single string containing all class names separated by spaces.
+ */
+export function mergeClasses(
+  a: string | string[] | null | undefined,
+  b: string | string[] | null | undefined,
+): string;
 /**
  * Converts all accepted directives format into proper directive name.
  * @param {string} name Name to normalize
@@ -571,5 +569,17 @@ export function wait(t?: number): Promise<void>;
  * // returns false
  */
 export function startsWith(str: string, search: string): boolean;
+/**
+ * Loads and instantiates a WebAssembly module.
+ * Tries streaming first, then falls back.
+ */
+export function instantiateWasm(
+  src: any,
+  imports?: {},
+): Promise<{
+  instance: WebAssembly.Instance;
+  exports: WebAssembly.Exports;
+  module: WebAssembly.Module;
+}>;
 export const isProxySymbol: unique symbol;
 export const ngAttrPrefixes: string[];