",
53 | "license": "Apache-2.0"
54 | }
55 |
--------------------------------------------------------------------------------
/scripts/make-systemjs-bundle.js:
--------------------------------------------------------------------------------
1 | var path = require('path');
2 | var Builder = require('systemjs-builder');
3 |
4 | var config = {
5 | baseURL: 'dist',
6 | paths: {
7 | 'a1atscript': "./src/a1atscript.js",
8 | 'a1atscript/*': './src/a1atscript/*'
9 | },
10 | transpiler: 'babel',
11 | babelOptions: {
12 | stage: 0
13 | }
14 | };
15 |
16 |
17 | build('a1atscript', '../dist/a1atscript.system.bundle.js');
18 |
19 | function build(name, outputFile) {
20 | var devBuilder = new Builder();
21 |
22 | devBuilder.config(config);
23 |
24 | devBuilder.bundle(name, path.resolve(__dirname, outputFile), {normalize: true, sourceMaps: true, sourceMapContents: true}).then(function() {
25 | process.exit(0);
26 | }, function(err) {
27 | console.error('dev died', err);
28 | process.exit(1);
29 | });
30 | }
31 |
32 | process.stdin.resume();
33 |
--------------------------------------------------------------------------------
/src/a1atscript.js:
--------------------------------------------------------------------------------
1 | export {
2 | registerInjector,
3 | getInjector,
4 | Injector
5 | } from './a1atscript/Injector.js';
6 |
7 | export {
8 | Config,
9 | Run,
10 | Controller,
11 | Directive,
12 | Service,
13 | Factory,
14 | Provider,
15 | Value,
16 | Constant,
17 | Filter,
18 | Animation,
19 | Module,
20 | AsModule
21 | } from './a1atscript/annotations.js';
22 |
23 | export { DirectiveObject } from './a1atscript/DirectiveObject.js';
24 |
25 | import './a1atscript/ng2Directives/ComponentInjector.js';
26 |
27 | export {
28 | Component,
29 | Template,
30 | View
31 | } from "./a1atscript/ng2Directives/Component.js";
32 |
33 | export { ToAnnotation } from './a1atscript/ToAnnotation.js';
34 |
35 | export { bootstrap } from './a1atscript/bootstrap.js';
36 |
37 | export { Router, RouteConfig } from './a1atscript/Router.js';
38 |
39 | export { applyAnnotation} from "./a1atscript/applyAnnotation.js";
40 |
--------------------------------------------------------------------------------
/src/a1atscript/AnnotationFinder.js:
--------------------------------------------------------------------------------
1 | export class AnnotationFinder {
2 | constructor(AnnotatedClass) {
3 | this.AnnotatedClass = AnnotatedClass;
4 | }
5 |
6 | annotationFor(AnnotationClass) {
7 | var OriginalClass = AnnotationClass.originalClass || AnnotationClass;
8 | if (this.AnnotatedClass.annotations) {
9 | return this.AnnotatedClass.annotations.find((annotation) => annotation instanceof OriginalClass)
10 | } else {
11 | return null;
12 | }
13 | }
14 |
15 | annotationsFor(AnnotationClass) {
16 | var OriginalClass = AnnotationClass.originalClass || AnnotationClass;
17 | if (this.AnnotatedClass.annotations) {
18 | return this.AnnotatedClass.annotations.filter((annotation) => annotation instanceof OriginalClass)
19 | } else {
20 | return null;
21 | }
22 | }
23 | }
24 |
--------------------------------------------------------------------------------
/src/a1atscript/DirectiveObject.js:
--------------------------------------------------------------------------------
1 | import {ListInjector} from './injectorTypes.js';
2 | import {registerInjector} from './Injector.js';
3 | import {ToAnnotation} from './ToAnnotation.js';
4 |
5 | class DirectiveObjectAnnotation {
6 | constructor(token, dependencies = []) {
7 | this.dependencies = dependencies;
8 | this.token = token;
9 | }
10 | }
11 |
12 | export const DirectiveObject = ToAnnotation(DirectiveObjectAnnotation);
13 |
14 | class DirectiveObjectInjector extends ListInjector {
15 | get annotationClass() {
16 | return DirectiveObject;
17 | }
18 |
19 | _createFactoryArray(ConstructorFn) {
20 | // get the array of dependencies that are needed by this component (as contained in the `$inject` array)
21 | var args = ConstructorFn.$inject || [];
22 | var factoryArray = args.slice(); // create a copy of the array
23 | // The factoryArray uses Angular's array notation whereby each element of the array is the name of a
24 | // dependency, and the final item is the factory function itself.
25 | factoryArray.push((...args) => {
26 | var directive = new ConstructorFn(...args);
27 | for (var key in directive) {
28 | directive[key] = directive[key];
29 | }
30 | return directive;
31 | });
32 |
33 | return factoryArray;
34 | }
35 |
36 | _cloneFunction(original) {
37 | return function() {
38 | return original.apply(this, arguments);
39 | };
40 | }
41 |
42 | _override(object, methodName, callback) {
43 | object[methodName] = callback(object[methodName]);
44 | }
45 |
46 | instantiateOne(module, directiveObject, metadata) {
47 | directiveObject['$inject'] = metadata.dependencies;
48 |
49 | if (!directiveObject.prototype.compile) {
50 | // create an empty compile function if none was defined.
51 | directiveObject.prototype.compile = () => {};
52 | }
53 |
54 | var originalCompileFn = this._cloneFunction(directiveObject.prototype.compile);
55 |
56 | // Decorate the compile method to automatically return the link method (if it exists)
57 | // and bind it to the context of the constructor (so `this` works correctly).
58 | // This gets around the problem of a non-lexical "this" which occurs when the directive class itself
59 | // returns `this.link` from within the compile function.
60 | this._override(directiveObject.prototype, 'compile', function () {
61 | return function () {
62 |
63 | originalCompileFn.apply(this, arguments);
64 |
65 | if (directiveObject.prototype.link) {
66 | return directiveObject.prototype.link.bind(this);
67 | }
68 | };
69 | });
70 |
71 | var factoryArray = this._createFactoryArray(directiveObject);
72 |
73 | module.directive(metadata.token, factoryArray);
74 | }
75 | }
76 |
77 | registerInjector('directiveObject', DirectiveObjectInjector);
78 |
79 |
80 | /*
81 | var originalCompileFn = _cloneFunction(constructorFn.prototype.compile);
82 |
83 | // Decorate the compile method to automatically return the link method (if it exists)
84 | // and bind it to the context of the constructor (so `this` works correctly).
85 | // This gets around the problem of a non-lexical "this" which occurs when the directive class itself
86 | // returns `this.link` from within the compile function.
87 | _override(constructorFn.prototype, 'compile', function () {
88 | return function () {
89 | originalCompileFn.apply(this, arguments);
90 |
91 | if (constructorFn.prototype.link) {
92 | return constructorFn.prototype.link.bind(this);
93 | }
94 | };
95 | });
96 |
97 | var factoryArray = _createFactoryArray(constructorFn);
98 |
99 | app.directive(name, factoryArray);
100 | return this;
101 | }
102 | */
103 |
--------------------------------------------------------------------------------
/src/a1atscript/Injector.js:
--------------------------------------------------------------------------------
1 | import { AsModule, Module } from './annotations.js';
2 | import { AnnotationFinder} from './AnnotationFinder.js';
3 |
4 | import {
5 | ConfigInjector,
6 | RunInjector,
7 | ControllerInjector,
8 | DirectiveInjector,
9 | ServiceInjector,
10 | FactoryInjector,
11 | ProviderInjector,
12 | ValueInjector,
13 | ConstantInjector,
14 | AnimationInjector,
15 | FilterInjector
16 | } from './injectorTypes.js';
17 |
18 | var registeredInjectors = {}
19 |
20 | export function registerInjector(name, InjectorClass) {
21 | registeredInjectors[name] = new InjectorClass();
22 | }
23 |
24 | export function getInjector(name) {
25 | return registeredInjectors[name];
26 | }
27 |
28 | registerInjector('config', ConfigInjector);
29 | registerInjector('run', RunInjector);
30 | registerInjector('controller', ControllerInjector);
31 | registerInjector('directive', DirectiveInjector);
32 | registerInjector('service', ServiceInjector);
33 | registerInjector('factory', FactoryInjector);
34 | registerInjector('provider', ProviderInjector);
35 | registerInjector('value', ValueInjector);
36 | registerInjector('constant', ConstantInjector);
37 | registerInjector('animation', AnimationInjector);
38 | registerInjector('filter', FilterInjector);
39 |
40 | export class Injector {
41 | constructor(appNamePrefix = "") {
42 | this.appNamePrefix = appNamePrefix;
43 | this.injectedModules = {};
44 | }
45 |
46 | get annotationClass() {
47 | return Module;
48 | }
49 |
50 | instantiate(moduleClass) {
51 | var metadata = this._getAnnotatedClass(moduleClass);
52 | if (!metadata) {
53 | return undefined;
54 | }
55 | if (this.injectedModules[metadata.token]) {
56 | return this.injectedModules[metadata.token];
57 | }
58 | var sortedDependencies = this._sortModuleDependencies(metadata);
59 | sortedDependencies = this._sortSelf(metadata, moduleClass, sortedDependencies);
60 | var moduleDependencies = this._instantiateModuleDependencies(sortedDependencies.module);
61 | var moduleName = metadata.token;
62 | if (this.appNamePrefix && moduleName != this.appNamePrefix) {
63 | moduleName = `${this.appNamePrefix}.${moduleName}`;
64 | }
65 | var instantiatedModule = angular.module(moduleName, moduleDependencies);
66 | delete sortedDependencies.module;
67 | this._instantiateOtherDependencies(sortedDependencies, instantiatedModule);
68 | this.injectedModules[metadata.token] = moduleName;
69 | return moduleName;
70 | }
71 |
72 | _sortSelf(metadata, moduleClass, sortedDependencies) {
73 | if (metadata == moduleClass) {
74 | return sortedDependencies;
75 | } else {
76 | var selfDependency = this._sortDependency(moduleClass, false);
77 | return this._mergeSortedDependencies(sortedDependencies, selfDependency);
78 | }
79 | }
80 |
81 | _getAnnotatedClass(moduleClass) {
82 | if (moduleClass instanceof Module) {
83 | moduleClass.injectable = false;
84 | return moduleClass;
85 | } else {
86 | var metadata = this._getModuleAnnotation(moduleClass);
87 | return metadata;
88 | }
89 | }
90 |
91 | _getDependencyType(dependency) {
92 | var annotations = dependency.annotations;
93 | for (var i=0; i < annotations.length; i++) {
94 | var annotation = annotations[i];
95 | var foundInjector = Object.keys(registeredInjectors).find(
96 | (key) => {
97 | var annotationClass = registeredInjectors[key].annotationClass;
98 | annotationClass = annotationClass.originalClass || annotationClass;
99 | return annotation instanceof annotationClass;
100 | });
101 | if (foundInjector) {
102 | return {
103 | key: foundInjector,
104 | metadata: annotation
105 | };
106 | }
107 | }
108 | return null;
109 | }
110 |
111 | _getModuleAnnotation(dependency) {
112 | return (new AnnotationFinder(dependency)).annotationFor(Module);
113 | }
114 |
115 | _mergeSortedDependencies(sorted1, sorted2) {
116 | var newSorted = {}
117 | Object.assign(newSorted, sorted1)
118 | Object.keys(sorted2).forEach((key) => {
119 | if (newSorted[key]) {
120 | newSorted[key] = newSorted[key].concat(sorted2[key]);
121 | } else {
122 | newSorted[key] = sorted2[key];
123 | }
124 | });
125 | return newSorted;
126 | }
127 |
128 | _sortDependency(dependency, checkModule = true) {
129 | var sorted = {};
130 |
131 | if (typeof dependency === "string" || dependency instanceof Module) {
132 | sorted.module = [dependency];
133 | } else if (dependency.annotations) {
134 | if (checkModule && this._getModuleAnnotation(dependency)) {
135 | sorted.module = [dependency];
136 | } else {
137 | var dependencyType = this._getDependencyType(dependency);
138 | if (dependencyType) {
139 | sorted[dependencyType.key] = [{
140 | dependency: dependency,
141 | metadata: dependencyType.metadata
142 | }];
143 | }
144 | }
145 | } else {
146 | Object.keys(dependency).forEach((key) => {
147 | var subDependency = dependency[key];
148 | var sortedSubDependencies = this._sortDependency(subDependency);
149 | sorted = this._mergeSortedDependencies(sorted, sortedSubDependencies);
150 | });
151 | }
152 | return sorted;
153 | }
154 |
155 | _sortModuleDependencies(moduleClass) {
156 | var sorted = {};
157 | moduleClass.dependencies.forEach((dependency) => {
158 | var newSortedDependencies = this._sortDependency(dependency);
159 | sorted = this._mergeSortedDependencies(sorted, newSortedDependencies);
160 | });
161 |
162 | return sorted;
163 | }
164 |
165 | _moduleMetadata(moduleClass) {
166 | return moduleClass.annotations.find((value) => value instanceof Module || value instanceof AsModule);
167 | }
168 |
169 | _instantiateModuleDependencies(moduleDependencies) {
170 | var returnedDependencies = [];
171 |
172 | if (moduleDependencies) {
173 | moduleDependencies.forEach((moduleDependency) => {
174 | if (typeof moduleDependency === "string") {
175 | returnedDependencies.push(moduleDependency);
176 | } else {
177 | returnedDependencies.push(this.instantiate(moduleDependency));
178 | }
179 | });
180 |
181 | }
182 |
183 | return returnedDependencies;
184 | }
185 |
186 | _instantiateOtherDependencies(sortedDependencies, instantiatedModule) {
187 | Object.keys(sortedDependencies).forEach((dependencyType) => {
188 | registeredInjectors[dependencyType].instantiate(
189 | instantiatedModule,
190 | sortedDependencies[dependencyType]
191 | );
192 | });
193 | }
194 | }
195 |
--------------------------------------------------------------------------------
/src/a1atscript/Router.js:
--------------------------------------------------------------------------------
1 | import {ComponentMapper} from "./router/ComponentMapper.js";
2 | import {RouteReader} from "./router/RouteReader.js";
3 | import { RouteInitializer } from "./router/RouteInitializer.js";
4 | export { RouteConfig } from "./router/RouteConfig.js";
5 |
6 | var componentMapper = new ComponentMapper();
7 | var routeReader = new RouteReader(componentMapper);
8 | var routeInitializer = new RouteInitializer(componentMapper);
9 |
10 | export var Router = {
11 | componentMapper: componentMapper,
12 | routeReader: routeReader,
13 | routeInitializer: routeInitializer
14 | };
15 |
--------------------------------------------------------------------------------
/src/a1atscript/ToAnnotation.js:
--------------------------------------------------------------------------------
1 | function defineAnnotation(target, AnnotationClass, callParams) {
2 | var oldAnnotation = Object.getOwnPropertyDescriptor(target, 'annotations');
3 | if (oldAnnotation) {
4 | var oldGetter = oldAnnotation.get
5 | Object.defineProperty(target, 'annotations', {
6 | configurable: true,
7 | get: function() {
8 | var oldValue = oldGetter();
9 | oldValue.unshift(new (Function.prototype.bind.apply(AnnotationClass, callParams)));
10 | return oldValue;
11 | }});
12 | } else {
13 | Object.defineProperty(target, 'annotations', {
14 | configurable: true,
15 | get: function() {
16 | return [new (Function.prototype.bind.apply(AnnotationClass, callParams))];
17 | }});
18 | }
19 | }
20 |
21 | function handleProperty(descriptor, AnnotationClass, callParams) {
22 | var value;
23 | if (descriptor.initializer) {
24 | value = descriptor.initializer();
25 | } else {
26 | value = descriptor.value;
27 | }
28 | defineAnnotation(value, AnnotationClass, callParams);
29 | if (descriptor.initializer) {
30 | descriptor.initializer = function() { return value; }
31 | }
32 | descriptor.enumerable = true;
33 | return descriptor;
34 | }
35 |
36 | export function ToAnnotation(AnnotationClass) {
37 | var decorator = function(...callParams) {
38 | if (this instanceof decorator) {
39 | return new AnnotationClass(...callParams)
40 | } else {
41 | callParams.unshift(null);
42 | return function(targetClass, ...otherParams) {
43 | if (otherParams.length >= 2) {
44 | return handleProperty(otherParams[1], AnnotationClass, callParams);
45 | } else {
46 | defineAnnotation(targetClass, AnnotationClass, callParams)
47 | return targetClass;
48 | }
49 | };
50 | }
51 | };
52 | decorator.originalClass = AnnotationClass;
53 | return decorator;
54 | }
55 |
--------------------------------------------------------------------------------
/src/a1atscript/annotations.js:
--------------------------------------------------------------------------------
1 | import {ToAnnotation} from './ToAnnotation.js';
2 |
3 | class NgAnnotation {
4 | constructor(...dependencies) {
5 | this.dependencies = dependencies;
6 | }
7 | }
8 |
9 | class NgNamedAnnotation {
10 | constructor(token, dependencies = []) {
11 | this.dependencies = dependencies;
12 | this.token = token;
13 | }
14 | }
15 |
16 | class ConfigAnnotation extends NgAnnotation {
17 | }
18 |
19 | export const Config = ToAnnotation(ConfigAnnotation);
20 |
21 | class RunAnnotation extends NgAnnotation {
22 |
23 | }
24 |
25 | export const Run = ToAnnotation(RunAnnotation);
26 |
27 | class ControllerAnnotation extends NgNamedAnnotation {
28 |
29 | }
30 |
31 | export const Controller = ToAnnotation(ControllerAnnotation);
32 |
33 | class DirectiveAnnotation extends NgNamedAnnotation {
34 |
35 | }
36 |
37 | export const Directive = ToAnnotation(DirectiveAnnotation);
38 |
39 | class ServiceAnnotation extends NgNamedAnnotation {
40 |
41 | }
42 |
43 | export const Service = ToAnnotation(ServiceAnnotation);
44 |
45 |
46 | class FactoryAnnotation extends NgNamedAnnotation {
47 |
48 | }
49 |
50 | export const Factory = ToAnnotation(FactoryAnnotation);
51 |
52 | class ProviderAnnotation extends NgNamedAnnotation {
53 |
54 | }
55 |
56 | export const Provider = ToAnnotation(ProviderAnnotation);
57 |
58 | class ValueAnnotation extends NgNamedAnnotation {
59 |
60 | }
61 |
62 | export const Value = ToAnnotation(ValueAnnotation);
63 |
64 | class ConstantAnnotation extends NgNamedAnnotation {
65 |
66 | }
67 |
68 | export const Constant = ToAnnotation(ConstantAnnotation);
69 |
70 | class FilterAnnotation extends NgNamedAnnotation {
71 |
72 | }
73 |
74 | export const Filter = ToAnnotation(FilterAnnotation);
75 |
76 | class AnimationAnnotation extends NgNamedAnnotation {
77 |
78 | }
79 |
80 | export const Animation = ToAnnotation(AnimationAnnotation);
81 |
82 | export class Module extends NgNamedAnnotation {
83 |
84 | }
85 |
86 | export const AsModule = ToAnnotation(Module);
87 |
--------------------------------------------------------------------------------
/src/a1atscript/applyAnnotation.js:
--------------------------------------------------------------------------------
1 | export function applyAnnotation(target, annotationClass, ...params) {
2 | var AnnotationVersion = annotationClass.originalClass || annotationClass;
3 | target.annotations = target.annotations || [];
4 | target.annotations.push(new AnnotationVersion(...params))
5 | }
6 |
--------------------------------------------------------------------------------
/src/a1atscript/bootstrap.js:
--------------------------------------------------------------------------------
1 | import {Injector} from "./Injector.js";
2 | import {Router} from "./Router.js";
3 |
4 | export function bootstrap(appModule, appPrefix = "") {
5 | var injector = new Injector(appPrefix);
6 | var moduleName = injector.instantiate(appModule);
7 | Router.routeInitializer.initialize(moduleName, appModule);
8 | }
9 |
--------------------------------------------------------------------------------
/src/a1atscript/injectorTypes.js:
--------------------------------------------------------------------------------
1 | import {
2 | Config,
3 | Run,
4 | Controller,
5 | Directive,
6 | Service,
7 | Factory,
8 | Provider,
9 | Value,
10 | Constant,
11 | Animation,
12 | Filter
13 | } from './annotations.js';
14 | import {Router} from "./Router.js";
15 |
16 | export class ListInjector {
17 | instantiate(module, dependencyList) {
18 | dependencyList.forEach((dependencyObject) => {
19 | this.instantiateOne(module, dependencyObject.dependency, dependencyObject.metadata);
20 | });
21 | }
22 | }
23 |
24 | export class ConfigInjector extends ListInjector {
25 |
26 | get annotationClass() {
27 | return Config;
28 | }
29 |
30 | instantiateOne(module, config, metadata) {
31 | config['$inject'] = metadata.dependencies;
32 | module.config(config);
33 | }
34 | }
35 |
36 | export class RunInjector extends ListInjector {
37 |
38 | get annotationClass() {
39 | return Run;
40 | }
41 |
42 | instantiateOne(module, run, metadata) {
43 | run['$inject'] = metadata.dependencies;
44 | module.run(run);
45 | }
46 | }
47 |
48 | export class ControllerInjector extends ListInjector {
49 |
50 | get annotationClass() {
51 | return Controller;
52 | }
53 |
54 | instantiateOne(module, controller, metadata) {
55 | controller['$inject'] = metadata.dependencies;
56 | Router.routeReader.read(controller);
57 | module.controller(metadata.token, controller);
58 | }
59 |
60 | }
61 |
62 | export class DirectiveInjector extends ListInjector {
63 |
64 | get annotationClass() {
65 | return Directive;
66 | }
67 |
68 | instantiateOne(module, directive, metadata) {
69 | directive['$inject'] = metadata.dependencies;
70 | module.directive(metadata.token, directive);
71 | }
72 |
73 | }
74 |
75 | export class ServiceInjector extends ListInjector {
76 |
77 | get annotationClass() {
78 | return Service;
79 | }
80 |
81 | instantiateOne(module, service, metadata) {
82 | service['$inject'] = metadata.dependencies;
83 | module.service(metadata.token, service);
84 | }
85 |
86 | }
87 |
88 | export class FactoryInjector extends ListInjector {
89 |
90 | get annotationClass() {
91 | return Factory;
92 | }
93 |
94 | instantiateOne(module, factory, metadata) {
95 | factory['$inject'] = metadata.dependencies;
96 | module.factory(metadata.token, factory);
97 | }
98 |
99 | }
100 |
101 | export class ProviderInjector extends ListInjector {
102 |
103 | get annotationClass() {
104 | return Provider;
105 | }
106 |
107 | instantiateOne(module, provider, metadata) {
108 | provider['$inject'] = metadata.dependencies;
109 | module.provider(metadata.token, provider);
110 | }
111 |
112 | }
113 |
114 | export class ValueInjector extends ListInjector {
115 |
116 | get annotationClass() {
117 | return Value;
118 | }
119 |
120 | instantiateOne(module, value, metadata) {
121 | value['$inject'] = metadata.dependencies;
122 | module.value(metadata.token, value);
123 | }
124 |
125 | }
126 |
127 | export class ConstantInjector extends ListInjector {
128 |
129 | get annotationClass() {
130 | return Constant;
131 | }
132 |
133 | instantiateOne(module, constant, metadata) {
134 | constant['$inject'] = metadata.dependencies;
135 | module.constant(metadata.token, constant);
136 | }
137 |
138 | }
139 |
140 | export class AnimationInjector extends ListInjector {
141 |
142 | get annotationClass() {
143 | return Animation;
144 | }
145 |
146 | instantiateOne(module, animation, metadata) {
147 | animation['$inject'] = metadata.dependencies;
148 | module.animation(metadata.token, animation);
149 | }
150 |
151 | }
152 |
153 | export class FilterInjector extends ListInjector {
154 |
155 | get annotationClass() {
156 | return Filter;
157 | }
158 |
159 | instantiateOne(module, filter, metadata) {
160 | filter['$inject'] = metadata.dependencies;
161 | module.filter(metadata.token, filter);
162 | }
163 |
164 | }
165 |
--------------------------------------------------------------------------------
/src/a1atscript/ng2Directives/BindBuilder.js:
--------------------------------------------------------------------------------
1 | export default class BindBuilder {
2 | constructor(bindParam, component) {
3 | this._bindParam = bindParam;
4 | this._component = component;
5 | }
6 |
7 | get bindObj() {
8 | if (!this._bindObj) {
9 | if (Array.isArray(this._bindParam)) {
10 | this._bindObj = {};
11 | var splitBind;
12 | this._bindParam.forEach((bind) => {
13 | splitBind = bind.split(/\s*:\s*/);
14 | if (splitBind.length == 1) {
15 | this._bindObj[bind] = bind;
16 | } else {
17 | this._bindObj[splitBind[0]] = splitBind[1];
18 | }
19 | })
20 | } else {
21 | this._bindObj = this._bindParam
22 | }
23 | }
24 | return this._bindObj;
25 | }
26 |
27 | build() {
28 | var properties = {};
29 | Object.keys(this.bindObj).forEach((key) => {
30 | this.setupProperty(key, properties)
31 | });
32 | return properties;
33 | }
34 | }
35 |
--------------------------------------------------------------------------------
/src/a1atscript/ng2Directives/Component.js:
--------------------------------------------------------------------------------
1 | import Ng2Directive from './Ng2Directive.js';
2 | import {ToAnnotation} from '../ToAnnotation.js';
3 |
4 | class ComponentAnnotation extends Ng2Directive {
5 | constructor(descriptor) {
6 | super(descriptor)
7 | this.appInjector = descriptor.appInjector || descriptor.injectables || descriptor.services;
8 | }
9 | }
10 |
11 | export const Component = ToAnnotation(ComponentAnnotation);
12 |
13 | export class ViewBase {
14 | constructor(descriptor) {
15 | this.templateUrl = descriptor.templateUrl || descriptor.url;
16 | this.template = descriptor.template || descriptor.inline;
17 | }
18 | }
19 |
20 | export const Template = ToAnnotation(ViewBase);
21 |
22 | export const View = ToAnnotation(ViewBase);
23 |
--------------------------------------------------------------------------------
/src/a1atscript/ng2Directives/ComponentInjector.js:
--------------------------------------------------------------------------------
1 | import {registerInjector} from '../Injector.js';
2 | import {Component, ViewBase} from './Component.js';
3 | import {ListInjector} from "../injectorTypes.js";
4 | import Ng2DirectiveDefinitionObject from "./Ng2DirectiveDefinitionObject.js";
5 | import PropertiesBuilder from "./PropertiesBuilder.js";
6 | import EventsBuilder from "./EventsBuilder.js";
7 | import {Router} from "../Router.js";
8 |
9 | class ComponentInjector extends ListInjector {
10 | constructor() {
11 | super();
12 | this.componentHooks = {before: [], after: []};
13 | }
14 |
15 | get annotationClass() {
16 | return Component;
17 | }
18 |
19 | _template(component) {
20 | return component.annotations.find((annotation) => annotation instanceof ViewBase) || {};
21 | }
22 |
23 | instantiateOne(module, component, annotation) {
24 | if (annotation.appInjector) {
25 | component.$inject = annotation.appInjector;
26 | }
27 | Router.routeReader.read(component);
28 | var template = this._template(component);
29 | var properties = {},
30 | events = {},
31 | bind;
32 | if (annotation.properties) {
33 | properties = (new PropertiesBuilder(annotation.properties, component)).build();
34 | }
35 | if (annotation.events) {
36 | events = (new EventsBuilder(annotation.events, component)).build();
37 | }
38 | bind = Object.assign({}, properties, events);
39 | if (bind === {}) bind = null;
40 | if (annotation.selector) {
41 | var ddo = new Ng2DirectiveDefinitionObject(component, annotation, template, bind);
42 | this.hooks('before', module, ddo);
43 | module.directive(ddo.name, ddo.factoryFn);
44 | this.hooks('after', module, ddo);
45 | }
46 | }
47 |
48 | hooks(phase, module, ddo) {
49 | this.componentHooks[phase].forEach((hook) => {
50 | hook(module, ddo);
51 | });
52 | }
53 | }
54 |
55 | registerInjector('component', ComponentInjector);
56 |
--------------------------------------------------------------------------------
/src/a1atscript/ng2Directives/EventsBuilder.js:
--------------------------------------------------------------------------------
1 | import BindBuilder from "./BindBuilder.js"
2 |
3 | var prefix = "___bindable___"
4 |
5 | export default class EventsBuilder extends BindBuilder {
6 |
7 | setupProperty(key, events) {
8 | events[key] = "=?on"+this.bindObj[key][0].toUpperCase() + this.bindObj[key].slice(1);
9 | }
10 |
11 | }
12 |
--------------------------------------------------------------------------------
/src/a1atscript/ng2Directives/Ng2Directive.js:
--------------------------------------------------------------------------------
1 | export default class Ng2Directive {
2 | constructor(descriptor) {
3 | this.selector = descriptor.selector;
4 | this.properties = descriptor.properties || descriptor.bind;
5 | this.controllerAs = descriptor.controllerAs;
6 | this.require = descriptor.require;
7 | this.transclude = descriptor.transclude;
8 | this.events = descriptor.events;
9 | }
10 | }
11 |
--------------------------------------------------------------------------------
/src/a1atscript/ng2Directives/Ng2DirectiveDefinitionObject.js:
--------------------------------------------------------------------------------
1 | import SelectorMatcher from "./SelectorMatcher.js";
2 |
3 | export default class Ng2DirectiveDefinitionObject {
4 |
5 | constructor(controller, annotation, template = {}, bind = null) {
6 | this._annotation = annotation;
7 | this._controller = controller;
8 | this._template = template;
9 | this._bind = bind;
10 | }
11 |
12 | get selectorMatcher() {
13 | this._selectorMatcher = this._selectorMatcher ||
14 | new SelectorMatcher(this._annotation.selector);
15 | return this._selectorMatcher;
16 | }
17 |
18 | get restrict() {
19 | return this.selectorMatcher.restrict;
20 | }
21 |
22 | get controllerAs() {
23 | return this._annotation.controllerAs || this.name;
24 | }
25 |
26 | get bindToController() {
27 | // bindToController as object syntax only supported on 1.4
28 | if (angular.version.major == 1 && angular.version.minor >= 4) {
29 | return this._bind || this._annotation.properties;
30 | } else {
31 | return true;
32 | }
33 |
34 | }
35 |
36 | get scope() {
37 | // bindToController as object syntax only supported on 1.4
38 | if (angular.version.major == 1 && angular.version.minor >= 4) {
39 | return {};
40 | } else {
41 | return this._bind || this._annotation.properties;
42 | }
43 | }
44 |
45 | get template() {
46 | return this._template.template;
47 | }
48 |
49 | get templateUrl() {
50 | return this._template.templateUrl;
51 | }
52 |
53 | get transclude() {
54 | return this._annotation.transclude;
55 | }
56 |
57 | get require() {
58 | return this._annotation.require;
59 | }
60 |
61 | get controller() {
62 | return this._controller;
63 | }
64 |
65 | get name() {
66 | return this.selectorMatcher.name;
67 | }
68 |
69 | get factoryFn() {
70 | return () => {
71 | return {
72 | scope: this.scope,
73 | restrict: this.restrict,
74 | template: this.template,
75 | require: this.require,
76 | transclude: this.transclude,
77 | templateUrl: this.templateUrl,
78 | controller: this.controller,
79 | bindToController: this.bindToController,
80 | controllerAs: this.controllerAs
81 | };
82 | };
83 | }
84 | }
85 |
--------------------------------------------------------------------------------
/src/a1atscript/ng2Directives/PropertiesBuilder.js:
--------------------------------------------------------------------------------
1 | import BindBuilder from "./BindBuilder.js"
2 |
3 | const BIND_PREFIX = "_=_";
4 | const STRING_PREFIX = "_@_";
5 | const BINDING = BIND_PREFIX;
6 | const RAW_STRING = STRING_PREFIX;
7 |
8 | export default class PropertiesBuilder extends BindBuilder {
9 |
10 | setupProperty(key, properties) {
11 | properties[STRING_PREFIX + key] = "@" + this.bindObj[key];
12 | properties[BIND_PREFIX + key] = "=?bind" + this.bindObj[key][0].toUpperCase() + this.bindObj[key].slice(1);
13 |
14 |
15 | // This property is used when user uses the `bind-property` attribute on a directive to bind an expression
16 | Object.defineProperty(this._component.prototype, BIND_PREFIX + key, {
17 | enumerable: true,
18 | configurable: true,
19 | set: genericSetter(BINDING, RAW_STRING),
20 | get: function() {
21 | return this[key];
22 | }
23 | });
24 |
25 | // This property is used when user uses the `property` attribute on a directive to bind a string
26 | Object.defineProperty(this._component.prototype, STRING_PREFIX + key, {
27 | enumerable: true,
28 | configurable: true,
29 | set: genericSetter(RAW_STRING, BINDING),
30 | get: function() {
31 | return this[key];
32 | }
33 | });
34 |
35 | function genericSetter(use, errorOn) {
36 | return function(value) {
37 | this.__using_binding__ = this.__using_binding__ || {};
38 |
39 | if (this.__using_binding__[key] === errorOn) {
40 | if (value !== undefined) {
41 | throw new Error(`Cannot use bind-${key} and ${key} simultaneously`);
42 | }
43 |
44 | return;
45 | }
46 |
47 | if (value !== undefined) {
48 | this.__using_binding__[key] = use;
49 | }
50 |
51 | this[key] = value;
52 | };
53 | }
54 | }
55 | }
56 |
--------------------------------------------------------------------------------
/src/a1atscript/ng2Directives/SelectorMatcher.js:
--------------------------------------------------------------------------------
1 | var SPECIAL_CHARS_REGEXP = /([\:\-\_]+(.))/g;
2 | var MOZ_HACK_REGEXP = /^moz([A-Z])/;
3 |
4 | export default class SelectorMatcher {
5 | constructor(selector: string) {
6 | this._selector = selector;
7 | }
8 |
9 | _camelizeName() {
10 | this._name = this._name.replace(SPECIAL_CHARS_REGEXP,
11 | (_, separator, letter, offset) => offset ? letter.toUpperCase() : letter ).
12 | replace(MOZ_HACK_REGEXP, 'Moz$1');
13 | }
14 |
15 | _split() {
16 | if (this._selector[0] == ".") {
17 | this._restrict = "C";
18 | this._name = this._selector.substring(1);
19 | } else if (this._selector[0] == "[" &&
20 | this._selector[this._selector.length-1] == "]") {
21 | this._restrict = "A";
22 | this._name = this._selector.substring(1, this._selector.length-1);
23 | } else {
24 | this._restrict = "E";
25 | this._name = this._selector;
26 | }
27 | }
28 |
29 | get name() {
30 | if (!this._name) {
31 | this._split();
32 | }
33 | this._camelizeName();
34 | return this._name;
35 | }
36 |
37 | get restrict() {
38 | if (!this._restrict) {
39 | this._split();
40 | }
41 | return this._restrict;
42 | }
43 |
44 | }
45 |
--------------------------------------------------------------------------------
/src/a1atscript/router/ComponentMapper.js:
--------------------------------------------------------------------------------
1 | import {Controller} from "../annotations.js";
2 | import {Component, ViewBase} from "../ng2Directives/Component.js";
3 | import {AnnotationFinder} from "../AnnotationFinder.js";
4 | import SelectorMatcher from "../ng2Directives/SelectorMatcher.js";
5 |
6 | var DEFAULT_CONTROLLER_SUFFIX = "Controller";
7 | var DEFAULT_COMPONENT_PREFIX = "a1atscript";
8 | var DEFAULT_CONTROLLER_PREFIX = "A1AtScript";
9 |
10 | class ComponentMapping {
11 | constructor(component, componentMapper) {
12 | this.component = component;
13 | this.componentMapper = componentMapper;
14 | }
15 |
16 | get componentName() {
17 | return this.componentMapper.map.get(this.component);
18 | }
19 |
20 | get templateUrl() {
21 | return this.componentMapper.registry[this.componentName].templateUrl;
22 | }
23 |
24 | get isController() {
25 | return this.componentMapper.registry[this.componentName].isController;
26 | }
27 |
28 | get controllerName() {
29 | return this.componentMapper.registry[this.componentName].controllerName;
30 | }
31 | }
32 |
33 | export class ComponentMapper {
34 | register(component) {
35 | if (!this.map.get(component)) {
36 | this._setupComponent(component);
37 | }
38 | return new ComponentMapping(component, this);
39 | }
40 |
41 | _getControllerComponentName(component) {
42 | var name = this._getControllerName(component);
43 | if (name) {
44 | if (name.endsWith(DEFAULT_CONTROLLER_SUFFIX)) {
45 | return name[0].toLowerCase() + name.substr(1, name.length - DEFAULT_CONTROLLER_SUFFIX.length - 1);
46 | } else {
47 | return name[0].toLowerCase() + name.substr(1, name.length - 1);
48 | }
49 | } else {
50 | return null;
51 | }
52 | }
53 |
54 | _getControllerName(component) {
55 | var controllerAnnotation = (new AnnotationFinder(component)).annotationFor(Controller);
56 | if (controllerAnnotation) {
57 | return controllerAnnotation.token;
58 | } else {
59 | return null;
60 | }
61 | }
62 |
63 | _isController(component) {
64 | var controllerAnnotation = (new AnnotationFinder(component)).annotationFor(Controller);
65 | if (controllerAnnotation) {
66 | return true;
67 | } else {
68 | return false;
69 | }
70 | }
71 | _getComponentName(component) {
72 | var componentAnnotation = (new AnnotationFinder(component)).annotationFor(Component);
73 | if (componentAnnotation) {
74 | if (componentAnnotation.controllerAs) {
75 | return componentAnnotation.controllerAs;
76 | } else if (componentAnnotation.selector) {
77 | var selectorMatcher = new SelectorMatcher(componentAnnotation.selector);
78 | return selectorMatcher.name;
79 | } else {
80 | return null;
81 | }
82 | } else {
83 | return null;
84 | }
85 | }
86 |
87 | _getGeneratedName() {
88 | this._componentIndex = this._componentIndex || 0;
89 | var name = `${DEFAULT_COMPONENT_PREFIX}Component_${this._componentIndex}`;
90 | this._componentIndex = this._componentIndex + 1;
91 | return name;
92 | }
93 |
94 | _generateName(component) {
95 | var name = this._getControllerComponentName(component);
96 | name = name || this._getComponentName(component);
97 | name = name || this._getGeneratedName();
98 | return name;
99 | }
100 |
101 | _generateTemplate(name, component) {
102 | var viewAnnotation = (new AnnotationFinder(component)).annotationFor(ViewBase);
103 | if (viewAnnotation && viewAnnotation.templateUrl) {
104 | return viewAnnotation.templateUrl;
105 | } else {
106 | return `./components/${name}/${name}.html`;
107 | }
108 | }
109 |
110 | _readInlineTemplate(templateUrl, component) {
111 | var viewAnnotation = (new AnnotationFinder(component)).annotationFor(ViewBase);
112 | if (viewAnnotation && viewAnnotation.template) {
113 | this.inlineTemplateCache[templateUrl] = viewAnnotation.template;
114 | }
115 | }
116 |
117 | _generateControllerName(name) {
118 | var componentBase;
119 | if (name.startsWith(DEFAULT_COMPONENT_PREFIX)) {
120 | componentBase = name.substring(DEFAULT_COMPONENT_PREFIX.length, name.length)
121 | } else {
122 | componentBase = name;
123 | }
124 | return DEFAULT_CONTROLLER_PREFIX + componentBase[0].toUpperCase() + componentBase.substring(1, componentBase.length) + DEFAULT_CONTROLLER_SUFFIX;
125 | }
126 |
127 | _setupComponent(component) {
128 | var name = this._generateName(component);
129 | var templateUrl = this._generateTemplate(name, component);
130 | var controllerName = this._getControllerName(component);
131 | var isController;
132 | if (controllerName) {
133 | isController = true;
134 | } else {
135 | isController = false;
136 | controllerName = this._generateControllerName(name);
137 | }
138 | this.map.set(component, name);
139 | this.registry[name] = { component: component, templateUrl: templateUrl, isController: isController, controllerName: controllerName }
140 | this.controllerRegistry[controllerName] = name;
141 | this._readInlineTemplate(templateUrl, component);
142 | }
143 |
144 | get registry() {
145 | this._componentRegistry = this._componentRegistry || {}
146 | return this._componentRegistry;
147 | }
148 |
149 | get map() {
150 | this._componentMap = this._componentMap || new Map();
151 | return this._componentMap;
152 | }
153 |
154 | getComponent(componentName) {
155 | return this.registry[componentName].component;
156 | }
157 |
158 | getTemplateUrl(componentName) {
159 | return this.registry[componentName].templateUrl;
160 | }
161 |
162 | getComponentName(component) {
163 | return this.map.get(component);
164 | }
165 |
166 | get controllerRegistry() {
167 | this._controllerRegistry = this._controllerRegistry || {}
168 | return this._controllerRegistry;
169 | }
170 |
171 | get inlineTemplateCache() {
172 | this._inlineTemplateCache = this._inlineTemplateCache || {}
173 | return this._inlineTemplateCache;
174 | }
175 | }
176 |
--------------------------------------------------------------------------------
/src/a1atscript/router/RouteConfig.js:
--------------------------------------------------------------------------------
1 | import {ToAnnotation} from '../ToAnnotation.js';
2 |
3 | class RouteConfigAnnotation {
4 | constructor(routeDescription) {
5 | this.routeDescription = routeDescription;
6 | }
7 | }
8 |
9 | export const RouteConfig = ToAnnotation(RouteConfigAnnotation);
10 |
--------------------------------------------------------------------------------
/src/a1atscript/router/RouteInitializer.js:
--------------------------------------------------------------------------------
1 | export class RouteInitializer {
2 | constructor(componentMapper) {
3 | this.componentMapper = componentMapper;
4 | }
5 |
6 | configurationFunction(componentMapperName) {
7 | var componentMapper = this.componentMapper;
8 | return function($injector) {
9 | var $componentMapper;
10 | try {
11 | $componentMapper = $injector.get(componentMapperName);
12 | } catch(e) {
13 | return;
14 | }
15 | $componentMapper.setCtrlNameMapping(function(name) {
16 | return componentMapper.registry[name].controllerName;
17 | });
18 | $componentMapper.setTemplateMapping(function(name) {
19 | return componentMapper.registry[name].templateUrl;
20 | });
21 | $componentMapper.setComponentFromCtrlMapping(function(controllerName) {
22 | return componentMapper.controllerRegistry[controllerName];
23 | });
24 | }
25 | }
26 |
27 | topRouteConfig(routerName, routeConfig) {
28 | return function($injector) {
29 | var $router;
30 | try {
31 | $router = $injector.get(routerName);
32 |
33 | } catch(e) {
34 | return;
35 | }
36 | $router.config(routeConfig);
37 | };
38 | }
39 |
40 | setupComponentControllers() {
41 | Object.keys(this.componentMapper.registry).forEach((component) => {
42 | var config = this.componentMapper.registry[component];
43 | if (!config.isController && config.component != this.topComponent) {
44 | this.module.controller(
45 | config.controllerName,
46 | config.component
47 | );
48 | }
49 | });
50 | }
51 |
52 | setupInlineTemplates() {
53 | var inlineTemplateCache = this.componentMapper.inlineTemplateCache;
54 | return function($templateCache) {
55 | Object.keys(inlineTemplateCache).forEach((templateUrl) => {
56 | $templateCache.put(templateUrl, inlineTemplateCache[templateUrl]);
57 | });
58 | };
59 | }
60 | initialize(ngModuleName, topComponent = null) {
61 | this.module = angular.module(ngModuleName);
62 |
63 | // ng-new-router changed the name of its componentMapper service recently
64 | // essentially the approach here is to try to configure the mapper with both names
65 | // catch exceptions if they don't exist.
66 | // if both throw an exception, than there is no component router present
67 | this.module.config(['$injector', this.configurationFunction('$componentLoaderProvider')]);
68 | this.module.run(['$injector', this.configurationFunction('$componentMapper')]);
69 |
70 | if (topComponent && topComponent.$routeConfig) {
71 | this.topComponent = topComponent;
72 | this.module.run(['$injector', this.topRouteConfig('$router', topComponent.$routeConfig)])
73 | }
74 |
75 | this.setupComponentControllers();
76 |
77 | this.module.run(['$templateCache', this.setupInlineTemplates()]);
78 |
79 | }
80 | }
81 |
--------------------------------------------------------------------------------
/src/a1atscript/router/RouteReader.js:
--------------------------------------------------------------------------------
1 | import {RouteConfig} from "./RouteConfig.js";
2 | import {AnnotationFinder} from "../AnnotationFinder.js";
3 |
4 | export class RouteReader {
5 | constructor(componentMapper) {
6 | this.componentMapper = componentMapper;
7 | }
8 |
9 | _routeConfigAnnotations(component) {
10 | return (new AnnotationFinder(component)).annotationsFor(RouteConfig);
11 | }
12 |
13 | _routeConfig(component) {
14 | return this._routeConfigAnnotations(component).map(this._convertConfig.bind(this));
15 | }
16 |
17 | _componentName(component) {
18 | if (typeof(component) === "string") {
19 | return component
20 | } else {
21 | return this.componentMapper.register(component).componentName;
22 | }
23 | }
24 |
25 | _convertConfig(routeConfigAnnotation) {
26 | var routeDescription = Object.assign({}, routeConfigAnnotation.routeDescription);
27 | if (routeDescription.component) {
28 | routeDescription.component = this._componentName(routeDescription.component);
29 | }
30 |
31 | if (routeDescription.components) {
32 | var components = {};
33 | Object.keys(routeDescription.components).forEach((key) => {
34 | components[key] = this._componentName(routeDescription.components[key]);
35 | });
36 | routeDescription.components = components;
37 | }
38 |
39 | return routeDescription;
40 | }
41 |
42 | read(component) {
43 | var mapping = this.componentMapper.register(component);
44 | component.$routeConfig = this._routeConfig(component);
45 | }
46 | }
47 |
--------------------------------------------------------------------------------
/test-babel/ToAnnotation_spec.js:
--------------------------------------------------------------------------------
1 | import {ToAnnotation} from '../src/a1atscript/ToAnnotation.js';
2 |
3 | class AnnoClassAnnotation {
4 |
5 | }
6 |
7 | const AnnoClass = ToAnnotation(AnnoClassAnnotation);
8 |
9 | class Anno2ClassAnnotation {
10 | constructor(awesome, awesomeness) {
11 | this.awesome = awesome;
12 | this.awesomeness = awesomeness;
13 | }
14 | }
15 |
16 | const Anno2Class = ToAnnotation(Anno2ClassAnnotation);
17 |
18 | @AnnoClass()
19 | @Anno2Class("cheese", "grater")
20 | class TargetClass {
21 |
22 | @AnnoClass()
23 | method() {
24 |
25 | }
26 | }
27 |
28 | var literal = {
29 | @AnnoClass()
30 | awesome() {}
31 | }
32 |
33 | describe("ToAnnotation decorator", function() {
34 |
35 | it("operating on class", function() {
36 | expect(TargetClass.annotations).toEqual([new (AnnoClass.originalClass)(), new (Anno2Class.originalClass)("cheese", "grater")]);
37 | });
38 |
39 | it("operating on method", function() {
40 | expect(TargetClass.prototype.method.annotations).toEqual([new (AnnoClass.originalClass)()]);
41 | });
42 |
43 | it("operating on literal property", function() {
44 | expect(literal.awesome.annotations).toEqual([new (AnnoClass.originalClass)()]);
45 | });
46 | });
47 |
--------------------------------------------------------------------------------
/test-help/main.js:
--------------------------------------------------------------------------------
1 | // The entry point for unit tests.
2 |
3 | console.log("loaded");
4 |
5 | var TEST_REGEXP = /_spec\.js$/;
6 |
7 | function pathToModule(path) {
8 | return path.replace(/^\/base\//, '').replace(/\.js$/, '');
9 | }
10 |
11 | function onlySpecs(path) {
12 | return TEST_REGEXP.test(path);
13 | }
14 |
15 | function getAllSpecs() {
16 | return Object.keys(window.__karma__.files)
17 | .filter(onlySpecs)
18 | .map(pathToModule);
19 | }
20 |
21 | require.config({
22 | // Karma serves files under `/base`, which is the `basePath` from `karma-conf.js` file.
23 | baseUrl: '/base',
24 |
25 | paths: {
26 | assert: './node_modules/rtts-assert/dist/amd/assert',
27 | angular: './bower_components/angular/angular',
28 | 'angular-mocks': './bower_components/angular-mocks/angular-mocks',
29 | 'angular-new-router': './node_modules/angular-new-router/dist/router.es5'
30 | },
31 |
32 | shim: {
33 | 'angular': {'exports': 'angular'},
34 | 'angular-mocks': {deps: ['angular'], 'exports': 'angular.mock'},
35 | 'angular-new-router': {deps: ['angular']}
36 | },
37 |
38 | // Dynamically load all test files.
39 | deps: getAllSpecs(),
40 |
41 | // Kickoff Jasmine, once all spec files are loaded.
42 | callback: window.__karma__.start
43 | });
44 |
--------------------------------------------------------------------------------
/test/AnnotationFinder_spec.js:
--------------------------------------------------------------------------------
1 | import {AnnotationFinder} from "../src/a1atscript/AnnotationFinder.js";
2 | import {ToAnnotation} from "../src/a1atscript/ToAnnotation.js";
3 |
4 | @ToAnnotation
5 | class Anno1 {
6 |
7 | }
8 |
9 | @ToAnnotation
10 | class Anno2 {
11 |
12 | }
13 |
14 | @Anno1()
15 | @Anno2()
16 | class Something {
17 | constructor() {
18 |
19 | }
20 | }
21 |
22 | describe("AnnotationFinder", function() {
23 | var anno1Class, anno2Class, annotationFinder;
24 | beforeEach(function() {
25 | anno1Class = Anno1.originalClass || Anno1;
26 | anno2Class = Anno2.originalClass || Anno2;
27 | annotationFinder = new AnnotationFinder(Something);
28 | });
29 |
30 | it("should find annotations", function () {
31 | expect(annotationFinder.annotationFor(Anno1)).toEqual(jasmine.any(anno1Class));
32 | expect(annotationFinder.annotationFor(Anno2)).toEqual(jasmine.any(anno2Class));
33 | });
34 | });
35 |
--------------------------------------------------------------------------------
/test/ComponentMapper_spec.js:
--------------------------------------------------------------------------------
1 | import {Controller} from '../src/a1atscript/annotations.js'
2 | import {Component, View} from '../src/a1atscript/ng2Directives/Component.js'
3 | import {ComponentMapper} from '../src/a1atscript/router/ComponentMapper.js'
4 |
5 | @Controller('AwesomeController', [])
6 | class AwesomeController {
7 | constructor() {
8 |
9 | }
10 | }
11 |
12 | @Controller('weirdName', [])
13 | class WeirdNameController {
14 | constructor() {
15 |
16 | }
17 | }
18 |
19 | @Component({
20 | selector: 'awesome'
21 | })
22 | @View({
23 | templateUrl: "cheese.tpl.html"
24 | })
25 | class AwesomeComponent {
26 | constructor() {
27 |
28 | }
29 | }
30 |
31 | @Component({
32 | controllerAs: 'cac'
33 | })
34 | @View({
35 | templateUrl: "cheese.tpl.html"
36 | })
37 | class ControllerAsComponent {
38 | constructor() {
39 |
40 | }
41 | }
42 |
43 | @Component({})
44 | class UnNamedComponent {
45 | constructor() {
46 |
47 | }
48 | }
49 |
50 | class NonAnnotatedComponent {
51 | constructor() {
52 |
53 | }
54 | }
55 |
56 | @Component({
57 | selector: "cheese"
58 | })
59 | @View({
60 | template: "Awesome
"
61 | })
62 | class InlineTemplateComponent {
63 | constructor() {
64 |
65 | }
66 | }
67 |
68 | describe("ComponentMapper", function() {
69 | var componentMapper, componentMapping;
70 |
71 | beforeEach(function() {
72 | componentMapper = new ComponentMapper();
73 | });
74 |
75 | describe("controllers", function() {
76 | it("should convert canonically named controllers to components", function() {
77 | componentMapping = componentMapper.register(AwesomeController);
78 | expect(componentMapping.componentName).toEqual("awesome");
79 | expect(componentMapping.templateUrl).toEqual("./components/awesome/awesome.html");
80 | expect(componentMapping.isController).toBe(true);
81 | expect(componentMapping.controllerName).toEqual("AwesomeController");
82 | expect(componentMapper.controllerRegistry["AwesomeController"]).toEqual("awesome");
83 | });
84 |
85 | it("should convert oddly named controllers to components", function() {
86 | componentMapping = componentMapper.register(WeirdNameController);
87 | expect(componentMapping.componentName).toEqual("weirdName");
88 | expect(componentMapping.templateUrl).toEqual("./components/weirdName/weirdName.html");
89 | expect(componentMapping.isController).toBe(true);
90 | expect(componentMapping.controllerName).toEqual("weirdName");
91 | expect(componentMapper.controllerRegistry["weirdName"]).toEqual("weirdName");
92 | });
93 | });
94 |
95 | describe("components", function() {
96 | it("should convert components with controllerAs value to components with same name", function() {
97 | componentMapping = componentMapper.register(ControllerAsComponent);
98 | expect(componentMapping.componentName).toEqual("cac");
99 | expect(componentMapping.controllerName).toEqual("A1AtScriptCacController");
100 | expect(componentMapper.controllerRegistry["A1AtScriptCacController"]).toEqual("cac");
101 | });
102 |
103 | it("should convert components with selector names to components with same name", function() {
104 | componentMapping = componentMapper.register(AwesomeComponent);
105 | expect(componentMapping.componentName).toEqual("awesome");
106 | expect(componentMapping.controllerName).toEqual("A1AtScriptAwesomeController");
107 | expect(componentMapper.controllerRegistry["A1AtScriptAwesomeController"]).toEqual("awesome");
108 | });
109 |
110 | it("should not mark them as controllers", function() {
111 | expect(componentMapping.isController).toBe(false);
112 | })
113 |
114 |
115 | it("should read templateUrls from View annotations", function() {
116 | componentMapping = componentMapper.register(AwesomeComponent);
117 | expect(componentMapping.templateUrl).toEqual("cheese.tpl.html");
118 | });
119 |
120 | it("should generate a name for components with no selector", function() {
121 | componentMapping = componentMapper.register(UnNamedComponent);
122 | expect(componentMapping.componentName).toEqual("a1atscriptComponent_0");
123 | expect(componentMapping.templateUrl).toEqual("./components/a1atscriptComponent_0/a1atscriptComponent_0.html");
124 | expect(componentMapping.controllerName).toEqual("A1AtScriptComponent_0Controller");
125 | expect(componentMapper.controllerRegistry["A1AtScriptComponent_0Controller"]).toEqual("a1atscriptComponent_0");
126 |
127 | // check idempotence
128 | componentMapping = componentMapper.register(UnNamedComponent);
129 | expect(componentMapping.componentName).toEqual("a1atscriptComponent_0");
130 | expect(componentMapping.templateUrl).toEqual("./components/a1atscriptComponent_0/a1atscriptComponent_0.html");
131 | expect(componentMapping.controllerName).toEqual("A1AtScriptComponent_0Controller");
132 | expect(componentMapper.controllerRegistry["A1AtScriptComponent_0Controller"]).toEqual("a1atscriptComponent_0");
133 |
134 | });
135 | });
136 |
137 | describe("non annotated classes", function() {
138 | it("should generate a name for classes with no annotation at all", function() {
139 | componentMapping = componentMapper.register(NonAnnotatedComponent);
140 | expect(componentMapping.componentName).toEqual("a1atscriptComponent_0");
141 | expect(componentMapping.controllerName).toEqual("A1AtScriptComponent_0Controller");
142 | expect(componentMapping.templateUrl).toEqual("./components/a1atscriptComponent_0/a1atscriptComponent_0.html");
143 | expect(componentMapping.isController).toBe(false);
144 | expect(componentMapper.controllerRegistry["A1AtScriptComponent_0Controller"]).toEqual("a1atscriptComponent_0");
145 | });
146 | });
147 |
148 | describe("inline template components", function() {
149 | it("should add the template to the inline template cache", function() {
150 | componentMapping = componentMapper.register(InlineTemplateComponent);
151 | expect(componentMapper.inlineTemplateCache["./components/cheese/cheese.html"]).toEqual("Awesome
");
152 | });
153 | })
154 | });
155 |
--------------------------------------------------------------------------------
/test/Component_spec.js:
--------------------------------------------------------------------------------
1 | import angular from 'angular';
2 | import 'angular-mocks';
3 |
4 | import {Component, View} from '../src/a1atscript/ng2Directives/Component'
5 | import "../src/a1atscript/ng2Directives/ComponentInjector";
6 |
7 | import {
8 | Module,
9 | Service
10 | } from '../src/a1atscript/annotations';
11 |
12 | import {
13 | bootstrap
14 | } from '../src/a1atscript/bootstrap';
15 |
16 | import {getInjector} from '../src/a1atscript/Injector';
17 |
18 | var mock = angular.mock;
19 |
20 | @Service('ExampleService')
21 | class ExampleService {
22 | constructor() {
23 | this.value = 'Set within controller';
24 | }
25 | }
26 |
27 | class AwesomeBase {
28 | constructor() {
29 | this.test = "test";
30 | }
31 |
32 | setValue() {
33 | this.value = this.exampleService.value;
34 | }
35 | }
36 |
37 | @Component({
38 | selector: "awesome",
39 | properties: {
40 | apple: "apple"
41 | },
42 | events: {
43 | click: "click"
44 | },
45 | appInjector: ["ExampleService"]
46 | })
47 | @View({
48 | templateUrl: "awesome.tpl.html"
49 | })
50 | class AwesomeComponent extends AwesomeBase {
51 | constructor(exampleService) {
52 | super();
53 | this.exampleService = exampleService;
54 | }
55 | setValue() {
56 | super.setValue();
57 | this.subValue = this.exampleService.value;
58 | }
59 | }
60 |
61 | angular.module("awesomeTemplate", []).run(["$templateCache", function($templateCache) {
62 | $templateCache.put("awesome.tpl.html",
63 | "{{awesome.test}} {{awesome.apple}}
");
64 | }]);
65 |
66 | var AppModule = new Module('AppModule', ['awesomeTemplate', ExampleService, AwesomeComponent])
67 |
68 | describe("Component", function() {
69 | var scope, isolateScope, element, injector, $compile, saveSpy,
70 | componentInjector, beforeHook, hooks;
71 |
72 | beforeEach(function() {
73 | hooks = {
74 | before(module, ddo) {
75 | ddo._bind.foo = "@"
76 | },
77 | after() {}
78 | };
79 |
80 | componentInjector = getInjector('component');
81 | spyOn(hooks, 'before').and.callThrough();
82 | spyOn(hooks, 'after');
83 | componentInjector.componentHooks.before.push(hooks.before);
84 | componentInjector.componentHooks.after.push(hooks.after);
85 |
86 | bootstrap(AppModule, "AppModule");
87 | mock.module('AppModule');
88 | mock.inject(function($rootScope, _$compile_) {
89 | scope = $rootScope.$new();
90 | scope.apple = "cheese";
91 | scope.save = function() { };
92 | saveSpy = spyOn(scope, 'save');
93 | $compile = _$compile_;
94 | element = '';
95 | element = $compile(element)(scope);
96 | scope.$digest();
97 | isolateScope = element.isolateScope();
98 | });
99 | });
100 |
101 | it("should function as a directive definition object", function() {
102 | expect(element.find('p').length).toEqual(1);
103 | expect(element.find('p')[0].innerHTML).toEqual("test cheese")
104 | });
105 |
106 | it("should setup the events", function() {
107 | isolateScope.awesome.click();
108 | expect(saveSpy).toHaveBeenCalled();
109 | });
110 |
111 | it("should call 'before' hook and allow altering ddo", function() {
112 | let hookArgs = hooks.before.calls.argsFor(0);
113 | let module = hookArgs[0];
114 | let ddo = hookArgs[1];
115 | let ComponentClass = Component.originalClass || Component;
116 | expect(module).toEqual(angular.module(AppModule.token));
117 | expect(ddo._annotation instanceof ComponentClass).toBeTruthy();
118 | expect(ddo._controller).toEqual(AwesomeComponent);
119 | expect(isolateScope.awesome.foo).toEqual('bar');
120 | });
121 |
122 | it("should call 'after' hook", function() {
123 | let hookArgs = hooks.after.calls.argsFor(0);
124 | let module = hookArgs[0];
125 | let ddo = hookArgs[1];
126 | let ComponentClass = Component.originalClass || Component;
127 | expect(module).toEqual(angular.module(AppModule.token));
128 | expect(ddo._annotation instanceof ComponentClass).toBeTruthy();
129 | expect(ddo._controller).toEqual(AwesomeComponent);
130 | });
131 |
132 | describe("this", function() {
133 | beforeEach(function() {
134 | isolateScope.awesome.setValue();
135 | });
136 | it("should be able to access this from within the link function", function() {
137 | expect(isolateScope.awesome.value).toEqual("Set within controller");
138 | expect(isolateScope.awesome.subValue).toEqual("Set within controller");
139 | })
140 | });
141 |
142 | });
143 |
--------------------------------------------------------------------------------
/test/DirectiveObject_spec.js:
--------------------------------------------------------------------------------
1 | import angular from 'angular';
2 | import 'angular-mocks';
3 |
4 | import {DirectiveObject} from '../src/a1atscript/DirectiveObject'
5 |
6 | import {
7 | Module,
8 | Service
9 | } from '../src/a1atscript/annotations';
10 |
11 | import {
12 | bootstrap
13 | } from '../src/a1atscript/bootstrap';
14 |
15 | var mock = angular.mock;
16 |
17 | @Service('ExampleService')
18 | class ExampleService {
19 | constructor() {
20 | this.value = 'Set within link';
21 | this.value2 = "Set within callback";
22 | }
23 |
24 | setValue(scope) {
25 | scope.value = this.exampleService.value;
26 | }
27 |
28 | }
29 |
30 | class ExampleBase {
31 | constructor() {
32 | this.restrict = "E";
33 | }
34 |
35 | link(scope, element, attrs) {
36 | this.setValue(scope);
37 | scope.setFromService = () => {
38 | scope.value2 = this.exampleService.value2;
39 | }
40 | }
41 |
42 | setValue(scope) {
43 | scope.value = this.exampleService.value;
44 | }
45 | }
46 |
47 | @DirectiveObject('exampleDirective', ['ExampleService'])
48 | class ExampleDirective extends ExampleBase {
49 | constructor(exampleService) {
50 | super();
51 | this.exampleService = exampleService;
52 | this.templateUrl = "template.tpl.html";
53 | }
54 | setValue(scope) {
55 | super.setValue(scope);
56 | scope.subValue = this.exampleService.value;
57 | }
58 | }
59 |
60 | angular.module("simpleTemplate", []).run(["$templateCache", function($templateCache) {
61 | $templateCache.put("template.tpl.html",
62 | "Hello
");
63 | }]);
64 |
65 | var AppModule = new Module('AppModule', ['simpleTemplate', ExampleService, ExampleDirective])
66 |
67 | describe("DirectiveObject", function() {
68 | var scope, element, injector, $compile;
69 |
70 | beforeEach(function() {
71 | bootstrap(AppModule, "AppModule");
72 | mock.module('AppModule');
73 | mock.inject(function($rootScope, _$compile_) {
74 | scope = $rootScope.$new();
75 | $compile = _$compile_;
76 | element = '';
77 | element = $compile(element)(scope);
78 | scope.$digest();
79 | });
80 | });
81 |
82 | it("should function as a directive definition object", function() {
83 | expect(element.find('p').length).toEqual(1);
84 | });
85 |
86 | describe("linking and this", function() {
87 | beforeEach(function() {
88 | scope.setFromService();
89 | });
90 | it("should be able to access this from within the link function", function() {
91 | expect(scope.value).toEqual("Set within link");
92 | expect(scope.subValue).toEqual("Set within link");
93 | expect(scope.value2).toEqual("Set within callback");
94 | })
95 | });
96 |
97 | });
98 |
--------------------------------------------------------------------------------
/test/EventsBuilder_spec.js:
--------------------------------------------------------------------------------
1 | import EventsBuilder from "../src/a1atscript/ng2Directives/EventsBuilder.js"
2 |
3 | class Component {
4 | constructor() {
5 |
6 | }
7 | }
8 |
9 | describe("EventsBuilder", function() {
10 | var eventsObj, events;
11 |
12 | beforeEach(function() {
13 | eventsObj = [ "cheese: danish", "apple"];
14 | events = (new EventsBuilder(eventsObj, Component)).build();
15 | });
16 |
17 | it("should setup the correct events", function() {
18 | expect(events).toEqual({
19 | "cheese": "=?onDanish",
20 | "apple": "=?onApple"
21 | });
22 | });
23 |
24 | });
25 |
--------------------------------------------------------------------------------
/test/Ng2DirectiveDefinitionObject_spec.js:
--------------------------------------------------------------------------------
1 | import Ng2Directive from '../src/a1atscript/ng2Directives/Ng2Directive.js';
2 | import Ng2DirectiveDefinitionObject from '../src/a1atscript/ng2Directives/Ng2DirectiveDefinitionObject.js';
3 |
4 | class Hello {
5 | constructor() {
6 | }
7 | }
8 |
9 | describe("DirectiveDefinitionObject", function() {
10 | var ng2DirectiveDefinitionObject, ng2Directive, ddoFactoryFn, templateProperties, bind;
11 |
12 | describe("regular behavior", function() {
13 | beforeEach(function() {
14 | ng2Directive = new Ng2Directive({
15 | selector: "[attr]",
16 | bind: {
17 | 'something': "something"
18 | }
19 | });
20 | angular.version.major = 1;
21 | angular.version.minor = 4;
22 | ng2DirectiveDefinitionObject = new Ng2DirectiveDefinitionObject(Hello, ng2Directive);
23 | });
24 |
25 | it("should have the right properties", function() {
26 | expect(ng2DirectiveDefinitionObject.restrict).toEqual("A");
27 | expect(ng2DirectiveDefinitionObject.name).toEqual("attr");
28 | expect(ng2DirectiveDefinitionObject.controllerAs).toEqual("attr");
29 | expect(ng2DirectiveDefinitionObject.bindToController).toEqual({
30 | 'something': "something"
31 | });
32 | expect(ng2DirectiveDefinitionObject.controller).toEqual(Hello);
33 | expect(ng2DirectiveDefinitionObject.scope).toEqual({});
34 | expect(ng2DirectiveDefinitionObject.template).toBe(undefined);
35 | expect(ng2DirectiveDefinitionObject.templateUrl).toBe(undefined);
36 | expect(ng2DirectiveDefinitionObject.require).toBe(undefined);
37 | expect(ng2DirectiveDefinitionObject.transclude).toBe(undefined);
38 | });
39 |
40 | describe("factoryFn", function() {
41 | beforeEach(function() {
42 | ddoFactoryFn = ng2DirectiveDefinitionObject.factoryFn;
43 | });
44 |
45 | it("should build a factory function that returns the right DDO", function() {
46 | expect(ddoFactoryFn()).toEqual({
47 | scope: {},
48 | restrict: "A",
49 | controllerAs: "attr",
50 | bindToController: {
51 | 'something': "something"
52 | },
53 | require: undefined,
54 | transclude: undefined,
55 | controller: Hello,
56 | template: undefined,
57 | templateUrl: undefined
58 | });
59 | });
60 | });
61 | });
62 |
63 | describe("with ng1 customizations", function() {
64 | beforeEach(function() {
65 | ng2Directive = new Ng2Directive({
66 | selector: "[attr]",
67 | bind: {
68 | 'something': "something"
69 | },
70 | controllerAs: "awesome",
71 | require: "power"
72 | });
73 | angular.version.major = 1;
74 | angular.version.minor = 4;
75 | ng2DirectiveDefinitionObject = new Ng2DirectiveDefinitionObject(Hello, ng2Directive);
76 | });
77 |
78 | it("should have the right properties", function() {
79 | expect(ng2DirectiveDefinitionObject.restrict).toEqual("A");
80 | expect(ng2DirectiveDefinitionObject.name).toEqual("attr");
81 | expect(ng2DirectiveDefinitionObject.controllerAs).toEqual("awesome");
82 | expect(ng2DirectiveDefinitionObject.bindToController).toEqual({
83 | 'something': "something"
84 | });
85 | expect(ng2DirectiveDefinitionObject.controller).toEqual(Hello);
86 | expect(ng2DirectiveDefinitionObject.scope).toEqual({});
87 | expect(ng2DirectiveDefinitionObject.template).toBe(undefined);
88 | expect(ng2DirectiveDefinitionObject.templateUrl).toBe(undefined);
89 | expect(ng2DirectiveDefinitionObject.require).toBe("power");
90 | expect(ng2DirectiveDefinitionObject.transclude).toBe(undefined);
91 |
92 | });
93 |
94 | describe("factoryFn", function() {
95 | beforeEach(function() {
96 | ddoFactoryFn = ng2DirectiveDefinitionObject.factoryFn;
97 | });
98 |
99 | it("should build a factory function that returns the right DDO", function() {
100 | expect(ddoFactoryFn()).toEqual({
101 | scope: {},
102 | restrict: "A",
103 | controllerAs: "awesome",
104 | bindToController: {
105 | 'something': "something"
106 | },
107 | require: "power",
108 | transclude: undefined,
109 | controller: Hello,
110 | template: undefined,
111 | templateUrl: undefined
112 | });
113 | });
114 | });
115 | });
116 |
117 | describe("with template", function() {
118 | beforeEach(function() {
119 | ng2Directive = new Ng2Directive({
120 | selector: "[attr]",
121 | bind: {
122 | 'something': 'something'
123 | }
124 | });
125 | templateProperties = {
126 | templateUrl: "attr.html"
127 | }
128 | angular.version.major = 1;
129 | angular.version.minor = 4;
130 | ng2DirectiveDefinitionObject = new Ng2DirectiveDefinitionObject(Hello, ng2Directive, templateProperties);
131 | });
132 |
133 | it("should have the right properties", function() {
134 | expect(ng2DirectiveDefinitionObject.restrict).toEqual("A");
135 | expect(ng2DirectiveDefinitionObject.name).toEqual("attr");
136 | expect(ng2DirectiveDefinitionObject.controllerAs).toEqual("attr");
137 | expect(ng2DirectiveDefinitionObject.bindToController).toEqual({
138 | 'something': "something"
139 | });
140 | expect(ng2DirectiveDefinitionObject.controller).toEqual(Hello);
141 | expect(ng2DirectiveDefinitionObject.scope).toEqual({});
142 | expect(ng2DirectiveDefinitionObject.template).toBe(undefined);
143 | expect(ng2DirectiveDefinitionObject.templateUrl).toBe("attr.html");
144 | expect(ng2DirectiveDefinitionObject.require).toBe(undefined);
145 | expect(ng2DirectiveDefinitionObject.transclude).toBe(undefined);
146 | });
147 |
148 | describe("factoryFn", function() {
149 | beforeEach(function() {
150 | ddoFactoryFn = ng2DirectiveDefinitionObject.factoryFn;
151 | });
152 |
153 | it("should build a factory function that returns the right DDO", function() {
154 | expect(ddoFactoryFn()).toEqual({
155 | scope: {},
156 | restrict: "A",
157 | controllerAs: "attr",
158 | bindToController: {
159 | 'something': "something"
160 | },
161 | require: undefined,
162 | transclude: undefined,
163 | controller: Hello,
164 | template: undefined,
165 | templateUrl: "attr.html"
166 | });
167 | });
168 | });
169 | });
170 |
171 | describe("with bind", function() {
172 | beforeEach(function() {
173 | ng2Directive = new Ng2Directive({
174 | selector: "[attr]",
175 | bind: {
176 | 'something': "something"
177 | }
178 | });
179 | bind = {
180 | other: "awesome"
181 | }
182 | angular.version.major = 1;
183 | angular.version.minor = 4;
184 | ng2DirectiveDefinitionObject = new Ng2DirectiveDefinitionObject(Hello, ng2Directive, {}, bind);
185 | });
186 |
187 | it("should have the right properties", function() {
188 | expect(ng2DirectiveDefinitionObject.restrict).toEqual("A");
189 | expect(ng2DirectiveDefinitionObject.name).toEqual("attr");
190 | expect(ng2DirectiveDefinitionObject.controllerAs).toEqual("attr");
191 | expect(ng2DirectiveDefinitionObject.bindToController).toEqual({
192 | other: "awesome"
193 | });
194 | expect(ng2DirectiveDefinitionObject.controller).toEqual(Hello);
195 | expect(ng2DirectiveDefinitionObject.scope).toEqual({});
196 | expect(ng2DirectiveDefinitionObject.template).toBe(undefined);
197 | expect(ng2DirectiveDefinitionObject.templateUrl).toBe(undefined);
198 | expect(ng2DirectiveDefinitionObject.require).toBe(undefined);
199 | expect(ng2DirectiveDefinitionObject.transclude).toBe(undefined);
200 | });
201 |
202 | describe("factoryFn", function() {
203 | beforeEach(function() {
204 | ddoFactoryFn = ng2DirectiveDefinitionObject.factoryFn;
205 | });
206 |
207 | it("should build a factory function that returns the right DDO", function() {
208 | expect(ddoFactoryFn()).toEqual({
209 | scope: {},
210 | restrict: "A",
211 | controllerAs: "attr",
212 | bindToController: {
213 | other: "awesome"
214 | },
215 | require: undefined,
216 | transclude: undefined,
217 | controller: Hello,
218 | template: undefined,
219 | templateUrl: undefined
220 | });
221 | });
222 | });
223 | });
224 |
225 | describe("angular < 1.4", function() {
226 | beforeEach(function() {
227 | ng2Directive = new Ng2Directive({
228 | selector: "[attr]",
229 | bind: {
230 | 'something': "something"
231 | }
232 | });
233 | angular.version.major = 1;
234 | angular.version.minor = 3;
235 | ng2DirectiveDefinitionObject = new Ng2DirectiveDefinitionObject(Hello, ng2Directive);
236 | });
237 |
238 | it("should have the right properties", function() {
239 | expect(ng2DirectiveDefinitionObject.restrict).toEqual("A");
240 | expect(ng2DirectiveDefinitionObject.name).toEqual("attr");
241 | expect(ng2DirectiveDefinitionObject.controllerAs).toEqual("attr");
242 | expect(ng2DirectiveDefinitionObject.bindToController).toEqual(true);
243 | expect(ng2DirectiveDefinitionObject.controller).toEqual(Hello);
244 | expect(ng2DirectiveDefinitionObject.scope).toEqual({
245 | 'something': "something"
246 | });
247 | expect(ng2DirectiveDefinitionObject.template).toBe(undefined);
248 | expect(ng2DirectiveDefinitionObject.templateUrl).toBe(undefined);
249 | expect(ng2DirectiveDefinitionObject.require).toBe(undefined);
250 | expect(ng2DirectiveDefinitionObject.transclude).toBe(undefined);
251 | });
252 |
253 | describe("factoryFn", function() {
254 | beforeEach(function() {
255 | ddoFactoryFn = ng2DirectiveDefinitionObject.factoryFn;
256 | });
257 |
258 | it("should build a factory function that returns the right DDO", function() {
259 | expect(ddoFactoryFn()).toEqual({
260 | scope: {
261 | 'something': "something"
262 | },
263 | restrict: "A",
264 | controllerAs: "attr",
265 | bindToController: true,
266 | require: undefined,
267 | transclude: undefined,
268 | controller: Hello,
269 | template: undefined,
270 | templateUrl: undefined
271 | });
272 | });
273 | });
274 | });
275 |
276 |
277 | });
278 |
--------------------------------------------------------------------------------
/test/NoRouterPresent_spec.js:
--------------------------------------------------------------------------------
1 | import angular from 'angular';
2 | import 'angular-mocks';
3 |
4 | import {Component, View} from '../src/a1atscript/ng2Directives/Component';
5 | import {RouteConfig} from '../src/a1atscript/router/RouteConfig';
6 | import "../src/a1atscript/ng2Directives/ComponentInjector";
7 |
8 | import {
9 | AsModule,
10 | Service
11 | } from '../src/a1atscript/annotations';
12 |
13 | import {
14 | bootstrap
15 | } from '../src/a1atscript/bootstrap';
16 |
17 | var mock = angular.mock;
18 |
19 | @Component({})
20 | @View({
21 | template: "Sub
"
22 | })
23 | class SubComponent {
24 |
25 | }
26 |
27 | @Component({})
28 | @View({
29 | template: "Home
"
30 | })
31 | @RouteConfig({
32 | path: "/sub", component: SubComponent
33 | })
34 | class HomeComponent {
35 | }
36 |
37 | @AsModule('NoRouterAppModule', ['templates', HomeComponent, SubComponent])
38 | @Component({
39 | selector: "awesome"
40 | })
41 | @View({
42 | templateUrl: "app.tpl.html"
43 | })
44 | @RouteConfig({
45 | path: "/home", component: HomeComponent
46 | })
47 | class AppComponent {
48 | }
49 |
50 | angular.module("templates", []).run(["$templateCache", function($templateCache) {
51 | $templateCache.put("app.tpl.html",
52 | "");
53 | }]);
54 |
55 | describe("Routable Component", function() {
56 | var scope, element, $compile;
57 |
58 | beforeEach(function() {
59 | bootstrap(AppComponent, "NoRouterAppModule");
60 | mock.module('NoRouterAppModule');
61 | mock.inject(function($rootScope, _$compile_) {
62 | scope = $rootScope.$new();
63 | $compile = _$compile_;
64 | element = '';
65 | element = $compile(element)(scope);
66 | $rootScope.$digest();
67 | });
68 | });
69 |
70 | it("should not build routes but should compile with no issues despite lack of router", function() {
71 | expect(element.find('ng-viewport').length).toEqual(1);
72 | });
73 | });
74 |
--------------------------------------------------------------------------------
/test/PropertiesBuilder_spec.js:
--------------------------------------------------------------------------------
1 | import PropertiesBuilder from "../src/a1atscript/ng2Directives/PropertiesBuilder.js"
2 |
3 | class Component {
4 | constructor() {
5 |
6 | }
7 | }
8 |
9 | describe("PropertiesBuilder", function() {
10 | var propertiesObj, properties;
11 |
12 | beforeEach(function() {
13 | propertiesObj = ["cheese:danish","apple"];
14 | properties = (new PropertiesBuilder(propertiesObj, Component)).build();
15 | });
16 |
17 | it("should setup the correct properties", function() {
18 | expect(properties).toEqual({
19 | "_@_cheese": "@danish",
20 | "_=_cheese": "=?bindDanish",
21 | "_@_apple": "@apple",
22 | "_=_apple": "=?bindApple"
23 | });
24 | });
25 |
26 | it("should setup the bind setter", function() {
27 | var component = new Component();
28 | component["_=_apple"] = "bind";
29 | expect(component.apple).toEqual("bind");
30 | });
31 |
32 | it("should setup the string setter", function() {
33 | var component = new Component();
34 | component["_@_apple"] = "string";
35 | expect(component.apple).toEqual("string");
36 | });
37 |
38 | it("should disable string if bind is used first", function() {
39 | var component = new Component();
40 | component["_=_apple"] = "bind";
41 | expect(() => component["_@_apple"] = "string").toThrow(new Error('Cannot use bind-apple and apple simultaneously'));
42 | expect(component.apple).toEqual('bind');
43 | });
44 |
45 | it("should disable bind if string is used first", function() {
46 | var component = new Component();
47 | component["_@_apple"] = "string";
48 | expect(() => component["_=_apple"] = "bind").toThrow(new Error('Cannot use bind-apple and apple simultaneously'));
49 | expect(component.apple).toEqual('string');
50 | });
51 |
52 | it("should generate getter for bind property that proxies to the bound object real property", function() {
53 | var component = new Component();
54 | component.apple = 'bind';
55 | expect(component["_=_apple"]).toEqual('bind');
56 | });
57 |
58 | it("should generate getter for string property that proxies to the bound object real property", function() {
59 | var component = new Component();
60 | component.apple = 'string';
61 | expect(component["_@_apple"]).toEqual('string');
62 | })
63 |
64 | it("should allow different component instances to use different property binding strategies (string and bind)", function() {
65 | var componentA = new Component();
66 | var componentB = new Component();
67 |
68 | componentA["_@_apple"] = "string";
69 | expect(() => componentB["_=_apple"] = "bind").not.toThrow();
70 | })
71 | });
72 |
--------------------------------------------------------------------------------
/test/RoutableComponent_spec.js:
--------------------------------------------------------------------------------
1 | import angular from 'angular';
2 | import 'angular-mocks';
3 | import 'angular-new-router';
4 |
5 | import {Component, View} from '../src/a1atscript/ng2Directives/Component';
6 | import {RouteConfig} from '../src/a1atscript/router/RouteConfig';
7 | import "../src/a1atscript/ng2Directives/ComponentInjector";
8 |
9 | import {
10 | AsModule,
11 | Service
12 | } from '../src/a1atscript/annotations';
13 |
14 | import {
15 | bootstrap
16 | } from '../src/a1atscript/bootstrap';
17 |
18 | var mock = angular.mock;
19 |
20 | @Component({})
21 | @View({
22 | template: "Sub
"
23 | })
24 | class SubComponent {
25 |
26 | }
27 |
28 | @Component({})
29 | @View({
30 | template: "Home
"
31 | })
32 | @RouteConfig({
33 | path: "/sub", component: SubComponent
34 | })
35 | class HomeComponent {
36 | }
37 |
38 | @AsModule('AppModule', ['templates', 'ngNewRouter', HomeComponent, SubComponent])
39 | @Component({
40 | selector: "awesome"
41 | })
42 | @View({
43 | templateUrl: "app.tpl.html"
44 | })
45 | @RouteConfig({
46 | path: "/home", component: HomeComponent
47 | })
48 | class AppComponent {
49 | }
50 |
51 | angular.module("templates", []).run(["$templateCache", function($templateCache) {
52 | $templateCache.put("app.tpl.html",
53 | "");
54 | }]);
55 |
56 | describe("Routable Component", function() {
57 | var scope, element, $compile;
58 |
59 | beforeEach(function() {
60 | bootstrap(AppComponent, "AppModule");
61 | mock.module('AppModule');
62 | mock.inject(function($rootScope, $router, _$compile_) {
63 | scope = $rootScope.$new();
64 | $compile = _$compile_;
65 | element = '';
66 | element = $compile(element)(scope);
67 | $router.navigate("/home/sub")
68 | $rootScope.$digest();
69 | });
70 | });
71 |
72 | it("should navigate correctly to the right route", function() {
73 | expect(element.find('p').length).toEqual(2);
74 | expect(element.find('p')[0].innerHTML).toEqual("Home")
75 | expect(element.find('p')[1].innerHTML).toEqual("Sub")
76 | });
77 | });
78 |
--------------------------------------------------------------------------------
/test/RouteInitializer_spec.js:
--------------------------------------------------------------------------------
1 | import angular from 'angular';
2 | import 'angular-mocks';
3 | import 'angular-new-router';
4 |
5 | import {RouteInitializer} from "../src/a1atscript/router/RouteInitializer.js";
6 |
7 | var mock = angular.mock;
8 |
9 | angular.module('testApp', ['ngNewRouter']);
10 |
11 | describe("RouteInitializer", function() {
12 |
13 | describe("initialize", function() {
14 | var componentMapper, routeInitializer, $templateCache, $componentLoader, TestComponent, TestController, controllerSpy, TopConfigComponent;
15 | beforeEach(function() {
16 | TestComponent = function() {
17 | };
18 | TestController = function() {
19 | };
20 | TopConfigComponent = function() {
21 | };
22 | TopConfigComponent.$routeConfig = [{
23 | path: "awesome", component: "awesome"
24 | }];
25 |
26 | componentMapper = {
27 | registry: {
28 | "awesome": {
29 | 'templateUrl': 'awesome.tpl.html',
30 | 'component': TestComponent,
31 | 'controllerName': 'AwesomeController',
32 | 'isController': false,
33 | 'routeConfig': [{
34 | path: "cheese", component: "cheese"
35 | }]
36 | },
37 | "cheese": {
38 | 'templateUrl': './components/cheese/cheese.html',
39 | 'component': TestController,
40 | 'controllerName': "CheesetasticController",
41 | 'isController': true
42 | },
43 | "topConfig": {
44 | 'templateUrl': 'topConfig.tpl.html',
45 | 'component': TopConfigComponent,
46 | 'controllerName': 'TopConfigController',
47 | 'isController': false,
48 | 'routeConfig': [{
49 | path: "awesome", component: "awesome"
50 | }]
51 | }
52 | },
53 | controllerRegistry: {
54 | "AwesomeController": "awesome",
55 | "CheesetasticController": "cheese"
56 | },
57 | inlineTemplateCache: {
58 | 'awesome.tpl.html': "FizzBuzz
"
59 | }
60 | };
61 |
62 | routeInitializer = new RouteInitializer(componentMapper);
63 | controllerSpy = spyOn(angular.module('testApp'), 'controller');
64 | routeInitializer.initialize('testApp', TopConfigComponent);
65 | mock.module("testApp", TopConfigComponent);
66 | mock.inject(function(_$componentLoader_, _$templateCache_) {
67 | $componentLoader = _$componentLoader_;
68 | $templateCache = _$templateCache_;
69 | });
70 | });
71 |
72 | it("should setup controller name mappings properly", function() {
73 | expect($componentLoader.controllerName("awesome")).toEqual("AwesomeController");
74 | expect($componentLoader.controllerName("cheese")).toEqual("CheesetasticController");
75 | });
76 |
77 | it("should setup template mappings properly", function() {
78 | expect($componentLoader.template("awesome")).toEqual("awesome.tpl.html")
79 | expect($componentLoader.template("cheese")).toEqual("./components/cheese/cheese.html")
80 | });
81 |
82 | it("should setup comopnent name mappings properly", function() {
83 | expect($componentLoader.component("AwesomeController")).toEqual("awesome");
84 | expect($componentLoader.component("CheesetasticController")).toEqual("cheese");
85 | });
86 |
87 | it("should initialize controllers for all components", function() {
88 | expect(controllerSpy).toHaveBeenCalledWith("AwesomeController", TestComponent);
89 | expect(controllerSpy).not.toHaveBeenCalledWith("CheesetasticController", TestController);
90 | expect(controllerSpy).not.toHaveBeenCalledWith("TopConfigController", TopConfigComponent);
91 | });
92 |
93 | it("should setup inline templates in the template cache", function() {
94 | expect($templateCache.get("awesome.tpl.html")).toEqual("FizzBuzz
");
95 | });
96 | });
97 | });
98 |
--------------------------------------------------------------------------------
/test/RouteReader_spec.js:
--------------------------------------------------------------------------------
1 | import {RouteReader} from '../src/a1atscript/router/RouteReader.js'
2 | import {RouteConfig} from '../src/a1atscript/router/RouteConfig';
3 |
4 |
5 | class UserComponent {
6 |
7 | }
8 |
9 | class AwesomeComponent {
10 |
11 | }
12 |
13 | @RouteConfig({
14 | path: 'cheese', component: 'awesome'
15 | })
16 | class MyController {
17 | }
18 |
19 | @RouteConfig({
20 | path: '/user', component: UserComponent
21 | })
22 | @RouteConfig({
23 | path: '/test', components: {
24 | test: AwesomeComponent,
25 | headline: MyController
26 | }
27 | })
28 | class AppComponent {
29 | }
30 |
31 | describe("RouteReader", function() {
32 | var componentMapper, componentMapperSpy, routeReader, routeConfig;
33 | beforeEach(function() {
34 | componentMapper = {
35 | map: new Map(),
36 |
37 | register: function(component) {
38 | if (!this.map.get(component)) {
39 | this.map.set(component,
40 | {
41 | get componentName() {
42 | if (component === AppComponent) {
43 | return "app";
44 | } else if (component === AwesomeComponent) {
45 | return "awesome";
46 | } else if (component == UserComponent) {
47 | return "user";
48 | } else if (component == MyController) {
49 | return "my";
50 | }
51 | }
52 | });
53 | };
54 | return this.map.get(component);
55 | }
56 | }
57 |
58 | componentMapperSpy = spyOn(componentMapper, "register").and.callThrough();
59 |
60 | routeReader = new RouteReader(componentMapper);
61 | });
62 |
63 | it("should register components", function() {
64 | routeReader.read(AppComponent);
65 | expect(componentMapperSpy).toHaveBeenCalledWith(AppComponent);
66 | expect(componentMapperSpy).toHaveBeenCalledWith(AwesomeComponent);
67 | expect(componentMapperSpy).toHaveBeenCalledWith(UserComponent);
68 | expect(componentMapperSpy).toHaveBeenCalledWith(MyController);
69 | });
70 |
71 | it("should set routes correctly", function() {
72 | routeReader.read(AppComponent);
73 | routeConfig = AppComponent.$routeConfig;
74 | expect(routeConfig).toEqual([
75 | {
76 | path: '/user', component: "user"
77 | },
78 | {
79 | path: '/test', components: {
80 | test: "awesome",
81 | headline: "my"
82 | }
83 | }
84 | ]);
85 | });
86 |
87 | it("should handle existing string names", function() {
88 | routeReader.read(MyController);
89 | routeConfig = MyController.$routeConfig;
90 | expect(routeConfig).toEqual([
91 | {
92 | path: 'cheese', component: 'awesome'
93 | }
94 | ]);
95 | });
96 | });
97 |
--------------------------------------------------------------------------------
/test/SelectorMatcher_spec.js:
--------------------------------------------------------------------------------
1 | import SelectorMatcher from "../src/a1atscript/ng2Directives/SelectorMatcher.js"
2 |
3 | describe("SelectorMatcher", function() {
4 | var selectorMatcher;
5 | describe("element", function() {
6 | beforeEach(function() {
7 | selectorMatcher = new SelectorMatcher("hello-test");
8 | });
9 |
10 | it("should be restricted to an element", function() {
11 | expect(selectorMatcher.restrict).toEqual('E');
12 | });
13 |
14 | it("should have the right name", function() {
15 | expect(selectorMatcher.name).toEqual('helloTest');
16 | });
17 | });
18 | describe("attribute", function() {
19 | beforeEach(function() {
20 | selectorMatcher = new SelectorMatcher("[hello-test]");
21 | });
22 |
23 | it("should be restricted to an element", function() {
24 | expect(selectorMatcher.restrict).toEqual('A');
25 | });
26 |
27 | it("should have the right name", function() {
28 | expect(selectorMatcher.name).toEqual('helloTest');
29 | });
30 | });
31 | describe("class", function() {
32 | beforeEach(function() {
33 | selectorMatcher = new SelectorMatcher(".hello-test");
34 | });
35 |
36 | it("should be restricted to an element", function() {
37 | expect(selectorMatcher.restrict).toEqual('C');
38 | });
39 |
40 | it("should have the right name", function() {
41 | expect(selectorMatcher.name).toEqual('helloTest');
42 | });
43 | });
44 | });
45 |
--------------------------------------------------------------------------------
/test/ToAnnotation_spec.js:
--------------------------------------------------------------------------------
1 | import {ToAnnotation} from '../src/a1atscript/ToAnnotation.js';
2 |
3 | class AnnoClass {
4 |
5 | }
6 |
7 | class Anno2Class {
8 | constructor(awesome, awesomeness) {
9 | this.awesome = awesome;
10 | this.awesomeness = awesomeness;
11 | }
12 | }
13 |
14 | class TargetClass {
15 | method() {
16 |
17 | }
18 | }
19 |
20 | describe("ToAnnotation decorator", function() {
21 | var annoDecorator, anno2Decorator;
22 | beforeEach(function() {
23 | annoDecorator = ToAnnotation(AnnoClass);
24 | anno2Decorator = ToAnnotation(Anno2Class);
25 | });
26 |
27 | it("on first annotation", function() {
28 | @annoDecorator()
29 | class MyTargetAnnoClass {
30 |
31 | }
32 | expect(MyTargetAnnoClass.annotations).toEqual([new AnnoClass()]);
33 | });
34 |
35 | it("on second annotation", function() {
36 | @annoDecorator()
37 | @anno2Decorator("cheese", "grater")
38 | class MyTargetAnno2Class {
39 |
40 | }
41 | expect(MyTargetAnno2Class.annotations).toContain(new Anno2Class("cheese", "grater"), new AnnoClass());
42 | });
43 |
44 | it("operating on method", function() {
45 | annoDecorator()(TargetClass.prototype, 'method', Object.getOwnPropertyDescriptor(TargetClass.prototype, 'method'));
46 | expect(TargetClass.prototype.method.annotations).toEqual([new AnnoClass()]);
47 | });
48 | });
49 |
--------------------------------------------------------------------------------
/test/annotations_spec.js:
--------------------------------------------------------------------------------
1 | import {
2 | Config,
3 | Run,
4 | Controller,
5 | Directive,
6 | Service,
7 | Factory,
8 | Provider,
9 | Value,
10 | Constant,
11 | Animation,
12 | Filter,
13 | AsModule
14 | } from '../src/a1atscript/annotations.js';
15 |
16 | var OriginalConfig = Config.originalClass || Config;
17 | var OriginalRun = Run.originalClass || Run;
18 | var OriginalController = Controller.originalClass || Controller;
19 | var OriginalDirective = Directive.originalClass || Directive;
20 | var OriginalService = Service.originalClass || Service;
21 | var OriginalFactory = Factory.originalClass || Factory;
22 | var OriginalProvider = Provider.originalClass || Provider;
23 | var OriginalValue = Value.originalClass || Value;
24 | var OriginalConstant = Constant.originalClass || Constant;
25 | var OriginalAnimation = Animation.originalClass || Animation;
26 | var OriginalFilter = Filter.originalClass || Filter;
27 | var OriginalAsModule = AsModule.originalClass || AsModule;
28 |
29 | describe("annotations", function() {
30 |
31 | describe("config", function() {
32 |
33 | @Config('dep1', 'dep2')
34 | class ExampleConfig {
35 | constructor(dep1, dep2) {
36 |
37 | }
38 | };
39 |
40 | it("should annotate the config", function() {
41 | expect(ExampleConfig.annotations[0]).toEqual(
42 | new OriginalConfig('dep1', 'dep2'));
43 | expect(ExampleConfig.annotations[0].dependencies).toEqual(['dep1', 'dep2'])
44 | });
45 |
46 | });
47 |
48 | describe("run", function() {
49 |
50 | @Run('dep1', 'dep2')
51 | class ExampleRun {
52 | constructor(dep1, dep2) {
53 |
54 | }
55 | };
56 |
57 | it("should annotate the run", function() {
58 | expect(ExampleRun.annotations[0]).toEqual(
59 | new OriginalRun('dep1', 'dep2'));
60 | expect(ExampleRun.annotations[0].dependencies).toEqual(['dep1', 'dep2'])
61 | });
62 |
63 | });
64 |
65 | describe("controller", function() {
66 |
67 | @Controller('ExampleController', ['dep1', 'dep2'])
68 | class ExampleController {
69 | constructor(dep1, dep2) {
70 |
71 | }
72 | };
73 |
74 | it("should annotate the controller", function() {
75 | expect(ExampleController.annotations[0]).toEqual(
76 | new OriginalController('ExampleController', ['dep1', 'dep2']));
77 | });
78 |
79 | });
80 |
81 | describe("directive", function() {
82 |
83 | @Directive('ExampleDirective', ['dep1', 'dep2'])
84 | class ExampleDirective {
85 | constructor(dep1, dep2) {
86 |
87 | }
88 | };
89 |
90 | it("should annotate the directive", function() {
91 | expect(ExampleDirective.annotations[0]).toEqual(
92 | new OriginalDirective('ExampleDirective', ['dep1', 'dep2']));
93 | });
94 |
95 | });
96 |
97 | describe("service", function() {
98 |
99 | @Service('ExampleService', ['dep1', 'dep2'])
100 | class ExampleService {
101 | constructor(dep1, dep2) {
102 |
103 | }
104 | };
105 |
106 | it("should annotate the service", function() {
107 | expect(ExampleService.annotations[0]).toEqual(
108 | new OriginalService('ExampleService', ['dep1', 'dep2']));
109 | });
110 |
111 | });
112 |
113 | describe("factory", function() {
114 |
115 | @Factory('ExampleFactory', ['dep1', 'dep2'])
116 | class ExampleFactory {
117 | constructor(dep1, dep2) {
118 |
119 | }
120 | };
121 |
122 | it("should annotate the factory", function() {
123 | expect(ExampleFactory.annotations[0]).toEqual(
124 | new OriginalFactory('ExampleFactory', ['dep1', 'dep2']));
125 | });
126 |
127 | });
128 |
129 | describe("provider", function() {
130 |
131 | @Provider('ExampleProvider', ['dep1', 'dep2'])
132 | class ExampleProvider {
133 | constructor(dep1, dep2) {
134 |
135 | }
136 | };
137 |
138 | it("should annotate the provider", function() {
139 | expect(ExampleProvider.annotations[0]).toEqual(
140 | new OriginalProvider('ExampleProvider', ['dep1', 'dep2']));
141 | });
142 |
143 | });
144 |
145 | describe("value", function() {
146 |
147 | @Value('ExampleValue', ['dep1', 'dep2'])
148 | class ExampleValue {
149 | constructor(dep1, dep2) {
150 |
151 | }
152 | };
153 |
154 | it("should annotate the value", function() {
155 | expect(ExampleValue.annotations[0]).toEqual(
156 | new OriginalValue('ExampleValue', ['dep1', 'dep2']));
157 | });
158 |
159 | });
160 |
161 | describe("constant", function() {
162 |
163 | @Constant('ExampleConstant', ['dep1', 'dep2'])
164 | class ExampleConstant {
165 | constructor(dep1, dep2) {
166 |
167 | }
168 | };
169 |
170 | it("should annotate the constant", function() {
171 | expect(ExampleConstant.annotations[0]).toEqual(
172 | new OriginalConstant('ExampleConstant', ['dep1', 'dep2']));
173 | });
174 |
175 | });
176 |
177 | describe("animation", function() {
178 |
179 | @Animation('ExampleAnimation', ['dep1', 'dep2'])
180 | class ExampleAnimation {
181 | constructor(dep1, dep2) {
182 |
183 | }
184 | };
185 |
186 | it("should annotate the animation", function() {
187 | expect(ExampleAnimation.annotations[0]).toEqual(
188 | new OriginalAnimation('ExampleAnimation', ['dep1', 'dep2']));
189 | });
190 |
191 | });
192 |
193 | describe("filter", function() {
194 |
195 | @Filter('ExampleFilter', ['dep1', 'dep2'])
196 | class ExampleFilter {
197 | constructor(dep1, dep2) {
198 |
199 | }
200 | };
201 |
202 | it("should annotate the filter", function() {
203 | expect(ExampleFilter.annotations[0]).toEqual(
204 | new OriginalFilter('ExampleFilter', ['dep1', 'dep2']));
205 | });
206 |
207 | });
208 |
209 |
210 | describe("asModule", function() {
211 |
212 | @AsModule('ExampleModule', ['dep1', 'dep2'])
213 | class ExampleModule {
214 | constructor(dep1, dep2) {
215 |
216 | }
217 | };
218 |
219 | it("should annotate the module", function() {
220 | expect(ExampleModule.annotations[0]).toEqual(
221 | new OriginalAsModule('ExampleModule', ['dep1', 'dep2']));
222 | });
223 |
224 | });
225 |
226 | });
227 |
--------------------------------------------------------------------------------
/test/injector_spec.js:
--------------------------------------------------------------------------------
1 | import angular from 'angular';
2 | import 'angular-mocks';
3 |
4 | import {
5 | Module,
6 | AsModule,
7 | Controller,
8 | Directive,
9 | Service
10 | } from '../src/a1atscript/annotations';
11 |
12 | import {
13 | Injector,
14 | registerInjector,
15 | getInjector
16 | } from '../src/a1atscript/Injector';
17 |
18 | import {
19 | applyAnnotation
20 | } from "../src/a1atscript/applyAnnotation.js";
21 | var mock = angular.mock;
22 |
23 | @Controller('ExampleController', ['$scope', 'ExampleService'])
24 | class ExampleController {
25 | constructor($scope, ExampleService) {
26 | $scope.value = ExampleService.value
27 | }
28 | }
29 |
30 | @AsModule('ServiceModule')
31 | @Service('ExampleService')
32 | class ExampleService {
33 | constructor() {
34 | this.value = 'Test Value';
35 | }
36 | }
37 |
38 | function testDirective() {
39 | return {
40 | restrict: 'E',
41 | template: "Hello");
125 | element = element(scope);
126 | }))
127 |
128 | it("should be able to use annotations on functions using apply annotation", function() {
129 | expect(element.find("p").length).toEqual(1);
130 | })
131 | })
132 | });
133 |
134 | });
135 |
136 | describe("Registering an injector", function() {
137 | it("should store an instance of the class", function() {
138 | class Bar {
139 |
140 | }
141 | class Foo {
142 | get annotationClass() {
143 | return Bar;
144 | }
145 | }
146 | registerInjector('foo', Foo);
147 | expect(getInjector('foo') instanceof Foo).toBeTruthy();
148 | })
149 | })
150 | });
151 |
--------------------------------------------------------------------------------
/wait_for_watcher.js:
--------------------------------------------------------------------------------
1 | // Wait for any outstanding Traceur watchers.
2 | // Hack to work-around https://youtrack.jetbrains.com/issue/WEB-14104
3 |
4 | // How it works?
5 | // WebStorm Traceur watcher writes LOCK_FILE when running and delete LOCK_FILE once all watchers are finished.
6 | // WebStorm Karma configuration waits for this process to finish (i.e. till the LOCK_FILE is removed).
7 |
8 | var fs = require('fs');
9 | var LOCK_FILE = '.atscriptwatcher';
10 | var START_DELAY = 500;
11 |
12 | setTimeout(function() {
13 | if (!fs.existsSync(LOCK_FILE)) {
14 | // Watcher was not running.
15 | process.exit(0);
16 | }
17 |
18 | fs.watch(LOCK_FILE, function() {
19 | if (!fs.existsSync(LOCK_FILE)) {
20 | // All watchers have finished.
21 | process.exit(0);
22 | }
23 | });
24 | }, START_DELAY);
25 |
26 |
27 |
--------------------------------------------------------------------------------
/webpack.config.js:
--------------------------------------------------------------------------------
1 | var path = require('path');
2 |
3 | module.exports = {
4 | entry: {
5 | app: './src/a1atscript.js'
6 | },
7 | output: {
8 | path: path.join(__dirname, 'dist'),
9 | filename: 'a1atscript.bundle.js',
10 | libraryTarget: 'commonjs'
11 | },
12 | module: {
13 | loaders: [
14 | {
15 | test: /\.js$/,
16 | exclude: 'node_modules',
17 | loader: 'babel',
18 | query: {
19 | optional: ['es7.decorators'],
20 | stage: 0
21 | }
22 | }
23 | ]
24 | },
25 | devtool: 'source-map'
26 | }
27 |
--------------------------------------------------------------------------------
/webstorm_traceur.js:
--------------------------------------------------------------------------------
1 | var inputFilename = process.argv[2];
2 | var outputFilename = process.argv[3] || inputFilename.replace(/\.ats$/, '.js');
3 |
4 | var path = require('path');
5 | var sourceRoot = path.relative(path.dirname(outputFilename), '');
6 |
7 | var TraceurNodeCompiler = require('traceur/src/node/NodeCompiler').NodeCompiler;
8 | var options = require('./config.json').traceur;
9 | var compiler = new TraceurNodeCompiler(options);
10 |
11 |
12 | // Increment the lock to delay Karma unit tests until all watchers are finished.
13 | var LOCK_FILE = '.atscriptwatcher';
14 | var fs = require('fs');
15 |
16 | if (fs.existsSync(LOCK_FILE)) {
17 | var lockCount = parseInt(fs.readFileSync(LOCK_FILE).toString(), 10);
18 | lockCount++;
19 | fs.writeFileSync(LOCK_FILE, lockCount.toString());
20 | } else {
21 | fs.writeFileSync(LOCK_FILE, '1');
22 | }
23 |
24 |
25 | // TODO(vojta): Fix this in Traceur instead.
26 | // Traceur generates source map file in the CWD.
27 | // This hacks Traceur to generate source map file in the output file directory, respecting the `sourceRoot` option.
28 | var writeFile = require('traceur/src/node/file-util').writeFile;
29 | compiler.writeTreeToFile = function(tree, filename) {
30 | filename = this.normalize(filename);
31 | // This is changed.
32 | // Pass sourceRoot to `this.write`. Traceur does not pass it through.
33 | var compiledCode = this.write(tree, filename, sourceRoot);
34 | if (this.options_.sourceMaps === 'file') {
35 | var sourcemap = this.getSourceMap();
36 | if (sourcemap) {
37 | // This is changed.
38 | // Generate the source map in the same folder as the output JS file.
39 | writeFile(filename.replace(/\.js$/, '.map'), sourcemap);
40 | }
41 | }
42 |
43 | writeFile(filename, compiledCode);
44 | };
45 |
46 |
47 | compiler.compileSingleFile(inputFilename, outputFilename, function(err) {
48 | console.error(err);
49 | });
50 |
51 | // Release/decrement the lock.
52 | var lockCount = parseInt(fs.readFileSync(LOCK_FILE).toString(), 10);
53 | lockCount--;
54 |
55 | if (lockCount === 0) {
56 | fs.unlinkSync(LOCK_FILE);
57 | } else {
58 | fs.writeFileSync(LOCK_FILE, lockCount.toString());
59 | }
60 |
--------------------------------------------------------------------------------