├── .github
    └── logo.png
├── .gitignore
├── .jsbeautifyrc
├── .jshintrc
├── CONTRIBUTING.md
├── LICENSE
├── README.md
├── circle.yml
├── doc-timestamp.js
├── package.json
├── release.sh
├── shell
    └── e2e.sh
├── src
    ├── Base
    │   ├── AttributeManager.ts
    │   ├── Constants.ts
    │   ├── EEObject.ts
    │   ├── Ensure.ts
    │   ├── IDObject.ts
    │   ├── IdResolver.ts
    │   ├── ListenerFunction.ts
    │   ├── MessageException.ts
    │   ├── NSDictionary.ts
    │   ├── NSIdentity.ts
    │   ├── NSSet.ts
    │   ├── Namespace.ts
    │   ├── Types.ts
    │   ├── Utility.ts
    │   ├── XMLHttpRequestAsync.ts
    │   └── XMLReader.ts
    ├── Components
    │   └── GrimoireComponent.ts
    ├── Converters
    │   ├── ArrayConverter.ts
    │   ├── BooleanConverter.ts
    │   ├── ComponentConverter.ts
    │   ├── EnumConverter.ts
    │   ├── NumberArrayConverter.ts
    │   ├── NumberConverter.ts
    │   ├── ObjectConverter.ts
    │   ├── StringArrayConverter.ts
    │   └── StringConverter.ts
    ├── Declaration
    │   └── IAttributeConverterDeclaration.ts
    ├── Interface
    │   ├── GomlInterfaceImpl.ts
    │   ├── GrimoireInterface.ts
    │   ├── GrimoireInterfaceImpl.ts
    │   └── NodeInterface.ts
    ├── Node
    │   ├── Attribute.ts
    │   ├── Component.ts
    │   ├── ComponentDeclaration.ts
    │   ├── GomlLoader.ts
    │   ├── GomlNode.ts
    │   ├── GomlParser.ts
    │   ├── IAttributeDeclaration.ts
    │   ├── ITreeInitializedInfo.ts
    │   ├── NodeDeclaration.ts
    │   └── NodeUtility.ts
    ├── main.ts
    └── static
    │   └── color.json
├── test
    ├── @
    │   └── GrimoireInterfaceTest.ts
    ├── AsyncSupport.ts
    ├── Base
    │   ├── AttributeManagerTest.ts
    │   ├── EnsureTest.ts
    │   ├── IdResolverTest.ts
    │   ├── NSIdentityTest.ts
    │   ├── NamespaceTest.ts
    │   ├── NamespacedDictionaryTest.ts
    │   ├── UtilityTest.ts
    │   └── XMLReaderTest.ts
    ├── Converters
    │   └── StringConverterTest.ts
    ├── Interfaces
    │   └── NodeInterfaceTest.ts
    ├── JsDOMAsync.ts
    ├── Node
    │   ├── GomlLoaderTest.ts
    │   ├── GomlNode2Test.ts
    │   ├── GomlNodeTest.ts
    │   ├── GomlParserTest.ts
    │   ├── GomlParserTest_Registering.ts
    │   └── NamespacedSetTest.ts
    ├── PageLoadingHelper.ts
    ├── XMLDomInit.ts
    ├── _TestResource
    │   ├── GomlLoaderTest_Case1.html
    │   ├── GomlLoaderTest_Case2.html
    │   ├── GomlLoaderTest_Case3.html
    │   ├── GomlLoaderTest_Case4.html
    │   ├── GomlNodeTest_Case1.goml
    │   ├── GomlNodeTest_Case1.html
    │   ├── GomlParserTest_Case1.goml
    │   ├── GomlParserTest_Case2.goml
    │   ├── GomlParserTest_Case3.goml
    │   ├── GomlParserTest_Case4.goml
    │   ├── GrimoireInterfaceTest_Case1.html
    │   ├── NSDictionary_QueryDOM.xml
    │   └── XMLReader_Case1.xml
    ├── fileHelper.ts
    └── tsconfig.json
├── tsconfig.json
├── tsconfig.test.json
├── tslint.json
├── typedoc.json
└── webpack.config.js


/.github/logo.png:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/GrimoireGL/GrimoireJS/9298762cac2a95e729707e129fea76e1de6b9c0a/.github/logo.png


--------------------------------------------------------------------------------
/.gitignore:
--------------------------------------------------------------------------------
  1 | 
  2 | # Created by https://www.gitignore.io/api/node,osx,windows,linux
  3 | 
  4 | ### Node ###
  5 | # Logs
  6 | logs
  7 | *.log
  8 | npm-debug.log*
  9 | 
 10 | # Runtime data
 11 | pids
 12 | *.pid
 13 | *.seed
 14 | *.pid.lock
 15 | 
 16 | # Directory for instrumented libs generated by jscoverage/JSCover
 17 | lib-cov
 18 | 
 19 | # Coverage directory used by tools like istanbul
 20 | coverage
 21 | 
 22 | # nyc test coverage
 23 | .nyc_output
 24 | 
 25 | # Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
 26 | .grunt
 27 | 
 28 | # node-waf configuration
 29 | .lock-wscript
 30 | 
 31 | # Compiled binary addons (http://nodejs.org/api/addons.html)
 32 | build/Release
 33 | 
 34 | # Dependency directories
 35 | node_modules
 36 | jspm_packages
 37 | 
 38 | # Optional npm cache directory
 39 | .npm
 40 | 
 41 | # Optional REPL history
 42 | .node_repl_history
 43 | 
 44 | 
 45 | ### OSX ###
 46 | *.DS_Store
 47 | .AppleDouble
 48 | .LSOverride
 49 | 
 50 | # Icon must end with two \r
 51 | Icon
 52 | 
 53 | 
 54 | # Thumbnails
 55 | ._*
 56 | 
 57 | # Files that might appear in the root of a volume
 58 | .DocumentRevisions-V100
 59 | .fseventsd
 60 | .Spotlight-V100
 61 | .TemporaryItems
 62 | .Trashes
 63 | .VolumeIcon.icns
 64 | .com.apple.timemachine.donotpresent
 65 | 
 66 | # Directories potentially created on remote AFP share
 67 | .AppleDB
 68 | .AppleDesktop
 69 | Network Trash Folder
 70 | Temporary Items
 71 | .apdisk
 72 | 
 73 | 
 74 | ### Windows ###
 75 | # Windows image file caches
 76 | Thumbs.db
 77 | ehthumbs.db
 78 | 
 79 | # Folder config file
 80 | Desktop.ini
 81 | 
 82 | # Recycle Bin used on file shares
 83 | $RECYCLE.BIN/
 84 | 
 85 | # Windows Installer files
 86 | *.cab
 87 | *.msi
 88 | *.msm
 89 | *.msp
 90 | 
 91 | # Windows shortcuts
 92 | *.lnk
 93 | 
 94 | 
 95 | ### Linux ###
 96 | *~
 97 | 
 98 | # temporary files which can be created if a process still has a handle open of a deleted file
 99 | .fuse_hidden*
100 | 
101 | # KDE directory preferences
102 | .directory
103 | 
104 | # Linux trash folder which might appear on any partition or disk
105 | .Trash-*
106 | 
107 | ### Grimoire.js ###
108 | 
109 | # Generated codes included in package publishing.
110 | lib
111 | lib-es5
112 | 
113 | # Generated codes just used in local environment
114 | lib-ts
115 | lib-test
116 | product
117 | src/**/*.js
118 | test/**/*.js
119 | 
120 | .grimoire.dependency
121 | 
122 | ci
123 | register
124 | ref
125 | test-es5
126 | src/index.ts
127 | yarn.lock
128 | docs
129 | test-lib
130 | test-lib-es5
131 | package-lock.json
132 | .vscode


--------------------------------------------------------------------------------
/.jsbeautifyrc:
--------------------------------------------------------------------------------
 1 | {
 2 | "indent_size": 2,
 3 | "indent_char": " ",
 4 | "indent_level": 0,
 5 | "indent_with_tabs": false,
 6 | "preserve_newlines": true,
 7 | "max_preserve_newlines": 10,
 8 | "space_after_anon_function": false,
 9 | "brace_style": "collapse-preserve-inline",
10 | "keep_array_indentation": false,
11 | "keep_function_indentation": false,
12 | "space_before_conditional": true,
13 | "break_chained_methods": false,
14 | "eval_code": false,
15 | "unescape_strings": false,
16 | "wrap_line_length": 0
17 | }
18 | 


--------------------------------------------------------------------------------
/.jshintrc:
--------------------------------------------------------------------------------
1 | {
2 |   "esnext":true
3 | }
4 | 


--------------------------------------------------------------------------------
/CONTRIBUTING.md:
--------------------------------------------------------------------------------
  1 | # Guideline for contribution
  2 | 
  3 | This contribution guide is not only for core package, also for plugins of grimoire.js maintained by our organization.
  4 | It is not necessary, but we encourage the other plugins made by third party should use same contribution guide line if possible.
  5 | 
  6 | ## Got a questions or problem?
  7 | 
  8 | Using slack is the best way to ask main contributors.  
  9 | Stack overflow is another choice to ask.
 10 | 
 11 | ## Found bugs?
 12 | 
 13 | Please report them with issues. You can write it in English or Japanese.  
 14 | If reporter write an issue with Japanese and it is fatal problem of this library,
 15 | main contributors would translate them for convenience.
 16 | 
 17 | ## Contributing to translation
 18 | 
 19 | We prepare to translate all of our documents written in Japanese to English.
 20 | Currently official site and most of documents are written in Japanese, but we will move the main language as English.
 21 | This is including a lot of stuff to do, we need contributors. Even if you correct our English syntax, we are welcome.
 22 | 
 23 | ## Contributing to code
 24 | 
 25 | Reducing works we need to do manually is very important.  
 26 | Please read this guideline for keeping clean repository and keeping developing environment efficiently.
 27 | 
 28 | ### Build library
 29 | 
 30 | You need to use npm to setup project build environment.(You can use yarn also)
 31 | 
 32 | ```sh
 33 | $ git clone <Path to this repository> .
 34 | $ npm install
 35 | $ npm start
 36 | ```
 37 | 
 38 | `npm start` trigger watch task to rebuild when you changed the codes in `src` folder.
 39 | This command will change `register/index.js` only.
 40 | 
 41 | If you want to generate `grimoire.js` or `grimoirejs-<library-name>.js` to link these script with `<script>` tag, you can use `env.browser` configuration with the following command.
 42 | 
 43 | ```sh
 44 | $ npm start -- --env.browser
 45 | ```
 46 | 
 47 | If you need to build with all build configurations, you can use `npm run build -- --env.prod` to generate all codes.
 48 | 
 49 | `npm test` will execute unit testing included in `test` folder.
 50 | 
 51 | If you need to use with the other plugins, `npm link` would be useful to use generated new codes.
 52 | 
 53 | ### E2E testing
 54 | 
 55 | Several plugins of Grimoire.js are using E2E testing for maintaining same rendering result.
 56 | If e2e testing are enabled on a repository, the repository should have e2e folder.
 57 | E2E folder has several folder containing test case to render.
 58 | 
 59 | CI would capture screen shot to compare last rendering result. If the compare result was different from last build, CI will send us notification on `#e2e` channel in our slack(See official site for more detail).
 60 | 
 61 | When the build was triggered with PR, CI would automatically make a comment containing rendering result.
 62 | 
 63 | ### Coding rule
 64 | 
 65 | Most of the coding rules are checked with `TSLint`. You can run `npm run lint` to check whether your code is fitting to coding rule.  
 66 | Lint task would run on CI also.
 67 | 
 68 | But, there are some coding rule not listed in tslint configurations. These rules are listed below.
 69 | 
 70 | #### Rules of methods
 71 | 
 72 | ```ts
 73 |    public publicMethod(): void;
 74 |    private _privateMethod(): void;
 75 |    protected __protectedMethod(): void;
 76 | ```
 77 | 
 78 | Public method name must begin with lower case and should following names are `camelCase`.
 79 | Private method name must begin with `_`, and following characters are same as public method name.
 80 | Protected method name must begin with two `__`, and following characters are same as public method name.
 81 | 
 82 | ### Commit message guideline
 83 | 
 84 | The version of this package uses `semantic-release`.  
 85 | To generate changelog and release new version automatically, please follow this rule.
 86 | 
 87 | ### When the commit is only changing comments(Anything no effect for logics)
 88 | 
 89 | ```
 90 | chore: COMMIT MESSAGE HERE
 91 | ```
 92 | 
 93 | #### When the commit is bug fix,refactor or chore (Anything no effect for API).
 94 | 
 95 | ```
 96 | fix: COMMIT MESSAGE HERE
 97 | ```
 98 | 
 99 | #### When the commit contains new feature not containing breaking change.
100 | 
101 | ```
102 | feat: COMMIT MESSAGE HERE
103 | ```
104 | 
105 | #### When the commit contains breaking change
106 | 
107 | But, keeping in mind that we should not break public API.
108 | 
109 | ```
110 | perf: COMMIT MESSAGE HERE
111 | ```
112 | 


--------------------------------------------------------------------------------
/LICENSE:
--------------------------------------------------------------------------------
1 | The MIT License (MIT)
2 | Copyright (c) 2016 GrimoireGL
3 | 
4 | Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
5 | 
6 | The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
7 | 
8 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
9 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
  1 | ![Grimoire.js](./.github/logo.png)
  2 | 
  3 | [![Slack Status](https://grimoire-slackin.herokuapp.com/badge.svg)](https://grimoire-slackin.herokuapp.com/)
  4 | [![Circle CI](https://circleci.com/gh/GrimoireGL/GrimoireJS.svg?style=svg)](https://circleci.com/gh/GrimoireGL/GrimoireJS)
  5 | [![LICENSE](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/jThreeJS/jThree/blob/develop/LICENSE)
  6 | [![Dependency Status](https://david-dm.org/GrimoireGL/GrimoireJS.svg)](https://david-dm.org/GrimoireGL/GrimoireJS)
  7 | [![devDependency Status](https://david-dm.org/GrimoireGL/GrimoireJS/dev-status.svg)](https://david-dm.org/GrimoireGL/GrimoireJS#info=devDependencies)
  8 | [![Greenkeeper badge](https://badges.greenkeeper.io/GrimoireGL/GrimoireJS.svg)](https://greenkeeper.io/)
  9 | 
 10 | ## Overview
 11 | 
 12 | **Grimoire.js provide a bridge between Web engineers and CG engineers**
 13 | 
 14 | There were big gap between the development flows used for each.
 15 | 
 16 | Web engineers have typically used `event driven` javascript programs for daily works. And they mutate DOM APIs to make Web pages dynamic.
 17 | 
 18 | However, CG engineers has typically used `loop based` programs for daily works. These are mostly build with a programming language with strong type like C++ or C#.  And recently CG engineers more like to use strongly structured engines like Unity.
 19 | 
 20 | This is why these 2 engineers have so much different flow for workings. This is why it is hard to learn CG stuff by Web engineers. And CG engineers are also hard to make suitable APIs for Web engineers working with.
 21 | 
 22 | **Grimoire.js is a javascript(Typescript) framework to solve this problem with strong architecture**
 23 | 
 24 | ## Features
 25 | 
 26 | You can see several feature of Grimoire.js providing in this section.  
 27 | 
 28 | **We strongly recommend to see our [top page](http://grimoire.gl) to learn these features. Most of written things are same as this README.md. But our samples on the top pages are working!!.**
 29 | 
 30 | ### HTML like markup
 31 | 
 32 | We provides a syntax like XML to compose WebGL canvas. This is kind of HTML for Web engineers.
 33 | You can create 360 degree image viewer on browser only by writing the code below.(See official page to see working example)
 34 | 
 35 | ```xml
 36 | <goml>
 37 |   <scene>
 38 |     <camera></camera>
 39 |     <mesh geometry="sphere" cull="front" texture="360.jpg">
 40 |       <mesh.components>
 41 |         <Rotate speed="0.1" />
 42 |       </mesh.components>
 43 |     </mesh>
 44 |   </scene>
 45 | </goml>
 46 | ```
 47 | 
 48 | ### DOM operation API
 49 | 
 50 | Web engineers typically write javascript to mutate DOM structures or attributes. All that kinds things are same at Grimoire. Web engineers can use query-based operation API to changing attributes, modifying structures of DOM or registering event handlers.
 51 | 
 52 | These are codes to co-work WebGL canvas and Web UIs that made with ordinal web development way. (You can see working example on our official top page)
 53 | 
 54 | ```xml
 55 | <goml>
 56 |   <scene>
 57 |     <camera></camera>
 58 |     <mesh texture="logo.png" geometry="cube">
 59 |       <mesh.components>
 60 |         <Rotate speed="0,0.1,0" />
 61 |       </mesh.components>
 62 |     </mesh>
 63 |   </scene>
 64 | </goml>
 65 | ```
 66 | 
 67 | ```js
 68 | gr(function() {
 69 |   var mesh = gr('#simple .canvas')('mesh')
 70 |   $('#simple .red').on('click', function () {
 71 |     mesh.setAttribute('color', 'red')
 72 |   })
 73 |   $('#simple .blue').on('click', function () {
 74 |     mesh.setAttribute('color', 'blue')
 75 |   })
 76 |   mesh.on('mouseenter', function () {
 77 |     mesh.setAttribute('scale', '2.0')
 78 |     $("#simple .bigger").addClass("bold-label");
 79 |     $("#simple .smaller").removeClass("bold-label");
 80 |   })
 81 |   mesh.on('mouseleave', function () {
 82 |     mesh.setAttribute('scale', '1.0')
 83 |     $("#simple .smaller").addClass("bold-label");
 84 |     $("#simple .bigger").removeClass("bold-label");
 85 |   })
 86 | })
 87 | ```
 88 | 
 89 | ### Simple and powerful architecture, Typescript ready
 90 | 
 91 | If you really want to make WebGL stuff on your page, it is hard to make only by Web engineers if that contents requires highly customized representation. In this situation, Web engineers and CG engineers need to co-work.
 92 | 
 93 | CG engineers can write a component. And these are reusable.
 94 | 
 95 | And these are able to be written by Typescript. Safe and effective environment for development.
 96 | 
 97 | This is a sample to make objects waving movement. (You can see full comprehensive this sample at our top page)
 98 | 
 99 | ```ts
100 | import Component from "grimoirejs/ref/Node/Component";
101 | import ISceneUpdateArgument from "grimoirejs-fundamental/ref/SceneRenderer/ISceneUpdateArgument";
102 | import TransformComponent from "grimoirejs-fundamental/ref/Components/TransformComponent";
103 | import Vector3 from "grimoirejs-math/ref/Vector3";
104 | import gr from "grimoirejs";
105 | class Wave extends Component{
106 |   public static attributes = {
107 |     amp:{
108 |       default:1.0,
109 |       converter:"Number"
110 |     },
111 |     speed:{
112 |       default:1.0,
113 |       converter:"Number"
114 |     }
115 |   };
116 | 
117 |   public amp:number;
118 | 
119 |   public speed:number;
120 | 
121 |   private transform: TransformComponent;
122 | 
123 |   public $mount():void{
124 |     this.transform = this.node.getComponent(TransformComponent);
125 |     this.__bindAttributes(); // bind component attributes to fields
126 |   }
127 |   public $update(t:ISceneUpdateArgument):void{
128 |     this.transfrom.position = new Vector3(this.transform.position.X,Math.sin(this.speed * t.timer.timeInSecound) * this.amp,this.transform.position.Z);
129 |   }
130 | }
131 | gr.registerComponent("Wave",Wave);
132 | ```
133 | 
134 | ## Download
135 | 
136 | Please see official site and [Download page](https://grimoire.gl/guide/1_essentials/01_installation.html).
137 | 
138 | ## Useful Links
139 | 
140 | * **Official Site**・・・http://grimoire.gl
141 | 
142 | ### API Reference
143 | 
144 | See [here](https://api.grimoire.gl/core).
145 | 
146 | This document is automatically generated. 
147 | 
148 | <!--DOCUMENT STAMP-->
149 | 
150 | Make sure the API reference is only containing core stuff(Mutating goml stuff, operating attributes, methods being available on Component instance and so on).
151 | 
152 | If you want to see WebGL related feature of API, you should see [renderer plugin page](https://api.grimoire.gl/grimoirejs-fundamental).
153 | 
154 | ## LICENSE
155 | 
156 | **MIT License**
157 | 
158 | (See the LICENSE file for more detail.)
159 | 


--------------------------------------------------------------------------------
/circle.yml:
--------------------------------------------------------------------------------
 1 | machine:
 2 |   node:
 3 |     version: 6.9.5
 4 | test:
 5 |   post:
 6 |     - sh release.sh
 7 |     - >-
 8 |       aws s3 cp ./coverage/ s3://coverage.grimoire.gl/core/$CIRCLE_BRANCH
 9 |       --recursive --region ap-northeast-1 --acl public-read
10 |   override:
11 |     - npm run lint && npm run build && npm run coverage
12 |     - sh -x shell/e2e.sh
13 | deployment:
14 |   deploy:
15 |     branch: master
16 |     commands:
17 |       - npm run doc
18 |       - >-
19 |         aws s3 cp ./docs/ s3://api.grimoire.gl/core --recursive --region
20 |         ap-northeast-1 --acl public-read
21 | 


--------------------------------------------------------------------------------
/doc-timestamp.js:
--------------------------------------------------------------------------------
 1 | const fs = require("fs");
 2 | 
 3 | fs.readFile("./package.json","utf8",(err,data)=>{
 4 |     if(err){
 5 |         console.error(err);
 6 |         process.exit(1);
 7 |     }else{
 8 |         const version = JSON.parse(data).version;
 9 |         fs.readFile("./README.md","utf8",(err,original)=>{
10 |             if(err){
11 |                 console.error(err);
12 |                 process.exit(1);
13 |             }else{
14 |                 const replaced = original.replace("<!--DOCUMENT STAMP-->",`* Update date: \`${new Date()}\`\n* Build version: \`${version}\``);
15 |                 fs.writeFile("./README.md",replaced,(err,data)=>{
16 |                     if(err){
17 |                         console.error(err);
18 |                         process.exit(1);                        
19 |                     }
20 |                 });
21 |             }
22 |         });
23 |     }
24 | });


--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "name": "grimoirejs",
 3 |   "version": "0.0.0-development",
 4 |   "description": "A service-oriented WebGL framework.",
 5 |   "main": "./ref/index.js",
 6 |   "typings": "./ref/index.d.ts",
 7 |   "files": [
 8 |     "ref",
 9 |     "register",
10 |     "lib"
11 |   ],
12 |   "keywords": [
13 |     "grimoire"
14 |   ],
15 |   "dependencies": {
16 |     "eventemitter3": "^2.0.3"
17 |   },
18 |   "devDependencies": {
19 |     "ava": "^0.22.0",
20 |     "babel-cli": "^6.26.0",
21 |     "babel-loader": "^7.1.2",
22 |     "babel-plugin-transform-runtime": "^6.23.0",
23 |     "babel-polyfill": "^6.26.0",
24 |     "babel-preset-es2015": "^6.24.0",
25 |     "babel-preset-stage-2": "^6.22.0",
26 |     "babel-register": "^6.26.0",
27 |     "condition-circle": "^1.5.0",
28 |     "cpx": "^1.5.0",
29 |     "grimoirejs-cauldron": "^3.1.8",
30 |     "jsdom": "^11.3.0",
31 |     "lodash": "^4.17.2",
32 |     "nyc": "^11.3.0",
33 |     "proxyquire": "^1.7.11",
34 |     "regenerator-runtime": "^0.11.0",
35 |     "remap-istanbul": "^0.9.5",
36 |     "semantic-release": "^7.0.2",
37 |     "sinon": "^3.3.0",
38 |     "trash-cli": "^1.4.0",
39 |     "ts-loader": "^2.3.7",
40 |     "tslint": "^5.8.0",
41 |     "typedoc": "^0.8.0",
42 |     "typedoc-md-theme": "^1.0.1",
43 |     "typescript": "^2.6.1",
44 |     "typescript-awaiter": "^1.0.0",
45 |     "webpack": "^3.8.1",
46 |     "webpack-shell-plugin": "^0.5.0",
47 |     "xhr-mock": "^1.9.1",
48 |     "xmldom": "^0.1.27",
49 |     "yargs": "^8.0.2"
50 |   },
51 |   "repository": "http://github.com/GrimoireGL/GrimoireJS",
52 |   "scripts": {
53 |     "coverage": "trash coverage && nyc --reporter=lcov --reporter=text --reporter=json --reporter=html npm run test",
54 |     "test": "trash test-lib && tsc -p tsconfig.test.json && cpx test/_TestResource/**/* test-lib/_TestResource && ava ./test-lib/**/*Test.js --verbose --serial",
55 |     "lint": "tslint -c tslint.json ./src/**/*.ts",
56 |     "prepublish": "webpack --progress --env.prod && npm test",
57 |     "start": "webpack --progress --watch",
58 |     "build": "webpack --progress",
59 |     "generate-expose": "cauldron generate-exposure --src ./src --dest ./src/index.ts --ts --main ./src/main.ts --core",
60 |     "generate-reference": "cauldron generate-reference --src ./src --dest ./src/index.ts --ts --main ./src/main.ts --dts ./ref --core",
61 |     "semantic-release": "semantic-release pre && npm publish && semantic-release post",
62 |     "doc": "node ./doc-timestamp.js && typedoc --out ./docs/ --options typedoc.json  ./tsconfig.json",
63 |     "clear-test": "rm -rf coverage .nyc_output test-lib",
64 |     "clear": "rm -rf ref register && npm run clear-test"
65 |   },
66 |   "license": "MIT",
67 |   "release": {
68 |     "verifyConditions": "condition-circle"
69 |   },
70 |   "babel": {
71 |     "presets": [
72 |       "es2015",
73 |       "stage-2"
74 |     ]
75 |   },
76 |   "ava": {
77 |     "failWithoutAssertions": false,
78 |     "require": [
79 |       "babel-register"
80 |     ],
81 |     "babel": "inherit"
82 |   },
83 |   "nyc": {
84 |     "include": [
85 |       "**/src/**/*"
86 |     ]
87 |   }
88 | }
89 | 


--------------------------------------------------------------------------------
/release.sh:
--------------------------------------------------------------------------------
1 | npm run semantic-release
2 | if [ $? = "0" ]; then
3 |   echo PRESET_UPDATE
4 |   curl "https://preset-updater.herokuapp.com/?repo=preset-basic&repoURL=https://github.com/GrimoireGL/grimoirejs-preset-basic.git&buildNumber=$CIRCLE_BUILD_NUM&currentPkg=grimoirejs"
5 | fi
6 | exit 0
7 | 


--------------------------------------------------------------------------------
/shell/e2e.sh:
--------------------------------------------------------------------------------
1 | aws s3 cp register/ s3://$S3_BUCKET_URL/js/$CIRCLE_SHA1 --recursive --acl public-read --region ap-northeast-1
2 | curl -X POST -d "repositoryURL=$CIRCLE_REPOSITORY_URL" -d "currentBranch=$CIRCLE_BRANCH" -d "currentBuildNumber=$CIRCLE_BUILD_NUM" -d "previousBuildNumber=$CIRCLE_PREVIOUS_BUILD_NUM" -d "sha1=$CIRCLE_SHA1" -d "pullRequest=$CI_PULL_REQUEST" $E2E_TRIGGER


--------------------------------------------------------------------------------
/src/Base/AttributeManager.ts:
--------------------------------------------------------------------------------
  1 | import Utility from "./Utility";
  2 | import Attribute from "../Node/Attribute";
  3 | import IdResolver from "./IdResolver";
  4 | import Namespace from "./Namespace";
  5 | import NSIdentity from "./NSIdentity";
  6 | import Ensure from "./Ensure";
  7 | import {Name, Undef} from "./Types";
  8 | 
  9 | type NameValPair<T> = { fqn: string, val: T };
 10 | 
 11 | class AttributeBuffer<T> {
 12 | 
 13 |   private _fqnList: NameValPair<T>[] = [];
 14 | 
 15 |   public add(fqn: string, val: T) {
 16 |     for (let i = 0; i < this._fqnList.length; i++) {
 17 |       const c = this._fqnList[i];
 18 |       if (c.fqn === fqn) {
 19 |         c.val = val;
 20 |         this._fqnList.splice(i, 1);
 21 |         this._fqnList.push(c);
 22 |         return;
 23 |       }
 24 |     }
 25 |     const obj = { fqn, val };
 26 |     this._fqnList.push(obj);
 27 |   }
 28 | 
 29 |   public resolve(fqn: string, remove: boolean): Undef<T> {
 30 |     const guess = this.guess(fqn, remove);
 31 |     return guess.length === 0 ? void 0 : guess[guess.length - 1];
 32 |   }
 33 | 
 34 |   /**
 35 |    * get list of value that matchs given fqn.
 36 |    * @param  {string}         fqn          [description]
 37 |    * @param  {[type]}         remove=false to remove match buffers.
 38 |    * @return {NameValPair<T>}              [description]
 39 |    */
 40 |   public guess(fqn: string, remove: boolean): T[] {
 41 |     const resolver = new IdResolver();
 42 |     resolver.add(fqn.split("."));
 43 |     const ret: T[] = [];
 44 |     for (let i = 0; i < this._fqnList.length; i++) {
 45 |       const name = this._fqnList[i].fqn;
 46 |       const r = resolver.get(name);
 47 |       if (r.length > 0) {
 48 |         ret.push(this._fqnList[i].val);
 49 |         if (remove) {
 50 |           this._fqnList.splice(i, 1);
 51 |           i--;
 52 |         }
 53 |       }
 54 |     }
 55 |     return ret;
 56 |   }
 57 | }
 58 | 
 59 | type observer = (newValue: any, oldValue: any, attr: Attribute) => void;
 60 | 
 61 | 
 62 | /**
 63 |  * internal use!
 64 |  * @return {[type]} [description]
 65 |  */
 66 | export default class AttributeManager {
 67 |   private _attributesFQNMap: { [fqn: string]: Attribute[] } = {};
 68 |   private _idResolver: IdResolver = new IdResolver();
 69 |   private _attrBuffer: AttributeBuffer<any> = new AttributeBuffer<any>();
 70 |   private _watchBuffer: AttributeBuffer<observer> = new AttributeBuffer<observer>();
 71 | 
 72 |   public constructor(public tag: string) { }
 73 | 
 74 |   public addAttribute(attr: Attribute): Attribute {
 75 |     const fqn = attr.name.fqn;
 76 |     if (this._idResolver.has(fqn)) { // already exists
 77 |       Utility.w(`attribute ${attr.name} is already exist in ${this.tag}`);
 78 |     }
 79 |     if (this._attributesFQNMap[fqn] === void 0) {
 80 |       this._attributesFQNMap[fqn] = [];
 81 |     }
 82 |     this._attributesFQNMap[fqn].push(attr);
 83 |     this._idResolver.add(attr.name);
 84 | 
 85 |     // check buffer value.
 86 |     const attrBuf = this._attrBuffer.resolve(attr.name.fqn, true);
 87 |     if (attrBuf !== void 0) {
 88 |       attr.Value = attrBuf;
 89 |     }
 90 | 
 91 |     const watchBuf = this._watchBuffer.guess(attr.name.fqn, true);
 92 |     for (let i = 0; i < watchBuf.length; i++) {
 93 |       attr.watch(watchBuf[i], true);
 94 |     }
 95 |     return attr;
 96 |   }
 97 | 
 98 |   public watch(attrName: Name, watcher: ((newValue: any, oldValue: any, attr: Attribute) => void), immediate = false) {
 99 |     const fqn = Ensure.tobeFQN(attrName);
100 |     if (fqn) {
101 |       const attrs = this._attributesFQNMap[fqn];
102 |       if (attrs === void 0 || attrs.length === 0) {
103 |         this._watchBuffer.add(fqn, watcher);
104 |         return;
105 |       }
106 |       for (let i = 0; i < attrs.length; i++) {
107 |         attrs[i].watch(watcher, immediate);
108 |       }
109 |     } else {
110 |       attrName = attrName as string;
111 |       let res = this._idResolver.get(Namespace.defineByArray(attrName.split(".")));
112 |       if (res.length === 0) {
113 |         this._watchBuffer.add(attrName, watcher);
114 |         return;
115 |       }
116 |       if (res.length > 1) {
117 |         throw new Error(`attribute ${attrName} is ambiguous`);
118 |       }
119 |       for (let i = 0; i < this._attributesFQNMap[res[0]].length; i++) {
120 |         this._attributesFQNMap[res[0]][i].watch(watcher, immediate);
121 |       }
122 |     }
123 |   }
124 | 
125 |   public setAttribute(attrFQN: string, value: any): void {
126 |     const attrs = this._attributesFQNMap[attrFQN];
127 |     if (attrs === void 0 || attrs.length === 0) {
128 |       this._attrBuffer.add(attrFQN, value);
129 |       return;
130 |     }
131 |     for (let i = 0; i < attrs.length; i++) {
132 |       attrs[i].Value = value;
133 |     }
134 |   }
135 | 
136 |   /**
137 |    * 文字列指定は曖昧性解消する。
138 |    * 曖昧はエラー。存在しないのはエラー。
139 |    * NSIdentityはfqnで。
140 |    * 指定されたFQNの属性が複数の場合エラー。
141 |    * @param  {Name}      attrName [description]
142 |    * @return {Attribute}          [description]
143 |    */
144 |   public getAttributeRaw(attrName: Name): Attribute {
145 |     const fqn = Ensure.tobeFQN(attrName);
146 |     if (fqn) {
147 |       const attrs = this._attributesFQNMap[fqn] || [];
148 |       if (attrs.length === 0) {
149 |         throw new Error(`attribute ${fqn} is not found.`);
150 |       } else if (attrs.length !== 1) {
151 |         throw new Error(`attribute ${fqn} is ambiguous. there are ${attrs.length} attributes has same fqn.`);
152 |       }
153 |       return attrs[0];
154 |     } else {
155 |       attrName = attrName as string;
156 |       let res = this._idResolver.get(attrName);
157 |       if (res.length === 0) {
158 |         throw new Error(`attribute ${attrName} is not found.`);
159 |       }
160 |       if (res.length > 1) {
161 |         throw new Error(`attribute ${attrName} is ambiguous. It has the following possibilities. ${res}`);
162 |       }
163 |       if (this._attributesFQNMap[res[0]].length !== 1) {
164 |         throw new Error(`attribute ${attrName} is ambiguous. there are ${this._attributesFQNMap[res[0]].length} attributes has same fqn.`);
165 |       }
166 |       return this._attributesFQNMap[res[0]][0];
167 |     }
168 |   }
169 | 
170 |   public getAttribute(attrName: Name): any {
171 |     const fqn = Ensure.tobeFQN(attrName);
172 |     if (fqn) {
173 |       const attrs = this._attributesFQNMap[fqn] || [];
174 |       if (attrs.length === 0) {
175 |         const attrBuf = this._attrBuffer.resolve(fqn, false);
176 |         if (attrBuf !== void 0) {
177 |           return attrBuf;
178 |         }
179 |         throw new Error(`attribute ${attrName} is not found.`);
180 |       } else if (attrs.length !== 1) {
181 |         throw new Error(`attribute ${attrName} is ambiguous. there are ${attrs.length} attributes has same fqn.`);
182 |       }
183 |       return attrs[0].Value;
184 |     } else {
185 |       attrName = attrName as string;
186 |       let res = this._idResolver.get(attrName);
187 |       if (res.length === 0) {
188 |         const attrBuf = this._attrBuffer.resolve(attrName, false);
189 |         if (attrBuf !== void 0) {
190 |           return attrBuf;
191 |         }
192 |         throw new Error(`attribute ${attrName} is not found.`);
193 |       }
194 |       if (res.length > 1) {
195 |         throw new Error(`attribute ${attrName} is ambiguous. there are ${this._attributesFQNMap[res[0]].length} attributes has same fqn.`);
196 |       }
197 |       return this._attributesFQNMap[res[0]][0].Value;
198 |     }
199 |   }
200 |   public removeAttribute(attr: Attribute): boolean {
201 |     if (this._attributesFQNMap[attr.name.fqn]) {
202 |       let attributes = this._attributesFQNMap[attr.name.fqn];
203 |       if (attributes.length === 1) {
204 |         this._idResolver.remove(attr.name);
205 |       }
206 |       Utility.remove(attributes, attr);
207 |       delete this._attributesFQNMap[attr.name.fqn];
208 |       return true;
209 |     }
210 |     return false;
211 |   }
212 | 
213 |   public guess(name: Name): NSIdentity[] {
214 |     if (name instanceof NSIdentity) {
215 |       return [name];
216 |     }
217 |     if (Ensure.checkFQNString(name)) {
218 |       return [NSIdentity.fromFQN(name)];
219 |     }
220 |     return this._idResolver.get(name).map(fqn => NSIdentity.fromFQN(fqn));
221 |   }
222 | }
223 | 


--------------------------------------------------------------------------------
/src/Base/Constants.ts:
--------------------------------------------------------------------------------
1 | export default class Constants {
2 |   public static get defaultNamespace(): string {
3 |     return "grimoirejs";
4 |   }
5 |   public static get x_gr_id(): string {
6 |     return "x-gr-id";
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Base/EEObject.ts:
--------------------------------------------------------------------------------
 1 | import { EventEmitter, ListenerFn } from "eventemitter3";
 2 | import IDObject from "./IDObject";
 3 | 
 4 | /**
 5 |  * EventEmitterをmixinしたIDObject
 6 |  */
 7 | class EEObject extends IDObject implements EventEmitter {
 8 |   /**
 9 |    * Return an array listing the events for which the emitter has registered
10 |    * listeners.
11 |    */
12 |   public eventNames: () => Array<string | symbol>;
13 | 
14 |   /**
15 |    * Return the listeners registered for a given event.
16 |    */
17 |   public listeners: ((event: string | symbol, exists: boolean) => Array<ListenerFn> | boolean) & ((event: string | symbol) => Array<ListenerFn>);
18 | 
19 |   /**
20 |    * Calls each of the listeners registered for a given event.
21 |    */
22 |   public emit: (event: string | symbol, ...args: Array<any>) => boolean;
23 | 
24 |   /**
25 |    * Add a listener for a given event.
26 |    */
27 |   public on: (event: string | symbol, fn: ListenerFn, context?: any) => this;
28 |   public addListener: (event: string | symbol, fn: ListenerFn, context?: any) => this;
29 | 
30 |   /**
31 |    * Add a one-time listener for a given event.
32 |    */
33 |   public once: (event: string | symbol, fn: ListenerFn, context?: any) => this;
34 | 
35 |   /**
36 |    * Remove the listeners of a given event.
37 |    */
38 |   public removeListener: (event: string | symbol, fn?: ListenerFn, context?: any, once?: boolean) => this;
39 |   public off: (event: string | symbol, fn?: ListenerFn, context?: any, once?: boolean) => this;
40 | 
41 |   /**
42 |    * Remove all listeners, or those of the specified event.
43 |    */
44 |   public removeAllListeners: (event?: string | symbol) => this;
45 |   constructor() {
46 |     super();
47 |     EventEmitter.call(this);
48 |   }
49 | }
50 | 
51 | function applyMixins(derivedCtor: any, baseCtors: any[]) {
52 |   baseCtors.forEach((baseCtor) => {
53 |     Object.getOwnPropertyNames(baseCtor.prototype).forEach((name) => {
54 |       derivedCtor.prototype[name] = baseCtor.prototype[name];
55 |     });
56 |   });
57 | }
58 | 
59 | applyMixins(EEObject, [EventEmitter]);
60 | 
61 | export default EEObject;
62 | 


--------------------------------------------------------------------------------
/src/Base/Ensure.ts:
--------------------------------------------------------------------------------
  1 | import GrimoireInterface from "../Interface/GrimoireInterface";
  2 | import NSIdentity from "./NSIdentity";
  3 | // import Namespace from "./Namespace";
  4 | import NSDictionary from "./NSDictionary";
  5 | import {Name, Nullable, Ctor} from "./Types";
  6 | import ComponentDeclaration from "../Node/ComponentDeclaration";
  7 | import Component from "../Node/Component";
  8 | /**
  9 |  * Provides static methods to ensure arguments are valid type.
 10 |  */
 11 | export default class Ensure {
 12 | 
 13 |   public static tobeComponentIdentity(component: Name | (new () => Component)): NSIdentity {
 14 |     if (typeof component === "function") {
 15 |       const obj = ComponentDeclaration.ctorMap.find(o => o.ctor === component);
 16 |       if (obj) {
 17 |         component = obj.name;
 18 |       } else {
 19 |         throw new Error(`Specified constructor have not registered to current context.`);
 20 |       }
 21 |     } else {
 22 |       component = Ensure.tobeNSIdentity(component);
 23 |     }
 24 |     return component;
 25 |   }
 26 |   /**
 27 |    * Ensure specified str being string
 28 |    * @param  {string | number}      str [description]
 29 |    * @return {string}      [description]
 30 |    */
 31 |   public static tobeString(str: string | number): string {
 32 |     if (typeof str === "string") {
 33 |       return str;
 34 |     } else if (typeof str === "number") {
 35 |       return str.toString();
 36 |     } else {
 37 |       throw new Error("Specified argument can not convert into string");
 38 |     }
 39 |   }
 40 | 
 41 |   /**
 42 |    * Ensure specified number being number
 43 |    * @param  {string | number}      str [description]
 44 |    * @return {string}      [description]
 45 |    */
 46 |   public static tobeNumber(num: string | number): number {
 47 |     if (typeof num === "string") {
 48 |       return parseInt(num, 10);
 49 |     } else if (typeof num === "number") {
 50 |       return num;
 51 |     } else {
 52 |       throw new Error("specified argument can not be converted into number");
 53 |     }
 54 |   }
 55 | 
 56 |   /**
 57 |    * string or NSIdentity ensure to be NSIdentity.
 58 |    * @param  {Name}       name [description]
 59 |    * @return {NSIdentity}      [description]
 60 |    */
 61 |   public static tobeNSIdentity(name: Name): NSIdentity {
 62 |     if (!name) {
 63 |       throw Error(`argument can not be null or undefined.`);
 64 |     }
 65 |     if (typeof name === "string") {
 66 |       return NSIdentity.guess(name);
 67 |     } else {
 68 |       return name;
 69 |     }
 70 |   }
 71 | 
 72 |   public static tobeNSIdentityArray(names: Name[]): NSIdentity[] {
 73 |     if (!names) {
 74 |       return [];
 75 |     }
 76 |     const newArr: NSIdentity[] = [];
 77 |     for (let i = 0; i < names.length; i++) {
 78 |       newArr.push(this.tobeNSIdentity(names[i]));
 79 |     }
 80 |     return newArr;
 81 |   }
 82 | 
 83 |   public static tobeNSDictionary<T>(dict: NSDictionary<T> | { [key: string]: T }): NSDictionary<T> {
 84 |     if (!dict) {
 85 |       return new NSDictionary<T>();
 86 |     }
 87 |     if (dict instanceof NSDictionary) {
 88 |       return dict;
 89 |     } else {
 90 |       const newDict = new NSDictionary<T>();
 91 |       for (let key in dict) {
 92 |         newDict.set(NSIdentity.guess(key), dict[key]);
 93 |       }
 94 |       return newDict;
 95 |     }
 96 |   }
 97 | 
 98 |   public static tobeMessage(message: string): string {
 99 |     if (message.startsWith("$")) {
100 |       if (message.startsWith("$$")) {
101 |         return message;
102 |       } else {
103 |         return "$" + message;
104 |       }
105 |     } else {
106 |       return "$$" + message;
107 |     }
108 |   }
109 | 
110 |   /**
111 |    * string, NSIdentity or constructor ensure to be constructor.
112 |    * return null if identity is not registered as component.
113 |    * @param  {[type]} typeofc==="function" [description]
114 |    * @return {[type]}                      [description]
115 |    */
116 |   public static tobeComponentConstructor<T>(c: Name | Ctor<T>): Nullable<Ctor<T>> {
117 |     if (typeof c === "function") {
118 |       return c;
119 |     } else {
120 |       const dec = GrimoireInterface.componentDeclarations.get(c);
121 |       if (dec) {
122 |         return dec.ctor as any as Ctor<T>;
123 |       }
124 |       return null;
125 |     }
126 |   }
127 | 
128 |   public static tobeFQN(name: Name): Nullable<string> {
129 |     if (typeof name === "string") {
130 |       if (Ensure.checkFQNString(name)) {
131 |         return name.substring(1);
132 |       }
133 |       return null;
134 |     } else {
135 |       return name.fqn;
136 |     }
137 |   }
138 | 
139 |   public static checkFQNString(name: string): boolean {
140 |     return name.startsWith("_");
141 |   }
142 | }
143 | 


--------------------------------------------------------------------------------
/src/Base/IDObject.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * Most based object for any Grimoire.js related classes.
 3 |  * @type {[type]}
 4 |  */
 5 | class IDObject {
 6 |     /**
 7 |      * ID related to this instance to identify.
 8 |      */
 9 |     public id: string;
10 | 
11 |     /**
12 |      * Generate random string
13 |      * @param  {number} length length of random string
14 |      * @return {string}        generated string
15 |      */
16 |     public static getUniqueRandom(length: number): string {
17 |         return Math.random().toString(36).slice(-length);
18 |     }
19 | 
20 |     constructor() {
21 |         this.id = IDObject.getUniqueRandom(10);
22 |     }
23 |     /**
24 |      * Obtain stringfied object.
25 |      * If this method was not overridden, this method return class name.
26 |      * @return {string} stringfied object
27 |      */
28 |     public toString(): string {
29 |         return this.getTypeName();
30 |     }
31 | 
32 |     /**
33 |      * Obtain class name
34 |      * @return {string} Class name of the instance.
35 |      */
36 |     public getTypeName(): string {
37 |         const funcNameRegex = /function (.{1,})\(/;
38 |         const result = (funcNameRegex).exec((this).constructor.toString());
39 |         return (result && result.length > 1) ? result[1] : "";
40 |     }
41 | }
42 | 
43 | export default IDObject;
44 | 


--------------------------------------------------------------------------------
/src/Base/IdResolver.ts:
--------------------------------------------------------------------------------
  1 | import Namespace from "./Namespace";
  2 | import NSIdentity from "./NSIdentity";
  3 | 
  4 | 
  5 | /**
  6 |  * Internal use!
  7 |  * Disambiguate according to the context from the namespace hierarchy.
  8 |  * @return {[type]} [description]
  9 |  */
 10 | export default class IdResolver {
 11 |   private _nameMap: { [name: string]: IdResolver } = {};
 12 |   private _FQNSet: Set<string> = new Set();
 13 |   private _isTerminal = false;
 14 | 
 15 |   public get count(): number {
 16 |     return this._FQNSet.size;
 17 |   }
 18 | 
 19 |   /**
 20 |    * add id to resolver context.
 21 |    * @param  {NSIdentity} id [description]
 22 |    * @return {boolean}       true if succcess adding.
 23 |    */
 24 |   public add(id: string[] | NSIdentity): boolean {
 25 |     if (!id) {
 26 |       throw new Error(`Argument ns is null or undefined.`);
 27 |     }
 28 |     if (id instanceof NSIdentity) {
 29 |       id = id.ns.hierarchy.concat([id.name]);
 30 |     }
 31 |     if (id.length === 0) {
 32 |       return false;
 33 |     }
 34 |     return this._add(id);
 35 |   }
 36 | 
 37 |   /**
 38 |    * Get all possible FQN.
 39 |    * @param  {string | string[]}    name [description]
 40 |    * @return {string[]}    list of FQN
 41 |    */
 42 |   public get(ns: Namespace | string): string[] {
 43 |     if (typeof ns === "string") {
 44 |       return this.get(Namespace.defineByArray(ns.split(".")));
 45 |     }
 46 |     const name = ns.hierarchy;
 47 |     let current_name = name[name.length - 1];
 48 |     if (!this._nameMap[current_name]) {
 49 |       return [];
 50 |     }
 51 |     let pathes = this._nameMap[current_name]._get(name.slice(0, name.length - 1));
 52 | 
 53 |     const res = [];
 54 | 
 55 |     for (let i = 0; i < pathes.length; i++) {
 56 |       let a = pathes[i];
 57 |       a.push(current_name);
 58 |       res.push(a.join("."));
 59 |     }
 60 |     return res;
 61 |   }
 62 |   public resolve(name: Namespace | string): string {
 63 |     if (typeof name === "string") {
 64 |       return this.resolve(Namespace.defineByArray(name.split(".")));
 65 |     }
 66 |     let pathes = this.get(name);
 67 |     if (pathes.length === 0) {
 68 |       throw new Error(`${name} is not found in this context.`);
 69 |     }
 70 |     if (pathes.length > 1) {
 71 |       throw new Error(`${name} is ambiguous in this context. [${pathes.join(", ")}]`);
 72 |     }
 73 |     return pathes[0];
 74 |   }
 75 |   public has(name: string): boolean {
 76 |     return !!this._nameMap[name];
 77 |   }
 78 |   public remove(name: NSIdentity): void {
 79 |     const fqn = name.fqn.split(".");
 80 |     this._remove(fqn);
 81 |   }
 82 |   public foreach(callback: (fqn: string) => void): void {
 83 |     this._FQNSet.forEach(callback);
 84 |   }
 85 | 
 86 |   private _remove(name: string[]): void {
 87 |     if (name.length === 1) {
 88 |       this._nameMap[name[0]]._isTerminal = false;
 89 |     } else {
 90 |       const next = this._nameMap[name[name.length - 1]];
 91 |       next._remove(name.slice(0, name.length - 1));
 92 |     }
 93 |   }
 94 | 
 95 |   private _get(name: string[]): string[][] {
 96 |     const res: string[][] = [];
 97 |     if (name.length === 0) {
 98 |       if (this.count === 0) {
 99 |         return [[]];
100 |       }
101 |       for (let key in this._nameMap) {
102 |         let match = this._nameMap[key]._get([])!;
103 |         for (let i = 0; i < match.length; i++) {
104 |           let m = match[i];
105 |           m.push(key);
106 |           res.push(m);
107 |         }
108 |       }
109 |       if (this._isTerminal) {
110 |         res.push([]);
111 |       }
112 |       return res;
113 |     }
114 |     let current_name = name[name.length - 1];
115 |     for (let key in this._nameMap) {
116 |       let match = key === current_name ? this._nameMap[key]._get(name.slice(0, name.length - 1)) : this._nameMap[key]._get(name);
117 |       if (match.length !== 0) {
118 |         for (let i = 0; i < match.length; i++) {
119 |           let m = match[i];
120 |           m.push(key);
121 |           res.push(m);
122 |         }
123 |       }
124 |     }
125 |     return res;
126 |   }
127 | 
128 |   /**
129 |    * nameはドットをフラット化済。nameの長さは0ではない。重複があればfalse新規ならtrueを返す。
130 |    * @param  {string[]} name [description]
131 |    * @return {boolean}       [description]
132 |    */
133 |   private _add(id: string[]): boolean {
134 |     const fqn = id.join(".");
135 |     if (this._FQNSet.has(fqn)) {
136 |       return false;
137 |     }
138 |     this._FQNSet.add(fqn);
139 |     if (!this._nameMap[id[id.length - 1]]) {
140 |       this._nameMap[id[id.length - 1]] = new IdResolver();
141 |     }
142 |     const next = id.slice(0, id.length - 1);
143 |     if (next.length === 0) {
144 |       this._nameMap[id[id.length - 1]]._isTerminal = true;
145 |     } else {
146 |       this._nameMap[id[id.length - 1]].add(next);
147 |     }
148 |     return true;
149 |   }
150 | }
151 | 


--------------------------------------------------------------------------------
/src/Base/ListenerFunction.ts:
--------------------------------------------------------------------------------
1 | import {ListenerFn} from "eventemitter3";
2 | export interface Fake {}
3 | export default ListenerFn;
4 | 


--------------------------------------------------------------------------------
/src/Base/MessageException.ts:
--------------------------------------------------------------------------------
 1 | import GomlNode from "../Node/GomlNode";
 2 | import Component from "../Node/Component";
 3 | /**
 4 |  * Exception representing uncought error caused in message function.
 5 |  * Do not thorow this error manually.
 6 |  */
 7 | export default class MessageException extends Error {
 8 |   /**
 9 |    * If this flag was set by events, message system will ignore this exception.
10 |    */
11 |   public handled = false;
12 | 
13 |   private _isMessageException = true;
14 |   constructor(public node: GomlNode, public component: Component, public messageName: string, public error: Error) {
15 |     super();
16 |     const isMessageException = (error as MessageException)._isMessageException;
17 |     if (!isMessageException) {
18 |       const components = this.node.getComponents<Component>();
19 |       let componentMessage = "";
20 |       for (let i = 0; i < components.length; i++) {
21 |         const singleComponent = components[i];
22 |         let marker = "";
23 |         if (this.component === singleComponent) {
24 |           marker = "<<<<<<<<< This component";
25 |         }
26 |         componentMessage += `  (${i})  <${singleComponent.name.fqn}>  ${marker}\n\n   Attributes:\n`;
27 |         singleComponent.attributes.forEach(a => {
28 |           try {
29 |             componentMessage += `    ${a.name.fqn} --- ${a.Value}\n`;
30 |           } catch (e) {
31 |             componentMessage += `    ${a.name.fqn} --- Failed to fetch\n`;
32 |           }
33 |         });
34 |         componentMessage += "\n\n";
35 |       }
36 |       this.message = `[${error.name}]: ${error.message}\n\nThis exception was thrown in message function. Following information are snapshot of GOML tree status.\n\n* Node:  <${node.toString()}>\n* Component:  <${component.name.fqn}>\n* Message:  ${messageName} \n\n* Node map:\n ${node.toStructualString(`--------(Error was thrown from ${component.name.fqn} component of this node.)`)}\n\n* Components of this node:\n${componentMessage}\n\n`;
37 |     } else {
38 |       this.message = `${error.message}\n [Message stack]: ${this.messageName} at <${this.component.name.fqn}> on <${this.node.toString()}>\n`;
39 |     }
40 |     this.stack = error.stack;
41 |     const proto = Object.getPrototypeOf(this);
42 |     proto.name = "MessageException";
43 |     proto.message = this.message;
44 |   }
45 | 
46 |   public toString(): string {
47 |     return this.message;
48 |   }
49 | }
50 | 


--------------------------------------------------------------------------------
/src/Base/NSDictionary.ts:
--------------------------------------------------------------------------------
  1 | import NSIdentity from "./NSIdentity";
  2 | import IdResolver from "./IdResolver";
  3 | import Namespace from "./Namespace";
  4 | import Ensure from "./Ensure";
  5 | import {Name, Nullable, Undef} from "./Types";
  6 | 
  7 | type Dict<V> = { [key: string]: V };
  8 | 
  9 | export default class NSDictionary<V> {
 10 | 
 11 |   private _fqnObjectMap: Dict<V> = {};
 12 |   private _idResolver: IdResolver = new IdResolver();
 13 | 
 14 |   public set(key: NSIdentity, value: V): void {
 15 |     this._fqnObjectMap[key.fqn] = value;
 16 |     this._idResolver.add(key);
 17 |   }
 18 | 
 19 |   public delete(key: NSIdentity): boolean {
 20 |     if (this._fqnObjectMap[key.fqn] !== void 0) {
 21 |       delete this._fqnObjectMap[key.fqn];
 22 |       this._idResolver.remove(key);
 23 |       return true;
 24 |     }
 25 |     return false;
 26 |   }
 27 | 
 28 |   public get(name: Name): V;
 29 |   public get(element: Element): V;
 30 |   public get(attribute: Attr): V;
 31 |   public get(arg1: string | Element | NSIdentity | Attr): Nullable<V> {
 32 |     if (!arg1) {
 33 |       throw new Error("NSDictionary.get() can not recieve args null or undefined.");
 34 |     }
 35 |     if (typeof arg1 === "string") {
 36 |       const fqn = Ensure.tobeFQN(arg1);
 37 |       if (fqn) {
 38 |         return this._fqnObjectMap[fqn];
 39 |       }
 40 |       const name = arg1.split(".");
 41 |       const res = this._idResolver.get(Namespace.defineByArray(name));
 42 |       // const namedMap = this._nameObjectMap[arg1];
 43 |       if (res.length === 0) {
 44 |         return null; // not exist.
 45 |       }
 46 |       if (res.length === 1) {
 47 |         return this._fqnObjectMap[res[0]];
 48 |       } else {
 49 |         throw new Error(`Specified tag name ${arg1} is ambiguous to identify.`);
 50 |       }
 51 | 
 52 |     } else {
 53 |       if (arg1 instanceof NSIdentity) {
 54 |         return this._fqnObjectMap[arg1.fqn];
 55 |       } else {
 56 |         if (arg1.namespaceURI) {
 57 |           return this.get(arg1.namespaceURI + "." + arg1.localName!);
 58 |         }
 59 |         return this.get(arg1.localName!);
 60 |       }
 61 |     }
 62 |   }
 63 | 
 64 |   /**
 65 |    * Check if name has possibility of multiple values.
 66 |    * @param  {string}  name [description]
 67 |    * @return {boolean}      Whether the name has multiple values.
 68 |    */
 69 |   public isAmbiguous(name: string): boolean {
 70 |     return this._idResolver.get(Namespace.defineByArray(name.split("."))).length > 1;
 71 |   }
 72 | 
 73 |   public has(name: string): boolean {
 74 |     return this._idResolver.get(Namespace.defineByArray(name.split("."))).length !== 0;
 75 |   }
 76 | 
 77 |   public pushDictionary(dict: NSDictionary<V>): NSDictionary<V> {
 78 |     dict.forEach((value, keyFQN) => {
 79 |       const id = NSIdentity.fromFQN(keyFQN);
 80 |       this.set(id, value);
 81 |     });
 82 |     return this;
 83 |   }
 84 | 
 85 |   public hasMatchingValue(name: NSIdentity): Undef<V> {
 86 |     const resolver = new IdResolver();
 87 |     resolver.add(name);
 88 |     let match: string | undefined = void 0;
 89 |     for (let key in this._fqnObjectMap) {
 90 |       let v = resolver.get(Namespace.defineByArray(key.split(".")));
 91 |       if (v.length === 1) {
 92 |         if (match === void 0) {
 93 |           match = key;
 94 |         } else {
 95 |           throw new Error(`matching attribute is ambiguous. It has following possibilities ${match} ${key}`);
 96 |         }
 97 |       }
 98 |     }
 99 |     if (match) {
100 |       return this._fqnObjectMap[match];
101 |     }
102 |     return void 0;
103 |   }
104 | 
105 |   public toArray(): V[] {
106 |     const ret: V[] = [];
107 |     Object.keys(this._fqnObjectMap).forEach(key => {
108 |       ret.push(this._fqnObjectMap[key]);
109 |     });
110 |     return ret;
111 |   }
112 |   public clone(): NSDictionary<V> {
113 |     const dict = new NSDictionary<V>();
114 |     return dict.pushDictionary(this);
115 |   }
116 |   public forEach(callback: (value: V, fqn: string) => void): NSDictionary<V> {
117 |     Object.keys(this._fqnObjectMap).forEach(key => {
118 |       callback(this._fqnObjectMap[key], key);
119 |     });
120 |     return this;
121 |   }
122 |   public map<T>(callback: ((value: V, fqn: string) => T)): NSDictionary<T> {
123 |     const ret = new NSDictionary<T>();
124 |     this.forEach((val, fqn) => {
125 |       const id = NSIdentity.fromFQN(fqn);
126 |       ret.set(id, callback(val, fqn));
127 |     });
128 |     return ret;
129 |   }
130 |   public clear(): void {
131 |     this._fqnObjectMap = {};
132 |     this._idResolver = new IdResolver();
133 |   }
134 | }
135 | 


--------------------------------------------------------------------------------
/src/Base/NSIdentity.ts:
--------------------------------------------------------------------------------
  1 | import Namespace from "./Namespace";
  2 | import IdResolver from "./IdResolver";
  3 | 
  4 | /**
  5 |  * The class to identity with XML namespace feature.
  6 |  */
  7 | export default class NSIdentity {
  8 | 
  9 | 
 10 |   private static _instances: { [fqn: string]: NSIdentity } = {};
 11 |   private static _mapBackingField: IdResolver;
 12 |   private static get _map(): IdResolver {
 13 |     if (this._mapBackingField === void 0) {
 14 |       this._mapBackingField = new IdResolver();
 15 |     }
 16 |     return this._mapBackingField;
 17 |   }
 18 | 
 19 |   private _ns: Namespace;
 20 |   private _name: string;
 21 |   private _fqn: string;
 22 | 
 23 |   /**
 24 |    * Generate an instance from Full qualified name.
 25 |    * @param  {string}             fqn [description]
 26 |    * @return {NSIdentity}     [description]
 27 |    */
 28 |   public static fromFQN(fqn: string): NSIdentity;
 29 |   public static fromFQN(qn: Namespace, name: string): NSIdentity;
 30 |   public static fromFQN(fqn: string | Namespace, name?: string): NSIdentity {
 31 |     const hierarchy = NSIdentity._ensureQNTobeArray(fqn, name);
 32 |     fqn = hierarchy.join(".");
 33 |     const inst = NSIdentity._instances[fqn];
 34 |     if (inst) {
 35 |       return inst;
 36 |     }
 37 |     const splitted = fqn.split(".");
 38 |     return new NSIdentity(splitted);
 39 |   }
 40 | 
 41 |   public static guess(...hierarchy: string[]): NSIdentity {
 42 |     return NSIdentity._from(hierarchy);
 43 |   }
 44 | 
 45 |   public static clear(): void {
 46 |     NSIdentity._instances = {};
 47 |     NSIdentity._mapBackingField = new IdResolver();
 48 |   }
 49 | 
 50 |   /**
 51 |    * return instance if exists.
 52 |    * generate and return new instanse if not exist id has same fqn.
 53 |    * @param  {string[]}   hierarchy [description]
 54 |    * @return {NSIdentity}           [description]
 55 |    */
 56 |   private static _from(hierarchy: string[]): NSIdentity {
 57 |     const fqn = hierarchy.join(".");
 58 |     const inst = NSIdentity._instances[fqn];
 59 |     if (inst) {
 60 |       return inst;
 61 |     }
 62 | 
 63 |     return NSIdentity.fromFQN(NSIdentity._map.resolve(Namespace.defineByArray(hierarchy)));
 64 |   }
 65 | 
 66 |   private static _ensureQNTobeArray(arg1: string | string[] | Namespace, name?: string): string[] {
 67 |     if (name) {
 68 |       return NSIdentity._ensureQNTobeArray((arg1 as Namespace).extend(name));
 69 |     }
 70 |     if (typeof arg1 === "string") {
 71 |       return arg1.split(".");
 72 |     }
 73 |     if (Array.isArray(arg1)) {
 74 |       return arg1;
 75 |     }
 76 |     return arg1.hierarchy;
 77 |   }
 78 | 
 79 |   public constructor(fqn: string | string[]);
 80 |   public constructor(qn: string[], n: string);
 81 |   public constructor(qn: string | string[], n?: string) {
 82 |     if (typeof qn === "string") {
 83 |       qn = qn.split(".");
 84 |     }
 85 |     if (n) {
 86 |       this._ns = Namespace.defineByArray(qn);
 87 |       this._name = n;
 88 |     } else {
 89 |       this._name = qn[qn.length - 1];
 90 |       qn = qn.slice(0, qn.length - 1);
 91 |       this._ns = Namespace.defineByArray(qn);
 92 | 
 93 |     }
 94 | 
 95 |     this._fqn = this.ns.hierarchy.concat([this.name]).join(".");
 96 | 
 97 |     NSIdentity._instances[this._fqn] = this;
 98 |     NSIdentity._map.add(qn.concat([this._name]));
 99 |   }
100 | 
101 |   /**
102 |    * Namespace of this identity
103 |    * @type {string}
104 |    */
105 |   public get ns(): Namespace {
106 |     return this._ns;
107 |   }
108 | 
109 |   /**
110 |    * Short name for this identity
111 |    * @type {string}
112 |    */
113 |   public get name(): string {
114 |     return this._name;
115 |   }
116 | 
117 |   /**
118 |    * Full qualified name of this identity
119 |    * @type {string}
120 |    */
121 |   public get fqn(): string {
122 |     return this._fqn;
123 |   }
124 | 
125 | 
126 |   public toString(): string {
127 |     return this.fqn;
128 |   }
129 | }
130 | 


--------------------------------------------------------------------------------
/src/Base/NSSet.ts:
--------------------------------------------------------------------------------
 1 | import NSIdentity from "./NSIdentity";
 2 | 
 3 | /**
 4 |  * set of NSIdentity
 5 |  * @param  {NSIdentity[]} array [description]
 6 |  * @return {NSSet}              [description]
 7 |  */
 8 | export default class NSSet {
 9 |   private _content: { [fqn: string]: NSIdentity } = {};
10 | 
11 |   public static fromArray(array: NSIdentity[]): NSSet {
12 |     const nSet = new NSSet();
13 |     nSet.pushArray(array);
14 |     return nSet;
15 |   }
16 | 
17 | 
18 |   constructor(content?: NSIdentity[]) {
19 |     if (content) {
20 |       this.pushArray(content);
21 |     }
22 |   }
23 | 
24 |   public push(item: NSIdentity): boolean {
25 |     if (!this._content[item.fqn]) {
26 |       this._content[item.fqn] = item;
27 |       return true;
28 |     }
29 |     return false;
30 |   }
31 | 
32 |   public pushArray(item: NSIdentity[]): NSSet {
33 |     item.forEach(v => {
34 |       this.push(v);
35 |     });
36 |     return this;
37 |   }
38 | 
39 |   public toArray(): NSIdentity[] {
40 |     const ret: NSIdentity[] = [];
41 |     for (let key in this._content) {
42 |       ret.push(this._content[key]);
43 |     }
44 |     return ret;
45 |   }
46 | 
47 |   public clone(): NSSet {
48 |     const newSet = new NSSet();
49 |     for (let key in this._content) {
50 |       newSet.push(this._content[key]);
51 |     }
52 |     return newSet;
53 |   }
54 | 
55 |   public merge(other: NSSet): NSSet {
56 |     this.pushArray(other.toArray());
57 |     return this;
58 |   }
59 | 
60 |   public forEach(func: (name: NSIdentity) => void): NSSet {
61 |     for (let key in this._content) {
62 |       func(this._content[key]);
63 |     }
64 |     return this;
65 |   }
66 | }
67 | 


--------------------------------------------------------------------------------
/src/Base/Namespace.ts:
--------------------------------------------------------------------------------
 1 | import NSIdentity from "./NSIdentity";
 2 | import Utility from "./Utility";
 3 | 
 4 | export default class Namespace {
 5 | 
 6 |   private _ns: string[];
 7 | 
 8 |   /**
 9 |    * create new Namespace instance.
10 |    * You can include dots in the name
11 |    * @param  {string[]}  ...name [description]
12 |    * @return {Namespace}         [description]
13 |    */
14 |   public static define(...name: string[]): Namespace {
15 |     return Namespace.defineByArray(name);
16 |   }
17 |   public static defineByArray(name: string[]): Namespace {
18 |     return new Namespace(Utility.flat(name.map(n => n.split("."))));
19 |   }
20 | 
21 |   public get hierarchy(): string[] {
22 |     return this._ns;
23 |   }
24 |   public get qualifiedName(): string {
25 |     return this._ns.join(".");
26 |   }
27 |   public extend(extension: string): Namespace {
28 |     return new Namespace(this._ns.concat([extension]));
29 |   }
30 |   public for(name: string): NSIdentity {
31 |     return NSIdentity.fromFQN(this, name);
32 |   }
33 |   public toString(): string {
34 |     return this.qualifiedName;
35 |   }
36 | 
37 |   private constructor(names: string[]) {
38 |     this._ns = names;
39 |   }
40 | }
41 | 


--------------------------------------------------------------------------------
/src/Base/Types.ts:
--------------------------------------------------------------------------------
 1 | import NSIdentity from "./NSIdentity";
 2 | import GomlInterfaceImpl from "../Interface/GomlInterfaceImpl";
 3 | import GomlNode from "../Node/GomlNode";
 4 | import GrimoireInterfaceImpl from "../Interface/GrimoireInterfaceImpl";
 5 | import NodeInterface from "../Interface/NodeInterface";
 6 | import IAttributeDeclaration from "../Node/IAttributeDeclaration";
 7 | 
 8 | export type Name = string | NSIdentity;
 9 | export type GomlInterface = GomlInterfaceImpl & IGomlInterface;
10 | export type IGrimoireInterface = {
11 |   (query: string): GomlInterface;
12 |   (query: GomlNode[]): GomlInterface;
13 |   (callback: (scriptTags: HTMLScriptElement[]) => void): void;
14 | };
15 | export type IGomlInterface = {
16 |   (query: string): NodeInterface;
17 | };
18 | export type GrimoireInterface = IGrimoireInterface & GrimoireInterfaceImpl;
19 | export type Nullable<T> = T | null;
20 | export type Undef<T> = Nullable<T> | undefined;
21 | export type Ctor<T> = (new () => T);
22 | export type ComponentRegistering<T> = T & {
23 |   attributes: { [key: string]: IAttributeDeclaration };
24 |   componentName?: Name;
25 |   [key: string]: any;
26 | };
27 | 
28 | export default null;
29 | 


--------------------------------------------------------------------------------
/src/Base/Utility.ts:
--------------------------------------------------------------------------------
 1 | import GrimoireInterface from "../Interface/GrimoireInterface";
 2 | 
 3 | 
 4 | export default class Utility {
 5 |   public static w(message: string): void {
 6 |     if (GrimoireInterface.debug) {
 7 |       console.warn(message);
 8 |     }
 9 |   }
10 |   public static isCamelCase(str: string): boolean {
11 |     return /^[A-Z][a-zA-Z0-9]*$/.test(str);
12 |   }
13 |   public static isSnakeCase(str: string): boolean {
14 |     return /^[a-z0-9\-]+$/.test(str);
15 |   }
16 |   public static flat<T>(array: T[][]): T[] {
17 |     let count = 0;
18 |     for (let i = 0; i < array.length; i++) {
19 |       count += array[i].length;
20 |     }
21 |     const ret = new Array<T>(count);
22 |     count = 0;
23 |     for (let i = 0; i < array.length; i++) {
24 |       const ar = array[i];
25 |       for (let j = 0; j < ar.length; j++) {
26 |         ret[count] = ar[j];
27 |         count++;
28 |       }
29 |     }
30 |     return ret;
31 |   }
32 |   public static flatMap<T>(source: T[], map: (a: T) => T[]): T[] {
33 |     const c = new Array<T[]>(source.length);
34 |     for (let i = 0; i < source.length; i++) {
35 |       c[i] = map(source[i]);
36 |     }
37 |     return Utility.flat(c);
38 |   }
39 |   public static sum(array: number[]): number {
40 |     let total = 0;
41 |     for (let i = 0; i < array.length; i++) {
42 |       total += array[i];
43 |     }
44 |     return total;
45 |   }
46 |   public static remove<T>(array: T[], target: T): boolean {
47 |     let index = -1;
48 |     for (let i = 0; i < array.length; i++) {
49 |       if (target === array[i]) {
50 |         index = i;
51 |         break;
52 |       }
53 |     }
54 |     if (index < 0) {
55 |       return false;
56 |     }
57 |     array.splice(index, 1);
58 |     return true;
59 |   }
60 | 
61 |   /**
62 |    * 重複がなければtrue
63 |    */
64 |   public static checkOverlap<T>(array: T[]): boolean {
65 |     const list = [];
66 |     for (let i = 0; i < array.length; i++) {
67 |       const item = array[i];
68 |       if (list.indexOf(item) !== -1) {
69 |         return false;
70 |       }
71 |       list.push(item);
72 |     }
73 |     return true;
74 |   }
75 | }
76 | 


--------------------------------------------------------------------------------
/src/Base/XMLHttpRequestAsync.ts:
--------------------------------------------------------------------------------
 1 | export default class XMLHttpRequestAsync {
 2 |   public static send(xhr: XMLHttpRequest, data?: Document | string): Promise<Event> {
 3 |     return new Promise((resolve, reject) => {
 4 |       xhr.onload = (e) => {
 5 |         resolve(e);
 6 |       };
 7 |       xhr.onerror = (e) => {
 8 |         reject(e);
 9 |       };
10 |       xhr.send(data);
11 |     });
12 |   }
13 | }
14 | 


--------------------------------------------------------------------------------
/src/Base/XMLReader.ts:
--------------------------------------------------------------------------------
 1 | import {Nullable} from "./Types";
 2 | 
 3 | /**
 4 |  * Provides safe xml read feature.
 5 |  */
 6 | class XMLReader {
 7 | 
 8 |   private static _parser: DOMParser = new DOMParser();
 9 | 
10 |   public static parseXML(doc: string, rootElementName?: string): Element[] {
11 |     const parsed = XMLReader._parser.parseFromString(doc as string, "text/xml");
12 |     if (!parsed || parsed.getElementsByTagName("parsererror").length > 0) {
13 |       const err = new XMLSerializer().serializeToString(parsed);
14 |       throw new Error(`Error parsing XML: ${err}`);
15 |     }
16 |     if (rootElementName) {
17 |       if (parsed.documentElement.tagName.toUpperCase() !== rootElementName.toUpperCase()) {
18 |         throw new Error("Specified document is invalid.");
19 |       }// TODO should throw more detail error
20 |     }
21 | 
22 |     return [parsed.documentElement]; // TODO: implenent!
23 |   }
24 | 
25 |   public static getElements(elem: Element, name: string): Element[] {
26 |     const result: Element[] = [];
27 |     const elems = elem.getElementsByTagName(name);
28 |     for (let i = 0; i < elems.length; i++) {
29 |       result.push(elems.item(i));
30 |     }
31 |     return result;
32 |   }
33 | 
34 |   public static getSingleElement(elem: Element, name: string, mandatory?: boolean): Nullable<Element> {
35 |     const result = XMLReader.getElements(elem, name);
36 |     if (result.length === 1) {
37 |       return result[0];
38 |     } else if (result.length === 0) { // When the element was not found
39 |       if (mandatory) {
40 |         throw new Error(`The mandatory element ${name} was required, but not found`);
41 |       } else {
42 |         return null;
43 |       }
44 |     } else {
45 |       throw new Error(`The element ${name} requires to exist in single. But there is ${result.length} count of elements`);
46 |     }
47 |   }
48 | 
49 |   public static getAttribute(elem: Element, name: string, mandatory?: boolean): Nullable<string> {
50 |     const result = elem.attributes.getNamedItem(name);
51 |     if (result) {
52 |       return result.value;
53 |     } else if (mandatory) {
54 |       throw new Error(`The mandatory attribute ${name} was required, but it was not found`);
55 |     } else {
56 |       return null;
57 |     }
58 |   }
59 | 
60 |   public static getAttributeFloat(elem: Element, name: string, mandatory?: boolean): Nullable<number> {
61 |     const resultStr = XMLReader.getAttribute(elem, name, mandatory);
62 |     return resultStr ? parseFloat(resultStr) : null;
63 |   }
64 | 
65 |   public static getAttributeInt(elem: Element, name: string, mandatory?: boolean): Nullable<number> {
66 |     const resultStr = XMLReader.getAttribute(elem, name, mandatory);
67 |     return resultStr ? parseInt(resultStr, 10) : null;
68 |   }
69 | 
70 |   public static getChildElements(elem: Element): Element[] {
71 |     const children = elem.childNodes;
72 |     const result: Element[] = [];
73 |     for (let i = 0; i < children.length; i++) {
74 |       if (children.item(i) instanceof Element) {
75 |         result.push(children.item(i) as Element);
76 |       }
77 |     }
78 |     return result;
79 |   }
80 | 
81 |   public static getAttributes(elem: Element, ns?: string): { [key: string]: string } {
82 |     const result: { [key: string]: string } = {};
83 |     const attrs = elem.attributes;
84 |     for (let i = 0; i < attrs.length; i++) {
85 |       const attr = attrs.item(i);
86 |       if (!ns || attr.namespaceURI === ns) {
87 |         result[attr.localName!] = attr.value;
88 |       }
89 |     }
90 |     return result;
91 |   }
92 | }
93 | 
94 | export default XMLReader;
95 | 


--------------------------------------------------------------------------------
/src/Components/GrimoireComponent.ts:
--------------------------------------------------------------------------------
 1 | import IAttributeDeclaration from "../Node/IAttributeDeclaration";
 2 | import Component from "../Node/Component";
 3 | 
 4 | export default class GrimoireComponent extends Component {
 5 |   public static componentName = "GrimoireComponent";
 6 |   public static attributes: { [key: string]: IAttributeDeclaration } = {
 7 |     id: {
 8 |       converter: "String",
 9 |       default: null
10 |     },
11 |     class: {
12 |       converter: "StringArray",
13 |       default: null
14 |     },
15 |     enabled: {
16 |       converter: "Boolean",
17 |       default: true
18 |     }
19 |   };
20 | 
21 |   public $awake(): void {
22 |     const node = this.node!;
23 |     node.resolveAttributesValue();
24 |     this.getAttributeRaw("id").watch((attr) => {
25 |       node.element.id = attr ? attr : "";
26 |     }, true, true);
27 |     this.getAttributeRaw("class").watch((attr) => {
28 |       node.element.className = Array.isArray(attr) ? attr.join(" ") : "";
29 |     }, true, true);
30 |     this.getAttributeRaw("enabled").watch(attr => {
31 |       node["_enabled"] = attr;
32 |       const p = node.parent;
33 |       node.notifyActivenessUpdate(p ? p.isActive && node.enabled : node.enabled);
34 |     }, false, true);
35 |     node["_enabled"] = this.getAttribute("enabled");
36 |     node["_isActive"] = node.parent ? node.parent.isActive && node.enabled : node.enabled;
37 |   }
38 | }
39 | 


--------------------------------------------------------------------------------
/src/Converters/ArrayConverter.ts:
--------------------------------------------------------------------------------
 1 | import GrimoireInterface from "../Interface/GrimoireInterface";
 2 | import Attribute from "../Node/Attribute";
 3 | 
 4 | const splitter = " ";
 5 | const escape = "\\";
 6 | 
 7 | /**
 8 |  * 配列のためのコンバータ。
 9 |  * 属性宣言にパラメータ`type`が必要です。
10 |  * このパラメータは配列の要素の型のためのコンバータ名です。
11 |  * このコンバータは、配列が与えられたらその内容すべてを、`type`で指定されたコンバータを通して生成した新しい配列を返します。
12 |  * 文字列が与えられたとき、*半角スペース*で区切られた文字列ごとに配列に分割して同様の処理を行います。
13 |  * ただし、`\`(バックスラッシュ)で*半角スペースをエスケープできます*
14 |  */
15 | export default {
16 |   name: "Array",
17 |   verify: function(attr: Attribute) {
18 |     if (!attr.declaration["type"]) {
19 |       throw new Error("Array converter needs to be specified type in attribute declaration.");
20 |     }
21 |   },
22 |   convert: function(val: any, attr: Attribute) {
23 |     let converter = GrimoireInterface.converters.get(attr.declaration["type"]);
24 |     if (!converter) {
25 |       throw new Error(`converter ${attr.declaration["type"]} is not registerd.`);
26 |     }
27 |     if (Array.isArray(val)) {
28 |       return val.map(v => converter.convert(v, attr));
29 |     }
30 |     if (typeof val === "string") {
31 |       let ar = val.split(splitter);
32 |       for (let i = 0; i < ar.length; i++) {
33 |         let s = ar[i];
34 |         if (s[s.length - 1] === escape) {
35 |           if (i === ar.length - 1) {
36 |             ar[i] = s.substring(0, s.length - escape.length) + splitter;
37 |           } else {
38 |             ar[i] = s.substring(0, s.length - escape.length) + splitter + ar[i + 1];
39 |             ar.splice(i + 1, 1);
40 |           }
41 |         }
42 |       }
43 | 
44 |       return ar.map(v => converter.convert(v, attr));
45 |     }
46 |     return null;
47 |   }
48 | };
49 | 


--------------------------------------------------------------------------------
/src/Converters/BooleanConverter.ts:
--------------------------------------------------------------------------------
 1 | 
 2 | /**
 3 |  * booleanのためのコンバータです。
 4 |  * booleanはそのまま通します。
 5 |  * 文字列は、`true`,`false`のみ通します。
 6 |  * @param  {any}       val  [description]
 7 |  * @param  {Attribute} attr [description]
 8 |  * @return {any}            [description]
 9 |  */
10 | export default function BooleanConverter(val: any): any {
11 |   if (typeof val === "boolean") {
12 |     return val;
13 |   } else if (typeof val === "string") {
14 |     switch (val) {
15 |       case "true":
16 |         return true;
17 |       case "false":
18 |         return false;
19 |     }
20 |   }
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Converters/ComponentConverter.ts:
--------------------------------------------------------------------------------
 1 | import Ensure from "../Base/Ensure";
 2 | import Component from "../Node/Component";
 3 | import GomlNode from "../Node/GomlNode";
 4 | import Attribute from "../Node/Attribute";
 5 | 
 6 | 
 7 | /**
 8 |  * コンポーネントのためのコンバータです。
 9 |  * 属性宣言に`target`パラメータの指定が必要です。
10 |  * nullに対してはnullを返します。
11 |  * `gomlnode`に対しては、`target`パラメータの値で`getComponent`した結果を返します。
12 |  * `Component`に対しては、`target`パラメータと型が一致していればそのまま返します。そうでなければ、例外を投げます。
13 |  * 文字列の場合、ノードに対するクエリとして解釈され、取得されたノードに対して`getComponent`されます。
14 |  */
15 | export default {
16 |   name: "Component",
17 |   verify: function(attr: Attribute) {
18 |     if (!attr.declaration["target"]) {
19 |       throw new Error("Component converter require to be specified target");
20 |     }
21 |   },
22 |   convert: function(val: any, attr: Attribute) {
23 |     if (val === null) {
24 |       return null;
25 |     }
26 |     if (val instanceof GomlNode) {
27 |       return val.getComponent(attr.declaration["target"]);
28 |     } else if (val instanceof Component) {
29 |       if (val.name.fqn === Ensure.tobeNSIdentity(attr.declaration["target"]).fqn) {
30 |         return val;
31 |       } else {
32 |         throw new Error(`Specified component must be ${attr.declaration["target"]}`);
33 |       }
34 |     } else {
35 |       const n = attr.tree!(val).first();
36 |       if (n) {
37 |         return n.getComponent(attr.declaration["target"]);
38 |       }
39 |       return null;
40 |     }
41 |   }
42 | };
43 | 


--------------------------------------------------------------------------------
/src/Converters/EnumConverter.ts:
--------------------------------------------------------------------------------
 1 | import Attribute from "../Node/Attribute";
 2 | /**
 3 |  * 列挙のためのコンバータ。
 4 |  * 属性宣言に`table`パラメータが必要です。
 5 |  * `table`パラメータは列挙する文字列から数値への連想配列です。
 6 |  * 数値の場合、そのまま返します。
 7 |  * 文字列の場合、テーブルの対応する値を返します。
 8 |  */
 9 | export default {
10 |   name: "Enum",
11 |   verify: function(attr: Attribute) {
12 |     if (!attr.declaration["table"]) {
13 |       throw new Error("Enum converter needs to be specified table in attribute dictionary");
14 |     }
15 |   },
16 |   convert: function(val: any, attr: Attribute) {
17 |     if (typeof val === "number") {
18 |       return val;
19 |     }
20 |     if (typeof val === "string") {
21 |       const result = attr.declaration["table"][val];
22 |       if (!result) {
23 |         throw new Error("Specified value is not exisiting in the relation table");
24 |       }
25 |       return result;
26 |     }
27 |   }
28 | };
29 | 


--------------------------------------------------------------------------------
/src/Converters/NumberArrayConverter.ts:
--------------------------------------------------------------------------------
 1 | export default function NumberArrayConverter(val: any): any {
 2 |   if (val instanceof Array) {
 3 |     return val;
 4 |   }
 5 |   if (typeof val === "string") {
 6 |     const splitted = val.split(",");
 7 |     return splitted.map(s => Number.parseFloat(s));
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Converters/NumberConverter.ts:
--------------------------------------------------------------------------------
 1 | import {Nullable, Undef} from "../Base/Types";
 2 | 
 3 | /**
 4 |  * converter for number value.
 5 |  * number,string,null will be converted.
 6 |  * Array<number> also convertable only if length equivalent to 1.
 7 |  * @param  {any}    val [description]
 8 |  * @return {number}     [description]
 9 |  */
10 | export default function NumberConverter(val: Nullable<number> | string | Array<number>): Undef<number> {
11 |   if (typeof val === "number") {
12 |     return val;
13 |   } else if (typeof val === "string") {
14 |     return Number.parseFloat(val);
15 |   } else if (val === null) {
16 |     return null;
17 |   } else if (Array.isArray(val) && val.length === 1) {
18 |     return val[0];
19 |   }
20 |   return undefined;
21 | }
22 | 


--------------------------------------------------------------------------------
/src/Converters/ObjectConverter.ts:
--------------------------------------------------------------------------------
 1 | /**
 2 |  * オブジェクトのコンバータ。
 3 |  * 値をそのまま返します。
 4 |  * @param  {any} val [description]
 5 |  * @return {any}     [description]
 6 |  */
 7 | export default function ObjectConverter(val: any): any {
 8 |   return val;
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Converters/StringArrayConverter.ts:
--------------------------------------------------------------------------------
1 | export default function StringArrayConverter(val: any): any {
2 |   if (Array.isArray(val) || !val) {
3 |     return val;
4 |   }
5 |   if (typeof val === "string") {
6 |     return val.split(" ");
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/src/Converters/StringConverter.ts:
--------------------------------------------------------------------------------
 1 | export default function StringConverter(val: any): any {
 2 |   if (typeof val === "string") {
 3 |     return val;
 4 |   } else if (!val) {
 5 |     return val;
 6 |   } else if (typeof val.toString === "function") {
 7 |     return val.toString();
 8 |   }
 9 | }
10 | 


--------------------------------------------------------------------------------
/src/Declaration/IAttributeConverterDeclaration.ts:
--------------------------------------------------------------------------------
 1 | import Attribute from "../Node/Attribute";
 2 | import {Name} from "../Base/Types";
 3 | 
 4 | interface IAttributeConverterDeclaration {
 5 |   name: Name;
 6 |   [params: string]: any;
 7 |   verify(attr: Attribute): void; // throw error if attribute is not satisfy condition converter needed.
 8 |   convert(val: any, attr: Attribute): any;
 9 | }
10 | export default IAttributeConverterDeclaration;
11 | 


--------------------------------------------------------------------------------
/src/Interface/GomlInterfaceImpl.ts:
--------------------------------------------------------------------------------
 1 | import Constants from "../Base/Constants";
 2 | import GrimoireInterface from "../Interface/GrimoireInterface";
 3 | import NodeInterface from "./NodeInterface";
 4 | import GomlNode from "../Node/GomlNode";
 5 | /**
 6 |  * Provides interfaces to treat whole goml tree for each.
 7 |  */
 8 | class GomlInterface {
 9 |   constructor(public rootNodes: GomlNode[]) {
10 | 
11 |   }
12 | 
13 |   public getNodeById(id: string): GomlNode[] {
14 |     return this.rootNodes.map(root => GomlNode.fromElement(root.element.ownerDocument.getElementById(id)!));
15 |   }
16 | 
17 |   public queryFunc(query: string): NodeInterface {
18 |     return new NodeInterface(this._queryNodes(query));
19 |   }
20 | 
21 |   private _queryNodes(query: string): GomlNode[][] {
22 |     return this.rootNodes.map(root => {
23 |       const nodelist = root.element.ownerDocument.querySelectorAll(query);
24 |       const nodes: GomlNode[] = [];
25 |       for (let i = 0; i < nodelist.length; i++) {
26 |         const id = nodelist.item(i).getAttribute(Constants.x_gr_id);
27 |         if (id) {
28 |           const node = GrimoireInterface.nodeDictionary[id];
29 |           if (node) {
30 |             nodes.push(node);
31 |           }
32 |         }
33 |       }
34 |       return nodes;
35 |     });
36 |   }
37 | }
38 | 
39 | export default GomlInterface;
40 | 


--------------------------------------------------------------------------------
/src/Interface/GrimoireInterface.ts:
--------------------------------------------------------------------------------
 1 | import GrimoireInterfaceImpl from "./GrimoireInterfaceImpl";
 2 | import GomlInterfaceImpl from "./GomlInterfaceImpl";
 3 | import GomlNode from "../Node/GomlNode";
 4 | import { GomlInterface, GrimoireInterface } from "../Base/Types";
 5 | 
 6 | 
 7 | const context = new GrimoireInterfaceImpl();
 8 | 
 9 | function obtainGomlInterface(query: string): GomlInterface;
10 | function obtainGomlInterface(query: GomlNode[]): GomlInterface;
11 | function obtainGomlInterface(callback: () => void): void;
12 | function obtainGomlInterface(query: string | GomlNode[] | (() => void)): void | GomlInterface {
13 |   if (typeof query === "string") {
14 |     const gomlContext = new GomlInterfaceImpl(context.queryRootNodes(query));
15 |     const queryFunc = gomlContext.queryFunc.bind(gomlContext);
16 |     Object.setPrototypeOf(queryFunc, gomlContext);
17 |     return queryFunc;
18 |   } else if (typeof query === "function") {
19 |     if (context.callInitializedAlready) {
20 |       query();
21 |     } else {
22 |       context.initializedEventHandler.push(query);
23 |     }
24 |   } else {
25 |     const gomlContext = new GomlInterfaceImpl(query);
26 |     const queryFunc = gomlContext.queryFunc.bind(gomlContext);
27 |     Object.setPrototypeOf(queryFunc, gomlContext);
28 |     return queryFunc;
29 |   }
30 | }
31 | Object.setPrototypeOf(obtainGomlInterface, context);
32 | export default obtainGomlInterface as GrimoireInterface;
33 | 


--------------------------------------------------------------------------------
/src/Interface/NodeInterface.ts:
--------------------------------------------------------------------------------
  1 | import Utility from "../Base/Utility";
  2 | import XMLReader from "../Base/XMLReader";
  3 | import GomlParser from "../Node/GomlParser";
  4 | import Attribute from "../Node/Attribute";
  5 | import GomlNode from "../Node/GomlNode";
  6 | import {Name, Nullable} from "../Base/Types";
  7 | import ListenerFunction from "../Base/ListenerFunction";
  8 | 
  9 | 
 10 | /**
 11 |  * interface for operate multicast nodes.
 12 |  */
 13 | export default class NodeInterface {
 14 |   /**
 15 |    * array of node targeted by this interface.
 16 |    * this property has two dimantion.
 17 |    * nodes[i] is node array in tree at i.
 18 |    * @param  {GomlNode[][]} nodes [description]
 19 |    * @return {[type]}             [description]
 20 |    */
 21 |   public nodes: GomlNode[][];
 22 | 
 23 |   constructor(nodes: GomlNode[][]) {
 24 |     if (!nodes) {
 25 |       throw new Error("nodes is null");
 26 |     }
 27 |     this.nodes = nodes;
 28 |   }
 29 | 
 30 |   /**
 31 |    * get count of targeted nodes.
 32 |    * @return {number} [description]
 33 |    */
 34 |   public get count(): number {
 35 |     if (this.nodes.length === 0) {
 36 |       return 0;
 37 |     }
 38 |     const counts = this.nodes.map(nodes => nodes.length);
 39 |     return Utility.sum(counts);
 40 |   }
 41 | 
 42 |   public get isEmpty(): boolean {
 43 |     return this.count === 0;
 44 |   }
 45 | 
 46 |   /**
 47 |    * Get node by index.
 48 |    * Calling with an argument omitted, the function returns first node.
 49 |    * and throw error if this interface is empty.
 50 |    *
 51 |    * Calling with one argument, it is treated as index of node.
 52 |    * this function returns the node at index across all tree.
 53 |    * throw error if index out of range.
 54 |    *
 55 |    * Calling with two arguments, they are treated as index of tree and node.
 56 |    * this function returns the node at node-index in a tree at tree-index.
 57 |    * throw error if index out of range.
 58 |    * @return {GomlNode} [description]
 59 |    */
 60 |   public get(): GomlNode;
 61 |   public get(nodeIndex: number): GomlNode;
 62 |   public get(treeIndex: number, nodeIndex: number): GomlNode;
 63 |   public get(i1?: number, i2?: number): GomlNode {
 64 |     if (i1 === void 0) {
 65 |       const first = this.first();
 66 |       if (!first) {
 67 |         throw new Error("this NodeInterface is empty.");
 68 |       } else {
 69 |         return first;
 70 |       }
 71 |     } else if (i2 === void 0) {
 72 |       if (this.count <= i1) {
 73 |         throw new Error("index out of range.");
 74 |       }
 75 |       let c = i1;
 76 |       return this.find(() => {
 77 |         if (c === 0) {
 78 |           return true;
 79 |         }
 80 |         c--;
 81 |         return false;
 82 |       })!;
 83 |     } else {
 84 |       if (this.nodes.length <= i1 || this.nodes[i1].length <= i2) {
 85 |         throw new Error("index out of range.");
 86 |       } else {
 87 |         return this.nodes[i1][i2];
 88 |       }
 89 |     }
 90 |   }
 91 | 
 92 |   public getAttribute(attrName: Name): any {
 93 |     const first = this.first();
 94 |     if (!first) {
 95 |       throw new Error("this NodeInterface is empty.");
 96 |     }
 97 |     return first.getAttribute(attrName);
 98 |   }
 99 |   public setAttribute(attrName: Name, value: any): void {
100 |     this.forEach(node => {
101 |       node.setAttribute(attrName, value, false);
102 |     });
103 |   }
104 | 
105 |   /**
106 |    * 対象ノードにイベントリスナを追加します。
107 |    * @param {string}   eventName [description]
108 |    * @param {ListenerFunction} listener  [description]
109 |    */
110 |   public on(eventName: string, listener: ListenerFunction): NodeInterface {
111 |     this.forEach(node => {
112 |       node.on(eventName, listener);
113 |     });
114 |     return this;
115 |   }
116 | 
117 |   /**
118 |    * 対象ノードに指定したイベントリスナが登録されていれば削除します
119 |    * @param {string}   eventName [description]
120 |    * @param {ListenerFunction} listener  [description]
121 |    */
122 |   public off(eventName: string, listener: ListenerFunction): NodeInterface {
123 |     this.forEach(node => {
124 |       node.removeListener(eventName, listener);
125 |     });
126 |     return this;
127 |   }
128 | 
129 |   /**
130 |    * このノードインタフェースが対象とするノードそれぞれに、
131 |    * タグで指定したノードを子要素として追加します。
132 |    * @param {string} tag [description]
133 |    */
134 |   public append(tag: string): NodeInterface {
135 |     this.forEach(node => {
136 |       const elems = XMLReader.parseXML(tag);
137 |       elems.forEach(elem => {
138 |         let child = GomlParser.parse(elem);
139 |         node.addChild(child);
140 |       });
141 |     });
142 |     return this;
143 |   }
144 | 
145 |   /**
146 |    * このノードインタフェースが対象とするノードをツリーから削除します。s
147 |    * @param {GomlNode} child [description]
148 |    */
149 |   public remove(): NodeInterface {
150 |     this.forEach(node => {
151 |       node.remove();
152 |     });
153 |     return this;
154 |   }
155 | 
156 |   /**
157 |    * execute provided function once for each element targeted by this interface.
158 |    * @param  {number} callback Function to execute for each element, taking three arguments:
159 |    * abort the iteration if function returns True.
160 |    * @return {[type]}          [description]
161 |    */
162 |   public forEach(callback: ((node: GomlNode, gomlIndex: number, nodeIndex: number, iterationHandler?: { abort: boolean }) => void)): NodeInterface {
163 |     for (let i = 0; i < this.nodes.length; i++) {
164 |       const array = this.nodes[i];
165 |       const gomlIndex = i;
166 |       for (let j = 0; j < array.length; j++) {
167 |         const node = array[j];
168 |         const nodeIndex = j;
169 |         const ih = { abort: false };
170 |         callback(node, gomlIndex, nodeIndex, ih);
171 |         if (ih.abort) {
172 |           return this;
173 |         }
174 |       }
175 |     }
176 |     return this;
177 |   }
178 | 
179 |   public map<T>(func: (node: GomlNode, gomlIndex: number, nodeIndex: number) => T): T[][] {
180 |     return this.nodes.map((array, gomlIndex) => {
181 |       return array.map((node, nodeIndex) => {
182 |         return func(node, gomlIndex, nodeIndex);
183 |       });
184 |     });
185 |   }
186 |   public find(predicate: (node: GomlNode, gomlIndex: number, nodeIndex: number) => boolean): Nullable<GomlNode> {
187 |     const nodes = this.nodes;
188 |     for (let i = 0; i < nodes.length; i++) {
189 |       const array = nodes[i];
190 |       for (let j = 0; j < array.length; j++) {
191 |         const node = array[j];
192 |         if (predicate(node, i, j)) {
193 |           return node;
194 |         }
195 |       }
196 |     }
197 |     return null;
198 |   }
199 |   public watch(attrName: Name, watcher: ((newValue: any, oldValue: any, attr: Attribute) => void), immediate = false) {
200 |     this.forEach(node => {
201 |       node.watch(attrName, watcher, immediate);
202 |     });
203 |   }
204 | 
205 |   /**
206 |    * このノードインタフェースが対象とするノードを有効、または無効にします。
207 |    * @param {boolean} enable [description]
208 |    */
209 |   public setEnable(enable: boolean): NodeInterface {
210 |     this.forEach(node => {
211 |       node.enabled = !!enable;
212 |     });
213 |     return this;
214 |   }
215 | 
216 |   /**
217 |    * このノードインタフェースが対象とするノードのそれぞれの子ノードを対象とする、
218 |    * 新しいノードインタフェースを取得します。
219 |    * @return {NodeInterface} [description]
220 |    */
221 |   public children(): NodeInterface {
222 |     const children = this.nodes.map(nodes => {
223 |       return Utility.flatMap(nodes, node => {
224 |         return node.children;
225 |       });
226 |     });
227 |     return new NodeInterface(children);
228 |   }
229 | 
230 |   /**
231 |    * 対象ノードにコンポーネントをアタッチします。
232 |    * @param {Component} component [description]
233 |    */
234 |   public addComponent(componentId: Name, attributes: { [key: string]: any } = {}): NodeInterface {
235 |     this.forEach(node => {
236 |       node.addComponent(componentId, attributes);
237 |     });
238 |     return this;
239 |   }
240 | 
241 |   /**
242 |    * 最初の対象ノードを取得する
243 |    * ひとつもなければnull
244 |    * @return {GomlNode} [description]
245 |    */
246 |   public first(): Nullable<GomlNode> {
247 |     return this.find(() => true);
248 |   }
249 | 
250 |   /**
251 |    * 対象となる唯一のノードを取得する。
252 |    * 対象が存在しない、あるいは複数存在するときは例外を投げる。
253 |    * @return {GomlNode} [description]
254 |    */
255 |   public single(): GomlNode {
256 |     if (this.count !== 1) {
257 |       throw new Error("this nodeInterface is not single.");
258 |     }
259 |     const first = this.first();
260 |     if (!first) {
261 |       throw new Error("this nodeInterface is not single,but is empty.");
262 |     }
263 |     return first;
264 |   }
265 | 
266 |   public filter(predicate: (node: GomlNode, gomlIndex: number, nodeIndex: number) => boolean): NodeInterface {
267 |     const newNodes: GomlNode[][] = [];
268 |     for (let i = 0; i < this.nodes.length; i++) {
269 |       const goml = this.nodes[i];
270 |       newNodes.push([]);
271 |       for (let j = 0; j < goml.length; j++) {
272 |         const node = goml[j];
273 |         if (predicate(node, i, j)) {
274 |           newNodes[i].push(node);
275 |         }
276 |       }
277 |     }
278 |     return new NodeInterface(newNodes);
279 |   }
280 |   public toArray(): GomlNode[] {
281 |     return Utility.flat(this.nodes);
282 |   }
283 | 
284 |   public addChildByName(nodeName: Name, attributes: { [attrName: string]: any }): NodeInterface {
285 |     return new NodeInterface(this.map(node => {
286 |       return node.addChildByName(nodeName, attributes);
287 |     }));
288 |   }
289 |   public sendMessage(message: string, args?: any): void {
290 |     this.forEach(node => {
291 |       node.sendMessage(message, args);
292 |     });
293 |   }
294 |   public broadcastMessage(range: number, name: string, args?: any): void;
295 |   public broadcastMessage(name: string, args?: any): void;
296 |   public broadcastMessage(arg1: number | string, arg2?: any, arg3?: any): void {
297 |     if (typeof arg1 === "number") {
298 |       this.forEach(node => {
299 |         node.broadcastMessage(arg1, arg2, arg3);
300 |       });
301 |     } else {
302 |       this.forEach(node => {
303 |         node.broadcastMessage(arg2, arg3);
304 |       });
305 |     }
306 |   }
307 | }
308 | 


--------------------------------------------------------------------------------
/src/Node/Attribute.ts:
--------------------------------------------------------------------------------
  1 | import IAttributeConverterDeclaration from "../Declaration/IAttributeConverterDeclaration";
  2 | import NSDictionary from "../Base/NSDictionary";
  3 | import Ensure from "../Base/Ensure";
  4 | import IAttributeDeclaration from "./IAttributeDeclaration";
  5 | import NSIdentity from "../Base/NSIdentity";
  6 | import IdResolver from "../Base/IdResolver";
  7 | import GrimoireInterface from "../Interface/GrimoireInterface";
  8 | import Component from "./Component";
  9 | import {GomlInterface, Name, Nullable} from "../Base/Types";
 10 | 
 11 | /**
 12 |  * Manage a attribute attached to components.
 13 |  */
 14 | export default class Attribute {
 15 | 
 16 |   /**
 17 |    * The name of attribute.
 18 |    * @type {NSIdentity}
 19 |    */
 20 |   public name: NSIdentity;
 21 | 
 22 |   /**
 23 |    * The declaration of attribute used for defining this attribute.
 24 |    * @type {IAttributeDeclaration}
 25 |    */
 26 |   public declaration: IAttributeDeclaration;
 27 | 
 28 |   /**
 29 |    * A function to convert any values into ideal type.
 30 |    * @type {AttributeConverter}
 31 |    */
 32 |   public converter: IAttributeConverterDeclaration;
 33 | 
 34 |   /**
 35 |    * A component reference that this attribute is bound to.
 36 |    * @type {Component}
 37 |    */
 38 |   public component: Component;
 39 | 
 40 |   public convertContext: any = {};
 41 |   /**
 42 |    * Cache of attribute value.
 43 |    * @type {any}
 44 |    */
 45 |   private _value: any;
 46 | 
 47 |   private _lastValuete: any;
 48 | 
 49 |   /**
 50 |    * List of functions that is listening changing values.
 51 |    */
 52 |   private _observers: ((newValue: any, oldValue: any, attr: Attribute) => void)[] = [];
 53 |   private _ignoireActivenessObservers: ((newValue: any, oldValue: any, attr: Attribute) => void)[] = [];
 54 | 
 55 |   /**
 56 |    * Goml tree interface which contains the component this attribute bound to.
 57 |    * @return {GomlInterface} [description]
 58 |    */
 59 |   public get tree(): Nullable<GomlInterface> {
 60 |     return this.component.tree;
 61 |   }
 62 | 
 63 |   /**
 64 |    * Companion map which is bounding to the component this attribute bound to.
 65 |    * @return {NSDictionary<any>} [description]
 66 |    */
 67 |   public get companion(): Nullable<NSDictionary<any>> {
 68 |     return this.component.companion;
 69 |   }
 70 | 
 71 |   /**
 72 |    * Get a value with specified type.
 73 |    * @return {any} value with specified type.
 74 |    */
 75 |   public get Value(): any {
 76 |     if (this._value === void 0) {
 77 |       const node = this.component.node;
 78 |       throw new Error(`attribute ${this.name.name} value is undefined in ${node ? node.name.name : "undefined"}`);
 79 |     }
 80 |     return this._valuate(this._value);
 81 |   }
 82 | 
 83 |   /**
 84 |    * Set a value with any type.
 85 |    * @param {any} val Value with string or specified type.
 86 |    */
 87 |   public set Value(val: any) {
 88 |     if (this._value === val) {
 89 |       return;
 90 |     }
 91 |     this._value = val;
 92 |     this._notifyChange(val);
 93 |   }
 94 | 
 95 | 
 96 |   public static convert(converter: Name, self: Attribute, val: any): any {
 97 |     const cname = Ensure.tobeNSIdentity(converter);
 98 |     const conv = GrimoireInterface.converters.get(cname);
 99 |     if (!conv) {
100 |       throw new Error(`converter ${cname.name} is not defined.`);
101 |     }
102 |     return conv.convert(val, self);
103 |   }
104 | 
105 |   /**
106 |    * Construct a new attribute with name of key and any value with specified type. If constant flag is true, This attribute will be immutable.
107 |    * If converter is not served, string converter will be set as default.
108 |    * @param {string}        key       Key of this attribute.
109 |    * @param {any}           value     Value of this attribute.
110 |    * @param {ConverterBase} converter Converter of this attribute.
111 |    * @param {boolean}       constant  Whether this attribute is immutable or not. False as default.
112 |    */
113 |   public static generateAttributeForComponent(name: string, declaration: IAttributeDeclaration, component: Component): Attribute {
114 |     const attr = new Attribute();
115 |     attr.name = NSIdentity.fromFQN(component.name.fqn + "." + name);
116 |     attr.component = component;
117 |     attr.declaration = declaration;
118 |     const converterName = Ensure.tobeNSIdentity(declaration.converter);
119 |     attr.converter = GrimoireInterface.converters.get(converterName);
120 |     if (attr.converter === void 0) {
121 |       // When the specified converter was not found
122 |       throw new Error(`Specified converter ${converterName.name} was not found from registered converters.\n Component: ${attr.component.name.fqn}\n Attribute: ${attr.name.name}`);
123 |     }
124 |     attr.component.attributes.set(attr.name, attr);
125 |     attr.converter.verify(attr);
126 |     return attr;
127 |   }
128 | 
129 |   /**
130 |    * Add event handler to observe changing this attribute.
131 |    * @param  {(attr: Attribute) => void} handler handler the handler you want to add.
132 |    * @param {boolean = false} callFirst whether that handler should be called first time.
133 |    */
134 |   public watch(watcher: (newValue: any, oldValue: any, attr: Attribute) => void, immedateCalls = false, ignoireActiveness = false): void {
135 |     if (ignoireActiveness) {
136 |       this._ignoireActivenessObservers.push(watcher);
137 |     } else {
138 |       this._observers.push(watcher);
139 |     }
140 |     if (immedateCalls) {
141 |       watcher(this.Value, void 0, this);
142 |     }
143 |   }
144 | 
145 |   /**
146 |    * Remove event handler you added.
147 |    * @param  {Attribute} handler [description]
148 |    * @return {[type]}            [description]
149 |    */
150 |   public unwatch(target: (newValue: any, oldValue: any, attr: Attribute) => void): void {
151 |     let index = this._observers.findIndex(f => f === target);
152 |     if (index >= 0) {
153 |       this._observers.splice(index, 1);
154 |       return;
155 |     }
156 |     index = this._ignoireActivenessObservers.findIndex(f => f === target);
157 |     if (index >= 0) {
158 |       this._ignoireActivenessObservers.splice(index, 1);
159 |       return;
160 |     }
161 |   }
162 | 
163 |   /**
164 |    * Bind converted value to specified field.
165 |    * When target object was not specified, field of owner component would be assigned.
166 |    * @param {string} variableName [description]
167 |    * @param {any} targetObject [description]
168 |    */
169 |   public boundTo(variableName: string, targetObject: any = this.component): void {
170 |     if (targetObject[variableName]) {
171 |       console.warn(`component field ${variableName} is already defined.`);
172 |     }
173 |     if (this.converter["lazy"]) {
174 |       Object.defineProperty(targetObject, variableName, {
175 |         get: () => this.Value,
176 |         set: (val) => { this.Value = val; },
177 |         enumerable: true,
178 |         configurable: true
179 |       });
180 |     } else {
181 |       let backing: any;
182 |       this.watch(v => {
183 |         backing = v;
184 |       }, true);
185 |       Object.defineProperty(targetObject, variableName, {
186 |         get: () => backing,
187 |         set: (val) => { this.Value = val; },
188 |         enumerable: true,
189 |         configurable: true
190 |       });
191 |     }
192 |   }
193 | 
194 |   /**
195 |    * Apply default value to attribute from DOM values.
196 |    * @param {string }} domValues [description]
197 |    */
198 |   public resolveDefaultValue(domValues: { [key: string]: string }): void {
199 |     if (this._value !== void 0) {// value is already exist.
200 |       return;
201 |     }
202 | 
203 |     // resolve by goml value
204 |     const resolver = new IdResolver();
205 |     resolver.add(this.name);
206 |     let tagAttrKey;
207 |     for (let key in domValues) {
208 |       if (Ensure.checkFQNString(key)) {
209 |         if (this.name.fqn === key.substring(1)) {
210 |           this.Value = domValues[key];
211 |           return;
212 |         }
213 |         continue;
214 |       }
215 |       let get = resolver.get(key);
216 |       if (get.length > 0) {
217 |         if (tagAttrKey === void 0) {
218 |           tagAttrKey = key;
219 |         } else {
220 |           throw new Error(`tag attribute is ambiguous for ${this.name.fqn}. It has the following possibilities ${tagAttrKey} ${get[0]}`);
221 |         }
222 |       }
223 |     }
224 |     if (tagAttrKey !== void 0) {
225 |       this.Value = domValues[tagAttrKey];
226 |       return;
227 |     }
228 | 
229 |     // resolve by node defaults.
230 |     const nodeDefaultValue = this.component.node!.nodeDeclaration.defaultAttributesActual.hasMatchingValue(this.name);
231 |     if (nodeDefaultValue !== void 0) {
232 |       this.Value = nodeDefaultValue; // Node指定値で解決
233 |       return;
234 |     }
235 | 
236 |     // resolve by component defaults.
237 |     this.Value = this.declaration.default;
238 |   }
239 | 
240 |   private _valuate(raw: any): any {
241 |     const v = this.converter.convert(raw, this);
242 |     if (v === void 0) {
243 |       const errorMessage = `Converting attribute value failed.\n\n* input : ${raw}\n* Attribute(Attribute FQN) : ${this.name.name}(${this.name.fqn})\n* Component : ${this.component.name.name}(${this.component.name.fqn})\n* Node(Node FQN) : ${this.component.node.name.name}(${this.component.node.name.fqn})\n* Converter : ${this.declaration.converter}\n\n* Structure map:\n${this.component.node.toStructualString(`--------------Error was thrown from '${this.name.name}' of this node.`)}`;
244 |       throw new Error(errorMessage);
245 |     }
246 |     this._lastValuete = v;
247 |     return v;
248 |   }
249 | 
250 |   private _notifyChange(newValue: any): void {
251 |     const lastvalue = this._lastValuete;
252 |     if (!this.component.isActive) {
253 |       if (this._ignoireActivenessObservers.length === 0) {
254 |         return;
255 |       }
256 |       const convertedNewValue = this._valuate(newValue);
257 |       this._ignoireActivenessObservers.forEach((watcher) => {
258 |         watcher(convertedNewValue, lastvalue, this);
259 |       });
260 |     } else {
261 |       const convertedNewValue = this._valuate(newValue);
262 |       this._observers.forEach((watcher) => {
263 |         watcher(convertedNewValue, lastvalue, this);
264 |       });
265 |       this._ignoireActivenessObservers.forEach((watcher) => {
266 |         watcher(convertedNewValue, lastvalue, this);
267 |       });
268 |     }
269 |   }
270 | }
271 | 


--------------------------------------------------------------------------------
/src/Node/Component.ts:
--------------------------------------------------------------------------------
  1 | import ITreeInitializedInfo from "./ITreeInitializedInfo";
  2 | import Utility from "../Base/Utility";
  3 | import Constants from "../Base/Constants";
  4 | import NodeUtility from "./NodeUtility";
  5 | import IAttributeDeclaration from "./IAttributeDeclaration";
  6 | import Attribute from "./Attribute";
  7 | import GomlNode from "./GomlNode";
  8 | import NSDictionary from "../Base/NSDictionary";
  9 | import NSIdentity from "../Base/NSIdentity";
 10 | import IDObject from "../Base/IDObject";
 11 | import Ensure from "../Base/Ensure";
 12 | import {GomlInterface, Nullable, Name} from "../Base/Types";
 13 | 
 14 | /**
 15 |  * Base class for any components
 16 |  * component must be attach to node before any operation.
 17 |  */
 18 | export default class Component extends IDObject {
 19 |   /**
 20 |    * Name of this component
 21 |    * @type {NSIdentity}
 22 |    */
 23 |   public name: NSIdentity;
 24 |   /**
 25 |    * Attributes managed by this component
 26 |    * @type {NSDictionary<Attribute>}
 27 |    */
 28 |   public attributes: NSDictionary<Attribute>;
 29 |   /**
 30 |    * Node this component is attached
 31 |    * @type {GomlNode}
 32 |    */
 33 |   public node: GomlNode;
 34 |   /**
 35 |    * XMLElement of this component
 36 |    * @type {Element}
 37 |    */
 38 |   public element: Element;
 39 | 
 40 |   /**
 41 |    * Whether this component was created by nodeDeclaration
 42 |    * @type {boolean}
 43 |    */
 44 |   public isDefaultComponent = false;
 45 | 
 46 |   public disposed = false;
 47 | 
 48 |   /**
 49 |    * Flag that this component is activated or not.
 50 |    * @type {boolean}
 51 |    */
 52 |   private _enabled = true;
 53 |   private _awaked = false;
 54 |   private _handlers: ((component: Component) => void)[] = [];
 55 |   private _additionalAttributesNames: NSIdentity[] = [];
 56 |   private _initializedInfo: Nullable<ITreeInitializedInfo> = null;
 57 | 
 58 |   public get enabled(): boolean {
 59 |     return this._enabled;
 60 |   }
 61 |   public set enabled(val) {
 62 |     if (this._enabled === val) {
 63 |       return;
 64 |     }
 65 |     this._enabled = val;
 66 |     this._handlers.forEach((handler) => {
 67 |       handler(this);
 68 |     });
 69 |   }
 70 |   /**
 71 |    * The dictionary which is shared in entire tree.
 72 |    * @return {NSDictionary<any>} [description]
 73 |    */
 74 |   public get companion(): NSDictionary<any> {
 75 |     return this.node.companion;
 76 |   }
 77 |   /**
 78 |    * Tree interface for the tree this node is attached.
 79 |    * @return {GomlInterface} [description]
 80 |    */
 81 |   public get tree(): GomlInterface {
 82 |     return this.node.tree;
 83 |   }
 84 |   public get isActive(): boolean {
 85 |     return this.enabled && !!this.node && this.node.isActive;
 86 |   }
 87 | 
 88 |   /**
 89 |    * Set value of attribute
 90 |    * @param {string} name  [description]
 91 |    * @param {any}    value [description]
 92 |    */
 93 |   public setAttribute(name: Name, value: any): void {
 94 |     if (typeof name === "string" && Ensure.checkFQNString(name)) {
 95 |       name = this.name.fqn + "." + name; // TODO: test
 96 |     }
 97 |     const attr = this.attributes.get(name);
 98 |     if (attr) {
 99 |       attr.Value = value;
100 |     }
101 |   }
102 | 
103 |   public getAttribute(name: Name): any {
104 |     if (typeof name === "string" && Ensure.checkFQNString(name)) {
105 |       name = this.name.fqn + "." + name; // TODO: test
106 |     }
107 |     const attr = this.getAttributeRaw(name);
108 |     if (attr) {
109 |       return attr.Value;
110 |     } else {
111 |       throw new Error(`attribute ${name} is not defined in ${this.name.fqn}`);
112 |     }
113 |   }
114 |   public getAttributeRaw(name: Name): Attribute {
115 |     if (typeof name === "string" && Ensure.checkFQNString(name)) {
116 |       name = this.name.fqn + "." + name; // TODO: test
117 |     }
118 |     return this.attributes.get(name);
119 |   }
120 | 
121 |   public addEnabledObserver(observer: (component: Component) => void): void {
122 |     this._handlers.push(observer);
123 |   }
124 | 
125 |   public removeEnabledObserver(observer: (component: Component) => void): boolean {
126 |     return Utility.remove(this._handlers, observer);
127 |   }
128 | 
129 |   public resolveDefaultAttributes(nodeAttributes?: { [key: string]: string; } |null): any {
130 |     const nodeAttr = nodeAttributes || {};
131 |     if (this.isDefaultComponent) { // If this is default component, the default attribute values should be retrived from node DOM.
132 |       this.attributes.forEach(attr => attr.resolveDefaultValue(nodeAttr));
133 |     } else { // If not,the default value of attributes should be retrived from this element.
134 |       const attrs = NodeUtility.getAttributes(this.element);
135 |       for (let key in attrs) {
136 |         if (key === Constants.x_gr_id) {
137 |           continue;
138 |         }
139 |       }
140 |       this.attributes.forEach(attr => attr.resolveDefaultValue(attrs));
141 |     }
142 |   }
143 | 
144 |   public dispose(): void {
145 |     this.node.removeComponent(this);
146 |   }
147 | 
148 |   public awake(): boolean {
149 |     if (this._awaked) {
150 |       return false;
151 |     }
152 |     this._awaked = true;
153 |     let method = (this as any)["$$awake"];
154 |     if (typeof method === "function") {
155 |       method();
156 |     }
157 |     return true;
158 |   }
159 | 
160 |   public initialized(info: ITreeInitializedInfo): void {
161 |     if (this._initializedInfo === info) {
162 |       return;
163 |     }
164 |     this._initializedInfo = info;
165 |     let method = (this as any)["$$initialized"];
166 |     if (typeof method === "function") {
167 |       method(info);
168 |     }
169 |   }
170 | 
171 |   protected __addAtribute(name: string, attribute: IAttributeDeclaration): void {
172 |     console.warn(`${this.name.fqn} is using '__addAtribute()'.\nthis method is deprecated because typo.\nplease use '__addAttribute() instead of.'`);
173 |     this.__addAttribute(name, attribute);
174 |   }
175 | 
176 |   /**
177 |    * Add additional attribute to this component.
178 |    * @param {string}                name      [description]
179 |    * @param {IAttributeDeclaration} attribute [description]
180 |    */
181 |   protected __addAttribute(name: string, attribute: IAttributeDeclaration): Attribute {
182 |     if (!attribute) {
183 |       throw new Error("can not add attribute null or undefined.");
184 |     }
185 |     const attr = Attribute.generateAttributeForComponent(name, attribute, this);
186 |     this.node.addAttribute(attr);
187 |     if (this.isDefaultComponent) { // If this is default component, the default attribute values should be retrived from node DOM.
188 |       attr.resolveDefaultValue(NodeUtility.getAttributes(this.node.element));
189 |     } else { // If not,the default value of attributes should be retrived from this element.
190 |       const attrs = NodeUtility.getAttributes(this.element);
191 |       attr.resolveDefaultValue(attrs);
192 |     }
193 |     this._additionalAttributesNames.push(attr.name);
194 |     return attr;
195 |   }
196 |   protected __removeAttributes(name?: string): void {
197 |     if (name) {
198 |       const index = this._additionalAttributesNames.findIndex(id => id.name === name);
199 |       if (index < 0) {
200 |         throw new Error("can not remove attributes :" + name);
201 |       }
202 |       const attrId = this._additionalAttributesNames[index];
203 |       this.node.removeAttribute(this.attributes.get(attrId));
204 |       this.attributes.delete(attrId);
205 |       this._additionalAttributesNames.splice(index, 1);
206 |     } else {
207 |       const arr = this._additionalAttributesNames.concat();
208 |       arr.forEach(id => {
209 |         this.__removeAttributes(id.name);
210 |       });
211 |     }
212 |   }
213 |   protected __bindAttributes(): void {
214 |     this.attributes.forEach(attr => {
215 |       const name = attr.name.name;
216 |       attr.boundTo(name);
217 |     });
218 |   }
219 | }
220 | 


--------------------------------------------------------------------------------
/src/Node/ComponentDeclaration.ts:
--------------------------------------------------------------------------------
  1 | import Constants from "../Base/Constants";
  2 | import GrimoireInterface from "../Interface/GrimoireInterface";
  3 | import Attribute from "./Attribute";
  4 | import NSDictionary from "../Base/NSDictionary";
  5 | import IAttributeDeclaration from "./IAttributeDeclaration";
  6 | import NSIdentity from "../Base/NSIdentity";
  7 | import IdResolver from "../Base/IdResolver";
  8 | import Component from "./Component";
  9 | import Ensure from "../Base/Ensure";
 10 | import {Ctor, Name, ComponentRegistering} from "../Base/Types";
 11 | 
 12 | export default class ComponentDeclaration {
 13 |   public static ctorMap: { ctor: ComponentRegistering<Object | Ctor<Component>>, name: NSIdentity }[] = [];
 14 | 
 15 |   public superComponent: Ctor<Component>;
 16 |   public ctor: Ctor<Component>;
 17 |   public idResolver: IdResolver = new IdResolver();
 18 |   public attributes: { [name: string]: IAttributeDeclaration }; // undefined until resolve dependency.
 19 | 
 20 |   private _resolvedDependency = false;
 21 |   private _super?: Name;
 22 | 
 23 |   public get isDependenyResolved() {
 24 |     return this._resolvedDependency;
 25 |   }
 26 | 
 27 |   public constructor(
 28 |     public name: NSIdentity,
 29 |     private _ctorOrObj: ComponentRegistering<Object | Ctor<Component>>,
 30 |     _super?: Name | Ctor<Component>) {
 31 |     if (!_super) {// no inherits.
 32 |       this.resolveDependency();
 33 |       return;
 34 |     }
 35 |     if (_super instanceof NSIdentity || typeof _super === "string") {
 36 |       this._super = _super;
 37 |     } else {
 38 |       this.superComponent = _super;
 39 |     }
 40 |   }
 41 | 
 42 |   public generateInstance(componentElement?: Element): Component { // TODO: obsolete.make all operation on gomlnode
 43 |     if (!this.isDependenyResolved) {
 44 |       this.resolveDependency();
 45 |     }
 46 |     componentElement = componentElement ? componentElement : document.createElementNS(this.name.ns.qualifiedName, this.name.name);
 47 |     const component = new this.ctor();
 48 |     componentElement.setAttribute(Constants.x_gr_id, component.id);
 49 |     GrimoireInterface.componentDictionary[component.id] = component;
 50 |     component.name = this.name;
 51 |     component.element = componentElement;
 52 |     component.attributes = new NSDictionary<Attribute>();
 53 |     for (let key in this.attributes) {
 54 |       Attribute.generateAttributeForComponent(key, this.attributes[key], component);
 55 |     }
 56 |     return component;
 57 |   }
 58 | 
 59 |   public resolveDependency(): boolean {
 60 |     if (this._resolvedDependency) {
 61 |       return false;
 62 |     }
 63 |     const attr: { [name: string]: IAttributeDeclaration } = {};
 64 |     let dec;
 65 |     if (this._super || this.superComponent) { // inherits
 66 |       const id = this._super ? Ensure.tobeNSIdentity(this._super) : this.superComponent["name"];
 67 |       dec = GrimoireInterface.componentDeclarations.get(id);
 68 |       dec.resolveDependency();
 69 |       for (let key in dec.attributes) {
 70 |         attr[key] = dec.attributes[key];
 71 |         this.idResolver.add(NSIdentity.fromFQN(this.name.fqn + "." + key));
 72 |       }
 73 |       this.superComponent = dec.ctor;
 74 |     }
 75 |     this.ctor = this._ensureTobeComponentConstructor(this.name, this._ctorOrObj, dec ? dec.ctor : void 0);
 76 |     for (let key in (this.ctor as any).attributes) {
 77 |       attr[key] = (this.ctor as any).attributes[key];
 78 |       this.idResolver.add(NSIdentity.fromFQN(this.name.fqn + "." + key));
 79 |     }
 80 |     this.attributes = attr;
 81 | 
 82 |     ComponentDeclaration.ctorMap.push({ ctor: this._ctorOrObj, name: this.name });
 83 |     return this._resolvedDependency = true;
 84 |   }
 85 | 
 86 | 
 87 |   /**
 88 |    * Ensure the given object or constructor to be an constructor inherits Component;
 89 |    * @param  {Object | (new ()=> Component} obj [The variable need to be ensured.]
 90 |    * @return {[type]}      [The constructor inherits Component]
 91 |    */
 92 |   private _ensureTobeComponentConstructor(id: NSIdentity, obj: ComponentRegistering<Object> | ComponentRegistering<Ctor<Component>>, baseConstructor?: Ctor<Component>): Ctor<Component> {
 93 |     if (typeof obj === "function") { // obj is constructor
 94 |       const inheritsAttr = this._extractInheritsAttributes(obj);
 95 |       if (baseConstructor) { // inherits
 96 |         const newCtor = function(this: any) {
 97 |           baseConstructor.call(this);
 98 |           obj.call(this);
 99 |         };
100 |         const proto = this._clonePrototypeChain(obj.prototype, baseConstructor.prototype);
101 |         newCtor.prototype = proto;
102 |         newCtor.prototype["name"] = id;
103 |         (newCtor as any).attributes = inheritsAttr;
104 |         return newCtor as any as Ctor<Component>;
105 |       } else {
106 |         obj.prototype["name"] = id;
107 |         obj.attributes = inheritsAttr;
108 |         return obj;
109 |       }
110 |     } else {
111 |       if (baseConstructor && !(baseConstructor.prototype instanceof Component) && baseConstructor !== Component) {
112 |         throw new Error("Base component comstructor must extends Compoent class.");
113 |       }
114 |       const ctor = baseConstructor || Component;
115 |       const newCtor = function(this: any) {
116 |         ctor.call(this);
117 |       };
118 |       (obj as any).__proto__ = ctor.prototype;
119 | 
120 |       newCtor.prototype = obj;
121 |       (newCtor as any).attributes = obj.attributes;
122 | 
123 |       newCtor.prototype["name"] = id;
124 |       return newCtor as any as Ctor<Component>;
125 |     }
126 |   }
127 | 
128 |   private _extractInheritsAttributes(ctor: Ctor<Component>): { [key: string]: IAttributeDeclaration } {
129 |     type D = { [key: string]: IAttributeDeclaration };
130 |     const attrs: D[] = [];
131 |     while (ctor) {
132 |       if (ctor === Component) {
133 |         break;
134 |       }
135 |       attrs.push((ctor as any).attributes as D);
136 |       ctor = ctor.prototype.__proto__.constructor;
137 |     }
138 |     const atr: D = {};
139 |     for (let i = attrs.length - 1; i >= 0; i--) {
140 |       for (let key in attrs[i]) {
141 |         atr[key] = attrs[i][key];
142 |       }
143 |     }
144 |     return atr;
145 |   }
146 | 
147 |   private _clonePrototypeChain(obj: Object, base: Object): any {
148 |     const chain = [];
149 |     let c = obj;
150 |     while (true) {
151 |       if (c.constructor === Component) {
152 |         break;
153 |       }
154 |       chain.push(c);
155 |       c = Object.getPrototypeOf(c);
156 |     }
157 |     chain.reverse();
158 |     chain.pop();
159 | 
160 |     let ret = base;
161 |     for (let i = 0; i < chain.length; i++) {
162 |       const props = (Object as any).getOwnPropertyDescriptors(chain[0]);
163 |       ret = Object.create(ret, props);
164 |     }
165 |     (obj as any).__proto__ = ret;
166 |     return obj;
167 |   }
168 | }
169 | 


--------------------------------------------------------------------------------
/src/Node/GomlLoader.ts:
--------------------------------------------------------------------------------
 1 | import GrimoireInterface from "../Interface/GrimoireInterface";
 2 | import GomlParser from "./GomlParser";
 3 | import XMLReader from "../Base/XMLReader";
 4 | import XMLHttpRequestAsync from "../Base/XMLHttpRequestAsync";
 5 | /**
 6 |  * Provides the features to fetch Goml source.
 7 |  */
 8 | class GomlLoader {
 9 |   public static callInitializedAlready = false;
10 | 
11 |   public static initializedEventHandlers: (() => void)[] = [];
12 | 
13 |   /**
14 |    * Obtain the Goml source from specified tag.
15 |    * @param  {HTMLScriptElement} scriptTag [the script tag to load]
16 |    * @return {Promise<void>}               [the promise to wait for loading]
17 |    */
18 |   public static async loadFromScriptTag(scriptTag: HTMLScriptElement): Promise<void> {
19 |     const srcAttr = scriptTag.getAttribute("src");
20 |     let source: string;
21 |     if (srcAttr) {
22 |       // ignore text element
23 |       const req = new XMLHttpRequest();
24 |       req.open("GET", srcAttr);
25 |       await XMLHttpRequestAsync.send(req);
26 |       source = req.responseText;
27 |     } else {
28 |       source = scriptTag.text;
29 |     }
30 |     const doc = XMLReader.parseXML(source, "GOML");
31 |     const rootNode = GomlParser.parse(doc[0]);
32 |     GrimoireInterface.addRootNode(scriptTag, rootNode);
33 |   }
34 |   /**
35 |    * Load from the script tags which will be found with specified query.
36 |    * @param  {string}          query [the query to find script tag]
37 |    * @return {Promise<void[]>}       [the promise to wait for all goml loading]
38 |    */
39 |   public static async loadFromQuery(query: string): Promise<void> {
40 |     const tags = document.querySelectorAll(query);
41 |     const pArray: Promise<void>[] = [];
42 |     const elements: HTMLScriptElement[] = [];
43 |     for (let i = 0; i < tags.length; i++) {
44 |       const element = tags.item(i) as HTMLScriptElement;
45 |       elements.push(element);
46 |       pArray[i] = GomlLoader.loadFromScriptTag(element);
47 |     }
48 |     if (pArray.length === 0 && GrimoireInterface.debug) {
49 |       console.warn("There was no goml file detected. Have you specified `type='text/goml'` to the script tag?");
50 |     }
51 |     await Promise.all<void>(pArray);
52 |     GomlLoader.initializedEventHandlers.forEach(handler => {
53 |       handler();
54 |     });
55 |     this.callInitializedAlready = true;
56 |   }
57 | 
58 |   /**
59 |    * Load all Goml sources contained in HTML.
60 |    * @return {Promise<void>} [the promise to wait for all goml loading]
61 |    */
62 |   public static async loadForPage(): Promise<void> {
63 |     await GomlLoader.loadFromQuery('script[type="text/goml"]');
64 |   }
65 | }
66 | 
67 | export default GomlLoader;
68 | 


--------------------------------------------------------------------------------
/src/Node/GomlParser.ts:
--------------------------------------------------------------------------------
  1 | import GomlNode from "./GomlNode";
  2 | import GrimoireInterface from "../Interface/GrimoireInterface";
  3 | 
  4 | /**
  5 |  * Parser of Goml to Node utilities.
  6 |  * This class do not store any nodes and goml properties.
  7 |  */
  8 | class GomlParser {
  9 |   /**
 10 |    * Domをパースする
 11 |    * @param  {Element}           source    [description]
 12 |    * @param  {GomlNode}          parent    あればこのノードにaddChildされる
 13 |    * @return {GomlNode}                    ルートノード
 14 |    */
 15 |   public static parse(source: Element, parent?: GomlNode |null): GomlNode {
 16 |     const newNode = GomlParser._createNode(source);
 17 | 
 18 |     // Parse children recursively
 19 |     const children = source.childNodes;
 20 |     const childNodeElements: Element[] = []; // for parse after .Components has resolved.
 21 |     if (children && children.length !== 0) { // When there is children
 22 |       const removeTarget: Node[] = [];
 23 |       for (let i = 0; i < children.length; i++) {
 24 |         const child = children.item(i);
 25 |         if (!GomlParser._isElement(child)) {
 26 |           removeTarget.push(child);
 27 |           continue;
 28 |         }
 29 |         if (this._isComponentsTag(child)) {
 30 |           // parse as components
 31 |           GomlParser._parseComponents(newNode, child);
 32 |           removeTarget.push(child);
 33 |         } else {
 34 |           // parse as child node.
 35 |           childNodeElements.push(child);
 36 |         }
 37 |       }
 38 |       // remove unused elements
 39 |       for (let i = 0; i < removeTarget.length; i++) {
 40 |         source.removeChild(removeTarget[i]);
 41 |       }
 42 |     }
 43 | 
 44 |     // generate tree
 45 |     if (parent) {
 46 |       parent.addChild(newNode, null, false);
 47 |     }
 48 | 
 49 |     childNodeElements.forEach((child) => {
 50 |       GomlParser.parse(child, newNode);
 51 |     });
 52 |     return newNode;
 53 |   }
 54 | 
 55 |   /**
 56 |    * GomlNodeのインスタンス化。GrimoireInterfaceへの登録
 57 |    * @param  {HTMLElement}      elem         [description]
 58 |    * @param  {GomlConfigurator} configurator [description]
 59 |    * @return {GomlTreeNodeBase}              [description]
 60 |    */
 61 |   private static _createNode(elem: Element): GomlNode {
 62 |     const tagName = elem.localName;
 63 |     const recipe = GrimoireInterface.nodeDeclarations.get(elem);
 64 |     if (!recipe) {
 65 |       throw new Error(`Tag "${tagName}" is not found.`);
 66 |     }
 67 |     return new GomlNode(recipe, elem);
 68 |   }
 69 | 
 70 |   /**
 71 |    * .COMPONENTSのパース。
 72 |    * @param {GomlNode} node          アタッチされるコンポーネント
 73 |    * @param {Element}  componentsTag .COMPONENTSタグ
 74 |    */
 75 |   private static _parseComponents(node: GomlNode, componentsTag: Element): void {
 76 |     let componentNodes = componentsTag.childNodes;
 77 |     if (!componentNodes) {
 78 |       return;
 79 |     }
 80 |     for (let i = 0; i < componentNodes.length; i++) {
 81 |       const componentNode = componentNodes.item(i) as Element;
 82 |       if (!GomlParser._isElement(componentNode)) {
 83 |         continue; // Skip if the node was not element
 84 |       }
 85 |       const componentDecl = GrimoireInterface.componentDeclarations.get(componentNode);
 86 |       if (!componentDecl) { // Verify specified component is actual existing.
 87 |         throw new Error(`Component ${componentNode.tagName} is not found.`);
 88 |       }
 89 | 
 90 |       const component = componentDecl.generateInstance(componentNode);
 91 |       node._addComponentDirectly(component, false);
 92 |     }
 93 |   }
 94 | 
 95 |   private static _isElement(node: Node): node is Element {
 96 |     return node.nodeType === Node.ELEMENT_NODE;
 97 |   }
 98 | 
 99 |   private static _isComponentsTag(element: Element): boolean {
100 |     const regexToFindComponent = /\.COMPONENTS$/mi; // TODO might needs to fix
101 |     return regexToFindComponent.test(element.nodeName);
102 |   }
103 | 
104 | }
105 | 
106 | export default GomlParser;
107 | 


--------------------------------------------------------------------------------
/src/Node/IAttributeDeclaration.ts:
--------------------------------------------------------------------------------
 1 | import {Name} from "../Base/Types";
 2 | 
 3 | interface IAttributeDeclaration {
 4 |   converter: Name;
 5 |   default: any;
 6 |   [parameters: string]: any;
 7 | }
 8 | 
 9 | export default IAttributeDeclaration;
10 | 


--------------------------------------------------------------------------------
/src/Node/ITreeInitializedInfo.ts:
--------------------------------------------------------------------------------
1 | interface ITreeInitializedInfo {
2 |     ownerScriptTag: HTMLScriptElement;
3 |     id: string;
4 | }
5 | 
6 | export default ITreeInitializedInfo;
7 | 


--------------------------------------------------------------------------------
/src/Node/NodeDeclaration.ts:
--------------------------------------------------------------------------------
  1 | import Ensure from "../Base/Ensure";
  2 | import NSDictionary from "../Base/NSDictionary";
  3 | import NSSet from "../Base/NSSet";
  4 | import NSIdentity from "../Base/NSIdentity";
  5 | import IdResolver from "../Base/IdResolver";
  6 | import GrimoireInterface from "../Interface/GrimoireInterface";
  7 | import {Name} from "../Base/Types";
  8 | 
  9 | export default class NodeDeclaration {
 10 |   public defaultComponents: NSSet;
 11 |   public defaultAttributes: NSDictionary<any> = new NSDictionary();
 12 |   public superNode?: NSIdentity;
 13 |   public freezeAttributes: NSSet;
 14 |   public idResolver = new IdResolver();
 15 | 
 16 |   private _defaultComponentsActual: NSSet;
 17 |   private _defaultAttributesActual: NSDictionary<any>;
 18 |   private _resolvedDependency = false;
 19 | 
 20 | 
 21 |   public get resolvedDependency() {
 22 |     return this._resolvedDependency;
 23 |   }
 24 | 
 25 |   public get defaultComponentsActual(): NSSet {
 26 |     if (!this._resolvedDependency) {
 27 |       throw new Error(`${this.name.fqn} is not resolved dependency!`);
 28 |     }
 29 |     return this._defaultComponentsActual;
 30 |   }
 31 | 
 32 |   public get defaultAttributesActual(): NSDictionary<any> {
 33 |     if (!this._resolvedDependency) {
 34 |       throw new Error(`${this.name.fqn} is not resolved dependency!`);
 35 |     }
 36 |     return this._defaultAttributesActual;
 37 |   }
 38 | 
 39 |   constructor(
 40 |     public name: NSIdentity,
 41 |     private _defaultComponents: Name[],
 42 |     private _defaultAttributes: { [key: string]: any },
 43 |     private _superNode?: Name,
 44 |     private _freezeAttributes: Name[] = []) {
 45 |     if (!this._superNode && this.name.name !== "grimoire-node-base") {
 46 |       this._superNode = new NSIdentity("grimoirejs.grimoire-node-base");
 47 |     }
 48 |     this._freezeAttributes = this._freezeAttributes || [];
 49 |   }
 50 | 
 51 |   public addDefaultComponent(componentName: Name): void {
 52 |     const componentId = Ensure.tobeNSIdentity(componentName);
 53 |     this.defaultComponents.push(componentId);
 54 |     if (this._defaultComponentsActual) {
 55 |       this._defaultComponentsActual.push(componentId);
 56 |     }
 57 |   }
 58 | 
 59 |   /**
 60 |    * resolve requiredComponents,superNode,defaults and freezeAttributes,
 61 |    * throw error if they have any ambiguity.
 62 |    * デフォルトコンポーネント、スーパノード、デフォルト値、フリーズ値の名前解決。曖昧は例外
 63 |    */
 64 |   public resolveDependency(): boolean {
 65 |     if (this._resolvedDependency) {
 66 |       return false;
 67 |     }
 68 |     this.defaultComponents = new NSSet(this._defaultComponents.map(name => Ensure.tobeNSIdentity(name)));
 69 | 
 70 |     for (let key in this._defaultAttributes) {
 71 |       let value = this._defaultAttributes[key];
 72 |       this.defaultAttributes.set(NSIdentity.fromFQN(key), value);
 73 |     }
 74 |     this.superNode = this._superNode ? Ensure.tobeNSIdentity(this._superNode) : void 0;
 75 |     this._resolveInherites();
 76 |     this._defaultComponentsActual.forEach(id => {
 77 |       const dec = GrimoireInterface.componentDeclarations.get(id);
 78 |       dec.idResolver.foreach(fqn => {
 79 |         this.idResolver.add(NSIdentity.fromFQN(fqn));
 80 |       });
 81 |     });
 82 |     this.freezeAttributes = new NSSet(this._freezeAttributes.map(name => Ensure.tobeNSIdentity(name)));
 83 |     this._resolvedDependency = true;
 84 |     return true;
 85 |   }
 86 | 
 87 | 
 88 |   private _resolveInherites(): void {
 89 |     if (!this.superNode) { // not inherit.
 90 |       this._defaultComponentsActual = this.defaultComponents;
 91 |       this._defaultAttributesActual = this.defaultAttributes;
 92 |       return;
 93 |     }
 94 |     const superNode = GrimoireInterface.nodeDeclarations.get(this.superNode);
 95 |     superNode.resolveDependency();
 96 |     const inheritedDefaultComponents = superNode.defaultComponentsActual;
 97 |     const inheritedDefaultAttribute = superNode.defaultAttributesActual;
 98 |     this._defaultComponentsActual = inheritedDefaultComponents.clone().merge(this.defaultComponents);
 99 |     this._defaultAttributesActual = inheritedDefaultAttribute.clone().pushDictionary(this.defaultAttributes);
100 |   }
101 | }
102 | 


--------------------------------------------------------------------------------
/src/Node/NodeUtility.ts:
--------------------------------------------------------------------------------
 1 | class NodeUtility { // TODO merge with Base/XMLReader
 2 |   /**
 3 |    * Get index of NodeList converted from index in Element
 4 |    * @param  {HTMLElement} targetElement Parent element of search target elements
 5 |    * @param  {number}      elementIndex  Index in element
 6 |    * @return {number}                    Index in NodeList
 7 |    */
 8 |   public static getNodeListIndexByElementIndex(targetElement: Element, elementIndex: number): number {
 9 |     const nodeArray: Node[] = Array.prototype.slice.call(targetElement.childNodes);
10 |     const elementArray = nodeArray.filter((v) => {
11 |       return v.nodeType === 1;
12 |     });
13 |     elementIndex = elementIndex < 0 ? elementArray.length + elementIndex : elementIndex;
14 |     return nodeArray.indexOf(elementArray[elementIndex]);
15 |   }
16 | 
17 |   public static getAttributes(element: Element): { [key: string]: string } {
18 |     const attributes: { [key: string]: string } = {};
19 |     const domAttr = element.attributes;
20 |     for (let i = 0; i < domAttr.length; i++) {
21 |       const attrNode = domAttr.item(i);
22 |       if (attrNode.name.startsWith("xmlns")) {
23 |         continue;
24 |       }
25 |       const name = attrNode.namespaceURI ? attrNode.namespaceURI + "." + attrNode.localName! : attrNode.localName!;
26 |       attributes[name] = attrNode.value;
27 |     }
28 |     return attributes;
29 |   }
30 | }
31 | 
32 | export default NodeUtility;
33 | 


--------------------------------------------------------------------------------
/src/main.ts:
--------------------------------------------------------------------------------
  1 | import GrimoireInterface from "./Interface/GrimoireInterface";
  2 | import GomlLoader from "./Node/GomlLoader";
  3 | 
  4 | interface IGrimoireWindow extends Window {
  5 |   GrimoireJS: typeof GrimoireInterface;
  6 |   gr?: typeof GrimoireInterface;
  7 | }
  8 | 
  9 | /**
 10 |  * Provides procedures for initializing.
 11 |  */
 12 | class GrimoireInitializer {
 13 | 
 14 |   /**
 15 |    * Start initializing
 16 |    * @return {Promise<void>} The promise which will be resolved when all of the Goml script was loaded.
 17 |    */
 18 |   public static async initialize(): Promise<void> {
 19 |     try {
 20 |       GrimoireInitializer._notifyLibraryLoadingToWindow();
 21 |       GrimoireInitializer._copyGLConstants();
 22 |       GrimoireInterface.initialize();
 23 |       await GrimoireInitializer._waitForDOMLoading();
 24 |       await GrimoireInitializer._waitForPluginLoadingSuspendPromise();
 25 |       GrimoireInitializer._logVersions();
 26 |       await GrimoireInterface.resolvePlugins();
 27 |       await GomlLoader.loadForPage();
 28 |     } catch (e) {
 29 |       console.error(e);
 30 |     }
 31 |   }
 32 | 
 33 |   /**
 34 |    * Ensure WebGLRenderingContext.[CONSTANTS] is exisiting.
 35 |    * Some of the browsers contains them in prototype.
 36 |    */
 37 |   private static _copyGLConstants(): void {
 38 |     if (WebGLRenderingContext.ONE) {
 39 |       // Assume the CONSTANTS are already in WebGLRenderingContext
 40 |       // Chrome,Firefox,IE,Edge...
 41 |       return;
 42 |     }
 43 |     // Otherwise like ""Safari""
 44 |     for (let propName in WebGLRenderingContext.prototype) {
 45 |       if (/^[A-Z]/.test(propName)) {
 46 |         const property = (<any>WebGLRenderingContext.prototype)[propName];
 47 |         (<any>WebGLRenderingContext)[propName] = property;
 48 |       }
 49 |     }
 50 |   }
 51 | 
 52 |   /**
 53 |    * Obtain the promise object which will be resolved when DOMContentLoaded event was rised.
 54 |    * @return {Promise<void>} the promise
 55 |    */
 56 |   private static _waitForDOMLoading(): Promise<void> {
 57 |     return new Promise<void>((resolve) => {
 58 |       if (document.readyState === "loading") {
 59 |         window.addEventListener("DOMContentLoaded", () => {
 60 |           resolve();
 61 |         });
 62 |       } else {
 63 |         resolve();
 64 |       }
 65 |     });
 66 |   }
 67 | 
 68 |   private static _logVersions(): void {
 69 |     const gr = GrimoireInterface;
 70 |     if (!gr.debug) {
 71 |       return;
 72 |     }
 73 |     let log = `%cGrimoire.js v${(gr as any)["__VERSION__"]}\nplugins:\n\n`;
 74 |     let i = 1;
 75 |     for (let key in gr.lib) {
 76 |       const plugin = gr.lib[key];
 77 |       log += `  ${i} : ${plugin.__NAME__ || key}@${plugin.__VERSION__}\n`;
 78 |       i++;
 79 |     }
 80 |     log += `\nTo suppress this message,please inject a line "gr.debug = false;" on the initializing timing.`;
 81 |     console.log(log, "color:#44F;font-weight:bold;");
 82 |   }
 83 | 
 84 |   private static _notifyLibraryLoadingToWindow(): void {
 85 |     window.postMessage({
 86 |       $source: "grimoirejs",
 87 |       $messageType: "library-loading"
 88 |     }, "*");
 89 |   }
 90 | 
 91 |   private static async _waitForPluginLoadingSuspendPromise(): Promise<void> {
 92 |     if (!GrimoireInterface.libraryPreference) {
 93 |       return;
 94 |     }
 95 |     await (GrimoireInterface.libraryPreference["postponeLoading"] as Promise<void>);
 96 |   }
 97 | }
 98 | 
 99 | /**
100 |  * Just start the process.
101 |  */
102 | export default function (): typeof GrimoireInterface {
103 |   const gwin = window as IGrimoireWindow;
104 |   if (gwin.GrimoireJS) {
105 |     GrimoireInterface.libraryPreference = gwin.GrimoireJS;
106 |   }
107 |   GrimoireInterface.noConflictPreserve = gwin.gr;
108 |   gwin.gr = gwin.GrimoireJS = GrimoireInterface;
109 |   GrimoireInitializer.initialize();
110 |   return GrimoireInterface;
111 | }
112 | 


--------------------------------------------------------------------------------
/src/static/color.json:
--------------------------------------------------------------------------------
  1 | {
  2 | 	"aliceblue": "#F0F8FF",
  3 | 	"antiquewhite": "#FAEBD7",
  4 | 	"aqua": "#00FFFF",
  5 | 	"aquamarine": "#7FFFD4",
  6 | 	"azure": "#F0FFFF",
  7 | 	"beige": "#F5F5DC",
  8 | 	"bisque": "#FFE4C4",
  9 | 	"black": "#000000",
 10 | 	"blanchedalmond": "#FFEBCD",
 11 | 	"blue": "#0000FF",
 12 | 	"blueviolet": "#8A2BE2",
 13 | 	"brown": "#A52A2A",
 14 | 	"burlywood": "#DEB887",
 15 | 	"cadetblue": "#5F9EA0",
 16 | 	"chartreuse": "#7FFF00",
 17 | 	"chocolate": "#D2691E",
 18 | 	"coral": "#FF7F50",
 19 | 	"cornflowerblue": "#6495ED",
 20 | 	"cornsilk": "#FFF8DC",
 21 | 	"crimson": "#DC143C",
 22 | 	"cyan": "#00FFFF",
 23 | 	"darkblue": "#00008B",
 24 | 	"darkcyan": "#008B8B",
 25 | 	"darkgoldenrod": "#B8860B",
 26 | 	"darkgray": "#A9A9A9",
 27 | 	"darkgreen": "#006400",
 28 | 	"darkgrey": "#A9A9A9",
 29 | 	"darkkhaki": "#BDB76B",
 30 | 	"darkmagenta": "#8B008B",
 31 | 	"darkolivegreen": "#556B2F",
 32 | 	"darkorange": "#FF8C00",
 33 | 	"darkorchid": "#9932CC",
 34 | 	"darkred": "#8B0000",
 35 | 	"darksalmon": "#E9967A",
 36 | 	"darkseagreen": "#8FBC8F",
 37 | 	"darkslateblue": "#483D8B",
 38 | 	"darkslategray": "#2F4F4F",
 39 | 	"darkslategrey": "#2F4F4F",
 40 | 	"darkturquoise": "#00CED1",
 41 | 	"darkviolet": "#9400D3",
 42 | 	"deeppink": "#FF1493",
 43 | 	"deepskyblue": "#00BFFF",
 44 | 	"dimgray": "#696969",
 45 | 	"dimgrey": "#696969",
 46 | 	"dodgerblue": "#1E90FF",
 47 | 	"firebrick": "#B22222",
 48 | 	"floralwhite": "#FFFAF0",
 49 | 	"forestgreen": "#228B22",
 50 | 	"fuchsia": "#FF00FF",
 51 | 	"gainsboro": "#DCDCDC",
 52 | 	"ghostwhite": "#F8F8FF",
 53 | 	"gold": "#FFD700",
 54 | 	"goldenrod": "#DAA520",
 55 | 	"gray": "#808080",
 56 | 	"green": "#008000",
 57 | 	"greenyellow": "#ADFF2F",
 58 | 	"grey": "#808080",
 59 | 	"honeydew": "#F0FFF0",
 60 | 	"hotpink": "#FF69B4",
 61 | 	"indianred": "#CD5C5C",
 62 | 	"indigo": "#4B0082",
 63 | 	"ivory": "#FFFFF0",
 64 | 	"khaki": "#F0E68C",
 65 | 	"lavender": "#E6E6FA",
 66 | 	"lavenderblush": "#FFF0F5",
 67 | 	"lawngreen": "#7CFC00",
 68 | 	"lemonchiffon": "#FFFACD",
 69 | 	"lightblue": "#ADD8E6",
 70 | 	"lightcoral": "#F08080",
 71 | 	"lightcyan": "#E0FFFF",
 72 | 	"lightgoldenrodyellow": "#FAFAD2",
 73 | 	"lightgray": "#D3D3D3",
 74 | 	"lightgreen": "#90EE90",
 75 | 	"lightgrey": "#D3D3D3",
 76 | 	"lightpink": "#FFB6C1",
 77 | 	"lightsalmon": "#FFA07A",
 78 | 	"lightseagreen": "#20B2AA",
 79 | 	"lightskyblue": "#87CEFA",
 80 | 	"lightslategray": "#778899",
 81 | 	"lightslategrey": "#778899",
 82 | 	"lightsteelblue": "#B0C4DE",
 83 | 	"lightyellow": "#FFFFE0",
 84 | 	"lime": "#00FF00",
 85 | 	"limegreen": "#32CD32",
 86 | 	"linen": "#FAF0E6",
 87 | 	"magenta": "#FF00FF",
 88 | 	"maroon": "#800000",
 89 | 	"mediumaquamarine": "#66CDAA",
 90 | 	"mediumblue": "#0000CD",
 91 | 	"mediumorchid": "#BA55D3",
 92 | 	"mediumpurple": "#9370DB",
 93 | 	"mediumseagreen": "#3CB371",
 94 | 	"mediumslateblue": "#7B68EE",
 95 | 	"mediumspringgreen": "#00FA9A",
 96 | 	"mediumturquoise": "#48D1CC",
 97 | 	"mediumvioletred": "#C71585",
 98 | 	"midnightblue": "#191970",
 99 | 	"mintcream": "#F5FFFA",
100 | 	"mistyrose": "#FFE4E1",
101 | 	"moccasin": "#FFE4B5",
102 | 	"navajowhite": "#FFDEAD",
103 | 	"navy": "#000080",
104 | 	"oldlace": "#FDF5E6",
105 | 	"olive": "#808000",
106 | 	"olivedrab": "#6B8E23",
107 | 	"orange": "#FFA500",
108 | 	"orangered": "#FF4500",
109 | 	"orchid": "#DA70D6",
110 | 	"palegoldenrod": "#EEE8AA",
111 | 	"palegreen": "#98FB98",
112 | 	"paleturquoise": "#AFEEEE",
113 | 	"palevioletred": "#DB7093",
114 | 	"papayawhip": "#FFEFD5",
115 | 	"peachpuff": "#FFDAB9",
116 | 	"peru": "#CD853F",
117 | 	"pink": "#FFC0CB",
118 | 	"plum": "#DDA0DD",
119 | 	"powderblue": "#B0E0E6",
120 | 	"purple": "#800080",
121 | 	"red": "#FF0000",
122 | 	"rosybrown": "#BC8F8F",
123 | 	"royalblue": "#4169E1",
124 | 	"saddlebrown": "#8B4513",
125 | 	"salmon": "#FA8072",
126 | 	"sandybrown": "#F4A460",
127 | 	"seagreen": "#2E8B57",
128 | 	"seashell": "#FFF5EE",
129 | 	"sienna": "#A0522D",
130 | 	"silver": "#C0C0C0",
131 | 	"skyblue": "#87CEEB",
132 | 	"slateblue": "#6A5ACD",
133 | 	"slategray": "#708090",
134 | 	"slategrey": "#708090",
135 | 	"snow": "#FFFAFA",
136 | 	"springgreen": "#00FF7F",
137 | 	"steelblue": "#4682B4",
138 | 	"tan": "#D2B48C",
139 | 	"teal": "#008080",
140 | 	"thistle": "#D8BFD8",
141 | 	"tomato": "#FF6347",
142 | 	"turquoise": "#40E0D0",
143 | 	"violet": "#EE82EE",
144 | 	"wheat": "#F5DEB3",
145 | 	"white": "#FFFFFF",
146 | 	"whitesmoke": "#F5F5F5",
147 | 	"yellow": "#FFFF00",
148 | 	"yellowgreen": "#9ACD32"
149 | }
150 | 


--------------------------------------------------------------------------------
/test/@/GrimoireInterfaceTest.ts:
--------------------------------------------------------------------------------
  1 | import "../AsyncSupport";
  2 | import "../XMLDomInit";
  3 | import xmldom from "xmldom";
  4 | import test from "ava";
  5 | import sinon from "sinon";
  6 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
  7 | import Constants from "../../src/Base/Constants";
  8 | import Component from "../../src/Node/Component";
  9 | import GomlParser from "../../src/Node/GomlParser";
 10 | import GomlLoader from "../../src/Node/GomlLoader";
 11 | import NSIdentity from "../../src/Base/NSIdentity";
 12 | import Namespace from "../../src/Base/Namespace";
 13 | import GomlNode from "../../src/Node/GomlNode";
 14 | 
 15 | declare namespace global {
 16 |   let Node: any;
 17 |   let document: any;
 18 | }
 19 | 
 20 | global.Node = {
 21 |   ELEMENT_NODE: 1
 22 | };
 23 | global.document = new DOMParser().parseFromString("<html></html>", "text/html");
 24 | 
 25 | 
 26 | test.beforeEach(() => {
 27 |   GrimoireInterface.clear();
 28 |   GrimoireInterface.resolvePlugins();
 29 | });
 30 | 
 31 | test("ns method should generate namespace generating function correctly", (t) => {
 32 |   const g = Namespace.define("grimoire");
 33 |   t.truthy(g.for("test").fqn === "grimoire.test");
 34 | });
 35 | 
 36 | test("registerComponent works correctly", (t) => {
 37 |   const l = GrimoireInterface.componentDeclarations.toArray().length;
 38 |   const dec = GrimoireInterface.registerComponent("Name", {
 39 |     attributes: {
 40 |       attr: { converter: "String", default: "aaa" }
 41 |     }
 42 |   });
 43 |   t.truthy(dec.attributes["attr"].default === "aaa");
 44 |   t.truthy(GrimoireInterface.componentDeclarations.toArray().length === l + 1);
 45 |   t.throws(() => {
 46 |     GrimoireInterface.registerComponent("Name", {
 47 |       attributes: {
 48 |         attr: { converter: "String", default: undefined }
 49 |       }
 50 |     });
 51 |   });
 52 | 
 53 |   class Hoo {
 54 |     public static attributes = {
 55 | 
 56 |     };
 57 |   }
 58 |   t.throws(() => {
 59 |     GrimoireInterface.registerComponent("Name", Hoo); // because not extends Component.
 60 |   });
 61 | });
 62 | 
 63 | test("registerComponent by object works correctly", async (t) => {
 64 |   const defaultComponentCount = GrimoireInterface.componentDeclarations.toArray().length;
 65 |   GrimoireInterface.registerComponent("Aaa", {
 66 |     attributes: {
 67 |       testValue: {
 68 |         converter: "String",
 69 |         default: "bbb"
 70 |       },
 71 |       testOverride: {
 72 |         converter: "String",
 73 |         default: "bbb"
 74 |       }
 75 |     },
 76 |     hoge: 0,
 77 |     $test: function() {
 78 |       this.hoge += 1;
 79 |     }
 80 |   });
 81 | 
 82 |   const aaa = GrimoireInterface.componentDeclarations.get("Aaa");
 83 |   t.truthy(GrimoireInterface.componentDeclarations.toArray().length === defaultComponentCount + 1);
 84 |   t.truthy(aaa.attributes.testValue);
 85 |   t.truthy(aaa.isDependenyResolved); // because no inherits.
 86 |   const aaa2 = aaa.generateInstance();
 87 |   const aaa22 = aaa.generateInstance();
 88 |   t.truthy(aaa2 instanceof Component);
 89 |   t.truthy(aaa2.attributes.get("testValue"));
 90 |   t.truthy(aaa2.enabled);
 91 |   t.truthy(aaa22.enabled);
 92 |   aaa2.enabled = false;
 93 |   t.truthy(!aaa2.enabled);
 94 |   t.truthy(aaa22.enabled);
 95 |   (aaa2 as any).$test();
 96 |   t.truthy((aaa2 as any).hoge === 1);
 97 |   t.truthy((aaa22 as any).hoge === 0);
 98 |   GrimoireInterface.registerComponent("Bbb", {
 99 |     attributes: {
100 |       testValue2: {
101 |         converter: "String",
102 |         default: "ccc"
103 |       },
104 |       testOverride: {
105 |         converter: "String",
106 |         default: "ccc"
107 |       }
108 |     },
109 |     $test2: function() {
110 |       // do nothing.
111 |     }
112 |   }, "Aaa");
113 |   t.truthy(GrimoireInterface.componentDeclarations.toArray().length === defaultComponentCount + 2);
114 |   const bbb = GrimoireInterface.componentDeclarations.get("Bbb");
115 | 
116 |   t.truthy(!bbb.isDependenyResolved); // because bbb is inherits Aaa.
117 |   await GrimoireInterface.resolvePlugins();
118 |   t.truthy(bbb.isDependenyResolved);
119 | 
120 |   t.truthy(bbb.attributes.testValue); // from Aaa
121 |   t.truthy(bbb.attributes.testValue2); // from Bbb
122 |   t.truthy(bbb.attributes.testOverride.default === "ccc"); // override attribute with inherits correctly.
123 | 
124 |   const bbb2 = bbb.generateInstance();
125 |   t.truthy(bbb2.attributes.get("testValue")); // inherits attr from Aaa
126 |   t.truthy(bbb2.attributes.get("testValue2")); // attr defined by Bbb
127 |   t.truthy((bbb2 as any).$test);
128 |   t.truthy((bbb2 as any).$test2);
129 | });
130 | test("registerComponent by class works correctly", async (t) => {
131 |   const defaultComponentCount = GrimoireInterface.componentDeclarations.toArray().length;
132 | 
133 |   class Aaa extends Component {
134 |     public static attributes = {
135 |       testValue: {
136 |         converter: "String",
137 |         default: "bbb"
138 |       },
139 |       testOverride: {
140 |         converter: "String",
141 |         default: "bbb"
142 |       }
143 |     };
144 |     public hoge = 0;
145 |     public $test() {
146 |       this.hoge += 1;
147 |     }
148 |     public overridedFunc() {
149 |       return this.hoge;
150 |     }
151 |   }
152 |   class Bbb extends Component {
153 |     public static attributes = {
154 |       testValue2: {
155 |         converter: "String",
156 |         default: "ccc"
157 |       },
158 |       testOverride: {
159 |         converter: "String",
160 |         default: "ccc"
161 |       }
162 |     };
163 |     public fuga = 7;
164 |     public $test2() {
165 |       return this.fuga;
166 |     }
167 |     public overridedFunc() {
168 |       return this.$test2();
169 |     }
170 |   }
171 | 
172 |   GrimoireInterface.registerComponent("Aaa", Aaa);
173 |   const aaa = GrimoireInterface.componentDeclarations.get("Aaa");
174 |   t.truthy(GrimoireInterface.componentDeclarations.toArray().length === defaultComponentCount + 1);
175 |   t.truthy(aaa.attributes.testValue);
176 |   t.truthy(aaa.isDependenyResolved); // because no inherits.
177 |   const aaa2 = aaa.generateInstance();
178 |   const aaa22 = aaa.generateInstance();
179 |   t.truthy(aaa2 instanceof Component);
180 |   t.truthy(aaa2.attributes.get("testValue"));
181 |   t.truthy(aaa2.enabled);
182 |   t.truthy(aaa22.enabled);
183 |   aaa2.enabled = false;
184 |   t.truthy(!aaa2.enabled);
185 |   t.truthy(aaa22.enabled);
186 |   (aaa2 as any).$test();
187 |   t.truthy((aaa2 as any).hoge === 1);
188 |   t.truthy((aaa22 as any).hoge === 0);
189 | 
190 |   GrimoireInterface.registerComponent("Bbb", Bbb, "Aaa");
191 |   t.truthy(GrimoireInterface.componentDeclarations.toArray().length === defaultComponentCount + 2);
192 |   const bbb = GrimoireInterface.componentDeclarations.get("Bbb");
193 | 
194 |   t.truthy(!bbb.isDependenyResolved);
195 |   await GrimoireInterface.resolvePlugins();
196 |   t.truthy(bbb.isDependenyResolved);
197 | 
198 |   const bbb2 = bbb.generateInstance();
199 |   t.truthy(bbb2.attributes.get("testValue"));
200 |   t.truthy(bbb2.attributes.get("testValue2"));
201 |   t.truthy(bbb2.attributes.get("testOverride"));
202 |   t.truthy(bbb.attributes.testValue);
203 |   t.truthy(bbb.attributes.testValue2);
204 |   t.truthy(bbb.attributes.testOverride.default === "ccc");
205 |   t.truthy((bbb2 as any).$test);
206 |   t.truthy((bbb2 as any).$test2);
207 |   t.truthy((bbb2 as any).fuga === 7);
208 |   t.truthy((bbb2 as any).hoge === 0);
209 |   (bbb2 as any).$test();
210 |   t.truthy((bbb2 as any).hoge === 1);
211 | 
212 |   t.truthy((bbb2 as any).overridedFunc() === 7);
213 | });
214 | test("registerComponent works correctly4", async (t) => {
215 |   const defaultComponentCount = GrimoireInterface.componentDeclarations.toArray().length;
216 |   class Aaa extends Component {
217 |     public static attributes: { [key: string]: any } = {
218 |       testValue: {
219 |         converter: "String",
220 |         default: "bbb"
221 |       },
222 |       testOverride: {
223 |         converter: "String",
224 |         default: "bbb"
225 |       }
226 |     };
227 |     public hoge = 0;
228 |     public $test() {
229 |       this.hoge += 1;
230 |     }
231 |   }
232 |   class Bbb2 extends Aaa {
233 |     public static attributes = {
234 |       testValue2: {
235 |         converter: "String",
236 |         default: "bbb"
237 |       },
238 |       testOverride: {
239 |         converter: "String",
240 |         default: "ccc"
241 |       }
242 |     };
243 |     public fuga = 7;
244 |     public $test2() {
245 |       // do nothing.
246 |     }
247 |   }
248 |   GrimoireInterface.registerComponent("Aaa", Aaa);
249 | 
250 |   const aaa = GrimoireInterface.componentDeclarations.get("Aaa");
251 |   t.truthy(GrimoireInterface.componentDeclarations.toArray().length === defaultComponentCount + 1);
252 |   t.truthy(aaa.attributes.testValue);
253 |   t.truthy(aaa.isDependenyResolved); // because no inherits.
254 |   const aaa2 = aaa.generateInstance();
255 |   const aaa22 = aaa.generateInstance();
256 |   t.truthy(aaa2 instanceof Component);
257 |   t.truthy(aaa2.attributes.get("testValue"));
258 |   t.truthy(aaa2.enabled);
259 |   t.truthy(aaa22.enabled);
260 |   aaa2.enabled = false;
261 |   t.truthy(!aaa2.enabled);
262 |   t.truthy(aaa22.enabled);
263 |   (aaa2 as any).$test();
264 |   t.truthy((aaa2 as any).hoge === 1);
265 |   t.truthy((aaa22 as any).hoge === 0);
266 | 
267 |   GrimoireInterface.registerComponent("Bbb", Bbb2);
268 |   t.truthy(GrimoireInterface.componentDeclarations.toArray().length === defaultComponentCount + 2);
269 |   const bbb = GrimoireInterface.componentDeclarations.get("Bbb");
270 |   await GrimoireInterface.resolvePlugins();
271 |   t.truthy(aaa.isDependenyResolved);
272 |   t.truthy(bbb.isDependenyResolved);
273 |   const bbb2 = bbb.generateInstance();
274 |   t.truthy(bbb2.attributes.get("testValue"));
275 |   t.truthy(bbb.attributes.testValue);
276 |   t.truthy(bbb.attributes.testValue2);
277 |   t.truthy(bbb.attributes.testOverride.default === "ccc");
278 |   t.truthy((bbb2 as any).$test);
279 |   t.truthy((bbb2 as any).$test2);
280 |   t.truthy((bbb2 as any).fuga === 7);
281 |   t.truthy((bbb2 as any).hoge === 0);
282 |   (bbb2 as any).$test();
283 |   t.truthy((bbb2 as any).hoge === 1);
284 | });
285 | test("registerNode/Component works correctly.", async t => {
286 |   GrimoireInterface.registerNode("a1");
287 |   GrimoireInterface.registerNode("a2", ["Hoge"]);
288 |   GrimoireInterface.registerNode("a3", [], { hoge: 7 }, "a2");
289 |   GrimoireInterface.registerComponent("Hoge", {
290 |     attributes: {
291 |       hoge: {
292 |         converter: "Number",
293 |         default: 9
294 |       }
295 |     }
296 |   });
297 |   await GrimoireInterface.resolvePlugins();
298 |   let a1 = GrimoireInterface.nodeDeclarations.get("a1");
299 |   let a2 = GrimoireInterface.nodeDeclarations.get("a2");
300 |   let a3 = GrimoireInterface.nodeDeclarations.get("a3");
301 |   t.truthy(a1.defaultComponentsActual.toArray().length === 1); // grimoireCompone
302 |   t.truthy(a2.defaultComponentsActual.toArray().length === 2); // grimoireCompone
303 |   t.truthy(a3.defaultComponentsActual.toArray().length === 2); // grimoireCompone
304 | 
305 |   // console.log(a2.idResolver)
306 |   t.truthy(a2.idResolver.resolve(Namespace.define("hoge")) === "grimoirejs.Hoge.hoge");
307 |   t.truthy(a3.idResolver.resolve(Namespace.define("hoge")) === "grimoirejs.Hoge.hoge");
308 | });
309 | test("throw error on attempt registerComponent/Node by duplicate name.", t => {
310 |   GrimoireInterface.registerComponent("Aaa", { attributes: {} });
311 |   GrimoireInterface.registerNode("node");
312 |   t.throws(() => {
313 |     GrimoireInterface.registerComponent("Aaa", {} as any);
314 |   });
315 |   t.throws(() => {
316 |     GrimoireInterface.registerNode("node");
317 |   });
318 | });
319 | 
320 | test("register and resolvePlugins works preperly", async () => {
321 |   const spy1 = sinon.spy();
322 |   const spy2 = sinon.spy();
323 |   const wrapPromise: any = function(spy) {
324 |     return () => {
325 |       return new Promise(resolve => {
326 |         spy();
327 |         resolve(null);
328 |       });
329 |     };
330 |   };
331 |   const spyp = wrapPromise(spy1);
332 |   const spyp2 = wrapPromise(spy2);
333 |   GrimoireInterface.register(spyp);
334 |   GrimoireInterface.register(spyp2);
335 |   await GrimoireInterface.resolvePlugins();
336 |   sinon.assert.callOrder(spy1, spy2);
337 | });
338 | 


--------------------------------------------------------------------------------
/test/AsyncSupport.ts:
--------------------------------------------------------------------------------
1 | const rr = require("regenerator-runtime");
2 | const __awaiter = require("typescript-awaiter");
3 | global["__awaiter"] = __awaiter;
4 | global["regeneratorRuntime"] = rr;
5 | 


--------------------------------------------------------------------------------
/test/Base/AttributeManagerTest.ts:
--------------------------------------------------------------------------------
 1 | import "../XMLDomInit";
 2 | import test from "ava";
 3 | import Ensure from "../../src/Base/Ensure";
 4 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
 5 | import NSDictionary from "../../src/Base/NSDictionary";
 6 | import AttributeManager from "../../src/Base/AttributeManager";
 7 | import NSIdentity from "../../src/Base/NSIdentity";
 8 | import Constants from "../../src/Base/Constants";
 9 | import Attribute from "../../src/Node/Attribute";
10 | import sinon from "sinon";
11 | 
12 | const genAttr: (name: NSIdentity, watch?: Function | undefined) => Attribute = (name, watch) => {
13 |   return { name: name, watch: watch, Value: "value of " + name } as Attribute;
14 | };
15 | 
16 | const ns1 = NSIdentity.fromFQN("aaa");
17 | const ns2 = NSIdentity.fromFQN("ns.bbb");
18 | const ns3 = NSIdentity.fromFQN("ns.hoge.ccc");
19 | 
20 | const genAM = () => {
21 |   const am = new AttributeManager("tag");
22 |   am.addAttribute(genAttr(ns1, new Function()));
23 |   am.addAttribute(genAttr(ns2, new Function()));
24 |   am.addAttribute(genAttr(ns3, new Function()));
25 |   return am;
26 | };
27 | 
28 | test("test", (t) => {
29 |   const am = genAM();
30 |   let count = 0;
31 |   for (let key in am["_attributesFQNMap"]) {
32 |     count += am["_attributesFQNMap"][key].length;
33 |   }
34 |   t.truthy(count === 3);
35 |   t.truthy(!!am.getAttribute(ns1.name));
36 | });
37 | 
38 | test("test addAttribute", (t) => {
39 |   const am = genAM();
40 |   let l = 0;
41 |   for (let key in am["_attributesFQNMap"]) {
42 |     l += am["_attributesFQNMap"][key].length;
43 |   }
44 |   am.addAttribute(genAttr(ns1));
45 |   let count = 0;
46 |   for (let key in am["_attributesFQNMap"]) {
47 |     count += am["_attributesFQNMap"][key].length;
48 |   }
49 |   t.truthy(count === l + 1);
50 |   am.addAttribute(genAttr(ns1));
51 |   count = 0;
52 |   for (let key in am["_attributesFQNMap"]) {
53 |     count += am["_attributesFQNMap"][key].length;
54 |   }
55 |   t.truthy(count === l + 2);
56 | });
57 | 
58 | test("test watch", () => {
59 |   const am = genAM();
60 |   const spy1 = sinon.spy();
61 |   const spy2 = sinon.spy();
62 |   am.addAttribute(genAttr(NSIdentity.fromFQN("hoge.aaa"), () => {
63 |     spy1("watch");
64 |   }));
65 |   am.addAttribute(genAttr(NSIdentity.fromFQN("hoge.aaa"), () => {
66 |     spy2("watch");
67 |   }));
68 |   am.watch(NSIdentity.guess("hoge.aaa"), (a, b, c) => { /*do nothing*/ });
69 |   sinon.assert.called(spy1);
70 |   sinon.assert.called(spy2);
71 | });
72 | 
73 | test("test set/getAttribute", (t) => {
74 |   const am = genAM();
75 |   am.setAttribute("aaa", "hoge");
76 |   t.truthy(am.getAttribute("aaa") === "hoge");
77 |   am.addAttribute(genAttr(NSIdentity.fromFQN("hoge.aaa")));
78 |   t.throws(() => {
79 |     am.getAttribute("aaa");
80 |   });
81 | });
82 | 


--------------------------------------------------------------------------------
/test/Base/EnsureTest.ts:
--------------------------------------------------------------------------------
 1 | import "../XMLDomInit";
 2 | import test from "ava";
 3 | import Ensure from "../../src/Base/Ensure";
 4 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
 5 | import NSDictionary from "../../src/Base/NSDictionary";
 6 | import NSIdentity from "../../src/Base/NSIdentity";
 7 | import Namespace from "../../src/Base/Namespace";
 8 | 
 9 | test.beforeEach(() => {
10 |   NSIdentity.clear();
11 | });
12 | 
13 | test("Ensure passed argument should be transformed as NSIdentity", (t) => {
14 |   NSIdentity.fromFQN("grimoirejs.HELLO");
15 |   t.truthy(Ensure.tobeNSIdentity("HELLO").fqn === "grimoirejs.HELLO");
16 |   t.truthy(Ensure.tobeNSIdentity(Namespace.define("test").for("WORLD")).fqn === "test.WORLD");
17 | });
18 | 
19 | test("Ensure passed argument are transformed into number", (t) => {
20 |   t.truthy(Ensure.tobeNumber("9") === 9);
21 |   t.truthy(Ensure.tobeNumber(9) === 9);
22 |   let a: any = () => {/*do nothing*/ };
23 |   t.throws(() => Ensure.tobeNumber(a));
24 | });
25 | 
26 | test("Ensure passed argument are transformed into string", (t) => {
27 |   t.truthy(Ensure.tobeString("9") === "9");
28 |   t.truthy(Ensure.tobeString(9) === "9");
29 |   let a: any = () => {/*do nothing*/ };
30 |   t.throws(() => Ensure.tobeString(a));
31 | });
32 | 
33 | test("Ensure passed array are transformed into NSIdentity[]", (t) => {
34 |   let transformed = Ensure.tobeNSIdentityArray(undefined);
35 |   const g = Namespace.define("test");
36 |   t.truthy(transformed.length === 0);
37 |   NSIdentity.fromFQN("HELLO");
38 |   NSIdentity.fromFQN("grimoire.WORLD");
39 |   transformed = Ensure.tobeNSIdentityArray(["HELLO", "WORLD"]);
40 |   t.truthy(transformed[0].fqn === "HELLO");
41 |   t.truthy(transformed[1].fqn === "grimoire.WORLD");
42 |   transformed = Ensure.tobeNSIdentityArray(["HELLO", g.for("WORLD")]);
43 |   t.truthy(transformed[0].fqn === "HELLO");
44 |   t.truthy(transformed[1].fqn === "test.WORLD");
45 | });
46 | 
47 | test("Ensure passed object are transformed into NSDictionary", (t) => {
48 |   let transformed = Ensure.tobeNSDictionary(void 0);
49 |   t.truthy(transformed instanceof NSDictionary);
50 |   let obj = {};
51 |   obj[NSIdentity.fromFQN("Hello").fqn] = "test1";
52 |   obj[NSIdentity.fromFQN("World").fqn] = "test2";
53 |   transformed = Ensure.tobeNSDictionary(obj);
54 |   t.truthy(transformed instanceof NSDictionary);
55 |   t.truthy(transformed.get("Hello") === "test1");
56 |   t.truthy(transformed.get("World") === "test2");
57 | });
58 | 
59 | test("Ensure name tobe fqn if name start with _", t => {
60 |   t.truthy(Ensure.tobeFQN("aaa") == null);
61 |   t.truthy(Ensure.tobeFQN("_aaa") == "aaa");
62 |   t.truthy(Ensure.tobeFQN("aaa.fff") == null);
63 |   t.truthy(Ensure.tobeFQN("_aaa.fff") == "aaa.fff");
64 |   t.truthy(Ensure.tobeFQN(NSIdentity.fromFQN("aaa.bbb")) == "aaa.bbb");
65 |   t.truthy(Ensure.tobeFQN(NSIdentity.fromFQN("aaa")) == "aaa");
66 | })
67 | 


--------------------------------------------------------------------------------
/test/Base/IdResolverTest.ts:
--------------------------------------------------------------------------------
 1 | import test from "ava";
 2 | import "../AsyncSupport";
 3 | import "../XMLDomInit";
 4 | import xmldom from "xmldom";
 5 | import sinon from "sinon";
 6 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
 7 | import Constants from "../../src/Base/Constants";
 8 | import Component from "../../src/Node/Component";
 9 | import GomlParser from "../../src/Node/GomlParser";
10 | import GomlLoader from "../../src/Node/GomlLoader";
11 | import GomlNode from "../../src/Node/GomlNode";
12 | import NSIdentity from "../../src/Base/NSIdentity";
13 | import Namespace from "../../src/Base/Namespace";
14 | import IdResolver from "../../src/Base/IdResolver";
15 | 
16 | 
17 | test("get() works correctly.", t => {
18 |   let r = new IdResolver();
19 |   r.add(NSIdentity.fromFQN("c.b.a"));
20 |   t.truthy(r.get(Namespace.define("a")).length === 1);
21 |   t.truthy(r.get(Namespace.define("b.a")).length === 1);
22 |   t.truthy(r.get(Namespace.define("c.a")).length === 1);
23 |   t.truthy(r.get(Namespace.define("c.b.a")).length === 1);
24 | });
25 | 
26 | test("Not accept to get invalid name or namespace", (t) => {
27 |   let r = new IdResolver();
28 | 
29 |   r.add(NSIdentity.fromFQN("a"));
30 |   r = new IdResolver();
31 | 
32 |   // console.log("a");
33 |   t.truthy(r.add(NSIdentity.fromFQN("a")));
34 |   t.truthy(r.count === 1);
35 |   t.truthy(!r.add(NSIdentity.fromFQN("a")));
36 |   t.truthy(r.count === 1);
37 |   // console.log("f");
38 |   r.add(Namespace.define("z").for("b"));
39 |   r.add(Namespace.define("y.b").hierarchy);
40 |   r.add(NSIdentity.fromFQN("c"));
41 |   t.truthy(r.count === 4);
42 |   t.truthy(r.get(Namespace.define("a")).length === 1);
43 |   t.truthy(r.get(Namespace.define("b")).length === 2);
44 | 
45 |   let id = NSIdentity.fromFQN("a.b.c");
46 |   t.truthy(id.name === "c");
47 |   t.truthy(id.ns.qualifiedName === "a.b");
48 |   id = NSIdentity.guess("b.c");
49 |   t.truthy(id.fqn === "a.b.c");
50 | 
51 | 
52 | });
53 | 
54 | test("Not accept to get invalid name or namespace", (t) => {
55 |   let r = new IdResolver();
56 |   // console.log(r);
57 |   r.add(NSIdentity.fromFQN("a"));
58 |   r.add(NSIdentity.fromFQN("hoge.b"));
59 |   r.add(NSIdentity.fromFQN("hage.huga.c"));
60 |   r.add(NSIdentity.fromFQN("hage.a"));
61 |   t.truthy(r.get(Namespace.define("a")).length === 2);
62 | 
63 | });
64 | 
65 | test("resolve works correctly", (t) => {
66 |   let r = new IdResolver();
67 |   r.add(NSIdentity.fromFQN("hoge.a"));
68 |   r.add(NSIdentity.fromFQN("hoge.b"));
69 |   r.add(NSIdentity.fromFQN("hage.huga.c"));
70 |   r.add(NSIdentity.fromFQN("hage.huga.a"));
71 |   t.truthy(r.get(Namespace.define("a")).length === 2);
72 |   t.truthy(r.get(Namespace.define("b")).length === 1);
73 |   t.truthy(r.resolve(Namespace.define("c")) === "hage.huga.c");
74 | 
75 | });
76 | 


--------------------------------------------------------------------------------
/test/Base/NSIdentityTest.ts:
--------------------------------------------------------------------------------
 1 | import test from "ava";
 2 | import "../AsyncSupport";
 3 | import "../XMLDomInit";
 4 | import xmldom from "xmldom";
 5 | import sinon from "sinon";
 6 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
 7 | import Constants from "../../src/Base/Constants";
 8 | import Component from "../../src/Node/Component";
 9 | import GomlParser from "../../src/Node/GomlParser";
10 | import GomlLoader from "../../src/Node/GomlLoader";
11 | import GomlNode from "../../src/Node/GomlNode";
12 | 
13 | import NSIdentity from "../../src/Base/NSIdentity";
14 | 
15 | test.beforeEach(() => {
16 |   NSIdentity.clear();
17 | });
18 | 
19 | test("Not accept to get invalid name or namespace", (t) => {
20 |   NSIdentity.fromFQN("hoge");
21 |   NSIdentity.fromFQN("a.b");
22 |   t.throws(() => {
23 |     NSIdentity.guess("aaa");
24 |   });
25 |   t.throws(() => {
26 |     NSIdentity.guess("b", "a");
27 |   });
28 |   t.throws(() => {
29 |     NSIdentity.guess("Wrongamespace", "WrongName");
30 |   });
31 |   t.notThrows(() => {
32 |     NSIdentity.guess("hoge");
33 |   });
34 |   t.notThrows(() => {
35 |     NSIdentity.guess("a", "b");
36 |   });
37 |   t.notThrows(() => {
38 |     NSIdentity.guess("b");
39 |   });
40 | });
41 | 
42 | test("Transform name and ns correctly", (t) => {
43 |   const i = NSIdentity.fromFQN("ns.Sample");
44 |   t.truthy(i.name === "Sample");
45 |   t.truthy(i.ns.qualifiedName === "ns");
46 | });
47 | 


--------------------------------------------------------------------------------
/test/Base/NamespaceTest.ts:
--------------------------------------------------------------------------------
 1 | import test from "ava";
 2 | import "../AsyncSupport";
 3 | import "../XMLDomInit";
 4 | import xmldom from "xmldom";
 5 | import sinon from "sinon";
 6 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
 7 | import Constants from "../../src/Base/Constants";
 8 | import Component from "../../src/Node/Component";
 9 | import GomlParser from "../../src/Node/GomlParser";
10 | import GomlLoader from "../../src/Node/GomlLoader";
11 | import GomlNode from "../../src/Node/GomlNode";
12 | import Namespace from "../../src/Base/Namespace";
13 | 
14 | test("constructor is works correctly.", (t) => {
15 |   let ns = Namespace.define("a").extend("b");
16 |   t.truthy(ns.qualifiedName === "a.b");
17 |   t.truthy(ns.hierarchy.length === 2);
18 | 
19 |   ns = Namespace.define("a", "b", "c");
20 |   t.truthy(ns.hierarchy.length === 3);
21 |   t.truthy(ns.qualifiedName === "a.b.c");
22 | 
23 |   let ns2 = ns.for("name");
24 |   t.truthy(ns2.fqn === "a.b.c.name");
25 | });
26 | 


--------------------------------------------------------------------------------
/test/Base/NamespacedDictionaryTest.ts:
--------------------------------------------------------------------------------
  1 | import "../AsyncSupport";
  2 | import "../XMLDomInit";
  3 | import test from "ava";
  4 | import sinon from "sinon";
  5 | import xhrmock from "xhr-mock";
  6 | import GomlLoader from "../../src/Node/GomlLoader";
  7 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
  8 | import NodeInterface from "../../src/Interface/NodeInterface";
  9 | import NSIdentity from "../../src/Base/NSIdentity";
 10 | import NSDictionary from "../../src/Base/NSDictionary";
 11 | import fs from "../fileHelper";
 12 | const xml = fs.readFile("../_TestResource/NSDictionary_QueryDOM.xml");
 13 | 
 14 | test.beforeEach(() => {
 15 |   NSIdentity.clear();
 16 | });
 17 | 
 18 | test("set element correctly", (t) => {
 19 |   const newKey = NSIdentity.fromFQN("hoge.test");
 20 |   const value = "Grimoire";
 21 |   const theDict = new NSDictionary();
 22 |   theDict.set(newKey, value);
 23 |   t.truthy(theDict.get("test") === value);
 24 |   t.truthy(theDict.get("hoge.test") === value);
 25 |   t.truthy(theDict.get("false") == null);
 26 | });
 27 | 
 28 | test("set element correctly when dupelicated name was given", (t) => {
 29 |   const newKey = NSIdentity.fromFQN("test");
 30 |   const secoundKey = NSIdentity.fromFQN("ns.test");
 31 |   const v1 = "gr1";
 32 |   const v2 = "gr2";
 33 |   const theDict = new NSDictionary();
 34 |   theDict.set(newKey, v1);
 35 |   theDict.set(secoundKey, v2);
 36 |   t.truthy(theDict.get(newKey) === v1);
 37 |   t.truthy(theDict.get(secoundKey) === v2);
 38 |   t.throws(() => theDict.get("test"));
 39 |   t.truthy(theDict.get("ns.test") === v2);
 40 | });
 41 | 
 42 | test("element should be repalaced when dupelicated fqn was given", (t) => {
 43 |   const newKey = NSIdentity.fromFQN("test");
 44 |   const secoundKey = NSIdentity.fromFQN("Test");
 45 |   const theDict = new NSDictionary();
 46 |   theDict.set(newKey, "test1");
 47 |   theDict.set(secoundKey, "test2");
 48 |   t.truthy(theDict.get(newKey) === "test1");
 49 |   t.truthy(theDict.get(secoundKey) === "test2");
 50 | });
 51 | 
 52 | test("get element with strict name", async (t) => {
 53 |   const newKey = NSIdentity.fromFQN("test");
 54 |   const secoundKey = NSIdentity.fromFQN("test.test");
 55 |   const theDict = new NSDictionary();
 56 |   theDict.set(newKey, "test1");
 57 |   theDict.set(secoundKey, "test2");
 58 |   const domParser = new DOMParser();
 59 | 
 60 |   const parsed = domParser.parseFromString(xml, "text/xml");
 61 |   const idElement = parsed.getElementById("test");
 62 |   const attr = idElement.getAttributeNode("d:test");
 63 |   t.truthy(theDict.get("test.test") === "test2");
 64 |   t.throws(() => theDict.get("test"));
 65 |   t.truthy(theDict.get(idElement) === "test2");
 66 |   t.truthy(theDict.get(secoundKey) === "test2");
 67 |   t.truthy(theDict.get(newKey) === "test1");
 68 |   t.truthy(theDict.get(attr) === "test2");
 69 | });
 70 | 
 71 | test("get element with shortened namespace prefix", async (t) => {
 72 |   const newKey = NSIdentity.fromFQN("test");
 73 |   const secoundKey = NSIdentity.fromFQN("grimoirejs.test");
 74 |   const theDict = new NSDictionary();
 75 |   theDict.set(newKey, "test1");
 76 |   theDict.set(secoundKey, "test2");
 77 |   const domParser = new DOMParser();
 78 |   const parsed = domParser.parseFromString(xml, "text/xml");
 79 |   const idElement = parsed.getElementById("test2");
 80 |   const attr = idElement.attributes.item(1);
 81 |   t.throws(() => {
 82 |     theDict.get(idElement);
 83 |   });
 84 |   t.throws(() => {
 85 |     theDict.get(attr);
 86 |   });
 87 | });
 88 | test("get element with shortened namespace prefix", async (t) => {
 89 |   const newKey = NSIdentity.fromFQN("test");
 90 |   const theDict = new NSDictionary();
 91 |   theDict.set(newKey, "test");
 92 |   const domParser = new DOMParser();
 93 |   const parsed = domParser.parseFromString(xml, "text/xml");
 94 |   const idElement = parsed.getElementById("test2");
 95 |   const attr = idElement.attributes.item(1);
 96 |   t.truthy(theDict.get(idElement) === "test");
 97 |   t.truthy(theDict.get(attr) === "test");
 98 | });
 99 | 
100 | test("get element with fuzzy name", async (t) => {
101 |   const secoundKey = NSIdentity.fromFQN("grimoirejs.test");
102 |   const theDict = new NSDictionary();
103 |   theDict.set(secoundKey, "test2");
104 |   const domParser = new DOMParser();
105 |   const parsed = domParser.parseFromString(xml, "text/xml");
106 |   const idElement = parsed.getElementById("test2");
107 |   const attr = idElement.attributes.item(1);
108 | 
109 |   t.truthy(theDict.get(idElement) === "test2");
110 |   t.truthy(theDict.get("test") === "test2");
111 |   t.truthy(theDict.get(attr) === "test2");
112 | });
113 | 
114 | test("get element with ambiguous name should throw error", async (t) => {
115 |   const newKey = NSIdentity.fromFQN("AATEST.test");
116 |   const secoundKey = NSIdentity.fromFQN("AATEST2.test");
117 |   const theDict = new NSDictionary();
118 |   theDict.set(newKey, "test1");
119 |   theDict.set(secoundKey, "test2");
120 |   const domParser = new DOMParser();
121 |   const parsed = domParser.parseFromString(xml, "text/xml");
122 |   const idElement = parsed.getElementById("test2");
123 |   const attr = idElement.attributes.item(1);
124 |   t.throws(() => {
125 |     theDict.get(idElement);
126 |   });
127 |   t.throws(() => {
128 |     theDict.get(attr);
129 |   });
130 | });
131 | 


--------------------------------------------------------------------------------
/test/Base/UtilityTest.ts:
--------------------------------------------------------------------------------
 1 | import "../XMLDomInit";
 2 | import test from "ava";
 3 | import Utility from "../../src/Base/Utility";
 4 | 
 5 | test("isCamelCase works correctly.", t => {
 6 |   t.truthy(Utility.isCamelCase("NameName123"));
 7 |   t.truthy(Utility.isCamelCase("N"));
 8 |   t.truthy(!Utility.isCamelCase("nameName"));
 9 |   t.truthy(!Utility.isCamelCase("Name_Name"));
10 |   t.truthy(!Utility.isCamelCase("1nameName"));
11 | });
12 | 
13 | test("isSnakeCase works correctly.", t => {
14 |   t.truthy(Utility.isSnakeCase("name-name-123"));
15 |   t.truthy(Utility.isSnakeCase("nm"));
16 |   t.truthy(Utility.isSnakeCase("--"));
17 |   t.truthy(!Utility.isSnakeCase("nameName"));
18 |   t.truthy(!Utility.isSnakeCase("Name_Name"));
19 |   t.truthy(!Utility.isSnakeCase("1nameName"));
20 | });
21 | 


--------------------------------------------------------------------------------
/test/Base/XMLReaderTest.ts:
--------------------------------------------------------------------------------
 1 | import "../XMLDomInit";
 2 | import test from "ava";
 3 | import xmldom from "xmldom";
 4 | import XMLReader from "../../src/Base/XMLReader";
 5 | import fs from "../fileHelper";
 6 | 
 7 | const xml = fs.readFile("../_TestResource/XMLReader_Case1.xml");
 8 | 
 9 | test("parseXML behaves correctly", t => {
10 |   const parsedDocument = XMLReader.parseXML(xml, "Goml");
11 |   t.truthy(parsedDocument[0].localName === "goml");
12 |   t.throws(() => {
13 |     XMLReader.parseXML(">", "Goml");
14 |   });
15 | });
16 | 


--------------------------------------------------------------------------------
/test/Converters/StringConverterTest.ts:
--------------------------------------------------------------------------------
1 | import test from "ava";
2 | import StringConverter from "../../src/Converters/StringConverter";
3 | 
4 | test("StringConverter should convert collectly", t => {
5 |   t.truthy(StringConverter("HELLO") === "HELLO");
6 | });
7 | 


--------------------------------------------------------------------------------
/test/Interfaces/NodeInterfaceTest.ts:
--------------------------------------------------------------------------------
  1 | import "../AsyncSupport";
  2 | import "../XMLDomInit";
  3 | import test from "ava";
  4 | import sinon from "sinon";
  5 | import xmldom from "xmldom";
  6 | import xhrmock from "xhr-mock";
  7 | import * as _ from "lodash";
  8 | import {
  9 |   goml,
 10 |   stringConverter,
 11 |   testComponent1,
 12 |   testComponent2,
 13 |   testComponent3,
 14 |   testComponentBase,
 15 |   testComponentOptional,
 16 |   testNode1,
 17 |   testNode2,
 18 |   testNode3,
 19 |   testNodeBase,
 20 |   conflictNode1,
 21 |   conflictNode2,
 22 |   conflictComponent1,
 23 |   conflictComponent2
 24 | } from "../Node/GomlParserTest_Registering";
 25 | import GomlLoader from "../../src/Node/GomlLoader";
 26 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
 27 | import fs from "../fileHelper";
 28 | 
 29 | const testcase1_goml = fs.readFile("../_TestResource/GomlNodeTest_Case1.goml");
 30 | const testcase1_html = fs.readFile("../_TestResource/GomlNodeTest_Case1.html");
 31 | 
 32 | xhrmock.setup();
 33 | xhrmock.get("./GomlNodeTest_Case1.goml", (req, res) => {
 34 |   return res.status(200).body(testcase1_goml);
 35 | });
 36 | 
 37 | let stringConverterSpy,
 38 |   testComponent1Spy,
 39 |   testComponent2Spy,
 40 |   testComponent3Spy,
 41 |   testComponentBaseSpy,
 42 |   testComponentOptionalSpy,
 43 |   conflictComponent1Spy,
 44 |   conflictComponent2Spy;
 45 | 
 46 | function resetSpies() {
 47 |   stringConverterSpy.reset();
 48 |   testComponent1Spy.reset();
 49 |   testComponent2Spy.reset();
 50 |   testComponent3Spy.reset();
 51 |   testComponentBaseSpy.reset();
 52 |   testComponentOptionalSpy.reset();
 53 |   conflictComponent1Spy.reset();
 54 |   conflictComponent2Spy.reset();
 55 | }
 56 | declare namespace global {
 57 |   let document: any;
 58 |   let Node: any;
 59 | }
 60 | 
 61 | test.beforeEach(async () => {
 62 |   GrimoireInterface.clear();
 63 |   const parser = new DOMParser();
 64 |   const htmlDoc = parser.parseFromString(testcase1_html, "text/html");
 65 |   global.document = htmlDoc;
 66 |   global.document.querySelectorAll = function(selector) {
 67 |     return global.document.getElementsByTagName("script");
 68 |   };
 69 |   global.Node = {
 70 |     ELEMENT_NODE: 1
 71 |   };
 72 |   goml();
 73 |   testNode1();
 74 |   testNode2();
 75 |   testNode3();
 76 |   testNodeBase();
 77 |   conflictNode1();
 78 |   conflictNode2();
 79 |   stringConverterSpy = stringConverter();
 80 |   testComponent1Spy = testComponent1();
 81 |   testComponent2Spy = testComponent2();
 82 |   testComponent3Spy = testComponent3();
 83 |   testComponentBaseSpy = testComponentBase();
 84 |   testComponentOptionalSpy = testComponentOptional();
 85 |   conflictComponent1Spy = conflictComponent1();
 86 |   conflictComponent2Spy = conflictComponent2();
 87 |   await GrimoireInterface.resolvePlugins();
 88 |   await GomlLoader.loadForPage();
 89 |   global["rootNode"] = _.values(GrimoireInterface.rootNodes)[0];
 90 |   global["rootNode"].element.ownerDocument = global["document"];
 91 | });
 92 | 
 93 | test("count first single.", (t) => {
 94 |   const ni = GrimoireInterface("script")("goml");
 95 |   // console.log(ni.nodes)
 96 |   // t.truthy(ni.count() === 1);
 97 |   // t.truthy(ni.first());
 98 |   t.truthy(true);
 99 | 
100 | });
101 | 


--------------------------------------------------------------------------------
/test/JsDOMAsync.ts:
--------------------------------------------------------------------------------
1 | const jsdom = require("jsdom");
2 | const {JSDOM} = jsdom;
3 | export default function(html: string, arr: any): Promise<any> {
4 |   return Promise.resolve((new JSDOM(html)).window);
5 | }
6 | 


--------------------------------------------------------------------------------
/test/Node/GomlLoaderTest.ts:
--------------------------------------------------------------------------------
  1 | import "../AsyncSupport";
  2 | import "../XMLDomInit";
  3 | import prequire from "proxyquire";
  4 | import jsdomAsync from "../JsDOMAsync";
  5 | import test from "ava";
  6 | import sinon from "sinon";
  7 | import xhrmock from "xhr-mock";
  8 | import XMLReader from "../../src/Base/XMLReader";
  9 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
 10 | import GomlParser from "../../src/Node/GomlParser";
 11 | import fs from "../fileHelper";
 12 | import {
 13 |   goml,
 14 |   stringConverter,
 15 |   testComponent1,
 16 |   testComponent2,
 17 |   testComponent3,
 18 |   testComponentBase,
 19 |   testComponentOptional,
 20 |   testNode1,
 21 |   testNode2,
 22 |   testNode3,
 23 |   testNodeBase,
 24 |   conflictNode1,
 25 |   conflictNode2,
 26 |   conflictComponent1,
 27 |   conflictComponent2
 28 | } from "./GomlParserTest_Registering";
 29 | 
 30 | declare namespace global {
 31 |   let Node: any;
 32 |   let document: any;
 33 | }
 34 | 
 35 | const testcase1_html = fs.readFile("../_TestResource/GomlLoaderTest_Case1.html");
 36 | const testcase2_html = fs.readFile("../_TestResource/GomlLoaderTest_Case2.html");
 37 | const testcase3_html = fs.readFile("../_TestResource/GomlLoaderTest_Case3.html");
 38 | const testcase4_html = fs.readFile("../_TestResource/GomlLoaderTest_Case4.html");
 39 | 
 40 | 
 41 | 
 42 | xhrmock.setup();
 43 | xhrmock.get("http://grimoire.gl/index.goml", (req, res) => {
 44 |   return res.status(200).body("<goml>\n</goml>");
 45 | });
 46 | xhrmock.get("http://grimoire.gl/index2.goml", (req, res) => {
 47 |   return res.status(200).body("<goml>\n</goml>");
 48 | });
 49 | xhrmock.get("http://grimoire.gl/index3.goml", (req, res) => {
 50 |   return res.status(200).body("<goml>\n</goml>");
 51 | });
 52 | 
 53 | function mockXMLParse(func) {
 54 |   return prequire("../../src/Node/GomlLoader", {
 55 |     "../Base/XMLReader": {
 56 |       default: {
 57 |         parseXML: (srcHtml) => {
 58 |           func(srcHtml);
 59 |           return XMLReader.parseXML(srcHtml);
 60 |         }
 61 |       }
 62 |     }
 63 |   }).default;
 64 | }
 65 | 
 66 | test.beforeEach(async () => {
 67 |   GrimoireInterface.clear();
 68 |   global.Node = {
 69 |     ELEMENT_NODE: 1
 70 |   };
 71 |   goml();
 72 |   testNode1();
 73 |   testNode2();
 74 |   testComponent1();
 75 |   testComponent2();
 76 |   testNodeBase();
 77 |   testComponentBase();
 78 | 
 79 |   await GrimoireInterface.resolvePlugins();
 80 | });
 81 | 
 82 | test("Processing script[type=\"text/goml\"] tag correctly when the text content was existing", async (t) => {
 83 |   const window = await jsdomAsync(testcase1_html, []);
 84 |   global.document = window.document;
 85 |   const scriptTags = window.document.querySelectorAll("script[type=\"text/goml\"]");
 86 |   const spy = sinon.spy();
 87 |   const mockedParseXML = mockXMLParse(xml => {
 88 |     spy(xml.replace(/[\n\s]/g, ""));
 89 |   });
 90 |   await mockedParseXML.loadFromScriptTag(scriptTags.item(0));
 91 |   t.truthy(spy.calledWith(`<goml><goml><goml></goml><goml/></goml></goml>`));
 92 | });
 93 | 
 94 | test("Processing script[type=\"text/goml\"] and call parse related methods in correct order", async (t) => {
 95 |   const src = testcase1_html;
 96 |   const window = await jsdomAsync(src, []);
 97 |   global.document = window.document;
 98 |   const scriptTags = window.document.querySelectorAll("script[type=\"text/goml\"]");
 99 |   const spy = sinon.spy();
100 |   const mockedParseXML = mockXMLParse(xml => {
101 |     spy(xml.replace(/[\n\s]/g, ""));
102 |   });
103 |   await mockedParseXML.loadFromScriptTag(scriptTags.item(0));
104 |   t.truthy(spy.calledWith(`<goml><goml><goml></goml><goml/></goml></goml>`));
105 | });
106 | 
107 | test("Processing script[type=\"text/goml\"] tag correctly when the src attribute was existing", async (t) => {
108 |   const src = testcase2_html;
109 |   const window = await jsdomAsync(src, []);
110 |   global.document = window.document;
111 |   const scriptTags = window.document.querySelectorAll("script[type=\"text/goml\"]");
112 |   const spy = sinon.spy();
113 |   const mockedParseXML = mockXMLParse(xml => {
114 |     spy(xml.replace(/[\n\s]/g, ""));
115 |   });
116 | 
117 |   await mockedParseXML.loadFromScriptTag(scriptTags.item(0));
118 |   t.truthy(spy.calledWith(`<goml></goml>`));
119 | });
120 | 
121 | test("Processing goml scripts from query", async (t) => {
122 |   const src = testcase3_html;
123 |   const window = await jsdomAsync(src, []);
124 |   global.document = window.document;
125 |   const spy = sinon.spy();
126 |   const mockedParseXML = mockXMLParse(xml => {
127 |     spy(xml.trim());
128 |   });
129 |   await mockedParseXML.loadFromQuery("script.call");
130 |   t.truthy(spy.calledWith("<goml>\n</goml>"));
131 | });
132 | 
133 | test("Processing goml scripts for page", async (t) => {
134 |   const src = testcase4_html;
135 |   const window = await jsdomAsync(src, []);
136 |   global.document = window.document;
137 |   const spy = sinon.spy();
138 |   const mockedParseXML = mockXMLParse(xml => {
139 |     spy(xml.trim());
140 |   });
141 |   await mockedParseXML.loadForPage();
142 |   t.truthy(spy.calledWith("<goml>\n</goml>"));
143 | });
144 | 


--------------------------------------------------------------------------------
/test/Node/GomlNodeTest.ts:
--------------------------------------------------------------------------------
  1 | import "../AsyncSupport";
  2 | import "../XMLDomInit";
  3 | import xmldom from "xmldom";
  4 | import test from "ava";
  5 | import sinon from "sinon";
  6 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
  7 | import Constants from "../../src/Base/Constants";
  8 | import Component from "../../src/Node/Component";
  9 | import GomlParser from "../../src/Node/GomlParser";
 10 | import GomlLoader from "../../src/Node/GomlLoader";
 11 | import NSIdentity from "../../src/Base/NSIdentity";
 12 | import GomlNode from "../../src/Node/GomlNode";
 13 | import Attribute from "../../src/Node/Attribute";
 14 | 
 15 | declare namespace global {
 16 |   let Node: any;
 17 |   let document: any;
 18 |   let rootNode: any;
 19 | }
 20 | 
 21 | global.Node = {
 22 |   ELEMENT_NODE: 1
 23 | };
 24 | 
 25 | test.beforeEach(async () => {
 26 |   GrimoireInterface.clear();
 27 |   const parser = new DOMParser();
 28 |   const htmlDoc = parser.parseFromString("<html></html>", "text/html");
 29 |   global.document = htmlDoc;
 30 |   GrimoireInterface.registerNode("goml");
 31 |   GrimoireInterface.registerNode("scenes");
 32 |   GrimoireInterface.registerNode("scene");
 33 |   GrimoireInterface.registerComponent("Test", { attributes: {}, valueTest: "Test"});
 34 |   GrimoireInterface.registerComponent("Test2", { attributes: {}, valueTest: "Test2"});
 35 |   await GrimoireInterface.resolvePlugins();
 36 | });
 37 | 
 38 | test("Add component works correctly", t => {
 39 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
 40 |   node.addComponent("Test");
 41 |   node.addComponent("Test2");
 42 |   node.addComponent("Test");
 43 |   t.truthy(node.getComponents("Test").length === 2);
 44 |   t.truthy(node.getComponents("Test2").length === 1);
 45 |   const a = node.getComponent("Test") as any;
 46 |   t.truthy(a.valueTest === "Test");
 47 |   const b = node.getComponent("Test2") as any;
 48 |   t.truthy(b.valueTest === "Test2");
 49 | });
 50 | 
 51 | test("Remove component actually delete specified insatnce", t => {
 52 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
 53 |   node.addComponent("Test");
 54 |   node.addComponent("Test2");
 55 |   node.addComponent("Test");
 56 |   const a = node.getComponent("Test") as any;
 57 |   node.removeComponent(a);
 58 |   t.truthy(node.getComponent("Test"));
 59 |   t.truthy(node.getComponents("Test").length === 1);
 60 | });
 61 | 
 62 | test("Remove components should delete specified all components in node", t => {
 63 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
 64 |   node.addComponent("Test");
 65 |   node.addComponent("Test");
 66 |   node.addComponent("Test");
 67 |   t.truthy(node.getComponents("Test").length === 3);
 68 |   node.removeComponents("Test");
 69 |   t.truthy(node.getComponents("Test").length === 0);
 70 | });
 71 | 
 72 | test("addChild method works correctly", t => {
 73 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
 74 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
 75 |   node.addChild(node2, null, null);
 76 |   node.addChild(node2, null, null);
 77 |   t.truthy(node.children[0].id === node2.id);
 78 |   t.truthy(node.children.length === 2);
 79 | });
 80 | 
 81 | test("delete method works correctly", t => {
 82 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
 83 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
 84 |   const node3 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scene"), null);
 85 |   node.addChild(node2, null, null);
 86 |   node2.addChild(node3, null, null);
 87 |   node2.remove();
 88 |   t.truthy(node.children.length === 0);
 89 |   t.truthy(node2.parent === null);
 90 |   t.truthy(node2.deleted === true);
 91 |   t.truthy(node3.deleted === true);
 92 |   t.truthy(node3.parent === null);
 93 | });
 94 | 
 95 | test("removeChild method works correctly", t => {
 96 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
 97 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
 98 |   const node3 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scene"), null);
 99 |   node.addChild(node2, null, null);
100 |   node2.addChild(node3, null, null);
101 |   node.removeChild(node2);
102 |   t.truthy(node2.deleted === true);
103 |   t.truthy(node3.deleted === true);
104 | });
105 | 
106 | test("detachChild method works correctly", t => {
107 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
108 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
109 |   const node3 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scene"), null);
110 |   node.addChild(node2, null, null);
111 |   node2.addChild(node3, null, null);
112 |   node.detachChild(node2);
113 |   t.truthy(node.children.length === 0);
114 |   t.truthy(node2.deleted === false);
115 |   t.truthy(node3.parent.id === node2.id);
116 |   t.truthy(node3.deleted === false);
117 | });
118 | 
119 | test("detach method works correctly", t => {
120 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
121 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
122 |   const node3 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scene"), null);
123 |   node.addChild(node2, null, null);
124 |   node2.addChild(node3, null, null);
125 |   node2.detach();
126 |   try {
127 |     node.detach();
128 |   } catch (err) {
129 |     t.truthy(err.message === "root Node cannot be detached.");
130 |   }
131 |   t.truthy(node.children.length === 0);
132 |   t.truthy(node2.deleted === false);
133 |   t.truthy(node3.parent.id === node2.id);
134 |   t.truthy(node3.deleted === false);
135 | });
136 | 
137 | test("getComponents method works correctly", t => {
138 |   GrimoireInterface.registerComponent("TestComponent", {
139 |     attributes: {
140 |       attr1: {
141 |         converter: "String",
142 |         default: "testAttr"
143 |       }
144 |     }
145 | 
146 |   });
147 |   GrimoireInterface.registerNode("test-node", ["TestComponent"]);
148 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("test-node"), null);
149 |   const components = node.getComponents();
150 |   t.truthy(components.length === 2);
151 | });
152 | 
153 | test("setMounted method works correctly", t => {
154 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
155 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
156 |   const node3 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scene"), null);
157 |   node.addChild(node2, null, null);
158 |   node2.addChild(node3, null, null);
159 |   node.setMounted(true);
160 |   t.truthy(node.mounted === true);
161 |   t.truthy(node2.mounted === true);
162 |   t.truthy(node3.mounted === true);
163 | });
164 | test("index method works correctly", t => {
165 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
166 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
167 |   node.addChild(node2);
168 |   t.truthy(node2.index === 0);
169 | });
170 | test("addComponent method works correctly", t => {
171 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
172 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
173 |   node.addChild(node2, null, null);
174 |   GrimoireInterface.registerComponent("TestComponent1", {
175 |     attributes: {
176 |       testAttr1: {
177 |         converter: "String",
178 |         default: "thisistest"
179 |       }
180 |     }
181 |   });
182 |   const component = GrimoireInterface.componentDeclarations.get("TestComponent1").generateInstance();
183 |   node._addComponentDirectly(component, true);
184 |   const components = node.getComponents<Component>();
185 |   t.truthy(components.length === 2);
186 |   t.truthy(components[1].name.name === "TestComponent1");
187 |   t.truthy(component.isDefaultComponent);
188 | });
189 | test("addComponent method works correctly", t => {
190 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
191 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
192 |   node.addChild(node2, null, null);
193 |   GrimoireInterface.registerComponent("TestComponent1", {
194 |     attributes: {
195 |       testAttr1: {
196 |         converter: "String",
197 |         default: "thisistest"
198 |       }
199 |     }
200 |   });
201 |   const component = node.addComponent("TestComponent1", { testAttr1: "testValue" });
202 |   const components = node.getComponents<Component>();
203 |   t.truthy(components.length === 2);
204 |   t.truthy(components[1].name.name === "TestComponent1");
205 |   t.truthy(components[1].getAttribute("testAttr1") === "testValue");
206 |   t.truthy(component.isDefaultComponent === false);
207 | });
208 | test("getComponent method overload works correctly", async t => {
209 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
210 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
211 |   node.addChild(node2, null, null);
212 |   GrimoireInterface.registerComponent("TestComponent1", {
213 |     attributes: {
214 |       testAttr1: {
215 |         converter: "String",
216 |         default: "thisistest"
217 |       }
218 |     }
219 |   });
220 |   GrimoireInterface.registerComponent("TestComponent2", {
221 |     attributes: {
222 |       testAttr1: {
223 |         converter: "String",
224 |         default: "thisistest"
225 |       }
226 |     }
227 |   }, "TestComponent1");
228 |   await GrimoireInterface.resolvePlugins();
229 | 
230 |   node.addComponent("TestComponent2");
231 |   t.truthy(node.getComponent<Component>("TestComponent2").name.name === "TestComponent2");
232 |   t.truthy(node.getComponent<Component>("TestComponent1").name.name === "TestComponent2");
233 | });
234 | test("getComponents method overload works correctly", t => {
235 |   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
236 |   const node2 = new GomlNode(GrimoireInterface.nodeDeclarations.get("scenes"), null);
237 |   node.addChild(node2, null, null);
238 |   GrimoireInterface.registerComponent("TestComponent1", {
239 |     attributes: {
240 |       testAttr1: {
241 |         converter: "String",
242 |         default: "thisistest"
243 |       }
244 |     }
245 |   });
246 |   GrimoireInterface.registerComponent("TestComponent2", {
247 |     attributes: {
248 |       testAttr1: {
249 |         converter: "String",
250 |         default: "thisistest"
251 |       }
252 |     }
253 |   });
254 |   node.addComponent("TestComponent1");
255 |   node.addComponent("TestComponent2");
256 |   const components = node.getComponents();
257 |   t.truthy(components.length === 3);
258 | });
259 | // test("addAttribute method works correctly", t => {
260 | //   const node = new GomlNode(GrimoireInterface.nodeDeclarations.get("goml"), null);
261 | //   GrimoireInterface.registerComponent("TestComponent1", {
262 | //     attributes: {
263 | //       testAttr1: {
264 | //         converter: "String",
265 | //         default: "thisistest"
266 | //       }
267 | //     }
268 | //   });
269 | //   const component = GrimoireInterface.componentDeclarations.get("TestComponent1").generateInstance();
270 | //   const attr = new Attribute("testAttr", {
271 | //     converter: "String",
272 | //     default: "thisistest"
273 | //   }, component);
274 | // });
275 | 


--------------------------------------------------------------------------------
/test/Node/GomlParserTest.ts:
--------------------------------------------------------------------------------
  1 | require("babel-polyfill");
  2 | import "../XMLDomInit";
  3 | import test from "ava";
  4 | import sinon from "sinon";
  5 | import GomlParser from "../../src/Node/GomlParser";
  6 | import xmldom from "xmldom";
  7 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
  8 | import NSIdentity from "../../src/Base/NSIdentity";
  9 | import Namespace from "../../src/Base/Namespace";
 10 | import fs from "../fileHelper";
 11 | import {
 12 |   goml,
 13 |   stringConverter,
 14 |   testComponent1,
 15 |   testComponent2,
 16 |   testComponentBase,
 17 |   testComponentOptional,
 18 |   testNode1,
 19 |   testNode2,
 20 |   testNodeBase,
 21 |   conflictNode1,
 22 |   conflictNode2,
 23 |   conflictComponent1,
 24 |   conflictComponent2
 25 | } from "./GomlParserTest_Registering";
 26 | 
 27 | declare namespace global {
 28 |   let Node: any;
 29 |   let document: any;
 30 |   let rootNode: any;
 31 | }
 32 | 
 33 | 
 34 | // Get element from test case source which is located with relative path.
 35 | function obtainElementTag(path) {
 36 |   const DOMParser = xmldom.DOMParser;
 37 |   global.Node = {
 38 |     ELEMENT_NODE: 1
 39 |   };
 40 |   const parser = new DOMParser();
 41 |   return parser.parseFromString(fs.readFile(path), "text/xml").documentElement;
 42 | }
 43 | 
 44 | let stringConverterSpy,
 45 |   testComponent1Spy,
 46 |   testComponent2Spy,
 47 |   testComponentBaseSpy,
 48 |   testComponentOptionalSpy,
 49 |   conflictComponent1Spy,
 50 |   conflictComponent2Spy;
 51 | 
 52 | test.beforeEach(async () => {
 53 |   GrimoireInterface.clear();
 54 |   const parser = new DOMParser();
 55 |   const htmlDoc = parser.parseFromString("<html></html>", "text/html");
 56 |   global.document = htmlDoc;
 57 |   goml();
 58 |   testNode1();
 59 |   testNode2();
 60 |   testNodeBase();
 61 |   conflictNode1();
 62 |   conflictNode2();
 63 |   stringConverterSpy = stringConverter();
 64 |   testComponent1Spy = testComponent1();
 65 |   testComponent2Spy = testComponent2();
 66 |   testComponentBaseSpy = testComponentBase();
 67 |   testComponentOptionalSpy = testComponentOptional();
 68 |   conflictComponent1Spy = conflictComponent1();
 69 |   conflictComponent2Spy = conflictComponent2();
 70 |   registerUserPlugin();
 71 |   await GrimoireInterface.resolvePlugins();
 72 | });
 73 | 
 74 | const gomlParserTestCasePath1 = "../_TestResource/GomlParserTest_Case1.goml";
 75 | const gomlParserTestCasePath2 = "../_TestResource/GomlParserTest_Case2.goml";
 76 | const gomlParserTestCasePath3 = "../_TestResource/GomlParserTest_Case3.goml";
 77 | const gomlParserTestCasePath4 = "../_TestResource/GomlParserTest_Case4.goml";
 78 | 
 79 | 
 80 | function registerUserPlugin() {
 81 |   GrimoireInterface.registerNode("scenes");
 82 |   GrimoireInterface.registerNode("scene");
 83 | }
 84 | 
 85 | test("aaa", t => {
 86 |   GrimoireInterface.nodeDeclarations.forEach(nm => {
 87 |     t.truthy(nm.resolvedDependency);
 88 |   });
 89 | });
 90 | test("bbb", async t => {
 91 |   await GrimoireInterface.resolvePlugins();
 92 |   GrimoireInterface.nodeDeclarations.forEach(nm => {
 93 |     t.truthy(nm.resolvedDependency);
 94 |   });
 95 | });
 96 | 
 97 | test("test for parsing node hierarchy.", (t) => {
 98 |   const element = obtainElementTag(gomlParserTestCasePath1);
 99 |   const node = GomlParser.parse(element);
100 |   t.truthy(node.parent === null);
101 |   t.truthy(node.children.length === 1);
102 |   const c = node.children[0];
103 |   t.truthy(c.parent === node);
104 |   t.truthy(c.children.length === 2);
105 |   t.truthy(c.children[0].children.length === 0);
106 |   t.truthy(c.children[0].parent === c);
107 |   t.truthy(c.children[1].children.length === 0);
108 |   t.truthy(c.children[1].parent === c);
109 | });
110 | 
111 | test("test for send/broadcastMessage and component Attribute parsing.", (t) => {
112 |   const element = obtainElementTag(gomlParserTestCasePath2);
113 |   const node = GomlParser.parse(element);
114 |   t.truthy(node.parent === null);
115 |   sinon.assert.notCalled(stringConverterSpy);
116 | });
117 | 
118 | test("test for parse user-define component.", (t) => {
119 |   const element = obtainElementTag(gomlParserTestCasePath3);
120 |   const node = GomlParser.parse(element);
121 |   node.setMounted(true);
122 | 
123 |   t.truthy(node.children.length === 1); // only test-node1
124 |   t.truthy(node.children[0].getAttribute("testAttr1") === "hugahuga"); // goml default
125 |   t.truthy(node.children[0].getAttribute("hoge") === "DEFAULT"); // component default
126 |   t.truthy(node.children[0].children.length === 1);
127 |   t.truthy(node.children[0].children[0].getAttribute("testAttr2") === "123");
128 |   node.broadcastMessage("onTest", "testArg");
129 |   sinon.assert.neverCalledWith(testComponent1Spy, "testArg");
130 |   sinon.assert.neverCalledWith(testComponent2Spy, "testArg");
131 |   sinon.assert.neverCalledWith(testComponentOptionalSpy, "testArg");
132 |   t.truthy("testArg" === testComponentBaseSpy.args[2][1]);
133 | });
134 | 
135 | test("test for namespace parsing.", (t) => {
136 |   const element = obtainElementTag(gomlParserTestCasePath4);
137 |   const node = GomlParser.parse(element);
138 |   node.setMounted(true);
139 |   node.broadcastMessage("onTest", "testArg");
140 |   sinon.assert.calledWith(conflictComponent1Spy, "aaa");
141 |   sinon.assert.calledWith(conflictComponent2Spy, "bbb");
142 | });
143 | 
144 | test("test for companion", (t) => {
145 |   const element = obtainElementTag(gomlParserTestCasePath4);
146 |   const node = GomlParser.parse(element);
147 |   const components = node.children[0].getComponents<any>();
148 |   const ns1 = NSIdentity.fromFQN("test1.ConflictComponent");
149 |   const ns2 = NSIdentity.fromFQN("test2.ConflictComponent");
150 |   const compo1 = components.find((comp) => ns1.fqn === comp.name.fqn);
151 |   const compo2 = components.find((comp) => ns2.fqn === comp.name.fqn);
152 |   t.truthy(compo1.companion === compo2.companion);
153 | });
154 | 
155 | test("treeInterface must be same if the node is included in same tree", (t) => {
156 |   const element = obtainElementTag(gomlParserTestCasePath4);
157 |   const node = GomlParser.parse(element);
158 |   const original = node["_treeInterface"];
159 |   node.callRecursively(v => {
160 |     t.truthy(original === v["_treeInterface"]);
161 |   });
162 | });
163 | 


--------------------------------------------------------------------------------
/test/Node/GomlParserTest_Registering.ts:
--------------------------------------------------------------------------------
  1 | import GrimoireInterface from "../../src/Interface/GrimoireInterface";
  2 | import sinon from "sinon";
  3 | 
  4 | export function testComponent1() {
  5 |   const spy = sinon.spy();
  6 |   GrimoireInterface.registerComponent("TestComponent1", {
  7 |     attributes: {
  8 |       testAttr1: {
  9 |         converter: "Str",
 10 |         default: null
 11 |       },
 12 |       hoge: {
 13 |         converter: "Str",
 14 |         default: "DEFAULT"
 15 |       }
 16 |     },
 17 |     $onTest: function(arg) {
 18 |       spy("onTest", arg);
 19 |     },
 20 |     $mount: function(arg) {
 21 |       spy("mount", arg);
 22 |     },
 23 |     $unmount: function(arg) {
 24 |       spy("unmount", arg);
 25 |     },
 26 |     $awake: function(arg) {
 27 |       spy("awake", arg);
 28 |     }
 29 |   });
 30 |   return spy;
 31 | }
 32 | 
 33 | export function testComponent2() {
 34 |   const spy = sinon.spy();
 35 |   GrimoireInterface.registerComponent("TestComponent2", {
 36 |     attributes: {
 37 |       testAttr2: {
 38 |         converter: "Str",
 39 |         default: "tc2default"
 40 |       }
 41 |     },
 42 |     $onTest: function(arg) {
 43 |       spy("onTest", arg);
 44 |     },
 45 |     $mount: function(arg) {
 46 |       spy("mount", arg);
 47 |     },
 48 |     $unmount: function(arg) {
 49 |       spy("unmount", arg);
 50 |     },
 51 |     $awake: function(arg) {
 52 |       spy("awake", arg);
 53 |     }
 54 |   });
 55 |   return spy;
 56 | }
 57 | 
 58 | export function testComponent3() {
 59 |   const spy = sinon.spy();
 60 |   GrimoireInterface.registerComponent("TestComponent3", {
 61 |     attributes: {
 62 |       testAttr3: {
 63 |         converter: "Str",
 64 |         default: "tc2default"
 65 |       },
 66 |       hogehoge: {
 67 |         converter: "Str",
 68 |         default: "hoge"
 69 |       },
 70 |       hoge: {
 71 |         converter: "Str",
 72 |         default: "hoge"
 73 |       }
 74 |     },
 75 |     $onTest: function(arg) {
 76 |       spy("onTest", arg);
 77 |     },
 78 |     $mount: function(arg) {
 79 |       spy("mount", arg);
 80 |     },
 81 |     $unmount: function(arg) {
 82 |       spy("unmount", arg);
 83 |     },
 84 |     $awake: function(arg) {
 85 |       spy("awake", arg);
 86 |     }
 87 |   });
 88 |   return spy;
 89 | }
 90 | 
 91 | export function testComponentBase() {
 92 |   const spy = sinon.spy();
 93 |   GrimoireInterface.registerComponent("TestComponentBase", {
 94 |     attributes: {
 95 |       inheritAttr: {
 96 |         converter: "Str",
 97 |         default: "base"
 98 |       }
 99 |     },
100 |     $onTest: function(arg) {
101 |       spy("onTest", arg);
102 |     },
103 |     $mount: function(arg) {
104 |       spy("mount", arg);
105 |     },
106 |     $unmount: function(arg) {
107 |       spy("unmount", arg);
108 |     },
109 |     $awake: function(arg) {
110 |       spy("awake", arg);
111 |     }
112 |   });
113 |   return spy;
114 | }
115 | 
116 | export function testComponentOptional() {
117 |   const spy = sinon.spy();
118 |   GrimoireInterface.registerComponent("TestComponentOptional", {
119 |     attributes: {
120 |       value: {
121 |         converter: "Str",
122 |         default: "optional"
123 |       }
124 |     },
125 |     $onTest: function(arg) {
126 |       spy("onTest", arg);
127 |     },
128 |     $mount: function(arg) {
129 |       spy("mount", arg);
130 |     },
131 |     $unmount: function(arg) {
132 |       spy("unmount", arg);
133 |     },
134 |     $awake: function(arg) {
135 |       spy("awake", arg);
136 |     }
137 |   });
138 |   return spy;
139 | }
140 | 
141 | export function conflictComponent1() {
142 |   const spy = sinon.spy();
143 |   const ns = GrimoireInterface.ns("test1");
144 |   GrimoireInterface.registerComponent(ns("ConflictComponent"), {
145 |     attributes: {
146 |       value: {
147 |         converter: "Str",
148 |         default: "aaa"
149 |       }
150 |     },
151 |     $onTest: function() {
152 |       spy(this.attributes.get("value").Value);
153 |     }
154 |   });
155 |   return spy;
156 | }
157 | 
158 | export function conflictComponent2() {
159 |   const spy = sinon.spy();
160 |   const ns = GrimoireInterface.ns("test2");
161 |   GrimoireInterface.registerComponent(ns("ConflictComponent"), {
162 |     attributes: {
163 |       value: {
164 |         converter: "Str",
165 |         default: "bbb"
166 |       }
167 |     },
168 |     $onTest: function() {
169 |       spy(this.attributes.get("value").Value);
170 |     }
171 |   });
172 |   return spy;
173 | }
174 | 
175 | 
176 | 
177 | // Nodes
178 | export function goml() {
179 |   GrimoireInterface.registerNode("goml");
180 | }
181 | 
182 | export function testNode1() {
183 |   GrimoireInterface.registerNode("test-node1", ["TestComponent1"]);
184 | }
185 | 
186 | export function testNode2() {
187 |   GrimoireInterface.registerNode("test-node2", ["TestComponent2"], null, "test-node-base");
188 | }
189 | 
190 | export function testNode3() {
191 |   GrimoireInterface.registerNode("test-node3", ["TestComponent3"], { hoge: "AAA" });
192 | }
193 | 
194 | export function testNodeBase() {
195 |   GrimoireInterface.registerNode("test-node-base", ["TestComponentBase"]);
196 | }
197 | 
198 | export function conflictNode1() {
199 |   const ns = GrimoireInterface.ns("test1");
200 |   GrimoireInterface.registerNode(ns("conflict-node"), ["TestComponent2"], {
201 |     attr1: "nodeA"
202 |   }, null, null);
203 | }
204 | 
205 | export function conflictNode2() {
206 |   const ns = GrimoireInterface.ns("test2");
207 |   GrimoireInterface.registerNode(ns("conflict-node"), ["TestComponent2"], {
208 |     attr1: "nodeB"
209 |   }, null, null);
210 | }
211 | 
212 | 
213 | // Converters
214 | export function stringConverter() {
215 |   const spy = sinon.spy();
216 |   GrimoireInterface.registerConverter("Str", (arg) => {
217 |     spy(arg);
218 |     if (typeof arg === "string" || !arg) {
219 |       return arg;
220 |     }
221 |     throw new Error("Not Implemented:" + arg);
222 |   });
223 |   return spy;
224 | }
225 | 


--------------------------------------------------------------------------------
/test/Node/NamespacedSetTest.ts:
--------------------------------------------------------------------------------
 1 | import "../XMLDomInit";
 2 | import test from "ava";
 3 | import GomlParser from "../../src/Node/GomlParser";
 4 | import xmldom from "xmldom";
 5 | import NSSet from "../../src/Base/NSSet";
 6 | import NSIdentity from "../../src/Base/NSIdentity";
 7 | 
 8 | 
 9 | test("test parse for goml parser", (t) => {
10 |   const name = NSIdentity.fromFQN("namespace1.name1");
11 |   const set = new NSSet();
12 |   set.push(name);
13 |   const array = set.toArray();
14 |   t.truthy(array.length === 1);
15 |   t.truthy(array[0].name === "name1");
16 | });
17 | 


--------------------------------------------------------------------------------
/test/PageLoadingHelper.ts:
--------------------------------------------------------------------------------
 1 | import GrimoireInterface from "../src/Interface/GrimoireInterface";
 2 | import GomlLoader from "../src/Node/GomlLoader";
 3 | import xhrmock from "xhr-mock";
 4 | 
 5 | import {
 6 |   goml,
 7 |   stringConverter,
 8 |   testComponent1,
 9 |   testComponent2,
10 |   testComponent3,
11 |   testComponentBase,
12 |   testComponentOptional,
13 |   testNode1,
14 |   testNode2,
15 |   testNode3,
16 |   testNodeBase,
17 |   conflictNode1,
18 |   conflictNode2,
19 |   conflictComponent1,
20 |   conflictComponent2
21 | } from "./Node/GomlParserTest_Registering";
22 | 
23 | declare namespace global {
24 |   let Node: any;
25 |   let document: any;
26 | }
27 | 
28 | export default class PageLoadingHelper {
29 |   public static async reset(gr: typeof GrimoireInterface, html: string): Promise<any> {
30 |     gr.clear();
31 |     const parser = new DOMParser();
32 |     const htmlDoc = parser.parseFromString(html, "text/html");
33 | 
34 |     global.document = htmlDoc;
35 |     global.document.querySelectorAll = function() {
36 |       return global.document.getElementsByTagName("script");
37 |     };
38 |     global.Node = {
39 |       ELEMENT_NODE: 1
40 |     };
41 |     goml();
42 |     testNode1();
43 |     testNode2();
44 |     testNode3();
45 |     testNodeBase();
46 |     conflictNode1();
47 |     conflictNode2();
48 |     const spys: any = {};
49 |     spys.stringConverterSpy = stringConverter();
50 |     spys.testComponent1Spy = testComponent1();
51 |     spys.testComponent2Spy = testComponent2();
52 |     spys.testComponent3Spy = testComponent3();
53 |     spys.testComponentBaseSpy = testComponentBase();
54 |     spys.testComponentOptionalSpy = testComponentOptional();
55 |     spys.conflictComponent1Spy = conflictComponent1();
56 |     spys.conflictComponent2Spy = conflictComponent2();
57 |     await gr.resolvePlugins();
58 |     await GomlLoader.loadForPage();
59 |     return spys;
60 |   }
61 | 
62 |   public static mockSetup(): void {
63 |     xhrmock.setup();
64 |   }
65 |   public static mock(path: string, content: string): void {
66 |     xhrmock.get(path, (req, res) => {
67 |       let aa = res.status(200).body(content);
68 |       return aa;
69 |     });
70 |   }
71 | }
72 | 


--------------------------------------------------------------------------------
/test/XMLDomInit.ts:
--------------------------------------------------------------------------------
1 | import xmldom from "xmldom";
2 | global["DOMParser"] = xmldom.DOMParser;
3 | 


--------------------------------------------------------------------------------
/test/_TestResource/GomlLoaderTest_Case1.html:
--------------------------------------------------------------------------------
 1 | <!--This template was sited from html5 boilerplate-->
 2 | <!doctype html>
 3 | <html class="no-js" lang="">
 4 |     <head>
 5 |         <meta charset="utf-8">
 6 |         <meta http-equiv="x-ua-compatible" content="ie=edge">
 7 |         <title></title>
 8 |         <meta name="description" content="">
 9 |         <meta name="viewport" content="width=device-width, initial-scale=1">
10 | 
11 |         <link rel="apple-touch-icon" href="apple-touch-icon.png">
12 |         <!-- Place favicon.ico in the root directory -->
13 | 
14 |         <link rel="stylesheet" href="css/normalize.css">
15 |         <link rel="stylesheet" href="css/main.css">
16 |         <script src="js/vendor/modernizr-2.8.3.min.js"></script>
17 |         <script type="text/goml">
18 |         <goml>
19 |           <goml>
20 |             <goml>
21 |             </goml>
22 |             <goml/>
23 |           </goml>
24 |         </goml>
25 |         </script>
26 |     </head>
27 |     <body>
28 |         <!--[if lt IE 8]>
29 |             <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
30 |         <![endif]-->
31 | 
32 |         <!-- Add your site or application content here -->
33 |         <p>Hello world! This is HTML5 Boilerplate.</p>
34 | 
35 |         <script src="https://code.jquery.com/jquery-{{JQUERY_VERSION}}.min.js"></script>
36 |         <script>window.jQuery || document.write('<script src="js/vendor/jquery-{{JQUERY_VERSION}}.min.js"><\/script>')</script>
37 |         <script src="js/plugins.js"></script>
38 |         <script src="js/main.js"></script>
39 | 
40 |         <!-- Google Analytics: change UA-XXXXX-Y to be your site's ID. -->
41 |         <script>
42 |             window.ga=function(){ga.q.push(arguments)};ga.q=[];ga.l=+new Date;
43 |             ga('create','UA-XXXXX-Y','auto');ga('send','pageview')
44 |         </script>
45 |         <script src="https://www.google-analytics.com/analytics.js" async defer></script>
46 |     </body>
47 | 


--------------------------------------------------------------------------------
/test/_TestResource/GomlLoaderTest_Case2.html:
--------------------------------------------------------------------------------
 1 | <!--This template was sited from html5 boilerplate-->
 2 | <!doctype html>
 3 | <html class="no-js" lang="">
 4 |     <head>
 5 |         <meta charset="utf-8">
 6 |         <meta http-equiv="x-ua-compatible" content="ie=edge">
 7 |         <title></title>
 8 |         <meta name="description" content="">
 9 |         <meta name="viewport" content="width=device-width, initial-scale=1">
10 | 
11 |         <link rel="apple-touch-icon" href="apple-touch-icon.png">
12 |         <!-- Place favicon.ico in the root directory -->
13 | 
14 |         <link rel="stylesheet" href="css/normalize.css">
15 |         <link rel="stylesheet" href="css/main.css">
16 |         <script src="js/vendor/modernizr-2.8.3.min.js"></script>
17 |         <script type="text/goml" src="http://grimoire.gl/index.goml"></script>
18 |     </head>
19 |     <body>
20 |         <!--[if lt IE 8]>
21 |             <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
22 |         <![endif]-->
23 | 
24 |         <!-- Add your site or application content here -->
25 |         <p>Hello world! This is HTML5 Boilerplate.</p>
26 | 
27 |         <script src="https://code.jquery.com/jquery-{{JQUERY_VERSION}}.min.js"></script>
28 |         <script>window.jQuery || document.write('<script src="js/vendor/jquery-{{JQUERY_VERSION}}.min.js"><\/script>')</script>
29 |         <script src="js/plugins.js"></script>
30 |         <script src="js/main.js"></script>
31 | 
32 |         <!-- Google Analytics: change UA-XXXXX-Y to be your site's ID. -->
33 |         <script>
34 |             window.ga=function(){ga.q.push(arguments)};ga.q=[];ga.l=+new Date;
35 |             ga('create','UA-XXXXX-Y','auto');ga('send','pageview')
36 |         </script>
37 |         <script src="https://www.google-analytics.com/analytics.js" async defer></script>
38 |     </body>
39 | 


--------------------------------------------------------------------------------
/test/_TestResource/GomlLoaderTest_Case3.html:
--------------------------------------------------------------------------------
 1 | <!--This template was sited from html5 boilerplate-->
 2 | <!doctype html>
 3 | <html class="no-js" lang="">
 4 |     <head>
 5 |         <meta charset="utf-8">
 6 |         <meta http-equiv="x-ua-compatible" content="ie=edge">
 7 |         <title></title>
 8 |         <meta name="description" content="">
 9 |         <meta name="viewport" content="width=device-width, initial-scale=1">
10 | 
11 |         <link rel="apple-touch-icon" href="apple-touch-icon.png">
12 |         <!-- Place favicon.ico in the root directory -->
13 | 
14 |         <link rel="stylesheet" href="css/normalize.css">
15 |         <link rel="stylesheet" href="css/main.css">
16 |         <script src="js/vendor/modernizr-2.8.3.min.js"></script>
17 |         <script class="call" type="text/goml" src="http://grimoire.gl/index.goml"></script>
18 |         <script type="text/goml" src="http://grimoire.gl/index2.goml"></script>
19 |         <script class="call" type="text/goml" src="http://grimoire.gl/index3.goml"></script>
20 |     </head>
21 |     <body>
22 |         <!--[if lt IE 8]>
23 |             <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
24 |         <![endif]-->
25 | 
26 |         <!-- Add your site or application content here -->
27 |         <p>Hello world! This is HTML5 Boilerplate.</p>
28 | 
29 |         <script src="https://code.jquery.com/jquery-{{JQUERY_VERSION}}.min.js"></script>
30 |         <script>window.jQuery || document.write('<script src="js/vendor/jquery-{{JQUERY_VERSION}}.min.js"><\/script>')</script>
31 |         <script src="js/plugins.js"></script>
32 |         <script src="js/main.js"></script>
33 | 
34 |         <!-- Google Analytics: change UA-XXXXX-Y to be your site's ID. -->
35 |         <script>
36 |             window.ga=function(){ga.q.push(arguments)};ga.q=[];ga.l=+new Date;
37 |             ga('create','UA-XXXXX-Y','auto');ga('send','pageview')
38 |         </script>
39 |         <script src="https://www.google-analytics.com/analytics.js" async defer></script>
40 |     </body>
41 | 


--------------------------------------------------------------------------------
/test/_TestResource/GomlLoaderTest_Case4.html:
--------------------------------------------------------------------------------
 1 | <!--This template was sited from html5 boilerplate-->
 2 | <!doctype html>
 3 | <html class="no-js" lang="">
 4 |     <head>
 5 |         <meta charset="utf-8">
 6 |         <meta http-equiv="x-ua-compatible" content="ie=edge">
 7 |         <title></title>
 8 |         <meta name="description" content="">
 9 |         <meta name="viewport" content="width=device-width, initial-scale=1">
10 | 
11 |         <link rel="apple-touch-icon" href="apple-touch-icon.png">
12 |         <!-- Place favicon.ico in the root directory -->
13 | 
14 |         <link rel="stylesheet" href="css/normalize.css">
15 |         <link rel="stylesheet" href="css/main.css">
16 |         <script src="js/vendor/modernizr-2.8.3.min.js"></script>
17 |         <script type="text/goml" src="http://grimoire.gl/index.goml"></script>
18 |         <script type="text/goml" src="http://grimoire.gl/index2.goml"></script>
19 |         <script type="text/goml" src="http://grimoire.gl/index3.goml">
20 |         <goml>
21 |         </goml>
22 |         </script>
23 |         <script type="text/goml">
24 |         <goml>
25 |         </goml>
26 |         </script>
27 | 
28 |     </head>
29 |     <body>
30 |         <!--[if lt IE 8]>
31 |             <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
32 |         <![endif]-->
33 | 
34 |         <!-- Add your site or application content here -->
35 |         <p>Hello world! This is HTML5 Boilerplate.</p>
36 | 
37 |         <script src="https://code.jquery.com/jquery-{{JQUERY_VERSION}}.min.js"></script>
38 |         <script>window.jQuery || document.write('<script src="js/vendor/jquery-{{JQUERY_VERSION}}.min.js"><\/script>')</script>
39 |         <script src="js/plugins.js"></script>
40 |         <script src="js/main.js"></script>
41 | 
42 |         <!-- Google Analytics: change UA-XXXXX-Y to be your site's ID. -->
43 |         <script>
44 |             window.ga=function(){ga.q.push(arguments)};ga.q=[];ga.l=+new Date;
45 |             ga('create','UA-XXXXX-Y','auto');ga('send','pageview')
46 |         </script>
47 |         <script src="https://www.google-analytics.com/analytics.js" async defer></script>
48 |     </body>
49 | 


--------------------------------------------------------------------------------
/test/_TestResource/GomlNodeTest_Case1.goml:
--------------------------------------------------------------------------------
 1 | <goml>
 2 |   <test-node3 id="test" class="classTest" enabled="false">
 3 |     <test-node2 testAttr2="123" inheritAttr="hogehoge">
 4 |       <test-node2.components>
 5 |         <TestComponentOptional value="999"/>
 6 |       </test-node2.components>
 7 |     </test-node2>
 8 |     <test-node1 testAttr1="hugahuga"></test-node1>
 9 |   </test-node3>
10 | </goml>
11 | 


--------------------------------------------------------------------------------
/test/_TestResource/GomlNodeTest_Case1.html:
--------------------------------------------------------------------------------
 1 | <!--This template was sited from html5 boilerplate-->
 2 | <!doctype html>
 3 | <html class="no-js" lang="">
 4 |     <head>
 5 |         <meta charset="utf-8">
 6 |         <meta http-equiv="x-ua-compatible" content="ie=edge">
 7 |         <title></title>
 8 |         <meta name="description" content="">
 9 |         <meta name="viewport" content="width=device-width, initial-scale=1">
10 | 
11 |         <link rel="apple-touch-icon" href="apple-touch-icon.png">
12 |         <!-- Place favicon.ico in the root directory -->
13 | 
14 |         <link rel="stylesheet" href="css/normalize.css">
15 |         <link rel="stylesheet" href="css/main.css">
16 |         <script type="text/goml" src="./GomlNodeTest_Case1.goml"></script>
17 |     </head>
18 |     <body>
19 |         <!--[if lt IE 8]>
20 |             <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
21 |         <![endif]-->
22 | 
23 |         <!-- Add your site or application content here -->
24 |         <p>Hello world! This is HTML5 Boilerplate.</p>
25 | </body>
26 | 


--------------------------------------------------------------------------------
/test/_TestResource/GomlParserTest_Case1.goml:
--------------------------------------------------------------------------------
1 | <goml>
2 |   <goml>
3 |     <goml>
4 |     </goml>
5 |     <goml/>
6 |   </goml>
7 | </goml>
8 | 


--------------------------------------------------------------------------------
/test/_TestResource/GomlParserTest_Case2.goml:
--------------------------------------------------------------------------------
1 | <goml testAttr = "node default Value">
2 |   <goml testAttr = "hogehoge">
3 |   </goml>
4 |   <goml>
5 |   </goml>
6 | </goml>
7 | 


--------------------------------------------------------------------------------
/test/_TestResource/GomlParserTest_Case3.goml:
--------------------------------------------------------------------------------
 1 | <goml>
 2 |   <test-node1 testAttr1 = "hugahuga">
 3 |     <test-node2 testAttr2 = "123" inheritAttr = "hogehoge">
 4 |       <test-node2.components>
 5 |         <TestComponentOptional value="999"/>
 6 |       </test-node2.components>
 7 |     </test-node2>
 8 |   </test-node1>
 9 | </goml>
10 | 


--------------------------------------------------------------------------------
/test/_TestResource/GomlParserTest_Case4.goml:
--------------------------------------------------------------------------------
 1 | <goml xmlns:a="test1" xmlns:b="test2">
 2 |   <a:conflict-node>
 3 |     <conflict-node.components>
 4 |       <a:ConflictComponent/>
 5 |       <b:ConflictComponent/>
 6 |     </conflict-node.components>
 7 |   </a:conflict-node>
 8 |   <b:conflict-node/>
 9 | </goml>
10 | 


--------------------------------------------------------------------------------
/test/_TestResource/GrimoireInterfaceTest_Case1.html:
--------------------------------------------------------------------------------
 1 | <!--This template was sited from html5 boilerplate-->
 2 | <!doctype html>
 3 | <html class="no-js" lang="">
 4 |     <head>
 5 |         <meta charset="utf-8">
 6 |         <meta http-equiv="x-ua-compatible" content="ie=edge">
 7 |         <title></title>
 8 |         <meta name="description" content="">
 9 |         <meta name="viewport" content="width=device-width, initial-scale=1">
10 | 
11 |         <link rel="apple-touch-icon" href="apple-touch-icon.png">
12 |         <!-- Place favicon.ico in the root directory -->
13 | 
14 |         <link rel="stylesheet" href="css/normalize.css">
15 |         <link rel="stylesheet" href="css/main.css">
16 |         <script src="js/vendor/modernizr-2.8.3.min.js"></script>
17 |         <script id="test" type="text/goml">
18 |           <goml>
19 |           <goml id = "testId1"/>
20 |           <goml id = "testId2"/>
21 |           </goml>
22 |         </script>
23 |     </head>
24 |     <body>
25 |         <!--[if lt IE 8]>
26 |             <p class="browserupgrade">You are using an <strong>outdated</strong> browser. Please <a href="http://browsehappy.com/">upgrade your browser</a> to improve your experience.</p>
27 |         <![endif]-->
28 | 
29 |         <!-- Add your site or application content here -->
30 |         <p>Hello world! This is HTML5 Boilerplate.</p>
31 | 
32 |         <script src="https://code.jquery.com/jquery-{{JQUERY_VERSION}}.min.js"></script>
33 |         <script>window.jQuery || document.write('<script src="js/vendor/jquery-{{JQUERY_VERSION}}.min.js"><\/script>')</script>
34 |         <script src="js/plugins.js"></script>
35 |         <script src="js/main.js"></script>
36 | 
37 |         <!-- Google Analytics: change UA-XXXXX-Y to be your site's ID. -->
38 |         <script>
39 |             window.ga=function(){ga.q.push(arguments)};ga.q=[];ga.l=+new Date;
40 |             ga('create','UA-XXXXX-Y','auto');ga('send','pageview')
41 |         </script>
42 |         <script src="https://www.google-analytics.com/analytics.js" async defer></script>
43 |     </body>
44 | 


--------------------------------------------------------------------------------
/test/_TestResource/NSDictionary_QueryDOM.xml:
--------------------------------------------------------------------------------
1 | <root xmlns:d="test">
2 |     <d:test id="test" d:test="test"/>
3 |     <test id="test2" test="test"/>
4 | </root>
5 | 


--------------------------------------------------------------------------------
/test/_TestResource/XMLReader_Case1.xml:
--------------------------------------------------------------------------------
 1 | <goml xmlns="http://grimoire.gl/ns/default">
 2 |   <viewports>
 3 |     <viewport cam=".camera"/>
 4 |   </viewports>
 5 |   <scenes>
 6 |     <scene>
 7 |       <mesh geo="cube"/>
 8 |     </scene>
 9 |   </scenes>
10 | </goml>
11 | 


--------------------------------------------------------------------------------
/test/fileHelper.ts:
--------------------------------------------------------------------------------
1 | const fs = require("fs");
2 | const pathaa = require("path");
3 | 
4 | export default class FileHelper {
5 |   public static readFile(path: string): string {
6 |     return fs.readFileSync(pathaa.join(__dirname, path), "utf8");
7 |   }
8 | }
9 | 


--------------------------------------------------------------------------------
/test/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es6",
 4 |     "module": "es6",
 5 |     "outDir":"../test-lib",
 6 |     "moduleResolution": "node",
 7 |     "allowJs":true,
 8 |     "sourceMap": true
 9 |   },
10 |   "include": [
11 |     "**/*.ts"
12 |   ]
13 | }
14 | 


--------------------------------------------------------------------------------
/tsconfig.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es6",
 4 |     "module": "es6",
 5 |     "declaration": true,
 6 |     "moduleResolution": "node",
 7 |     "outDir": "./lib",
 8 |     "declarationDir": "./ref",
 9 |     "noImplicitReturns": true,
10 |     "noUnusedParameters": true,
11 |     "noUnusedLocals": false,
12 |     "strict": true
13 |   },
14 |   "include": [
15 |     "src/**/*.ts"
16 |   ]
17 | }


--------------------------------------------------------------------------------
/tsconfig.test.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "compilerOptions": {
 3 |     "target": "es6",
 4 |     "module": "es6",
 5 |     "outDir":"./test-lib",
 6 |     "moduleResolution": "node",
 7 |     "inlineSourceMap": true
 8 |   },
 9 |   "include": [
10 |     "src/**/*.ts",
11 |     "test/**/*.ts"
12 |   ]
13 | }
14 | 


--------------------------------------------------------------------------------
/tslint.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "rulesDirectory":[],
 3 |   "rules": {
 4 |     "class-name": true,
 5 |     "comment-format": [true, "check-space"],
 6 |     "curly": true,
 7 |     "eofline": true,
 8 |     "indent": [true, "spaces"],
 9 |     "label-position": true,
10 |     "member-access": true,
11 |     "member-ordering": [true,
12 |       "public-before-private",
13 |       "static-before-instance",
14 |       "variables-before-functions"
15 |     ],
16 |     "no-arg": true,
17 |     "no-console": [true,
18 |       "debug",
19 |       "time",
20 |       "timeEnd",
21 |       "trace"
22 |     ],
23 |     "no-construct": true,
24 |     "no-debugger": true,
25 |     "no-duplicate-variable": true,
26 |     "no-empty": true,
27 |     "no-eval": true,
28 |     "no-inferrable-types": true,
29 |     "no-shadowed-variable": true,
30 |     "no-switch-case-fall-through": true,
31 |     "no-trailing-whitespace": true,
32 |     "no-unused-expression": true,
33 |     "no-use-before-declare": true,
34 |     "no-var-keyword": true,
35 |     "one-line": [true,
36 |       "check-open-brace",
37 |       "check-catch",
38 |       "check-else",
39 |       "check-whitespace"
40 |     ],
41 |     "quotemark": [true, "double", "avoid-escape"],
42 |     "radix": true,
43 |     "semicolon": true,
44 |     "triple-equals": [true, "allow-null-check"],
45 |     "typedef-whitespace": [true, {
46 |       "call-signature": "nospace",
47 |       "index-signature": "nospace",
48 |       "parameter": "nospace",
49 |       "property-declaration": "nospace",
50 |       "variable-declaration": "nospace"
51 |     }],
52 |     "variable-name": false,
53 |     "whitespace": [true,
54 |       "check-branch",
55 |       "check-decl",
56 |       "check-operator",
57 |       "check-separator",
58 |       "check-type"
59 |     ]
60 |   }
61 | }
62 | 


--------------------------------------------------------------------------------
/typedoc.json:
--------------------------------------------------------------------------------
 1 | {
 2 |   "mode": "file",
 3 |   "moduleResolution": "node",
 4 |   "tsconfig": "tsconfig.json",
 5 |   "includeDeclarations": true,
 6 |   "ignoreCompilerErrors": true,
 7 |   "excludePrivate": true,
 8 |   "excludeExternals": true
 9 | }
10 | 


--------------------------------------------------------------------------------
/webpack.config.js:
--------------------------------------------------------------------------------
  1 | const path = require("path");
  2 | const webpack = require("webpack");
  3 | const fs = require("fs");
  4 | 
  5 | // Shot package name will be used for prefix of filename
  6 | const fnPrefix = JSON.parse(fs.readFileSync(path.resolve(__dirname, "package.json"), "utf-8")).name.replace("grimoirejs", "grimoire");
  7 | 
  8 | // Copy task for optimization
  9 | class CopyPlugin {
 10 |   constructor(copyFrom, copyTo) {
 11 |     this.copyFrom = copyFrom;
 12 |     this.copyTo = copyTo;
 13 |   }
 14 |   apply(compiler) {
 15 |     compiler.plugin("after-emit", (compiler, callback) => {
 16 |       fs.createReadStream(this.copyFrom).pipe(fs.createWriteStream(this.copyTo));
 17 |       callback();
 18 |     });
 19 |   }
 20 | }
 21 | 
 22 | // Couldron generate-expose and generate-reference execute with build tasks.
 23 | class CauldronPlugin {
 24 |   apply(compiler) {
 25 |     compiler.plugin("compile", () => {
 26 |       try {
 27 |         console.log(require('child_process').execSync('npm run generate-expose').toString());
 28 |       } catch (e) {
 29 |         console.log(e);
 30 |       }
 31 |     });
 32 |     compiler.plugin('after-emit', (compiler, callback) => {
 33 |       try {
 34 |         console.log(require('child_process').execSync('npm run generate-reference').toString());
 35 |       } catch (e) {
 36 |         console.log(e);
 37 |       } finally {
 38 |         callback();
 39 |       }
 40 |     });
 41 |   }
 42 | }
 43 | 
 44 | const getBuildTask = (fileName, plugins, needPolyfill) => {
 45 |   return {
 46 |     cache: true,
 47 |     entry: needPolyfill ? ['babel-polyfill', path.resolve(__dirname, "src/index.ts")] : path.resolve(__dirname, "src/index.ts"),
 48 |     output: {
 49 |       path: __dirname,
 50 |       filename: "./register/" + fileName,
 51 |       libraryTarget: "umd"
 52 |     },
 53 |     module: {
 54 |       loaders: [{
 55 |         test: /\.ts$/,
 56 |         exclude: /node_modules/,
 57 |         loader: "babel-loader?presets[]=es2015,presets[]=stage-2!ts-loader"
 58 |       }]
 59 |     },
 60 |     resolve: {
 61 |       extensions: ['.ts', '.js']
 62 |     },
 63 |     plugins: plugins,
 64 |     devtool: 'source-map'
 65 |   }
 66 | };
 67 | 
 68 | module.exports = (env = {}) => {
 69 |   // This line might need to be modified for each plugin build environment.
 70 |   // If the plugin containing grimoirejs directly(calling require("grimoirejs/register")),
 71 |   // browser build and production build should contain babel-polyfill.
 72 |   // Make sure this is not require("grimoirejs")
 73 |   let includeCore = true;
 74 |   //
 75 |   //
 76 |   //
 77 |   if(!env.browser && !env.npm && !env.prod){
 78 |     env.browser = true;
 79 |   }
 80 |   const productPlugins = [new webpack.optimize.UglifyJsPlugin({compress: {warnings: false}}),new webpack.optimize.OccurrenceOrderPlugin(),new webpack.optimize.AggressiveMergingPlugin()];
 81 |   let buildTasks = [];
 82 |   let skipIndex = false;
 83 |   let cauldron = new CauldronPlugin();
 84 |   if (env.browser || env.prod) {
 85 |     const plugins = [];
 86 |     // if needs index also and it was not including core, index.js must be copied from fnPrefix.js
 87 |     // since these are completely same build task. Yeah, optimization.
 88 |     if (!includeCore && (env.prod || env.npm)) {
 89 |       plugins.push(new CopyPlugin(`./register/${fnPrefix}.js`, './register/index.js'));
 90 |       plugins.push(new CopyPlugin(`./register/${fnPrefix}.js.map`, './register/index.js.map'));
 91 |       skipIndex = true;
 92 |       console.log(`${index}.js will be generated for NPM environment by copy`);      
 93 |     }
 94 |     buildTasks.push(getBuildTask(`${fnPrefix}.js`, [cauldron,...plugins], includeCore));
 95 |     console.log(`${fnPrefix}.js will be generated for browser environment`);
 96 |   }
 97 |   if (!skipIndex && (env.npm || env.prod)) {
 98 |     buildTasks.push(getBuildTask("index.js", [cauldron], false));
 99 |     console.log(`index.js will be generated for NPM environment`);          
100 |   }
101 |   if (env.prod) {
102 |     buildTasks.push(getBuildTask(fnPrefix + ".min.js", [cauldron,...productPlugins],includeCore));
103 |     console.log(`${fnPrefix}.min.js will be generated for browser environment`);          
104 |   }
105 |   return buildTasks;
106 | };
107 | 


--------------------------------------------------------------------------------