@angular-wave/angular.ts 0.12.0 → 0.13.0

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/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/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

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

@@ -582,4 +582,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/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/