{"id":13481702,"url":"https://github.com/pbastowski/angular2-now","last_synced_at":"2025-08-20T08:31:59.608Z","repository":{"id":30652586,"uuid":"34208216","full_name":"pbastowski/angular2-now","owner":"pbastowski","description":"Angular 2 @Component syntax for Angular 1 apps","archived":false,"fork":false,"pushed_at":"2016-09-06T07:31:37.000Z","size":518,"stargazers_count":145,"open_issues_count":0,"forks_count":15,"subscribers_count":9,"default_branch":"master","last_synced_at":"2024-10-30T06:40:43.868Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":"","language":"JavaScript","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":"mit","status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/pbastowski.png","metadata":{"files":{"readme":"README.md","changelog":"CHANGELOG.md","contributing":null,"funding":null,"license":"LICENSE","code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2015-04-19T13:43:43.000Z","updated_at":"2023-03-28T12:36:11.000Z","dependencies_parsed_at":"2022-08-31T04:42:15.453Z","dependency_job_id":null,"html_url":"https://github.com/pbastowski/angular2-now","commit_stats":null,"previous_names":[],"tags_count":4,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pbastowski%2Fangular2-now","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pbastowski%2Fangular2-now/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pbastowski%2Fangular2-now/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/pbastowski%2Fangular2-now/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/pbastowski","download_url":"https://codeload.github.com/pbastowski/angular2-now/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":230408170,"owners_count":18220974,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-07-31T17:00:54.437Z","updated_at":"2024-12-19T09:06:47.966Z","avatar_url":"https://github.com/pbastowski.png","language":"JavaScript","readme":"# angular2-now  [![Build Status](https://travis-ci.org/pbastowski/angular2-now.svg?branch=master)](https://travis-ci.org/pbastowski/angular2-now)  [![Coverage Status](https://coveralls.io/repos/pbastowski/angular2-now/badge.svg?branch=master\u0026service=github)](https://coveralls.io/github/pbastowski/angular2-now?branch=master)\n\n## Angular 2.0 component syntax for Angular 1 apps\n\nAngular2-now gives you the ability to start coding your Angular 1.4+ apps using Angular 2 component syntax. You get to keep your investment in Angular 1 while learning some Angular 2 concepts.\n\nSo, if you like the clean syntax of Angular 2, but are not yet ready or able to commit to it, then this library might just be what you're looking for.\n\n\u003e **Meteor note**: Meteor package version 1.1.0 of angular2-now works with Meteor 1.2 or higher (repo branch `master`). The latest Meteor 1.1 package version is 0.3.18 (repo branch `meteor1.1`).\n\n## If you are going to use Meteor 1.3...\n... then you can install angular2-now with NPM, like this: \n\n    npm install angular2-now\n\nYou will need to import from `angular2-now` instead of `angular2now`. See the extra \"-\"? Here is an example:\n\n````js\nimport { Component } from \"angular2-now\"\n````\n\n\u003e Temporarily, with Meteor 1.3 you need to do what's shown below, before you call `SetModule()`. This will be fixed in an upcoming release.\n\n```js\nimport { init } from \"angular2-now\";\ninit();\n```\n\n## Install\n\n**NPM and Meteor 1.3**\n\n    npm install angular2-now\n    \n**BOWER**\n\n    bower install angular2-now\n\n**Meteor**\n\n    meteor add pbastowski:angular2-now\n\n**CDN**\n\n```html\n\u003c!-- Meteor 1.2 --\u003e\n\u003cscript src=\"https://unpkg.com/angular2-now@1.1.5/dist/angular2-now.js\"\u003e\u003c/script\u003e\n \n\u003c!-- Meteor 1.1 --\u003e\n\u003cscript src=\"https://unpkg.com/angular2-now@0.3.15/angular2-now.js\"\u003e\u003c/script\u003e\n```\n    \n## Usage with ES6\n\nUse angular2-now with an **ES6 transpiler** like **Babel** or **TypeScript**. Both work equally well.\n\nInclude angular2-now in your AngularJS project, ensuring that it loads before any of it's functions are used. If you're not using any module loaders, then `window.angular2now` gives you direct access to all the annotation functions.\n\n\u003e See the **Examples and Demos** section below for examples.\n \n### With SystemJS\n \nIf your app loads SystemJS before angular2-now, then angular2-now will register itself with SystemJS and you will be able to import annotations as shown below.\n\n```javascript\nimport {Component, View, Inject, bootstrap, Options} from 'angular2now';\n```\n\n### With Meteor\n\nWith Meteor 1.2 you will be using `angular2-now` in combination with `angular-meteor`, whose package name is simply `angular`. `angular-meteor` automatically includes `pbastowski:angular-babel`, which provides ES6 (ES2015) support. So, there is no need for you to add Babel to your Meteor project explicitly. You can also use TypeScript, if you want, by adding the package `pbastowski:typescript` to your project.\n\n#### Meteor and SystemJS module loader\n\nSystemJS support is provided by adding the package `pbastowski:systemjs` to your project. Make sure to read the [README](https://github.com/pbastowski/angular-meteor-babel/tree/meteor1.2) for `pbastowski:angular-babel` to understand:\n- how to enable SystemJS support and \n- how `angular-babel` names SystemJS modules in your project\n\nOtherwise, you might have trouble importing from them. \n\n#### Meteor without SystemJS (the old way)\n\nMeteor does not need any kind of module loader, because it bundles and loads your files according to its [convention](http://docs.meteor.com/#/full/fileloadorder). This may be enough for you, if you're happy to use angular2-now through the globally visible `window.angular2now` object.\n  \nOn the other hand, if you like to use ES6 `import ... from` statements in your project and don't want to use SystemJS, then add the package `pbastowski:require` to your project. It provides basic `module.exports` functionality in the browser and will allow you to export like this\n\n**MyService.js**\n\n```javascript\nexport class MyService { }\n \nexport var things = {\n    thing1,\n    thing2\n}\n```\n\nAnd import like this\n\n**MyComponent.js**\n\n```javascript\nimport \"MyService\";\n\nimport {thing1} from \"things\"    \n```\n\n\u003e When using `pbastowski:require` individual objects are exported by their name. There is no concept of a module, as such. Think of exporting as making the object global. In fact you can also access the exported object through `window.things` or `window.MyService`. \n\nIn the above example, when we `import \"MyService\"` we are actually importing the whole class object, whereas `thing1` is the only object imported from `things`. \n\n## Which Angular 2 annotations can I use in my Angular 1 apps?\n\nThe following annotations have been implemented to support Angular 2.0 component syntax. Any parameters preceeded with `?` are optional.\n\n```javascript\n// SetModule is not actually in Angular2, but is required in Angular1\n// in place of angular.module().\nSetModule('my-app', ['angular-meteor']);\n\n@Component({ \n    selector: 'my-app', \n    ?template: '\u003cdiv\u003eInline template\u003c/div\u003e',   // inline template \n    ?templateUrl: 'path/to/the_template.html', // importing a template\n    ?bind: { twoWay: '=', value: '@', function: '\u0026' },\n    ?providers: ['$http', '$q', 'myService'],  // alias for @Inject\n    ?replace: true or false,\n    ?transclude: true or false,\n    ?scope: undefined or true or same as bind\n})\n\n// View is optional, as all it's properties are also available in @Component\n@View({ \n    template: '\u003cdiv\u003eInline template\u003c/div\u003e',    // inline template \n    templateUrl: 'path/to/the_template.html',  // importing a template\n    ?transclude: true or false\n})\n\n// Inject is optional, as injected objects can be specified in the \n// providers property of @Component\n@Inject('$http', '$q'); // Passing injectables directly\n                        // Also valid: @Inject(['$http', '$q'])\n\nclass App {\n    constructor($http, $q) { }\n}\n\nbootstrap(App, ?config);  // config is optional\n```\n\nThe annotations below are not Angular 2, but for me they make coding in Angular a bit nicer. \n\n```javascript\n@Service({ name: 'serviceName' })\n \n@Filter({ name: 'filterName' })\n \n@Directive()     // alias for @Component\n \n@ScopeShared()  // same as { scope: undefined } on @Directive\n \n@ScopeNew()     // same as { scope: true } on @Directive \n```\n\nClient-side routing with ui-router\n```javascript\n@State({\n    name: 'stateName', \n    ?url: '/stateurl', \n    ?defaultRoute: true/false or '/default/route/url',\n    ?abstract: true or false,\n    ?html5Mode: true/false,\n    ?params: { id: 123 },  // default params, see ui-router docs\n    ?data: { a: 1, b: 2},  // custom data\n    ?resolve: {...}, \n    ?controller: controllerFunction, \n    ?template: '\u003cdiv\u003e\u003c/div\u003e',\n    ?templateUrl: 'client/app/app.html',\n    ?templateProvider: function() { return \"\u003ch1\u003econtent\u003c/h1\u003e\"; }\n}))\n```\n\n### Meteor specific annotations\n\nThe annotation below will only work with Meteor.\n\n```javascript\n@MeteorMethod( ?options )\n```\n\n## Examples and Demos\n\nPlease visit the following github repositories and Plunker examples before you start coding. It will save you some \"WTF\" time.\n\n#### ES6 example\n\n[ES6 Angular2-now Plunker](http://plnkr.co/edit/JhHlOr?p=preview)\n\n#### Meteor examples on GitHub\n\n[Thinkster-MEAN-Tutorial-in-angular-meteor](https://github.com/pbastowski/Thinkster-MEAN-Tutorial-in-angular-meteor/tree/feature/ng2-now-with-services)\n\n[meteor-angular-socially](https://github.com/pbastowski/meteor-angular-socially/tree/feature/ng2now)\n\n[todo-ng2now](https://github.com/pbastowski/todo-ng2now)\n\n\n## API in-depth\n\n### Component vs Directive\n\n`Directive` is an alias for `Component`, which means it does the same thing, but is spelled different. The main difference between directives and components is that directives have no template HTML. A Directive is an attribute on an existing HTML element that simply adds new behaviour to that element. It is one attribute amongst any number of other attributes on an element.\n\nThere is an implication to this, in that AngularJS only allows one directive to have isolate scope on the same HTML element. By default, `Component` creates isolate scope and since `Directive` is an alias for `Component` it also creates isolate scope. This sometimes causes issues.\n \n To overcome that, you can use a couple of annotations: \n - `ScopeShared` same as passing `{ scope: undefined }` to `@Directive`\n - `ScopeNew` same as passing `{ scope: true }` to `@Directive`\n \n ```javascript\n@Directive({ ... })\n@ScopeShared()\nclass MyDirective { }\n```\n\n### SetModule instead of angular.module\n\n```javascript\nSetModule( 'app', ['angular-meteor', 'ui.router', 'my-other-module'] )\n```\n\nYou must use `SetModule` at least once in your app, before you use any annotations, to tell angular2-now in which module to create all Components, Services, Filters and State configuration. The syntax is identical to Angular's own [angular.module()](https://docs.angularjs.org/api/ng/function/angular.module). Use `SetModule` in the same places you would normally use `angular.module`.\n  \n### ui-router support through @State\n\nThis is completely not Angular 2, but I love how easy it makes my routing. You'll have to include ui-router in your app\n\nMeteor:\n\n    meteor add angularui:angular-ui-router\n    \nBower:\n\n    bower install angular-ui-router\n\nAnd then add the `ui.router` dependency to your bootstrap module, like this\n  \n    SetModule('myApp', ['angular-meteor', 'ui.router']);\n\nThen, you can simply annotate your component with the route/state info, like so \n\n```javascript\n@State({name: 'defect', url: '/defect', defaultRoute: true})\n\n@Component({selector: 'defect'})\n@View({templateUrl: 'client/defect/defect.html'})\n@Inject(['lookupTables'])\nclass Defect { \n}\n```\n\n#### defaultRoute\n\n```javascript\n{ name: 'root',               url: '' }\n{ name: 'root.defect',        url: '/defect', defaultRoute: '/defect' }\n{ name: 'root.defect.report', url: '/report', defaultRoute: '/defect/report' }\n{ name: 'root.defect',        url: '/defect', defaultRoute: true }\n```\n\nThe `defaultRoute` property makes the annotated state the default for your app. That is, if the user types an unrecognised path into the address bar, or does not type any path other than the url of your app, they will be redirected to the path specified in defaultRoute. It is a bit like the old 404 not found redirect, except that in single page apps there is no 404. There is just the default page (or route). \n\n\u003e Meteor's web server automatically redirects all unrecognised routes to the app root \"/\". However, if you're not using Meteor, you'll want to make sure that all unrecognised routes are redirected to the app root, which in many cases is \"/\". \n\nNote that `defaultRoute: true` only works when the state's `url` is the same as it's defaultRoute.\n\nFor example\n\n```javascript\n{ name: 'root.defect', url: '/defect', defaultRoute: '/defect' }\n```\n\ncan be replaced with \n\n```javascript\n{ name: 'root.defect', url: '/defect', defaultRoute: true }\n```\n \nFor nested states, where the default state has parent states with their own URLs, always specify the `defaultRoute` as a string that represents the final URL that you want the app to navigate to by default.\n\n#### Resolving Values\n\nA `ui-router` resolve block can be added to the @State annotation, as shown below.\n\n```javascript\n@State({\n    name: 'defect', \n    url: '/defect', \n    defaultRoute: true,\n    resolve: {\n        user: ['$q', function($q) { return 'paul'; }],\n        role: function() { return 'admin'; }\n    }\n})\n\n@Component({ selector: 'defect' })\n@View({ tamplateUrl: 'client/defect/defect.html' })\n@Inject('defect')\n\nclass Defect {\n    constructor(defect) { \n        // defect.name == 'paul'\n        // defect.role == 'admin'\n    }\n}\n```\n\nAdding a @State annotation to a Component does NOT make the component's Class the State's controller and thus you can't directly inject resolved values into it. This is, because the Component's Class is the Component's controller and can not also be reused as the State's controller.\n\nRead on for how to inject the resolved values into your component's controller.\n\n####  Injecting Resolved Dependencies into your component's controller\n\nThe resolved values are made available for injection into a component's constructor, as shown in the example above. The injected parameter `defect` is the name of a service automatically created for you, which holds the resolved return values. The name of this service is always the camelCased version of your component's selector. So, if the selector == 'my-app', then the name of the injectable service will be 'myApp'. \n\n\n#### States without a component\n    \nIt is also possible to define a state without a component, as shown below, provided that you do not also annotate it's Class as a Component.\n\n```javascript\n@State({ \n    name: 'test', \n    url: '/test', \n    resolve: { \n        user: function() { return 'paul'; },\n        role: function() { return 'admin'; } \n    } \n})\nclass App {\n    constructor(user, role) {\n        console.log('myApp resolved: ', user, role);\n    }\n}\n```\n\nIn this case, the class constructor is the controller for the route and receives the injected properties directly (as per ui-router documentation).  \n\n### Bootstrapping the app\n\nThis allows you to bootstrap your Angular 1 app using the Angular 2 component bootstrap syntax. There is no need to use `ng-app`. \n\n```javascript\nbootstrap (App [, config ])\n``` \n\nUsing `bootstrap` is the equivalent of the Angular 1 manual bootstrapping method: `angular.bootstrap(DOMelement, ['app'])`. The bootstrap function also knows how to handle Cordova apps.\n`config` is the same parameter as in [angular.bootstrap()](https://code.angularjs.org/1.3.15/docs/api/ng/function/angular.bootstrap). It can be used to enforce strictDi, for testing before deployment to production. \n\n#### An example showing how to bootstrap an app\n\nIn your HTML body add this:\n\n```html\n\u003cmy-app\u003eOptional content inside my app that can be transcluded\u003c/my-app\u003e\n```\n\nAnd in your JavaScript add the code below.  \n\n```javascript\nSetModule('my-app', []);\n\n@Component({selector: 'my-app' })\n@View({template: `\u003ccontent\u003e\u003c/content\u003e`})\nclass App { \n}\n\nbootstrap(App);\n```\n\n\u003e The bootstrap module must have the same name as the bootstrap component's selector.\n\n### ControllerAs syntax\n\nThe created components use `ControllerAs` syntax. So, when referring to properties or functions on the controller's \"scope\", make sure to prefix them with `this` in the controller and with the camel-cased selector name in the HTML templates. If the component's selector is `home-page` then your html might look like this:\n\n```html\n\u003cdiv ng-click=\"homePage.test()\"\u003e\u003c/div\u003e\n```\n\n#### Can I use `vm` instead of `homePage`?\n\nSure. If you want to use `vm` as the controller name for a specific component, then do this:\n\n```javascript\n@Component({ selector: 'defect', controllerAs: 'vm' })\nclass Defect { \n    test() {}\n}\n```\n\nand then in your HTML template you will then be able do this:\n\n```html\n\u003cdiv ng-click=\"vm.test()\"\u003e\u003c/div\u003e\n```\n\n#### I want to use \"vm\" as the name of all my component's controllers\n\nNo problem. Just configure angular2-now to use `vm` instead, like this\n\n```javascript\nimport {options} from 'angular2now';\noptions({ controllerAs: 'vm' })\n```\n\nDo this before you use any angular2-now components!\n\n\n### Transclusion\n \n#### Inline templates\n \nIf your inline `template` includes `\u003ccontent\u003e\u003c/content\u003e` then `@View` will automatically add `ng-transclude` to it and internally the directive's `transclude` flag will be set to `true`.\n\nSo, this inline HTML template\n\n```html\nh2 This is my header\n\u003ccontent\u003e\u003c/content\u003e  \n```\n\nwill be automatically changed to look like this \n\n```html\nh2 This is my header\n\u003ccontent ng-transclude\u003e\u003c/content\u003e  \n```\n\n#### `templateUrl` and transclusion\n\nTemplates specified using the `templateUrl` property aren't currently checked and thus do not get `ng-transclude` added to them by `@View`. You will have to manually add ng-transclude to the element you want to transclude in your template. You will also need to add `transclude: true` to the @View annotation's options, as shown below:\n\n```javascript\n@View({ templateUrl: '/client/mytemplate.html', transclude: true })\n```\n\n### How do I access `ngModel` and other component's controllers?\n\nYou `@Inject` the names of the components whose controllers you want. Prefix each controller name with `\"@\"` or `\"@^\"` (looks for a parent controller). These dependencies are not directly injected into the constructor (controller), because they are not available at the time the constructor executes, but at `link` time (see AngularJS documentation about this). However, they can be accessed within the constructor like this: \n\n```javascript\n@Component({ selector: 'tab' })\n@Inject('@ngModel', '@^tabContainer')\nclass Tab {\n    constructor() {\n    \n        this.$dependson = function (ngModel, tabContainer) {\n            ngModel.$parsers.unshift(function (value) { ... });\n            \n            // This gives you access to tabContainer's scope methods and properties\n            tabContainer.someFunction();\n            if (tabContainer.tabCount === 0) { ... }\n        }\n    }\n}\n```\n\nPlease note that the injected component controllers are not listed as arguments to the constructor.\n\n### angular2-now `options`\n\nBelow is the list of angular2-now options that can be changed.\n\nAttribute | Type | Description\n----------|------|-------------------\ncontrollerAs | string | Allows you to specify a default controllerAs prefix to use for all components. The default prefix is the camel-cased version of the component's selector.   \nspinner\t| object | Exposes show() and hide() methods, that show and hide a busy-spinner\nevents\t| object | Exposes beforeCall() and afterCall(), which will be called before and after the ajax call. Only `afterCall` is guaranteed to run after the call to the MeteorMethod completes.\n\n\nOptions can be defined or changed like this:\n\n```javascript\nimport {options} from 'angular2now';\n\noptions({\n    spinner: {\n        show: function () { document.body.style.background = 'yellow'; },\n        hide: function () { document.body.style.background = ''; }\n    },\n    events:  {\n        beforeCall: () =\u003e console.log('\u003c BEFORE call'),\n        afterCall:  () =\u003e console.log('\u003e AFTER call'),\n    }\n})\n```\n\nDo this before executing any other angular2-now code.\n\n\n## Meteor Helper Annotations\n\n### MeteorMethod\n\n```javascript\n@MeteorMethod( ?options )\n```\n\nThe `MeteorMethod` annotation is used to create a client-side method that calls a procedure defined on the Meteor server. The `options` argument is optional. Here is an example.\n\nOn the server side you create the Meteor method like this:\n\n```javascript\nMeteor.methods({\n    sendEmail: function(from, to, subject, body) {\n        try {\n            Email.send({from: from, to: to, subject: subject, text: body});\n        } catch (er) {\n            return er;\n        }\n    }\n})\n```\n\nOn the client side, you annotate a stub method, in this case `sendEmail(){}`, in your `Service` or `Component` class with `@MeteorMethod()`. The name of the stub method must be the same as the name of the Meteor method on the server:\n \n```javascript\nclass Mail {\n   @MeteorMethod()\n   sendEmail() { }\n}\n```\n\nAnd then you call ` sendEmail() ` somewhere, like this:\n\n```javascript\n@Inject('mail')\nclass MyComponent {\n    constructor(mail) {\n        mail.sendEmail('me@home.com', 'you@wherever.net', 'hello', 'Hi there!')\n            .then( () =\u003e console.log('success'), (er) =\u003e console.log('Error: ', er) );\n    }\n}\n```\n\n#### The `options` argument\n\nThe `options` argument of `MeteorMethod` allows you to override global options on a per-method basis. To find out what global angular2-now options are available please the **angular2-now  Options** section.\n\nWhen defining a `MeteorMethod`, the options can be overridden like this:\n\n```javascript\n@MeteorMethod({ spinner: { ... }, events: { ... })\nsendEmail() {}\n```\n\n## Breaking changes between 1.0.0 and 0.3.15\n\n- `angular.module` is no longer monkey-patched by angular2-now. You must use `SetModule` instead of `angular.module` for all modules where you wish to use angular2-now. SetModule has the exact same syntax as angular.module. This change was necessary due to problems encountered with the monkey-patching approach under certain conditions.\n\n## What environment is required?\n- Angular 1.4+ \n- Babel 5.1.10+\n- Meteor 1.2+\n\n### Browsers\n- IE9+\n- Chrome\n- FireFox\n- Safari desktop and mobile (IOS 7 or better)\n\n## I need more Angular 2 features\n\nThen you may want to have a look at [ng-forward](https://github.com/ngUpgraders/ng-forward). It is a very comprehensive library with a lot of Angular 2 features and it is developed by really clever people, whom I had the pleasure to work with :)\n\n### But I really love angular2-now, so, can't you just add more Angular 2 features?\n\nThe short answer is no, because I designed `angular2-now` for a specific purpose with narrow requirements:\n\n- make Angular 1 coding simple and fun for myself and my team\n- make me think of web apps in terms of components within components, instead of HTML + controllers + directives + ui-router \n- make ui-router configuration simple (because it is not) \n\nAs it stands now, the above three requirements are satisfied for myself, but if you would like to contribute then I am happy to consider a PR.\n\n## Contributing\n\nIf you think you have a great feature that should be incorporated in the main library, or a fix for a bug, or some doco updates then please send me a PR.\n\nWhen sending code changes or new code make sure to describe in details what it is that you are trying to achieve and what the code does. I am not going to accept pure code without detailed descriptions of what it does and why.\n\n### Contributors\n\nOver time there were varied contributors to this repo, however, below are those that had the biggest influence:\n\n- Paul Bastowski (pbastowski)\n- Uri Goldshtein (urigo)\n- Kamil Kisiela (kamilkisiela)\n- Aaron Roberson (aaronroberson)\n- Dotan Simha (dotansimha)\n","funding_links":[],"categories":["Uncategorized"],"sub_categories":["Uncategorized"],"project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpbastowski%2Fangular2-now","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Fpbastowski%2Fangular2-now","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Fpbastowski%2Fangular2-now/lists"}