@angular-wave/angular.ts 0.11.0 → 0.13.0

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,6 @@
+export interface StorageBackend {
+  get(key: string): string | undefined;
+  set(key: string, value: string): void;
+  remove(key: string): void;
+}
+export type StorageType = "local" | "session" | "cookie" | "custom";

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,18 +99,18 @@ 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.
  *
  * @param {Element|Node|ChildNode} element - The DOM element to set data on.
- * @param {import("../core/scope/scope.js").Scope} scope - The Scope attached to this element
+ * @param {ng.Scope} scope - The Scope attached to this element
  */
 export function setScope(
   element: Element | Node | ChildNode,
-  scope: import("../core/scope/scope.js").Scope,
+  scope: ng.Scope,
 ): void;
 /**
  * Gets isolate scope for a given element.
@@ -123,23 +123,20 @@ export function getIsolateScope(element: Element): any;
  * Set isolate scope for a given element.
  *
  * @param {Element} element - The DOM element to set data on.
- * @param {import("../core/scope/scope.js").Scope} scope - The Scope attached to this element
+ * @param {ng.Scope} scope - The Scope attached to this element
  */
-export function setIsolateScope(
-  element: Element,
-  scope: import("../core/scope/scope.js").Scope,
-): void;
+export function setIsolateScope(element: Element, scope: ng.Scope): void;
 /**
  * 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] - Controller name.
- * @returns {import("../core/scope/scope.js").Scope|undefined} - The retrieved data
+ * @returns {ng.Scope|undefined} - The retrieved data
  */
 export function getController(
   element: Element,
   name?: string,
-): import("../core/scope/scope.js").Scope | undefined;
+): ng.Scope | undefined;
 /**
  *
  * @param {Node} element
@@ -233,10 +230,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,20 @@ 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 BADARG: "badarg";
+export const BADARGKEY: "badarg: key";
+export const BADARGVALUE: "badarg: value";
 export const ngAttrPrefixes: string[];

package/README.md

@@ -16,6 +16,7 @@ AngularTS adds:
 - built-in enterprise-level router (`ui-router` ported as `ng-router`)
 - built-in animations (`animate`)
 - new directives, inspired by `HTMX`
+- new injectables for REST resources, persistent stores, Web Workers and WASM modules
 
 The result is a high-performance, buildless, progressive and battle-tested JS framework that stays as close to Web standards as possible.
 If you write server-rendered web applications for desktop and mobile, and do not wish to leave the comfort of your tech-stack, this is your new secret weapon.
@@ -43,97 +44,9 @@ Initialize your app
 <div ng-app ng-init="x='world'">Hello {{ x }}</div>
 ```
 
-Or check out the updated [Angular seed](https://github.com/angular-qave/angular-seed), which can serve as a solid starting point
+Or check out the updated [Angular seed](https://github.com/angular-wave/angular-seed), which can serve as a solid starting point
 or a source of inspiration for new ideas.
 
-New docs website is coming!
-
-### Legacy docs
-
----
-
-- Web site: https://angularjs.org
-- Tutorial: https://docs.angularjs.org/tutorial
-- API Docs: https://docs.angularjs.org/api
-- Developer Guide: https://docs.angularjs.org/guide
-- Contribution guidelines: [CONTRIBUTING.md](CONTRIBUTING.md)
-- Core Development: [DEVELOPERS.md](DEVELOPERS.md)
-- Dashboard: https://dashboard.angularjs.org
-
 ## Documentation
 
-Go to https://docs.angularjs.org
-
-## Contribute
-
-We've set up a separate document for our
-[contribution guidelines](https://github.com/angular/angular.js/blob/master/CONTRIBUTING.md).
-
-## Develop
-
-We've set up a separate document for
-[developers](https://github.com/angular/angular.js/blob/master/DEVELOPERS.md).
-
-## What to use AngularTS for and when to use it
-
-AngularTS is the next generation framework where each component is designed to work with every other
-component in an interconnected way like a well-oiled machine. AngularTS is JavaScript MVC made easy
-and done right. (Well it is not really MVC, read on, to understand what this means.)
-
-#### MVC, no, MV\* done the right way!
-
-[MVC](https://en.wikipedia.org/wiki/Model%E2%80%93view%E2%80%93controller), short for
-Model-View-Controller, is a design pattern, i.e. how the code should be organized and how the
-different parts of an application separated for proper readability and debugging. Model is the data
-and the database. View is the user interface and what the user sees. Controller is the main link
-between Model and View. These are the three pillars of major programming frameworks present on the
-market today. On the other hand AngularTS works on MV\*, short for Model-View-_Whatever_. The
-_Whatever_ is AngularTS's way of telling that you may create any kind of linking between the Model
-and the View here.
-
-Unlike other frameworks in any programming language, where MVC, the three separate components, each
-one has to be written and then connected by the programmer, AngularTS helps the programmer by asking
-him/her to just create these and everything else will be taken care of by AngularTS.
-
-#### Interconnection with HTML at the root level
-
-AngularTS uses HTML to define the user's interface. AngularTS also enables the programmer to write
-new HTML tags (AngularTS Directives) and increase the readability and understandability of the HTML
-code. Directives are AngularTS’s way of bringing additional functionality to HTML. Directives
-achieve this by enabling us to invent our own HTML elements. This also helps in making the code DRY
-(Don't Repeat Yourself), which means once created, a new directive can be used anywhere within the
-application.
-
-HTML is also used to determine the wiring of the app. Special attributes in the HTML determine where
-to load the app, which components or controllers to use for each element, etc. We specify "what"
-gets loaded, but not "how". This declarative approach greatly simplifies app development in a sort
-of WYSIWYG way. Rather than spending time on how the program flows and orchestrating the various
-moving parts, we simply define what we want and AngularTS will take care of the dependencies.
-
-#### Data Handling made simple
-
-Data and Data Models in AngularTS are plain JavaScript objects and one can add and change properties
-directly on it and loop over objects and arrays at will.
-
-#### Two-way Data Binding
-
-One of AngularTS's strongest features. Two-way Data Binding means that if something changes in the
-Model, the change gets reflected in the View instantaneously, and the same happens the other way
-around. This is also referred to as Reactive Programming, i.e. suppose `a = b + c` is being
-programmed and after this, if the value of `b` and/or `c` is changed then the value of `a` will be
-automatically updated to reflect the change. AngularTS uses its "scopes" as a glue between the Model
-and View and makes these updates in one available for the other.
-
-#### Less Written Code and Easily Maintainable Code
-
-Everything in AngularTS is created to enable the programmer to end up writing less code that is
-easily maintainable and readable by any other new person on the team. Believe it or not, one can
-write a complete working two-way data binded application in less than 10 lines of code. Try and see
-for yourself!
-
-#### Testing Ready
-
-AngularTS has Dependency Injection, i.e. it takes care of providing all the necessary dependencies
-to its controllers and services whenever required. This helps in making the AngularTS code ready for
-unit testing by making use of mock dependencies created and injected. This makes AngularTS more
-modular and easily testable thus in turn helping a team create more robust applications.
+Go to https://angular-wave.github.io/angular.ts/