@angular-wave/angular.ts 0.9.7 → 0.9.8

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/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.7 - October 26, 2025 04:17:19 */
+/* 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",
@@ -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"));
+        }
       },
     };
   };
@@ -35500,6 +35557,89 @@ function ngElDirective() {
   };
 }
 
+/**
+ * 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
@@ -35560,6 +35700,7 @@ function registerNgModule(angular) {
               ngSetter: ngSetterDirective,
               ngShow: ngShowDirective,
               ngStyle: ngStyleDirective,
+              ngSse: ngSseDirective,
               ngSwitch: ngSwitchDirective,
               ngSwitchWhen: ngSwitchWhenDirective,
               ngSwitchDefault: ngSwitchDefaultDirective,
@@ -35631,6 +35772,7 @@ function registerNgModule(angular) {
             $router: Router,
             $sce: SceProvider,
             $sceDelegate: SceDelegateProvider,
+            $sse: SseProvider,
             $templateCache: TemplateCacheProvider,
             $templateRequest: TemplateRequestProvider,
             $urlConfig: UrlConfigProvider,
@@ -35673,7 +35815,7 @@ class Angular {
     /**
      * @type {string} `version` from `package.json`
      */
-    this.version = "0.9.7"; //inserted via rollup plugin
+    this.version = "0.9.8"; //inserted via rollup plugin
 
     /** @type {!Array<string|any>} */
     this.bootsrappedModules = [];

package/dist/angular-ts.umd.js

@@ -1,4 +1,4 @@
-/* Version: 0.9.7 - October 26, 2025 04:17:18 */
+/* Version: 0.9.8 - October 26, 2025 19:05:34 */
 (function (global, factory) {
   typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
   typeof define === 'function' && define.amd ? define(['exports'], factory) :
@@ -1816,6 +1816,7 @@
     $sceDelegate: "$sceDelegate",
     $state: "$state",
     $stateRegistry: "$stateRegistry",
+    $sse: "$sse",
     $$sanitizeUri: "$$sanitizeUri",
     $$sanitizeUriProvider: "$$sanitizeUriProvider",
     $templateCache: "$templateCache",
@@ -18307,7 +18308,7 @@
       $injectTokens.$sce,
       /**
        *
-       * @param {import("../../core/di/internal-injector.js").InjectorService} $injector
+       * @param {ng.InjectorService} $injector
        * @param {*} $sce
        * @returns
        */
@@ -35111,10 +35112,18 @@
    * @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;
   }
 
@@ -35130,6 +35139,9 @@
   /** @type {ng.DirectiveFactory} */
   const ngPutDirective = defineDirective("put");
 
+  /** @type {ng.DirectiveFactory} */
+  const ngSseDirective = defineDirective("get", "ngSse");
+
   /**
    * @typedef {"click" | "change" | "submit"} EventType
    */
@@ -35247,9 +35259,10 @@
      * @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.
        *
@@ -35338,7 +35351,6 @@
           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
@@ -35392,7 +35404,6 @@
                 $compile,
               );
             };
-
             if (isDefined(attrs["delay"])) {
               await wait(parseInt(attrs["delay"]) | 0);
             }
@@ -35431,11 +35442,57 @@
               }
               $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"));
+          }
         },
       };
     };
@@ -35506,6 +35563,89 @@
     };
   }
 
+  /**
+   * 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
@@ -35566,6 +35706,7 @@
                 ngSetter: ngSetterDirective,
                 ngShow: ngShowDirective,
                 ngStyle: ngStyleDirective,
+                ngSse: ngSseDirective,
                 ngSwitch: ngSwitchDirective,
                 ngSwitchWhen: ngSwitchWhenDirective,
                 ngSwitchDefault: ngSwitchDefaultDirective,
@@ -35637,6 +35778,7 @@
               $router: Router,
               $sce: SceProvider,
               $sceDelegate: SceDelegateProvider,
+              $sse: SseProvider,
               $templateCache: TemplateCacheProvider,
               $templateRequest: TemplateRequestProvider,
               $urlConfig: UrlConfigProvider,
@@ -35679,7 +35821,7 @@
       /**
        * @type {string} `version` from `package.json`
        */
-      this.version = "0.9.7"; //inserted via rollup plugin
+      this.version = "0.9.8"; //inserted via rollup plugin
 
       /** @type {!Array<string|any>} */
       this.bootsrappedModules = [];