@angular-wave/angular.ts 0.9.6 → 0.9.8

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

@@ -0,0 +1,4 @@
+/**
+ * @returns {ng.Directive}
+ */
+export function ngElDirective(): ng.Directive;

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

@@ -1,21 +1,18 @@
 /**
  *
- * @param {import("../../core/parse/interface.ts").ParseService} $parse
- * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
+ * @param {ng.ParseService} $parse
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
  * @param {string} directiveName
  * @param {string} eventName
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
 export function createEventDirective(
-  $parse: import("../../core/parse/interface.ts").ParseService,
-  $exceptionHandler: import("../../services/exception/exception-handler.js").ErrorHandler,
+  $parse: ng.ParseService,
+  $exceptionHandler: ng.ExceptionHandlerService,
   directiveName: string,
   eventName: string,
-): import("../../interface.ts").Directive;
+): ng.Directive;
 /**
- * @type {Record<string, import("../../interface.js").DirectiveFactory>}
+ * @type {Record<string, ng.DirectiveFactory>}
  */
-export const ngEventDirectives: Record<
-  string,
-  import("../../interface.js").DirectiveFactory
->;
+export const ngEventDirectives: Record<string, ng.DirectiveFactory>;

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

@@ -43,4 +43,6 @@ export const ngDeleteDirective: ng.DirectiveFactory;
 export const ngPostDirective: ng.DirectiveFactory;
 /** @type {ng.DirectiveFactory} */
 export const ngPutDirective: ng.DirectiveFactory;
+/** @type {ng.DirectiveFactory} */
+export const ngSseDirective: ng.DirectiveFactory;
 export type EventType = "click" | "change" | "submit";

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

@@ -104,9 +104,7 @@ export const patternDirective: (
  */
 export const maxlengthDirective: (
   | string
-  | ((
-      $parse: import("../../core/parse/interface.ts").ParseService,
-    ) => import("../../interface.ts").Directive)
+  | (($parse: ng.ParseService) => ng.Directive)
 )[];
 /**
  *

package/@types/namespace.d.ts

@@ -30,6 +30,10 @@ import {
 import { StateProvider } from "./router/state/state-service.js";
 import { HttpService as THttpService } from "./services/http/interface.ts";
 import { LogService as TLogService } from "./services/log/interface.ts";
+import {
+  SseService as TSseService,
+  SseConfig as TSseConfig,
+} from "./services/sse/interface.ts";
 declare global {
   interface Function {
     $inject?: readonly string[] | undefined;
@@ -67,6 +71,8 @@ declare global {
     type RootElementService = Element;
     type RootScopeService = InstanceType<typeof Scope>;
     type StateService = InstanceType<typeof StateProvider>;
+    type SseService = TSseService;
+    type SseConfig = TSseConfig;
     type TemplateCacheService = InstanceType<typeof Map<string, string>>;
     type TemplateRequestService = TTemplateRequestService;
     type ErrorHandlingConfig = TErrorHandlingConfig;

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

@@ -106,7 +106,7 @@ export class HttpProvider {
   $get: (
     | string
     | ((
-        $injector: import("../../core/di/internal-injector.js").InjectorService,
+        $injector: ng.InjectorService,
         $sce: any,
       ) => {
         (requestConfig: any): Promise<any>;

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

@@ -0,0 +1,16 @@
+/**
+ * Configuration object for SSE
+ */
+export interface SseConfig {
+  withCredentials?: boolean;
+  headers?: Record<string, string>;
+  onOpen?: (event: Event) => void;
+  onMessage?: (data: any, event: MessageEvent) => void;
+  onError?: (err: Event) => void;
+  transformMessage?: (data: string) => any;
+  params?: Record<string, any>;
+}
+/**
+ * $sse service type
+ */
+export type SseService = (url: string, config?: SseConfig) => EventSource;

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

@@ -0,0 +1,26 @@
+/**
+ * SSE Provider
+ *
+ * Usage:
+ *   const source = $sse('/events', {
+ *     onMessage: (data) => console.log(data),
+ *     onError: (err) => console.error(err),
+ *     withCredentials: true
+ *   });
+ *
+ *   // later:
+ *   source.close();
+ */
+export class SseProvider {
+  /**
+   * Optional provider-level defaults
+   * @type {ng.SseConfig}
+   */
+  defaults: ng.SseConfig;
+  /**
+   * Returns the $sse service function
+   * @returns {ng.SseService}
+   */
+  $get: () => ng.SseService;
+  #private;
+}

package/dist/angular-ts.esm.js

@@ -1,4 +1,4 @@
-/* Version: 0.9.6 - October 23, 2025 19:46:24 */
+/* Version: 0.9.8 - October 26, 2025 19:05:36 */
 const VALID_CLASS = "ng-valid";
 const INVALID_CLASS = "ng-invalid";
 const PRISTINE_CLASS = "ng-pristine";
@@ -1810,6 +1810,7 @@ const $injectTokens = Object.freeze({
   $sceDelegate: "$sceDelegate",
   $state: "$state",
   $stateRegistry: "$stateRegistry",
+  $sse: "$sse",
   $$sanitizeUri: "$$sanitizeUri",
   $$sanitizeUriProvider: "$$sanitizeUriProvider",
   $templateCache: "$templateCache",
@@ -4010,7 +4011,7 @@ function SceProvider() {
  */
 
 /**
- * @type {Record<string, import("../../interface.js").DirectiveFactory>}
+ * @type {Record<string, ng.DirectiveFactory>}
  */
 const ngEventDirectives = {};
 
@@ -4023,7 +4024,7 @@ const ngEventDirectives = {};
       "$exceptionHandler",
       /**
        * @param {import("../../core/parse/interface.ts").ParseService} $parse
-       * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
+       * @param {ng.ExceptionHandlerService} $exceptionHandler
        * @returns
        */
       ($parse, $exceptionHandler) => {
@@ -4039,11 +4040,11 @@ const ngEventDirectives = {};
 
 /**
  *
- * @param {import("../../core/parse/interface.ts").ParseService} $parse
- * @param {import('../../services/exception/exception-handler.js').ErrorHandler} $exceptionHandler
+ * @param {ng.ParseService} $parse
+ * @param {ng.ExceptionHandlerService} $exceptionHandler
  * @param {string} directiveName
  * @param {string} eventName
- * @returns {import("../../interface.ts").Directive}
+ * @returns {ng.Directive}
  */
 function createEventDirective(
   $parse,
@@ -13343,17 +13344,17 @@ const patternDirective = [
 const maxlengthDirective = [
   $injectTokens.$parse,
   /**
-   * @param {import("../../core/parse/interface.ts").ParseService} $parse
-   * @returns {import("../../interface.ts").Directive}
+   * @param {ng.ParseService} $parse
+   * @returns {ng.Directive}
    */
   ($parse) => ({
     restrict: "A",
     require: "?ngModel",
     link:
       /**
-       * @param {import("../../core/scope/scope.js").Scope} scope
-       * @param {*} _elm
-       * @param {import("../../core/compile/attributes.js").Attributes} attr
+       * @param {ng.Scope} scope
+       * @param {Element} _elm
+       * @param {ng.Attributes} attr
        * @param {import("../../interface.ts").NgModelController} ctrl
        * @returns
        */
@@ -18301,7 +18302,7 @@ function HttpProvider() {
     $injectTokens.$sce,
     /**
      *
-     * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
+     * @param {ng.InjectorService} $injector
      * @param {*} $sce
      * @returns
      */
@@ -35105,10 +35106,18 @@ function ngSetterDirective($parse, $log) {
  * @param {"get" | "delete" | "post" | "put"} method
  * @returns {ng.DirectiveFactory}
  */
-function defineDirective(method) {
-  const attrName = "ng" + method.charAt(0).toUpperCase() + method.slice(1);
+function defineDirective(method, attrOverride) {
+  const attrName =
+    attrOverride || "ng" + method.charAt(0).toUpperCase() + method.slice(1);
   const directive = createHttpDirective(method, attrName);
-  directive["$inject"] = [$injectTokens.$http, $injectTokens.$compile, $injectTokens.$log, $injectTokens.$parse, $injectTokens.$state];
+  directive["$inject"] = [
+    $injectTokens.$http,
+    $injectTokens.$compile,
+    $injectTokens.$log,
+    $injectTokens.$parse,
+    $injectTokens.$state,
+    $injectTokens.$sse,
+  ];
   return directive;
 }
 
@@ -35124,6 +35133,9 @@ const ngPostDirective = defineDirective("post");
 /** @type {ng.DirectiveFactory} */
 const ngPutDirective = defineDirective("put");
 
+/** @type {ng.DirectiveFactory} */
+const ngSseDirective = defineDirective("get", "ngSse");
+
 /**
  * @typedef {"click" | "change" | "submit"} EventType
  */
@@ -35241,9 +35253,10 @@ function createHttpDirective(method, attrName) {
    * @param {ng.LogService} $log
    * @param {ng.ParseService} $parse
    * @param {ng.StateService} $state
+   * @param {Function} $sse
    * @returns {ng.Directive}
    */
-  return function ($http, $compile, $log, $parse, $state) {
+  return function ($http, $compile, $log, $parse, $state, $sse) {
     /**
      * Collects form data from the element or its associated form.
      *
@@ -35332,7 +35345,6 @@ function createHttpDirective(method, attrName) {
         element.addEventListener(eventName, async (event) => {
           if (/** @type {HTMLButtonElement} */ (element).disabled) return;
           if (tag === "form") event.preventDefault();
-
           const swap = attrs["swap"] || "innerHTML";
           const targetSelector = attrs["target"];
           const target = targetSelector
@@ -35386,7 +35398,6 @@ function createHttpDirective(method, attrName) {
               $compile,
             );
           };
-
           if (isDefined(attrs["delay"])) {
             await wait(parseInt(attrs["delay"]) | 0);
           }
@@ -35425,11 +35436,57 @@ function createHttpDirective(method, attrName) {
             }
             $http[method](url, data, config).then(handler).catch(handler);
           } else {
-            $http[method](url).then(handler).catch(handler);
+            // If SSE mode is enabled
+            if (method === "get" && attrs["ngSse"]) {
+              const sseUrl = url;
+              const config = {
+                withCredentials: attrs["withCredentials"] === "true",
+                transformMessage: (data) => {
+                  try {
+                    return JSON.parse(data);
+                  } catch {
+                    return data;
+                  }
+                },
+                onOpen: () => {
+                  $log.info(`${attrName}: SSE connection opened to ${sseUrl}`);
+                  if (isDefined(attrs["loading"])) attrs.$set("loading", false);
+                  if (isDefined(attrs["loadingClass"]))
+                    attrs.$removeClass(attrs["loadingClass"]);
+                },
+                onMessage: (data) => {
+                  const res = { status: 200, data };
+                  handler(res);
+                },
+                onError: (err) => {
+                  $log.error(`${attrName}: SSE error`, err);
+                  const res = { status: 500, data: err };
+                  handler(res);
+                },
+              };
+
+              // Open the SSE connection using the injected service
+              const source = $sse(sseUrl, config);
+
+              // Cleanup on scope destroy
+              scope.$on("$destroy", () => {
+                $log.info(`${attrName}: closing SSE connection`);
+                source.close();
+              });
+            } else {
+              $http[method](url).then(handler).catch(handler);
+            }
           }
         });
 
-        scope.$on("$destroy", () => clearInterval(intervalId));
+        if (intervalId) {
+          scope.$on("$destroy", () => clearInterval(intervalId));
+        }
+
+        // Eagerly execute for 'load' event
+        if (eventName == "load") {
+          element.dispatchEvent(new Event("load"));
+        }
       },
     };
   };
@@ -35469,6 +35526,120 @@ function ngInjectDirective($log, $injector) {
   };
 }
 
+/**
+ * @returns {ng.Directive}
+ */
+function ngElDirective() {
+  return {
+    restrict: "A",
+    link(scope, element, attrs) {
+      const expr = attrs["ngEl"];
+      const key = !expr ? element.id : expr;
+
+      scope.$target[key] = element;
+      const parent = element.parentNode;
+      if (!parent) return;
+
+      const observer = new MutationObserver((mutations) => {
+        for (const mutation of mutations) {
+          Array.from(mutation.removedNodes).forEach((removedNode) => {
+            if (removedNode === element) {
+              //
+              delete scope.$target[key];
+              observer.disconnect();
+            }
+          });
+        }
+      });
+
+      observer.observe(parent, { childList: true });
+    },
+  };
+}
+
+/**
+ * SSE Provider
+ *
+ * Usage:
+ *   const source = $sse('/events', {
+ *     onMessage: (data) => console.log(data),
+ *     onError: (err) => console.error(err),
+ *     withCredentials: true
+ *   });
+ *
+ *   // later:
+ *   source.close();
+ */
+
+class SseProvider {
+  constructor() {
+    /**
+     * Optional provider-level defaults
+     * @type {ng.SseConfig}
+     */
+    this.defaults = {};
+  }
+
+  /**
+   * Returns the $sse service function
+   * @returns {ng.SseService}
+   */
+  $get =
+    () =>
+    (url, config = {}) => {
+      const finalUrl = this.#buildUrl(url, config.params);
+      return this.#createEventSource(finalUrl, config);
+    };
+
+  /**
+   * Build URL with query parameters
+   * @param {string} url - Base URL
+   * @param {Record<string, any>=} params - Query parameters
+   * @returns {string} URL with serialized query string
+   */
+  #buildUrl(url, params) {
+    if (!params) return url;
+    const query = Object.entries(params)
+      .map(([k, v]) => `${encodeURIComponent(k)}=${encodeURIComponent(v)}`)
+      .join("&");
+    return url + (url.includes("?") ? "&" : "?") + query;
+  }
+
+  /**
+   * Create and manage an EventSource
+   * @param {string} url - URL for SSE connection
+   * @param {ng.SseConfig} config - Configuration object
+   * @returns {EventSource} The EventSource instance wrapped as SseService
+   */
+  #createEventSource(url, config) {
+    const es = new EventSource(url, {
+      withCredentials: !!config.withCredentials,
+    });
+
+    if (config.onOpen) {
+      es.addEventListener("open", (e) => config.onOpen(e));
+    }
+
+    es.addEventListener("message", (e) => {
+      let data = e.data;
+      try {
+        data = config.transformMessage
+          ? config.transformMessage(data)
+          : JSON.parse(data);
+      } catch {
+        // leave as raw string if not JSON
+      }
+      config.onMessage?.(data, e);
+    });
+
+    if (config.onError) {
+      es.addEventListener("error", (e) => config.onError(e));
+    }
+
+    return es;
+  }
+}
+
 /**
  * Initializes core `ng` module.
  * @param {import('./angular.js').Angular} angular
@@ -35508,6 +35679,7 @@ function registerNgModule(angular) {
               ngController: ngControllerDirective,
               ngDelete: ngDeleteDirective,
               ngDisabled: ngDisabledAriaDirective,
+              ngEl: ngElDirective,
               ngForm: ngFormDirective,
               ngGet: ngGetDirective,
               ngHide: ngHideDirective,
@@ -35528,6 +35700,7 @@ function registerNgModule(angular) {
               ngSetter: ngSetterDirective,
               ngShow: ngShowDirective,
               ngStyle: ngStyleDirective,
+              ngSse: ngSseDirective,
               ngSwitch: ngSwitchDirective,
               ngSwitchWhen: ngSwitchWhenDirective,
               ngSwitchDefault: ngSwitchDefaultDirective,
@@ -35599,6 +35772,7 @@ function registerNgModule(angular) {
             $router: Router,
             $sce: SceProvider,
             $sceDelegate: SceDelegateProvider,
+            $sse: SseProvider,
             $templateCache: TemplateCacheProvider,
             $templateRequest: TemplateRequestProvider,
             $urlConfig: UrlConfigProvider,
@@ -35641,7 +35815,7 @@ class Angular {
     /**
      * @type {string} `version` from `package.json`
      */
-    this.version = "0.9.6"; //inserted via rollup plugin
+    this.version = "0.9.8"; //inserted via rollup plugin
 
     /** @type {!Array<string|any>} */
     this.bootsrappedModules = [];