@angular-wave/angular.ts 0.12.0 → 0.14.0

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

@@ -0,0 +1,106 @@
+/**
+ * @template T, ID
+ */
+export class RestService<T, ID> {
+  static $nonscope: boolean;
+  /**
+   * Core REST service for CRUD operations.
+   * Safe, predictable, and optionally maps raw JSON to entity class instances.
+   *
+   * @param {ng.HttpService} $http Angular-like $http service
+   * @param {string} baseUrl Base URL or URI template
+   * @param {ng.EntityClass<T>} [entityClass] Optional constructor to map JSON to objects
+   * @param {Object} [options] Optional settings (interceptors, headers, etc.)
+   */
+  constructor(
+    $http: ng.HttpService,
+    baseUrl: string,
+    entityClass?: ng.EntityClass<T>,
+    options?: any,
+  );
+  /** @private */
+  private $http;
+  /** @private */
+  private baseUrl;
+  /** @private */
+  private entityClass;
+  /** @private */
+  private options;
+  /**
+   * Build full URL from template and parameters
+   * @param {string} template
+   * @param {Record<string, any>} params
+   * @returns {string}
+   */
+  buildUrl(template: string, params: Record<string, any>): string;
+  /**
+   * List entities
+   * @param {Record<string, any>=} params
+   * @returns {Promise<T[]>}
+   */
+  list(params?: Record<string, any> | undefined): Promise<T[]>;
+  /**
+   * Read single entity by ID
+   * @param {ID} id
+   * @param {Record<string, any>=} params
+   * @returns {Promise<T|null>}
+   */
+  read(id: ID, params?: Record<string, any> | undefined): Promise<T | null>;
+  /**
+   * Create a new entity
+   * @param {T} item
+   * @returns {Promise<T>}
+   */
+  create(item: T): Promise<T>;
+  /**
+   * Update entity by ID
+   * @param {ID} id
+   * @param {Partial<T>} item
+   * @returns {Promise<T|null>}
+   */
+  update(id: ID, item: Partial<T>): Promise<T | null>;
+  /**
+   * Delete entity by ID
+   * @param {ID} id
+   * @returns {Promise<boolean>}
+   */
+  delete(id: ID): Promise<boolean>;
+  #private;
+}
+/**
+ * Provider for registering REST endpoints during module configuration.
+ */
+export class RestProvider {
+  /** @private @type {ng.RestDefinition<any>[]} */
+  private definitions;
+  /**
+   * Register a REST resource at config phase
+   * @template T
+   * @param {string} name Service name
+   * @param {string} url Base URL or URI template
+   * @param {{new(data:any):T}=} entityClass Optional entity constructor
+   * @param {Object=} options Optional service options
+   */
+  rest<T>(
+    name: string,
+    url: string,
+    entityClass?:
+      | {
+          new (data: any): T;
+        }
+      | undefined,
+    options?: any | undefined,
+  ): void;
+  /**
+   * $get factory: returns a factory function and allows access to named services
+   * @returns {(baseUrl:string, entityClass?:Function, options?:object) => RestService & { get(name:string): RestService, listNames(): string[] }}
+   */
+  $get: (
+    | string
+    | (($http: any) => {
+        (baseUrl: any, entityClass: any, options?: {}): RestService<any, any>;
+        get(name: any): any;
+        listNames(): any[];
+      })
+  )[];
+}

package/@types/services/rest/rfc.d.ts

@@ -0,0 +1,40 @@
+/**
+ * RFC 6570 Level 4 URI Template expander
+ *
+ * Supports operators: (none), +, #, ., /, ;, ?, &
+ * Supports varspec modifiers: explode (*) and prefix (:len)
+ *
+ * Usage:
+ *   expandUriTemplate("/users/{id}", { id: 10 }) === "/users/10"
+ *   expandUriTemplate("/search{?q,lang}", { q: "a b", lang: "en" }) === "/search?q=a%20b&lang=en"
+ *   expandUriTemplate("/repos/{owner}/{repo}/issues{?labels*}", { labels: ["bug","ui"] }) === "/repos/x/y/issues?labels=bug&labels=ui"
+ *
+ * @param {string} template
+ * @param {Object<string, any>} vars
+ * @returns {string}
+ */
+export function expandUriTemplate(
+  template: string,
+  vars?: {
+    [x: string]: any;
+  },
+): string;
+/**
+ * Helper: percent-encode a string. If allowReserved true, reserved chars are NOT encoded.
+ * @param {string} str
+ * @param {boolean} allowReserved
+ * @returns {string}
+ */
+export function pctEncode(str: string, allowReserved: boolean): string;
+/**
+ * Parse and expand a single expression (content between { and }).
+ * @param {string} expression
+ * @param {Object<string, any>} vars
+ * @returns {string}
+ */
+export function expandExpression(
+  expression: string,
+  vars: {
+    [x: string]: any;
+  },
+): string;

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

@@ -1,4 +1,4 @@
-export function escapeForRegexp(s: any): any;
+export function escapeForRegexp(str: any): any;
 export function adjustMatcher(matcher: any): any;
 export function SceProvider(): void;
 export class SceProvider {

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

@@ -3,3 +3,4 @@ export interface StorageBackend {
   set(key: string, value: string): void;
   remove(key: string): void;
 }
+export type StorageType = "local" | "session" | "cookie" | "custom";

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

@@ -1,4 +1,4 @@
-export function equals(o1: any, o2: any): any;
+export function equals(o1: any, o2: any): boolean;
 /**
  * prototypal inheritance helper.
  * Creates a new object which has `parent` object as its prototype, and then copies the properties from `extra` onto it

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

@@ -106,11 +106,11 @@ 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
@@ -152,13 +149,13 @@ export function getInheritedData(element: Node, name: string): any;
  * @param {Node} element
  * @param {string|string[]} name
  * @param {any} [value]
- * @returns
+ * @returns {any|undefined}
  */
 export function setInheritedData(
   element: Node,
   name: string | string[],
   value?: any,
-): any;
+): any | undefined;
 /**
  *
  * @param {Element} element

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

@@ -46,7 +46,7 @@ export function curry(fn: any): any | (() => any | any);
  * let composed = compose(f,g,h)
  * then, composed is: f(g(h(x)))
  */
-export function compose(...args: any[]): () => any;
+export function compose(...fns: any[]): (...args: any[]) => any;
 /**
  * Given a class constructor, returns a predicate function that checks
  * whether a given object is an instance of that class.
@@ -105,4 +105,4 @@ export function pattern(struct: any): (arg0: any) => any;
  */
 export const propEq: any;
 export function parse(path: any): (obj: any) => any;
-export function val(v: any): () => any;
+export function val(value: any): () => any;

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

@@ -17,3 +17,4 @@ export interface ErrorHandlingConfig {
    */
   urlErrorParamsEnabled?: boolean;
 }
+export type Validator = (value: unknown) => boolean;

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

@@ -3,6 +3,7 @@
  * Provides guarantees around presence and access.
  */
 export class NodeRef {
+  static $nonscope: boolean;
   /**
    * @param {Node | Element | string | NodeList | Node[]} element - The DOM node(s) or HTML string to wrap.
    * @throws {Error} If the argument is invalid or cannot be wrapped properly.

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

@@ -1,16 +1,14 @@
-/**
- * Functions that manipulate strings
- */
 /**
  * Returns a string shortened to a maximum length
  *
  * If the string is already less than the `max` length, return the string.
  * Else return the string, shortened to `max - 3` and append three dots ("...").
  *
- * @param max the maximum length of the string to return
- * @param str the input string
+ * @param {number} max the maximum length of the string to return
+ * @param {string} str the input string
+ * @returns {string}
  */
-export function maxLength(max: any, str: any): any;
+export function maxLength(max: number, str: string): string;
 /**
  * Returns a string, with spaces added to the end, up to a desired str length
  *
@@ -24,7 +22,7 @@ export function padString(length: any, str: any): any;
 export function kebobString(camelCase: any): any;
 export function functionToString(fn: any): any;
 export function fnToString(fn: any): any;
-export function stringify(o: any): any;
+export function stringify(value: any): any;
 /**
  * Splits on a delimiter, but returns the delimiters in the array
  *
@@ -48,5 +46,5 @@ export function splitOnDelim(delim: any): (str: any) => any;
  * arr.reduce(joinNeighborsR, []) // ["foobar", 1, "bazqux" ]
  * ```
  */
-export function joinNeighborsR(acc: any, x: any): any;
+export function joinNeighborsR(acc: any, str: any): any;
 export function stripLastPathElement(str: any): any;

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

@@ -57,13 +57,7 @@ export function isObject(value: any): boolean;
  * @returns {boolean} True if `value` is an `Object` with a null prototype
  */
 export function isBlankObject(value: any): boolean;
-/**
- * Determines if a reference is a `String`.
- *
- * @param {*} value Reference to check.
- * @returns {boolean} True if `value` is a `String`.
- */
-export function isString(value: any): boolean;
+export function isString(value: unknown): boolean;
 /**
  * Determines if a reference is a null.
  *
@@ -78,6 +72,13 @@ export function isNull(value: any): boolean;
  * @returns {boolean} True if `value` is null or undefined.
  */
 export function isNullOrUndefined(obj: any): boolean;
+/**
+ * Determines if a reference is not null or undefined.
+ *
+ * @param {*} obj Reference to check.
+ * @returns {boolean} True if `value` is null or undefined.
+ */
+export function notNullOrUndefined(obj: any): boolean;
 /**
  * Determines if a reference is a `Number`.
  *
@@ -180,10 +181,30 @@ export function snakeCase(name: any, separator: any): any;
 /**
  * Set or clear the hashkey for an object.
  * @param obj object
- * @param h the hashkey (!truthy to delete the hashkey)
- */
-export function setHashKey(obj: any, h: any): void;
-export function baseExtend(dst: any, objs: any, deep: any): any;
+ * @param hashkey the hashkey (!truthy to delete the hashkey)
+ */
+export function setHashKey(obj: any, hashkey: any): void;
+/**
+ * Deeply extends a destination object with one or more source objects.
+ * Safely handles Dates, RegExps, DOM nodes, arrays, and nested objects.
+ * Ignores the `__proto__` key to prevent prototype pollution.
+ *
+ * @param {Object<string, any>} dst - The destination object to extend.
+ * @param {Array<Object<string, any>>} objs - Array of source objects to copy properties from.
+ * @param {boolean} [deep=false] - Whether to perform a deep merge of nested objects.
+ * @returns {Object<string, any>} The extended destination object.
+ */
+export function baseExtend(
+  dst: {
+    [x: string]: any;
+  },
+  objs: Array<{
+    [x: string]: any;
+  }>,
+  deep?: boolean,
+): {
+  [x: string]: any;
+};
 /**
  * Extends the destination object `dst` by copying own enumerable properties from the `src` object(s)
  * to `dst`. You can specify multiple `src` objects. If you want to preserve original objects, you can do so
@@ -227,7 +248,7 @@ export function includes(array: any, obj: any): boolean;
  * @returns {number} - The index of the removed value, or -1 if the value was not found.
  */
 export function arrayRemove<T>(array: Array<T>, value: T): number;
-export function simpleCompare(a: any, b: any): boolean;
+export function simpleCompare(val1: any, val2: any): boolean;
 /**
  * Determines if two objects or two values are equivalent. Supports value types, regular
  * expressions, arrays and objects.
@@ -286,7 +307,6 @@ export function simpleCompare(a: any, b: any): boolean;
   </example>
  */
 export function equals(o1: any, o2: any): boolean;
-export function csp(): any;
 /**
  * throw error if the name given is hasOwnProperty
  * @param  {string} name    the name to test
@@ -373,9 +393,9 @@ export function toKeyValue(obj: any): string;
  * Tries to decode the URI component without throwing an exception.
  *
  * @param  {string} value potential URI component to check.
- * @returns {string|void}
+ * @returns {string|undefined}
  */
-export function tryDecodeURIComponent(value: string): string | void;
+export function tryDecodeURIComponent(value: string): string | undefined;
 /**
  * We need our custom method because encodeURIComponent is too aggressive and doesn't follow
  * http://www.ietf.org/rfc/rfc3986.txt with regards to the character set (pchar) allowed in path
@@ -414,6 +434,31 @@ export function shallowCopy(src: any, dst: any): any;
  * @param {string} errorMsg
  */
 export function assert(argument: boolean, errorMsg?: string): void;
+/**
+ * Validate a value using a predicate function.
+ * Throws if the predicate returns false.
+ *
+ * @param {ng.Validator} fn - Predicate validator function.
+ * @param {*} arg - The value to validate.
+ * @param {string} name - Parameter name (included in error message).
+ * @returns {*} The validated value.
+ * @throws {TypeError} If the value does not satisfy the validator.
+ */
+export function validate(fn: ng.Validator, arg: any, name: string): any;
+/**
+ * @param {*} arg - The value to validate.
+ * @param {string} name - Parameter name (included in error message).
+ * @returns {*} The validated value.
+ * @throws {TypeError} If the value does not satisfy the validator.
+ */
+export function validateRequired(arg: any, name: string): any;
+/**
+ * @param {*} arg - The value to validate.
+ * @param {string} name - Parameter name (included in error message).
+ * @returns {*} The validated value.
+ * @throws {TypeError} If the value does not satisfy the validator.
+ */
+export function validateArray(arg: any, name: string): any;
 /**
  * Throw error if the argument is falsy.
  */
@@ -429,12 +474,12 @@ export function assertArgFn(
  *
  * Omitted or undefined options will leave the corresponding configuration values unchanged.
  *
- * @param {import("./interface.ts").ErrorHandlingConfig} [config]
- * @returns {import("./interface.ts").ErrorHandlingConfig}
+ * @param {ng.ErrorHandlingConfig} [config]
+ * @returns {ng.ErrorHandlingConfig}
  */
 export function errorHandlingConfig(
-  config?: import("./interface.ts").ErrorHandlingConfig,
-): import("./interface.ts").ErrorHandlingConfig;
+  config?: ng.ErrorHandlingConfig,
+): ng.ErrorHandlingConfig;
 /**
  * This object provides a utility for producing rich Error messages within
  * AngularTS. It can be called as follows:
@@ -479,13 +524,13 @@ export function hashKey(obj: any): string;
  * 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).
+ * @param {string | string[] | null | undefined} firstClass - The first class name(s).
+ * @param {string | string[] | null | undefined} secondClass - 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,
+  firstClass: string | string[] | null | undefined,
+  secondClass: string | string[] | null | undefined,
 ): string;
 /**
  * Converts all accepted directives format into proper directive name.
@@ -538,10 +583,10 @@ export function callBackAfterFirst(fn: Function): Function;
 /**
  * Delays execution for a specified number of milliseconds.
  *
- * @param {number} [t=0] - The number of milliseconds to wait. Defaults to 0.
+ * @param {number} [timeout=0] - The number of milliseconds to wait. Defaults to 0.
  * @returns {Promise<void>} A promise that resolves after the delay.
  */
-export function wait(t?: number): Promise<void>;
+export function wait(timeout?: number): Promise<void>;
 /**
  * Checks if a given string starts with a specified substring.
  *
@@ -582,4 +627,7 @@ export function instantiateWasm(
   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/LICENSE

@@ -1,6 +1,7 @@
 The MIT License
 
 Copyright (c) 2010-2020 Google LLC. http://angularjs.org
+Copyright (c) 2021-present Angular Wave contributors. https://angular-wave.github.io/angular.ts/
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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/