fuhtho/tethys-feature-service
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

First commit

Browse source
This commit is contained in:
Thomas Fuhrmann 2023-10-02 15:04:02 +02:00
commit 87d22a4516
235 changed files with 51802 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

21
node_modules/xml-js/LICENSE generated vendored Normal file
View file

@ -0,0 +1,21 @@
The MIT License (MIT)
Copyright (c) 2016-2017 Yousuf Almarzooqi
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:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
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.

390
node_modules/xml-js/README.md generated vendored Normal file
View file

@ -0,0 +1,390 @@
![XML ⇔ JS/JSON](http://nashwaan.github.io/xml-js/images/logo.svg)
Convert XML text to Javascript object / JSON text (and vice versa).
[![Build Status](https://ci.appveyor.com/api/projects/status/0ky9f115m0f0r0gf?svg=true)](https://ci.appveyor.com/project/nashwaan/xml-js)
[![Build Status](https://travis-ci.org/nashwaan/xml-js.svg?branch=master)](https://travis-ci.org/nashwaan/xml-js)
[![Build Status](https://img.shields.io/circleci/project/nashwaan/xml-js.svg)](https://circleci.com/gh/nashwaan/xml-js)
<!-- [![pipeline status](https://gitlab.com/nashwaan/xml-js/badges/master/pipeline.svg)](https://gitlab.com/nashwaan/xml-js/commits/master) -->
[![Coverage Status](https://coveralls.io/repos/github/nashwaan/xml-js/badge.svg?branch=master)](https://coveralls.io/github/nashwaan/xml-js?branch=master)
[![codecov](https://codecov.io/gh/nashwaan/xml-js/branch/master/graph/badge.svg)](https://codecov.io/gh/nashwaan/xml-js)
[![Codacy Badge](https://api.codacy.com/project/badge/Grade/f6ed5dd79a5b4041bfd2732963c4d09b)](https://www.codacy.com/app/ysf953/xml-js?utm_source=github.com&amp;utm_medium=referral&amp;utm_content=nashwaan/xml-js&amp;utm_campaign=Badge_Grade)
[![Code Climate](https://codeclimate.com/github/nashwaan/xml-js/badges/gpa.svg)](https://codeclimate.com/github/nashwaan/xml-js)
[![npm](http://img.shields.io/npm/v/xml-js.svg)](https://www.npmjs.com/package/xml-js)
[![License](https://img.shields.io/npm/l/xml-js.svg)](LICENSE)
[![Downloads/month](https://img.shields.io/npm/dm/xml-js.svg)](http://www.npmtrends.com/xml-js)
[![Dependency Status](https://david-dm.org/nashwaan/xml-js.svg)](https://david-dm.org/nashwaan/xml-js)
[![Package Quality](http://npm.packagequality.com/shield/xml-js.svg)](http://packagequality.com/#?package=xml-js)
# Synopsis
![Convert XML ↔ JS/JSON as compact or non-compact](http://nashwaan.github.io/xml-js/images/synopsis.svg)
<!---![Convert XML ↔ JS/JSON as compact or non-compact](/synopsis.png?raw=true "Synopsis Diagram")-->
# Features
* **Maintain Order of Elements**:
Most libraries will convert `<a/><b/><a/>` to `{a:[{},{}],b:{}}` which merges any node of same name into an array. This library can create the following to preserve the order of elements:
`{"elements":[{"type":"element","name":"a"},{"type":"element","name":"b"},{"type":"element","name":"a"}]}`.
This is very important and it is the main reason why this library was created. Read also [Compact vs Non-Compact](#compact-vs-non-compact) for more info.
* **Fully XML Compliant**:
Can parse: elements, attributes, texts, comments, CData, DOCTYPE, XML declarations, and Processing Instructions.
* **Reversible**:
Whether converting xml→json or json→xml, the result can be converted back to its original form.
* **Minimal Dependencies**:
This library depends only on one external npm module.
* **Change Property Key Name**:
Usually output of XML attributes are stored in `@attr`, `_atrr`, `$attr` or `$` in order to avoid conflicting with name of sub-elements.
This library store them in `attributes`, but most importantly, you can change this to whatever you like.
* **Support Upwards Traversal**:
By setting `{addParent: true}` option, an extra property named `parent` will be generated along each element so that its parent can be referenced.
Therefore, anywhere during the traversal of an element, its children **and** its parent can be easily accessed.
* **Support Command Line**:
To quickly convert xml or json files, this module can be installed globally or locally (i.e. use it as [script](https://docs.npmjs.com/misc/scripts) in package.json).
* **Customize Processing using Callback Hooks**:
[Custom functions](#options-for-custom-processing-functions) can be supplied to do additional processing for different parts of xml or json (like cdata, comments, elements, attributes ...etc).
* **Portable Code**:
Written purely in JavaScript which means it can be used in Node environment and **browser** environment (via bundlers like browserify/JSPM/Webpack).
* **Typings Info Included**:
Support type checking and code suggestion via intellisense.
Thanks to the wonderful efforts by [DenisCarriere](https://github.com/DenisCarriere).
## Compact vs Non-Compact
Most XML to JSON converters (including online converters) convert `<a/>` to some compact output like `{"a":{}}`
instead of non-compact output like `{"elements":[{"type":"element","name":"a"}]}`.
While compact output might work in most situations, there are cases when elements of different names are mixed inside a parent element. Lets use `<a x="1"/><b x="2"/><a x="3"/>` as an example.
Most converters will produce compact output like this `{a:[{_:{x:"1"}},{_:{x:"3"}}], b:{_:{x:"2"}}}`,
which has merged both `<a>` elements into an array. If you try to convert this back to xml, you will get `<a x="1"/><a x="3"/><b x="2"/>`
which has not preserved the order of elements!
The reason behind this behavior is due to the inherent limitation in the compact representation.
Because output like `{a:{_:{x:"1"}}, b:{_:{x:"2"}}, a:{_:{x:"3"}}}` is illegal (same property name `a` should not appear twice in an object). This leaves no option but to use array `{a:[{_:{x:"1"}},{_:{x:"3"}}]`.
The non-compact output, which is supported by this library, will produce more information and always guarantees the order of the elements as they appeared in the XML file.
Another drawback of compact output is the resultant element can be an object or an array and therefore makes the client code a little awkward in terms of the extra check needed on object type before processing.
NOTE: Although non-compact output is more accurate representation of original XML than compact version, the non-compact version is verbose and consumes more space.
This library provides both options. Use `{compact: false}` if you are not sure because it preserves everything;
otherwise use `{compact: true}` if you want to save space and you don't care about mixing elements of same name and losing their order.
Tip: You can reduce the output size by using shorter [key names](#options-for-changing-key-names).
# Usage
## Installation
```
npm install --save xml-js
```
You can also install it globally to use it as a command line convertor (see [Command Line](#command-line)).
```
npm install --global xml-js
```
## Quick start
```js
var convert = require('xml-js');
var xml =
'<?xml version="1.0" encoding="utf-8"?>' +
'<note importance="high" logged="true">' +
' <title>Happy</title>' +
' <todo>Work</todo>' +
' <todo>Play</todo>' +
'</note>';
var result1 = convert.xml2json(xml, {compact: true, spaces: 4});
var result2 = convert.xml2json(xml, {compact: false, spaces: 4});
console.log(result1, '\n', result2);
```
To see the result of this code, see the output above in [Synopsis](#synopsis) section.
Or [run and edit](https://runkit.com/587874e079a2f60013c1f5ac/587874e079a2f60013c1f5ad) this code live in the browser.
## Sample Conversions
| XML | JS/JSON compact | JS/JSON non-compact |
|:----|:----------------|:--------------------|
| `<a/>` | `{"a":{}}` | `{"elements":[{"type":"element","name":"a"}]}` |
| `<a/><b/>` | `{"a":{},"b":{}}` | `{"elements":[{"type":"element","name":"a"},{"type":"element","name":"b"}]}` |
| `<a><b/></a>` | `{"a":{"b":{}}}` | `{"elements":[{"type":"element","name":"a","elements":[{"type":"element","name":"b"}]}]}` |
| `<a> Hi </a>` | `{"a":{"_text":" Hi "}}` | `{"elements":[{"type":"element","name":"a","elements":[{"type":"text","text":" Hi "}]}]}` |
| `<a x="1.234" y="It's"/>` | `{"a":{"_attributes":{"x":"1.234","y":"It's"}}}` | `{"elements":[{"type":"element","name":"a","attributes":{"x":"1.234","y":"It's"}}]}` |
| `<?xml?>` | `{"_declaration":{}}` | `{"declaration":{}}` |
| `<?go there?>` | `{"_instruction":{"go":"there"}}` | `{"elements":[{"type":"instruction","name":"go","instruction":"there"}]}` |
| `<?xml version="1.0" encoding="utf-8"?>` | `{"_declaration":{"_attributes":{"version":"1.0","encoding":"utf-8"}}}` | `{"declaration":{"attributes":{"version":"1.0","encoding":"utf-8"}}}` |
| `<!--Hello, World!-->` | `{"_comment":"Hello, World!"}` | `{"elements":[{"type":"comment","comment":"Hello, World!"}]}` |
| `<![CDATA[<foo></bar>]]>` | `{"_cdata":"<foo></bar>"}` | `{"elements":[{"type":"cdata","cdata":"<foo></bar>"}]}` |
# API Reference
This library provides 4 functions: `js2xml()`, `json2xml()`, `xml2js()`, and `xml2json()`. Here are the usages for each one (see more details in the following sections):
```js
var convert = require('xml-js');
result = convert.js2xml(js, options); // to convert javascript object to xml text
result = convert.json2xml(json, options); // to convert json text to xml text
result = convert.xml2js(xml, options); // to convert xml text to javascript object
result = convert.xml2json(xml, options); // to convert xml text to json text
```
## Convert JS object / JSON → XML
To convert JavaScript object to XML text, use `js2xml()`. To convert JSON text to XML text, use `json2xml()`.
```js
var convert = require('xml-js');
var json = require('fs').readFileSync('test.json', 'utf8');
var options = {compact: true, ignoreComment: true, spaces: 4};
var result = convert.json2xml(json, options);
console.log(result);
```
### Options for Converting JS object / JSON → XML
The below options are applicable for both `js2xml()` and `json2xml()` functions.
| Option | Default | Description |
|:----------------------|:--------|:------------|
| `spaces` | `0` | Number of spaces to be used for indenting XML output. Passing characters like `' '` or `'\t'` are also accepted. |
| `compact` | `false` | Whether the *input* object is in compact form or not. By default, input is expected to be in non-compact form. |
| | | IMPORTANT: Remeber to set this option `compact: true` if you are supplying normal json (which is likely equivalent to compact form). Otherwise, the function assumes your json input is non-compact form and you will not get a result if it is not in that form. See [Synopsis](#synopsis) to know the difference between the two json forms |
| `fullTagEmptyElement` | `false` | Whether to produce element without sub-elements as full tag pairs `<a></a>` rather than self closing tag `<a/>`. |
| `indentCdata` | `false` | Whether to write CData in a new line and indent it. Will generate `<a>\n <![CDATA[foo]]></a>` instead of `<a><![CDATA[foo]]></a>`. See [discussion](https://github.com/nashwaan/xml-js/issues/14) |
| `indentAttributes` | `false` | Whether to print attributes across multiple lines and indent them (when `spaces` is not `0`). See [example](https://github.com/nashwaan/xml-js/issues/31). |
| `ignoreDeclaration` | `false` | Whether to ignore writing declaration directives of xml. For example, `<?xml?>` will be ignored. |
| `ignoreInstruction` | `false` | Whether to ignore writing processing instruction of xml. For example, `<?go there?>` will be ignored. |
| `ignoreAttributes` | `false` | Whether to ignore writing attributes of the elements. For example, `x="1"` in `<a x="1"></a>` will be ignored |
| `ignoreComment` | `false` | Whether to ignore writing comments of the elements. That is, no `<!-- -->` will be generated. |
| `ignoreCdata` | `false` | Whether to ignore writing CData of the elements. That is, no `<![CDATA[ ]]>` will be generated. |
| `ignoreDoctype` | `false` | Whether to ignore writing Doctype of the elements. That is, no `<!DOCTYPE >` will be generated. |
| `ignoreText` | `false` | Whether to ignore writing texts of the elements. For example, `hi` text in `<a>hi</a>` will be ignored. |
## Convert XML → JS object / JSON
To convert XML text to JavaScript object, use `xml2js()`. To convert XML text to JSON text, use `xml2json()`.
```js
var convert = require('xml-js');
var xml = require('fs').readFileSync('test.xml', 'utf8');
var options = {ignoreComment: true, alwaysChildren: true};
var result = convert.xml2js(xml, options); // or convert.xml2json(xml, options)
console.log(result);
```
### Options for Converting XML → JS object / JSON
The below options are applicable for both `xml2js()` and `xml2json()` functions.
| Option | Default | Description |
|:--------------------|:--------|:------------|
| `compact` | `false` | Whether to produce detailed object or compact object. |
| `trim` | `false` | Whether to trim whitespace characters that may exist before and after the text. |
| `sanitize` ([Deprecated](https://github.com/nashwaan/xml-js/issues/26)) | `false` | Whether to replace `&` `<` `>` with `&amp;` `&lt;` `&gt;` respectively, in the resultant text. |
| `nativeType` | `false` | Whether to attempt converting text of numerals or of boolean values to native type. For example, `"123"` will be `123` and `"true"` will be `true` |
| `nativeTypeAttributes` | `false` | Whether to attempt converting attributes of numerals or of boolean values to native type. See also `nativeType` above. |
| `addParent` | `false` | Whether to add `parent` property in each element object that points to parent object. |
| `alwaysArray` | `false` | Whether to always put sub element, even if it is one only, as an item inside an array. `<a><b/></a>` will be `a:[{b:[{}]}]` rather than `a:{b:{}}` (applicable for compact output only). If the passed value is an array, only elements with names in the passed array are always made arrays. |
| `alwaysChildren` | `false` | Whether to always generate `elements` property even when there are no actual sub elements. `<a></a>` will be `{"elements":[{"type":"element","name":"a","elements":[]}]}` rather than `{"elements":[{"type":"element","name":"a"}]}` (applicable for non-compact output). |
| `instructionHasAttributes` | `false` | Whether to parse contents of Processing Instruction as attributes or not. `<?go to="there"?>` will be `{"_instruction":{"go":{"_attributes":{"to":"there"}}}}` rather than `{"_instruction":{"go":"to=\"there\""}}`. See [discussion](https://github.com/nashwaan/xml-js/issues/17). |
| `ignoreDeclaration` | `false` | Whether to ignore parsing declaration property. That is, no `declaration` property will be generated. |
| `ignoreInstruction` | `false` | Whether to ignore parsing processing instruction property. That is, no `instruction` property will be generated. |
| `ignoreAttributes` | `false` | Whether to ignore parsing attributes of elements.That is, no `attributes` property will be generated. |
| `ignoreComment` | `false` | Whether to ignore parsing comments of the elements. That is, no `comment` will be generated. |
| `ignoreCdata` | `false` | Whether to ignore parsing CData of the elements. That is, no `cdata` will be generated. |
| `ignoreDoctype` | `false` | Whether to ignore parsing Doctype of the elements. That is, no `doctype` will be generated. |
| `ignoreText` | `false` | Whether to ignore parsing texts of the elements. That is, no `text` will be generated. |
The below option is applicable only for `xml2json()` function.
| Option | Default | Description |
|:--------------------|:--------|:------------|
| `spaces` | `0` | Number of spaces to be used for indenting JSON output. Passing characters like `' '` or `'\t'` are also accepted. |
## Options for Changing Key Names
To change default key names in the output object or the default key names assumed in the input JavaScript object / JSON, use the following options:
| Option | Default | Description |
|:--------------------|:--------|:------------|
| `declarationKey` | `"declaration"` or `"_declaration"` | Name of the property key which will be used for the declaration. For example, if `declarationKey: '$declaration'` then output of `<?xml?>` will be `{"$declaration":{}}` *(in compact form)* |
| `instructionKey` | `"instruction"` or `"_instruction"` | Name of the property key which will be used for the processing instruction. For example, if `instructionKey: '$instruction'` then output of `<?go there?>` will be `{"$instruction":{"go":"there"}}` *(in compact form)* |
| `attributesKey` | `"attributes"` or `"_attributes"` | Name of the property key which will be used for the attributes. For example, if `attributesKey: '$attributes'` then output of `<a x="hello"/>` will be `{"a":{$attributes:{"x":"hello"}}}` *(in compact form)* |
| `textKey` | `"text"` or `"_text"` | Name of the property key which will be used for the text. For example, if `textKey: '$text'` then output of `<a>hi</a>` will be `{"a":{"$text":"Hi"}}` *(in compact form)* |
| `cdataKey` | `"cdata"` or `"_cdata"` | Name of the property key which will be used for the cdata. For example, if `cdataKey: '$cdata'` then output of `<![CDATA[1 is < 2]]>` will be `{"$cdata":"1 is < 2"}` *(in compact form)* |
| `doctypeKey` | `"doctype"` or `"_doctype"` | Name of the property key which will be used for the doctype. For example, if `doctypeKey: '$doctype'` then output of `<!DOCTYPE foo>` will be `{"$doctype":" foo}` *(in compact form)* |
| `commentKey` | `"comment"` or `"_comment"` | Name of the property key which will be used for the comment. For example, if `commentKey: '$comment'` then output of `<!--note-->` will be `{"$comment":"note"}` *(in compact form)* |
| `parentKey` | `"parent"` or `"_parent"` | Name of the property key which will be used for the parent. For example, if `parentKey: '$parent'` then output of `<a></b></a>` will be `{"a":{"b":{$parent:_points_to_a}}}` *(in compact form)* |
| `typeKey` | `"type"` | Name of the property key which will be used for the type. For example, if `typeKey: '$type'` then output of `<a></a>` will be `{"elements":[{"$type":"element","name":"a"}]}` *(in non-compact form)* |
| `nameKey` | `"name"` | Name of the property key which will be used for the name. For example, if `nameKey: '$name'` then output of `<a></a>` will be `{"elements":[{"type":"element","$name":"a"}]}` *(in non-compact form)* |
| `elementsKey` | `"elements"` | Name of the property key which will be used for the elements. For example, if `elementsKey: '$elements'` then output of `<a></a>` will be `{"$elements":[{"type":"element","name":"a"}]}` *(in non-compact form)* |
Two default values mean the first is used for *non-compact* output and the second is for *compact* output.
> **TIP**: In compact mode, you can further reduce output result by using fewer characters for key names `{textKey: '_', attributesKey: '$', commentKey: 'value'}`. This is also applicable to non-compact mode.
> **TIP**: In non-compact mode, you probably want to set `{textKey: 'value', cdataKey: 'value', commentKey: 'value'}`
> to make it more consistent and easier for your client code to go through the contents of text, cdata, and comment.
## Options for Custom Processing Functions
For XML → JS object / JSON, following custom callback functions can be supplied:
```js
var convert = require('xml-js');
var xml = '<foo:Name>Ali</Name> <bar:Age>30</bar:Age>';
var options = {compact: true, elementNameFn: function(val) {return val.replace('foo:','').toUpperCase();}};
var result = convert.xml2json(xml, options);
console.log(result); // {"NAME":{"_text":"Ali"},"BAR:AGE":{"_text":"30"}}
```
| Option | Signature | Description |
|:--------------------|:----------|:------------|
| `doctypeFn` | `(value, parentElement)` | To perform additional processing for DOCTYPE. For example, `{doctypeFn: function(val) {return val.toUpperCase();}}` |
| `instructionFn` | `(instructionValue, instructionName, parentElement)` | To perform additional processing for content of Processing Instruction value. For example, `{instructionFn: function(val) {return val.toUpperCase();}}`. Note: `instructionValue` will be an object if `instructionHasAttributes` is enabled. |
| `cdataFn` | `(value, parentElement)` | To perform additional processing for CData. For example, `{cdataFn: function(val) {return val.toUpperCase();}}`. |
| `commentFn` | `(value, parentElement)` | To perform additional processing for comments. For example, `{commentFn: function(val) {return val.toUpperCase();}}`. |
| `textFn` | `(value, parentElement)` | To perform additional processing for texts inside elements. For example, `{textFn: function(val) {return val.toUpperCase();}}`. |
| `instructionNameFn` | `(instructionName, instructionValue, parentElement)` | To perform additional processing for Processing Instruction name. For example, `{instructionNameFn: function(val) {return val.toUpperCase();}}`. Note: `instructionValue` will be an object if `instructionHasAttributes` is enabled. |
| `elementNameFn` | `(value, parentElement)` | To perform additional processing for element name. For example, `{elementNameFn: function(val) {return val.toUpperCase();}}`. |
| `attributeNameFn` | `(attributeName, attributeValue, parentElement)` | To perform additional processing for attribute name. For example, `{attributeNameFn: function(val) {return val.toUpperCase();}}`. |
| `attributeValueFn` | `(attributeValue, attributeName, parentElement)` | To perform additional processing for attributeValue. For example, `{attributeValueFn: function(val) {return val.toUpperCase();}}`. |
| `attributesFn` | `(value, parentElement)` | To perform additional processing for attributes object. For example, `{attributesFn: function(val) {return val.toUpperCase();}}`. |
For JS object / JSON → XML, following custom callback functions can be supplied:
```js
var convert = require('xml-js');
var json = '{"name":{"_text":"Ali"},"age":{"_text":"30"}}';
var options = {compact: true, textFn: function(val, elementName) {return elementName === 'age'? val + '';}};
var result = convert.json2xml(json, options);
console.log(result); // <foo:Name>Ali</Name> <bar:Age>30</bar:Age>
```
| Option | Signature | Description |
|:--------------------|:----------|:------------|
| `doctypeFn` | `(value, currentElementName, currentElementObj)` | To perform additional processing for DOCTYPE. For example, `{doctypeFn: function(val) {return val.toUpperCase();}`. |
| `instructionFn` | `(instructionValue, instructionName, currentElementName, currentElementObj)` | To perform additional processing for content of Processing Instruction value. For example, `{instructionFn: function(val) {return val.toUpperCase();}}`. Note: `instructionValue` will be an object if `instructionHasAttributes` is enabled. |
| `cdataFn` | `(value, currentElementName, currentElementObj)` | To perform additional processing for CData. For example, `{cdataFn: function(val) {return val.toUpperCase();}}`. |
| `commentFn` | `(value, currentElementName, currentElementObj)` | To perform additional processing for comments. For example, `{commentFn: function(val) {return val.toUpperCase();}}`. |
| `textFn` | `(value, currentElementName, currentElementObj)` | To perform additional processing for texts inside elements. For example, `{textFn: function(val) {return val.toUpperCase();}}`. |
| `instructionNameFn` | `(instructionName, instructionValue, currentElementName, currentElementObj)` | To perform additional processing for Processing Instruction name. For example, `{instructionNameFn: function(val) {return val.toUpperCase();}}`. Note: `instructionValue` will be an object if `instructionHasAttributes` is enabled. |
| `elementNameFn` | `(value, currentElementName, currentElementObj)` | To perform additional processing for element name. For example, `{elementNameFn: function(val) {return val.toUpperCase();}}`. |
| `attributeNameFn` | `(attributeName, attributeValue, currentElementName, currentElementObj)` | To perform additional processing for attribute name. For example, `{attributeNameFn: function(val) {return val.toUpperCase();}}`. |
| `attributeValueFn` | `(attributeValue, attributeName, currentElementName, currentElementObj)` | To perform additional processing for attributeValue. For example, `{attributeValueFn: function(val) {return val.toUpperCase();}}`. |
| `attributesFn` | `(value, currentElementName, currentElementObj)` | To perform additional processing for attributes object. For example, `{attributesFn: function(val) {return val.toUpperCase();}}`. |
| `fullTagEmptyElementFn` | `(currentElementName, currentElementObj)` | Whether to generate full tag or just self closing tag for elements that has no sub elements. For example, `{fullTagEmptyElementFn: function(val) {return val === 'foo'}}`. |
# Command Line
Because any good library should support command line usage, this library is no different.
## As Globally Accessible Command
```
npm install -g xml-js // install this library globally
xml-js test.json --spaces 4 // xml result will be printed on screen
xml-js test.json --spaces 4 --out test.xml // xml result will be saved to test.xml
xml-js test.xml --spaces 4 // json result will be printed on screen
xml-js test.xml --spaces 4 --out test.json // json result will be saved to test.json
```
## As Locally Accessible Command
If you want to use it as script in package.json (can also be helpful in [task automation via npm scripts](http://blog.keithcirkel.co.uk/how-to-use-npm-as-a-build-tool/))
```
npm install --save xml-js // no need to install this library globally
```
In package.json, write a script:
```json
...
"dependencies": {
"xml-js": "latest"
},
"scripts": {
"convert": "xml-js test.json --spaces 4"
}
```
Now in the command line, you can run this script by typing:
```
npm run convert // task 'scripts.convert' will be executed
```
## CLI Arguments
```
Usage: xml-js src [options]
src Input file that need to be converted.
Conversion type xml->json or json->xml will be inferred from file extension.
Options:
--help, -h Display this help content.
--version, -v Display version number of this module.
--out Output file where result should be written.
--spaces Specifies amount of space indentation in the output.
--full-tag XML elements will always be in <a></a> form.
--no-decl Declaration directive <?xml?> will be ignored.
--no-inst Processing instruction <?...?> will be ignored.
--no-attr Attributes of elements will be ignored.
--no-text Texts of elements will be ignored.
--no-cdata CData of elements will be ignored.
--no-doctype DOCTYPE of elements will be ignored.
--no-comment Comments of elements will be ignored.
--trim Any whitespaces surrounding texts will be trimmed.
--compact JSON is in compact form.
--native-type Numbers and boolean will be converted (coerced) to native type instead of text.
--always-array Every element will always be an array type (applicable if --compact is set).
--always-children Every element will always contain sub-elements (applicable if --compact is not set).
--text-key To change the default 'text' key.
--cdata-key To change the default 'cdata' key.
--doctype-key To change the default 'doctype' key.
--comment-key To change the default 'comment' key.
--attributes-key To change the default 'attributes' key.
--declaration-key To change the default 'declaration' key.
--instruction-key To change the default 'processing instruction' key.
--type-key To change the default 'type' key (applicable if --compact is not set).
--name-key To change the default 'name' key (applicable if --compact is not set).
--elements-key To change the default 'elements' key (applicable if --compact is not set).
```
# Contribution
## Testing
To perform tests on this project, download the full repository from GitHub (not from npm) and then do the following:
```
cd xml-js
npm install
npm test
```
For live testing, use `npm start` instead of `npm test`.
## Reporting
Use [this link](https://github.com/nashwaan/xml-js/issues) to report an issue or bug. Please include a sample code where the code is failing.
# License
[MIT](https://github.com/nashwaan/xml-js/blob/master/LICENSE)

47
node_modules/xml-js/bin/cli-helper.js generated vendored Normal file
View file

@ -0,0 +1,47 @@
module.exports = {
getCommandLineHelp: function (command, requiredArgs, optionalArgs) {
var reqArgs = requiredArgs.reduce(function (res, arg) {return res + ' <' + arg.arg + '>';}, '');
var output = 'Usage: ' + command + reqArgs + ' [options]\n';
requiredArgs.forEach(function (argument) {
output += ' <' + argument.arg + '>' + Array(20 - argument.arg.length).join(' ') + argument.desc + '\n';
});
output += '\nOptions:\n';
optionalArgs.forEach(function (argument) {
output += ' --' + argument.arg + Array(20 - argument.arg.length).join(' ') + argument.desc + '\n';
});
return output;
},
mapCommandLineArgs: function (requiredArgs, optionalArgs) {
var options = {}, r, o, a = 2;
for (r = 0; r < requiredArgs.length; r += 1) {
if (a < process.argv.length && process.argv[a].substr(0, 1) !== '-' && process.argv[a] !== 'JASMINE_CONFIG_PATH=./jasmine.json') {
options[requiredArgs[r].option] = process.argv[a++];
} else {
break;
}
}
for (; a < process.argv.length; a += 1) {
for (o = 0; o < optionalArgs.length; o += 1) {
if (optionalArgs[o].alias === process.argv[a].slice(1) || optionalArgs[o].arg === process.argv[a].slice(2)) {
break;
}
}
if (o < optionalArgs.length) {
switch (optionalArgs[o].type) {
case 'file': case 'string': case 'number':
if (a + 1 < process.argv.length) {
a += 1;
options[optionalArgs[o].option] = (optionalArgs[o].type === 'number' ? Number(process.argv[a]) : process.argv[a]);
}
break;
case 'flag':
options[optionalArgs[o].option] = true; break;
}
}
}
return options;
}
};

83
node_modules/xml-js/bin/cli.js generated vendored Normal file
View file

@ -0,0 +1,83 @@
#!/usr/bin/env node
var fs = require('fs');
var helper = require('./cli-helper');
var project = require('../package.json');
var xml2json = require('../lib/xml2json');
var json2xml = require('../lib/json2xml');
var output = '';
var stream = '';
var options = {};
var requiredArgs = [
{ arg: 'src', type: 'file', option: 'src', desc: 'Input file that need to be converted.'}
];
var optionalArgs = [
{ arg: 'help', alias: 'h', type: 'flag', option: 'help', desc: 'Display this help content.' },
{ arg: 'version', alias: 'v', type: 'flag', option: 'version', desc: 'Display version number of this module.' },
{ arg: 'out', type: 'file', option: 'out', desc: 'Output file where the converted result should be written.' },
{ arg: 'to-json', type: 'flag', option:'toJason', desc: 'Convert.' },
{ arg: 'compact', type: 'flag', option:'compact', desc: 'Compact JSON form (see explanation in www.npmjs.com/package/xml-js).' },
{ arg: 'spaces', type: 'number', option:'spaces', desc: 'Specifies amount of space indentation in the output.' },
{ arg: 'trim', type: 'flag', option:'trim', desc: 'Any whitespaces surrounding texts will be trimmed.' },
// { arg: 'sanitize', type: 'flag', option:'sanitize', desc: 'Special xml characters will be replaced with entity codes.' },
{ arg: 'native-type', type: 'flag', option:'nativeType', desc: 'Numbers and boolean will be converted (coerced) to native type instead of text.' },
{ arg: 'always-array', type: 'flag', option:'alwaysArray', desc: 'Every element will always be an array type (applicable if --compact is set). If the passed value is an array, only elements with names in the passed array are always made arrays.' },
{ arg: 'always-children', type: 'flag', option:'alwaysChildren', desc: 'Every element will always contain sub-elements (applicable if --compact is not set).' },
{ arg: 'instruction-attr', type: 'flag', option:'instructionHasAttributes', desc: 'Whether to parse contents of processing instruction as attributes.' },
{ arg: 'full-tag', type: 'flag', option:'fullTagEmptyElement', desc: 'XML elements will always be in <a></a> form.' },
{ arg: 'no-decl', type: 'flag', option:'ignoreDeclaration', desc: 'Declaration instruction <?xml?> will be ignored.' },
{ arg: 'no-decl', type: 'flag', option:'ignoreInstruction', desc: 'Processing instruction <?...?> will be ignored.' },
{ arg: 'no-attr', type: 'flag', option:'ignoreAttributes', desc: 'Attributes of elements will be ignored.' },
{ arg: 'no-text', type: 'flag', option:'ignoreText', desc: 'Texts of elements will be ignored.' },
{ arg: 'no-cdata', type: 'flag', option:'ignoreCdata', desc: 'CData of elements will be ignored.' },
{ arg: 'no-doctype', type: 'flag', option:'ignoreDoctype', desc: 'DOCTYPE of elements will be ignored.' },
{ arg: 'no-comment', type: 'flag', option:'ignoreComment', desc: 'Comments of elements will be ignored.' },
{ arg: 'text-key', type: 'string', option:'textKey', desc: 'To change the default \'text\' key.' },
{ arg: 'cdata-key', type: 'string', option:'cdataKey', desc: 'To change the default \'cdata\' key.' },
{ arg: 'doctype-key', type: 'string', option:'doctypeKey', desc: 'To change the default \'doctype\' key.' },
{ arg: 'comment-key', type: 'string', option:'commentKey', desc: 'To change the default \'comment\' key.' },
{ arg: 'attributes-key', type: 'string', option:'attributesKey', desc: 'To change the default \'attributes\' key.' },
{ arg: 'declaration-key', type: 'string', option:'declarationKey', desc: 'To change the default \'declaration\' key <?xml?>.' },
{ arg: 'instruction-key', type: 'string', option:'instructionKey', desc: 'To change the default \'processing instruction\' key <?...?>.' },
{ arg: 'type-key', type: 'string', option:'typeKey', desc: 'To change the default \'type\' key (applicable if --compact is not set).' },
{ arg: 'name-key', type: 'string', option:'nameKey', desc: 'To change the default \'name\' key (applicable if --compact is not set).' },
{ arg: 'elements-key', type: 'string', option:'elementsKey', desc: 'To change the default \'elements\' key (applicable if --compact is not set).' }
];
process.stdin.setEncoding('utf8');
process.stdin.on('readable', function () {
var chunk = process.stdin.read();
if (chunk !== null) {
stream += chunk;
}
});
process.stdin.on('end', function () {
process.stdout.write(xml2json(stream, {}) + '\n');
});
options = helper.mapCommandLineArgs(requiredArgs, optionalArgs);
if (options.version) {
console.log(project.version);
process.exit(0);
} else if (options.help || process.argv.length <= 2 + requiredArgs.length - 1) {
console.log(helper.getCommandLineHelp('xml-js', requiredArgs, optionalArgs));
process.exit(process.argv.length <= 2 ? 1 : 0);
} else if ('src' in options) {
if (fs.statSync(options.src).isFile()) {
if (options.src.split('.').pop() === 'xml') {
output = xml2json(fs.readFileSync(options.src, 'utf8'), options);
} else if (options.src.split('.').pop() === 'json') {
output = json2xml(fs.readFileSync(options.src, 'utf8'), options);
}
if (options.out) {
fs.writeFileSync(options.out, output, 'utf8');
} else {
console.log(output);
}
process.exit(0);
}
} else {
process.exit(1);
}

23
node_modules/xml-js/bin/test.json generated vendored Normal file
View file

@ -0,0 +1,23 @@
{
"elements": [
{
"type": "element",
"name": "a",
"attributes": {
"x": "1"
},
"elements": [
{
"type": "element",
"name": "b",
"elements": [
{
"type": "text",
"text": "bye!"
}
]
}
]
}
]
}

3
node_modules/xml-js/bin/test.xml generated vendored Normal file
View file

@ -0,0 +1,3 @@
<a x="1">
<b>bye!</b>
</a>

8310
node_modules/xml-js/dist/xml-js.js generated vendored Normal file
View file

File diff suppressed because it is too large Load diff

8
node_modules/xml-js/dist/xml-js.min.js generated vendored Normal file
View file

File diff suppressed because one or more lines are too long

1
node_modules/xml-js/index.js generated vendored Normal file
View file

@ -0,0 +1 @@
module.exports = require('./lib');

11
node_modules/xml-js/lib/array-helper.js generated vendored Normal file
View file

@ -0,0 +1,11 @@
module.exports = {
isArray: function(value) {
if (Array.isArray) {
return Array.isArray(value);
}
// fallback for older browsers like IE 8
return Object.prototype.toString.call( value ) === '[object Array]';
}
};

13
node_modules/xml-js/lib/index.js generated vendored Normal file
View file

@ -0,0 +1,13 @@
/*jslint node:true */
var xml2js = require('./xml2js');
var xml2json = require('./xml2json');
var js2xml = require('./js2xml');
var json2xml = require('./json2xml');
module.exports = {
xml2js: xml2js,
xml2json: xml2json,
js2xml: js2xml,
json2xml: json2xml
};

320
node_modules/xml-js/lib/js2xml.js generated vendored Normal file
View file

@ -0,0 +1,320 @@
var helper = require('./options-helper');
var isArray = require('./array-helper').isArray;
var currentElement, currentElementName;
function validateOptions(userOptions) {
var options = helper.copyOptions(userOptions);
helper.ensureFlagExists('ignoreDeclaration', options);
helper.ensureFlagExists('ignoreInstruction', options);
helper.ensureFlagExists('ignoreAttributes', options);
helper.ensureFlagExists('ignoreText', options);
helper.ensureFlagExists('ignoreComment', options);
helper.ensureFlagExists('ignoreCdata', options);
helper.ensureFlagExists('ignoreDoctype', options);
helper.ensureFlagExists('compact', options);
helper.ensureFlagExists('indentText', options);
helper.ensureFlagExists('indentCdata', options);
helper.ensureFlagExists('indentAttributes', options);
helper.ensureFlagExists('indentInstruction', options);
helper.ensureFlagExists('fullTagEmptyElement', options);
helper.ensureFlagExists('noQuotesForNativeAttributes', options);
helper.ensureSpacesExists(options);
if (typeof options.spaces === 'number') {
options.spaces = Array(options.spaces + 1).join(' ');
}
helper.ensureKeyExists('declaration', options);
helper.ensureKeyExists('instruction', options);
helper.ensureKeyExists('attributes', options);
helper.ensureKeyExists('text', options);
helper.ensureKeyExists('comment', options);
helper.ensureKeyExists('cdata', options);
helper.ensureKeyExists('doctype', options);
helper.ensureKeyExists('type', options);
helper.ensureKeyExists('name', options);
helper.ensureKeyExists('elements', options);
helper.checkFnExists('doctype', options);
helper.checkFnExists('instruction', options);
helper.checkFnExists('cdata', options);
helper.checkFnExists('comment', options);
helper.checkFnExists('text', options);
helper.checkFnExists('instructionName', options);
helper.checkFnExists('elementName', options);
helper.checkFnExists('attributeName', options);
helper.checkFnExists('attributeValue', options);
helper.checkFnExists('attributes', options);
helper.checkFnExists('fullTagEmptyElement', options);
return options;
}
function writeIndentation(options, depth, firstLine) {
return (!firstLine && options.spaces ? '\n' : '') + Array(depth + 1).join(options.spaces);
}
function writeAttributes(attributes, options, depth) {
if (options.ignoreAttributes) {
return '';
}
if ('attributesFn' in options) {
attributes = options.attributesFn(attributes, currentElementName, currentElement);
}
var key, attr, attrName, quote, result = [];
for (key in attributes) {
if (attributes.hasOwnProperty(key) && attributes[key] !== null && attributes[key] !== undefined) {
quote = options.noQuotesForNativeAttributes && typeof attributes[key] !== 'string' ? '' : '"';
attr = '' + attributes[key]; // ensure number and boolean are converted to String
attr = attr.replace(/"/g, '&quot;');
attrName = 'attributeNameFn' in options ? options.attributeNameFn(key, attr, currentElementName, currentElement) : key;
result.push((options.spaces && options.indentAttributes? writeIndentation(options, depth+1, false) : ' '));
result.push(attrName + '=' + quote + ('attributeValueFn' in options ? options.attributeValueFn(attr, key, currentElementName, currentElement) : attr) + quote);
}
}
if (attributes && Object.keys(attributes).length && options.spaces && options.indentAttributes) {
result.push(writeIndentation(options, depth, false));
}
return result.join('');
}
function writeDeclaration(declaration, options, depth) {
currentElement = declaration;
currentElementName = 'xml';
return options.ignoreDeclaration ? '' : '<?' + 'xml' + writeAttributes(declaration[options.attributesKey], options, depth) + '?>';
}
function writeInstruction(instruction, options, depth) {
if (options.ignoreInstruction) {
return '';
}
var key;
for (key in instruction) {
if (instruction.hasOwnProperty(key)) {
break;
}
}
var instructionName = 'instructionNameFn' in options ? options.instructionNameFn(key, instruction[key], currentElementName, currentElement) : key;
if (typeof instruction[key] === 'object') {
currentElement = instruction;
currentElementName = instructionName;
return '<?' + instructionName + writeAttributes(instruction[key][options.attributesKey], options, depth) + '?>';
} else {
var instructionValue = instruction[key] ? instruction[key] : '';
if ('instructionFn' in options) instructionValue = options.instructionFn(instructionValue, key, currentElementName, currentElement);
return '<?' + instructionName + (instructionValue ? ' ' + instructionValue : '') + '?>';
}
}
function writeComment(comment, options) {
return options.ignoreComment ? '' : '<!--' + ('commentFn' in options ? options.commentFn(comment, currentElementName, currentElement) : comment) + '-->';
}
function writeCdata(cdata, options) {
return options.ignoreCdata ? '' : '<![CDATA[' + ('cdataFn' in options ? options.cdataFn(cdata, currentElementName, currentElement) : cdata.replace(']]>', ']]]]><![CDATA[>')) + ']]>';
}
function writeDoctype(doctype, options) {
return options.ignoreDoctype ? '' : '<!DOCTYPE ' + ('doctypeFn' in options ? options.doctypeFn(doctype, currentElementName, currentElement) : doctype) + '>';
}
function writeText(text, options) {
if (options.ignoreText) return '';
text = '' + text; // ensure Number and Boolean are converted to String
text = text.replace(/&amp;/g, '&'); // desanitize to avoid double sanitization
text = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
return 'textFn' in options ? options.textFn(text, currentElementName, currentElement) : text;
}
function hasContent(element, options) {
var i;
if (element.elements && element.elements.length) {
for (i = 0; i < element.elements.length; ++i) {
switch (element.elements[i][options.typeKey]) {
case 'text':
if (options.indentText) {
return true;
}
break; // skip to next key
case 'cdata':
if (options.indentCdata) {
return true;
}
break; // skip to next key
case 'instruction':
if (options.indentInstruction) {
return true;
}
break; // skip to next key
case 'doctype':
case 'comment':
case 'element':
return true;
default:
return true;
}
}
}
return false;
}
function writeElement(element, options, depth) {
currentElement = element;
currentElementName = element.name;
var xml = [], elementName = 'elementNameFn' in options ? options.elementNameFn(element.name, element) : element.name;
xml.push('<' + elementName);
if (element[options.attributesKey]) {
xml.push(writeAttributes(element[options.attributesKey], options, depth));
}
var withClosingTag = element[options.elementsKey] && element[options.elementsKey].length || element[options.attributesKey] && element[options.attributesKey]['xml:space'] === 'preserve';
if (!withClosingTag) {
if ('fullTagEmptyElementFn' in options) {
withClosingTag = options.fullTagEmptyElementFn(element.name, element);
} else {
withClosingTag = options.fullTagEmptyElement;
}
}
if (withClosingTag) {
xml.push('>');
if (element[options.elementsKey] && element[options.elementsKey].length) {
xml.push(writeElements(element[options.elementsKey], options, depth + 1));
currentElement = element;
currentElementName = element.name;
}
xml.push(options.spaces && hasContent(element, options) ? '\n' + Array(depth + 1).join(options.spaces) : '');
xml.push('</' + elementName + '>');
} else {
xml.push('/>');
}
return xml.join('');
}
function writeElements(elements, options, depth, firstLine) {
return elements.reduce(function (xml, element) {
var indent = writeIndentation(options, depth, firstLine && !xml);
switch (element.type) {
case 'element': return xml + indent + writeElement(element, options, depth);
case 'comment': return xml + indent + writeComment(element[options.commentKey], options);
case 'doctype': return xml + indent + writeDoctype(element[options.doctypeKey], options);
case 'cdata': return xml + (options.indentCdata ? indent : '') + writeCdata(element[options.cdataKey], options);
case 'text': return xml + (options.indentText ? indent : '') + writeText(element[options.textKey], options);
case 'instruction':
var instruction = {};
instruction[element[options.nameKey]] = element[options.attributesKey] ? element : element[options.instructionKey];
return xml + (options.indentInstruction ? indent : '') + writeInstruction(instruction, options, depth);
}
}, '');
}
function hasContentCompact(element, options, anyContent) {
var key;
for (key in element) {
if (element.hasOwnProperty(key)) {
switch (key) {
case options.parentKey:
case options.attributesKey:
break; // skip to next key
case options.textKey:
if (options.indentText || anyContent) {
return true;
}
break; // skip to next key
case options.cdataKey:
if (options.indentCdata || anyContent) {
return true;
}
break; // skip to next key
case options.instructionKey:
if (options.indentInstruction || anyContent) {
return true;
}
break; // skip to next key
case options.doctypeKey:
case options.commentKey:
return true;
default:
return true;
}
}
}
return false;
}
function writeElementCompact(element, name, options, depth, indent) {
currentElement = element;
currentElementName = name;
var elementName = 'elementNameFn' in options ? options.elementNameFn(name, element) : name;
if (typeof element === 'undefined' || element === null || element === '') {
return 'fullTagEmptyElementFn' in options && options.fullTagEmptyElementFn(name, element) || options.fullTagEmptyElement ? '<' + elementName + '></' + elementName + '>' : '<' + elementName + '/>';
}
var xml = [];
if (name) {
xml.push('<' + elementName);
if (typeof element !== 'object') {
xml.push('>' + writeText(element,options) + '</' + elementName + '>');
return xml.join('');
}
if (element[options.attributesKey]) {
xml.push(writeAttributes(element[options.attributesKey], options, depth));
}
var withClosingTag = hasContentCompact(element, options, true) || element[options.attributesKey] && element[options.attributesKey]['xml:space'] === 'preserve';
if (!withClosingTag) {
if ('fullTagEmptyElementFn' in options) {
withClosingTag = options.fullTagEmptyElementFn(name, element);
} else {
withClosingTag = options.fullTagEmptyElement;
}
}
if (withClosingTag) {
xml.push('>');
} else {
xml.push('/>');
return xml.join('');
}
}
xml.push(writeElementsCompact(element, options, depth + 1, false));
currentElement = element;
currentElementName = name;
if (name) {
xml.push((indent ? writeIndentation(options, depth, false) : '') + '</' + elementName + '>');
}
return xml.join('');
}
function writeElementsCompact(element, options, depth, firstLine) {
var i, key, nodes, xml = [];
for (key in element) {
if (element.hasOwnProperty(key)) {
nodes = isArray(element[key]) ? element[key] : [element[key]];
for (i = 0; i < nodes.length; ++i) {
switch (key) {
case options.declarationKey: xml.push(writeDeclaration(nodes[i], options, depth)); break;
case options.instructionKey: xml.push((options.indentInstruction ? writeIndentation(options, depth, firstLine) : '') + writeInstruction(nodes[i], options, depth)); break;
case options.attributesKey: case options.parentKey: break; // skip
case options.textKey: xml.push((options.indentText ? writeIndentation(options, depth, firstLine) : '') + writeText(nodes[i], options)); break;
case options.cdataKey: xml.push((options.indentCdata ? writeIndentation(options, depth, firstLine) : '') + writeCdata(nodes[i], options)); break;
case options.doctypeKey: xml.push(writeIndentation(options, depth, firstLine) + writeDoctype(nodes[i], options)); break;
case options.commentKey: xml.push(writeIndentation(options, depth, firstLine) + writeComment(nodes[i], options)); break;
default: xml.push(writeIndentation(options, depth, firstLine) + writeElementCompact(nodes[i], key, options, depth, hasContentCompact(nodes[i], options)));
}
firstLine = firstLine && !xml.length;
}
}
}
return xml.join('');
}
module.exports = function (js, options) {
options = validateOptions(options);
var xml = [];
currentElement = js;
currentElementName = '_root_';
if (options.compact) {
xml.push(writeElementsCompact(js, options, 0, true));
} else {
if (js[options.declarationKey]) {
xml.push(writeDeclaration(js[options.declarationKey], options, 0));
}
if (js[options.elementsKey] && js[options.elementsKey].length) {
xml.push(writeElements(js[options.elementsKey], options, 0, !xml.length));
}
}
return xml.join('');
};

18
node_modules/xml-js/lib/json2xml.js generated vendored Normal file
View file

@ -0,0 +1,18 @@
var js2xml = require('./js2xml.js');
module.exports = function (json, options) {
if (json instanceof Buffer) {
json = json.toString();
}
var js = null;
if (typeof (json) === 'string') {
try {
js = JSON.parse(json);
} catch (e) {
throw new Error('The JSON structure is invalid');
}
} else {
js = json;
}
return js2xml(js, options);
};

43
node_modules/xml-js/lib/options-helper.js generated vendored Normal file
View file

@ -0,0 +1,43 @@
var isArray = require('./array-helper').isArray;
module.exports = {
copyOptions: function (options) {
var key, copy = {};
for (key in options) {
if (options.hasOwnProperty(key)) {
copy[key] = options[key];
}
}
return copy;
},
ensureFlagExists: function (item, options) {
if (!(item in options) || typeof options[item] !== 'boolean') {
options[item] = false;
}
},
ensureSpacesExists: function (options) {
if (!('spaces' in options) || (typeof options.spaces !== 'number' && typeof options.spaces !== 'string')) {
options.spaces = 0;
}
},
ensureAlwaysArrayExists: function (options) {
if (!('alwaysArray' in options) || (typeof options.alwaysArray !== 'boolean' && !isArray(options.alwaysArray))) {
options.alwaysArray = false;
}
},
ensureKeyExists: function (key, options) {
if (!(key + 'Key' in options) || typeof options[key + 'Key'] !== 'string') {
options[key + 'Key'] = options.compact ? '_' + key : key;
}
},
checkFnExists: function (key, options) {
return key + 'Fn' in options;
}
};

362
node_modules/xml-js/lib/xml2js.js generated vendored Normal file
View file

@ -0,0 +1,362 @@
var sax = require('sax');
var expat /*= require('node-expat');*/ = { on: function () { }, parse: function () { } };
var helper = require('./options-helper');
var isArray = require('./array-helper').isArray;
var options;
var pureJsParser = true;
var currentElement;
function validateOptions(userOptions) {
options = helper.copyOptions(userOptions);
helper.ensureFlagExists('ignoreDeclaration', options);
helper.ensureFlagExists('ignoreInstruction', options);
helper.ensureFlagExists('ignoreAttributes', options);
helper.ensureFlagExists('ignoreText', options);
helper.ensureFlagExists('ignoreComment', options);
helper.ensureFlagExists('ignoreCdata', options);
helper.ensureFlagExists('ignoreDoctype', options);
helper.ensureFlagExists('compact', options);
helper.ensureFlagExists('alwaysChildren', options);
helper.ensureFlagExists('addParent', options);
helper.ensureFlagExists('trim', options);
helper.ensureFlagExists('nativeType', options);
helper.ensureFlagExists('nativeTypeAttributes', options);
helper.ensureFlagExists('sanitize', options);
helper.ensureFlagExists('instructionHasAttributes', options);
helper.ensureFlagExists('captureSpacesBetweenElements', options);
helper.ensureAlwaysArrayExists(options);
helper.ensureKeyExists('declaration', options);
helper.ensureKeyExists('instruction', options);
helper.ensureKeyExists('attributes', options);
helper.ensureKeyExists('text', options);
helper.ensureKeyExists('comment', options);
helper.ensureKeyExists('cdata', options);
helper.ensureKeyExists('doctype', options);
helper.ensureKeyExists('type', options);
helper.ensureKeyExists('name', options);
helper.ensureKeyExists('elements', options);
helper.ensureKeyExists('parent', options);
helper.checkFnExists('doctype', options);
helper.checkFnExists('instruction', options);
helper.checkFnExists('cdata', options);
helper.checkFnExists('comment', options);
helper.checkFnExists('text', options);
helper.checkFnExists('instructionName', options);
helper.checkFnExists('elementName', options);
helper.checkFnExists('attributeName', options);
helper.checkFnExists('attributeValue', options);
helper.checkFnExists('attributes', options);
return options;
}
function nativeType(value) {
var nValue = Number(value);
if (!isNaN(nValue)) {
return nValue;
}
var bValue = value.toLowerCase();
if (bValue === 'true') {
return true;
} else if (bValue === 'false') {
return false;
}
return value;
}
function addField(type, value) {
var key;
if (options.compact) {
if (
!currentElement[options[type + 'Key']] &&
(isArray(options.alwaysArray) ? options.alwaysArray.indexOf(options[type + 'Key']) !== -1 : options.alwaysArray)
) {
currentElement[options[type + 'Key']] = [];
}
if (currentElement[options[type + 'Key']] && !isArray(currentElement[options[type + 'Key']])) {
currentElement[options[type + 'Key']] = [currentElement[options[type + 'Key']]];
}
if (type + 'Fn' in options && typeof value === 'string') {
value = options[type + 'Fn'](value, currentElement);
}
if (type === 'instruction' && ('instructionFn' in options || 'instructionNameFn' in options)) {
for (key in value) {
if (value.hasOwnProperty(key)) {
if ('instructionFn' in options) {
value[key] = options.instructionFn(value[key], key, currentElement);
} else {
var temp = value[key];
delete value[key];
value[options.instructionNameFn(key, temp, currentElement)] = temp;
}
}
}
}
if (isArray(currentElement[options[type + 'Key']])) {
currentElement[options[type + 'Key']].push(value);
} else {
currentElement[options[type + 'Key']] = value;
}
} else {
if (!currentElement[options.elementsKey]) {
currentElement[options.elementsKey] = [];
}
var element = {};
element[options.typeKey] = type;
if (type === 'instruction') {
for (key in value) {
if (value.hasOwnProperty(key)) {
break;
}
}
element[options.nameKey] = 'instructionNameFn' in options ? options.instructionNameFn(key, value, currentElement) : key;
if (options.instructionHasAttributes) {
element[options.attributesKey] = value[key][options.attributesKey];
if ('instructionFn' in options) {
element[options.attributesKey] = options.instructionFn(element[options.attributesKey], key, currentElement);
}
} else {
if ('instructionFn' in options) {
value[key] = options.instructionFn(value[key], key, currentElement);
}
element[options.instructionKey] = value[key];
}
} else {
if (type + 'Fn' in options) {
value = options[type + 'Fn'](value, currentElement);
}
element[options[type + 'Key']] = value;
}
if (options.addParent) {
element[options.parentKey] = currentElement;
}
currentElement[options.elementsKey].push(element);
}
}
function manipulateAttributes(attributes) {
if ('attributesFn' in options && attributes) {
attributes = options.attributesFn(attributes, currentElement);
}
if ((options.trim || 'attributeValueFn' in options || 'attributeNameFn' in options || options.nativeTypeAttributes) && attributes) {
var key;
for (key in attributes) {
if (attributes.hasOwnProperty(key)) {
if (options.trim) attributes[key] = attributes[key].trim();
if (options.nativeTypeAttributes) {
attributes[key] = nativeType(attributes[key]);
}
if ('attributeValueFn' in options) attributes[key] = options.attributeValueFn(attributes[key], key, currentElement);
if ('attributeNameFn' in options) {
var temp = attributes[key];
delete attributes[key];
attributes[options.attributeNameFn(key, attributes[key], currentElement)] = temp;
}
}
}
}
return attributes;
}
function onInstruction(instruction) {
var attributes = {};
if (instruction.body && (instruction.name.toLowerCase() === 'xml' || options.instructionHasAttributes)) {
var attrsRegExp = /([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|(\w+))\s*/g;
var match;
while ((match = attrsRegExp.exec(instruction.body)) !== null) {
attributes[match[1]] = match[2] || match[3] || match[4];
}
attributes = manipulateAttributes(attributes);
}
if (instruction.name.toLowerCase() === 'xml') {
if (options.ignoreDeclaration) {
return;
}
currentElement[options.declarationKey] = {};
if (Object.keys(attributes).length) {
currentElement[options.declarationKey][options.attributesKey] = attributes;
}
if (options.addParent) {
currentElement[options.declarationKey][options.parentKey] = currentElement;
}
} else {
if (options.ignoreInstruction) {
return;
}
if (options.trim) {
instruction.body = instruction.body.trim();
}
var value = {};
if (options.instructionHasAttributes && Object.keys(attributes).length) {
value[instruction.name] = {};
value[instruction.name][options.attributesKey] = attributes;
} else {
value[instruction.name] = instruction.body;
}
addField('instruction', value);
}
}
function onStartElement(name, attributes) {
var element;
if (typeof name === 'object') {
attributes = name.attributes;
name = name.name;
}
attributes = manipulateAttributes(attributes);
if ('elementNameFn' in options) {
name = options.elementNameFn(name, currentElement);
}
if (options.compact) {
element = {};
if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
element[options.attributesKey] = {};
var key;
for (key in attributes) {
if (attributes.hasOwnProperty(key)) {
element[options.attributesKey][key] = attributes[key];
}
}
}
if (
!(name in currentElement) &&
(isArray(options.alwaysArray) ? options.alwaysArray.indexOf(name) !== -1 : options.alwaysArray)
) {
currentElement[name] = [];
}
if (currentElement[name] && !isArray(currentElement[name])) {
currentElement[name] = [currentElement[name]];
}
if (isArray(currentElement[name])) {
currentElement[name].push(element);
} else {
currentElement[name] = element;
}
} else {
if (!currentElement[options.elementsKey]) {
currentElement[options.elementsKey] = [];
}
element = {};
element[options.typeKey] = 'element';
element[options.nameKey] = name;
if (!options.ignoreAttributes && attributes && Object.keys(attributes).length) {
element[options.attributesKey] = attributes;
}
if (options.alwaysChildren) {
element[options.elementsKey] = [];
}
currentElement[options.elementsKey].push(element);
}
element[options.parentKey] = currentElement; // will be deleted in onEndElement() if !options.addParent
currentElement = element;
}
function onText(text) {
if (options.ignoreText) {
return;
}
if (!text.trim() && !options.captureSpacesBetweenElements) {
return;
}
if (options.trim) {
text = text.trim();
}
if (options.nativeType) {
text = nativeType(text);
}
if (options.sanitize) {
text = text.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
}
addField('text', text);
}
function onComment(comment) {
if (options.ignoreComment) {
return;
}
if (options.trim) {
comment = comment.trim();
}
addField('comment', comment);
}
function onEndElement(name) {
var parentElement = currentElement[options.parentKey];
if (!options.addParent) {
delete currentElement[options.parentKey];
}
currentElement = parentElement;
}
function onCdata(cdata) {
if (options.ignoreCdata) {
return;
}
if (options.trim) {
cdata = cdata.trim();
}
addField('cdata', cdata);
}
function onDoctype(doctype) {
if (options.ignoreDoctype) {
return;
}
doctype = doctype.replace(/^ /, '');
if (options.trim) {
doctype = doctype.trim();
}
addField('doctype', doctype);
}
function onError(error) {
error.note = error; //console.error(error);
}
module.exports = function (xml, userOptions) {
var parser = pureJsParser ? sax.parser(true, {}) : parser = new expat.Parser('UTF-8');
var result = {};
currentElement = result;
options = validateOptions(userOptions);
if (pureJsParser) {
parser.opt = {strictEntities: true};
parser.onopentag = onStartElement;
parser.ontext = onText;
parser.oncomment = onComment;
parser.onclosetag = onEndElement;
parser.onerror = onError;
parser.oncdata = onCdata;
parser.ondoctype = onDoctype;
parser.onprocessinginstruction = onInstruction;
} else {
parser.on('startElement', onStartElement);
parser.on('text', onText);
parser.on('comment', onComment);
parser.on('endElement', onEndElement);
parser.on('error', onError);
//parser.on('startCdata', onStartCdata);
//parser.on('endCdata', onEndCdata);
//parser.on('entityDecl', onEntityDecl);
}
if (pureJsParser) {
parser.write(xml).close();
} else {
if (!parser.parse(xml)) {
throw new Error('XML parsing error: ' + parser.getError());
}
}
if (result[options.elementsKey]) {
var temp = result[options.elementsKey];
delete result[options.elementsKey];
result[options.elementsKey] = temp;
delete result.text;
}
return result;
};

22
node_modules/xml-js/lib/xml2json.js generated vendored Normal file
View file

@ -0,0 +1,22 @@
var helper = require('./options-helper');
var xml2js = require('./xml2js');
function validateOptions (userOptions) {
var options = helper.copyOptions(userOptions);
helper.ensureSpacesExists(options);
return options;
}
module.exports = function(xml, userOptions) {
var options, js, json, parentKey;
options = validateOptions(userOptions);
js = xml2js(xml, options);
parentKey = 'compact' in options && options.compact ? '_parent' : 'parent';
// parentKey = ptions.compact ? '_parent' : 'parent'; // consider this
if ('addParent' in options && options.addParent) {
json = JSON.stringify(js, function (k, v) { return k === parentKey? '_' : v; }, options.spaces);
} else {
json = JSON.stringify(js, null, options.spaces);
}
return json.replace(/\u2028/g, '\\u2028').replace(/\u2029/g, '\\u2029');
};

111
node_modules/xml-js/package.json generated vendored Normal file
View file

@ -0,0 +1,111 @@
{
"name": "xml-js",
"version": "1.6.11",
"description": "A convertor between XML text and Javascript object / JSON text.",
"repository": {
"type": "git",
"url": "git+https://github.com/nashwaan/xml-js.git"
},
"author": "Yousuf Almarzooqi <ysf953@gmail.com>",
"license": "MIT",
"bugs": {
"url": "https://github.com/nashwaan/xml-js/issues"
},
"homepage": "https://github.com/nashwaan/xml-js#readme",
"keywords": [
"XML",
"xml",
"js",
"JSON",
"json",
"cdata",
"CDATA",
"doctype",
"processing instruction",
"Javascript",
"js2xml",
"json2xml",
"xml2js",
"xml2json",
"transform",
"transformer",
"transforming",
"transformation",
"convert",
"convertor",
"converting",
"conversion",
"parse",
"parser",
"parsing"
],
"main": "lib/index.js",
"bin": "./bin/cli.js",
"types": "./types/index.d.ts",
"scripts": {
"build": "webpack",
"doc": "node doc/compile-doc.js",
"watch:doc": "watch \"npm run doc\" doc/templates/",
"live:doc": "browser-sync start --port 9997 --server doc/ --files doc/templates/ --no-open --no-ui --no-online",
"open:doc": "biased-opener --browser chrome http://localhost:9997",
"start:doc": "npm-run-all --parallel watch:doc live:doc open:doc",
"debug": "nodemon --inspect --watch lib/ --watch test/ --debug-brk test/index.js",
"debug:cli": "nodemon --inspect --watch lib/ --debug-brk index.js -- --help",
"jest": "jest --config=test/jest.conf.js",
"jasmine": "jasmine JASMINE_CONFIG_PATH=./test/jasmine.json",
"watch:jasmine": "watch \"npm run jasmine\" lib/ test/ --ignoreDirectoryPattern=/browse-.+/",
"bundle:jasmine": "globify test/*.spec.js --watch --verbose --list --outfile test/browse-jasmine/bundle.js",
"live:jasmine": "browser-sync start --port 9999 --server test/browse-jasmine/ --files test/browse-jasmine/ --no-open --no-ui --no-online",
"open-help": "biased-opener --help",
"open:jasmine": "biased-opener --browser chrome http://localhost:9999",
"istanbul-original": "istanbul cover --dir test/coverage-jasmine -x test/browse-** test/index.js",
"istanbul": "istanbul cover --dir test/coverage-jasmine test/index.js",
"watch:istanbul": "watch \"npm run istanbul\" lib/ test/ --ignoreDirectoryPattern=/coverage-.+/",
"live:istanbul": "browser-sync start --port 9998 --server test/coverage-jasmine/lcov-report/ --files test/coverage-jasmine/lcov-report/ --no-open --no-ui --no-online",
"open:istanbul": "biased-opener --browser chrome http://localhost:9998",
"live": "npm-run-all --parallel live:* open:*",
"start": "npm-run-all --parallel bundle:jasmine live:jasmine open:jasmine watch:istanbul live:istanbul open:istanbul",
"git:commit": "git add . && git commit -a -m \"Committed by npm script.\" && git push origin master",
"git:push": "git push origin master",
"deploy": "npm-run-all --serial coverage:* git:*",
"coverage": "npm-run-all coverage:*",
"coverage:a-step": "npm run istanbul",
"coverage:coveralls": "cross-env COVERALLS_REPO_TOKEN=CaEwzjHxsKRqomJSYmGagrJdlR7uLHhHC && cat ./test/coverage-jasmine/lcov.info | coveralls",
"coverage:codecov": "codecov --token=0e52af41-702b-4d7f-8aa3-61145ac36624 --file=test/coverage-jasmine/lcov.info ",
"coverage:codacy": "cross-env CODACY_PROJECT_TOKEN=0207815122ea49a68241d1aa435f21f1 && cat ./test/coverage-jasmine/lcov.info | codacy-coverage",
"coverage:codeclimate": "cross-env CODECLIMATE_REPO_TOKEN=60848a077f9070acf358b0c7145f0a2698a460ddeca7d8250815e75aa4333f7d codeclimate-test-reporter < test\\coverage-jasmine\\lcov.info",
"prepublish": "npm run test",
"test": "npm run jasmine && npm run jest && npm run test:types",
"test:types": "tsc -p ./types"
},
"dependencies": {
"sax": "^1.2.4"
},
"devDependencies": {
"babel-core": "^6.26.3",
"babel-loader": "^7.1.4",
"babel-preset-env": "^1.7.0",
"biased-opener": "^0.2.8",
"browser-sync": "^2.26.3",
"cash-cat": "^0.2.0",
"codacy-coverage": "^3.4.0",
"codeclimate-test-reporter": "^0.5.1",
"codecov": "^3.1.0",
"coveralls": "^3.0.2",
"cross-env": "^5.2.0",
"eslint": "^5.12.0",
"globify": "^2.3.4",
"istanbul": "^0.4.5",
"jasmine": "^3.3.1",
"jest": "^20.0.4",
"jest-cli": "^20.0.4",
"jsonpath": "^1.0.0",
"nodemon": "^1.18.9",
"npm-run-all": "^4.1.5",
"prismjs": "^1.15.0",
"typescript": "^3.2.2",
"unminified-webpack-plugin": "^1.4.2",
"watch": "^1.0.1",
"webpack": "^3.10.0"
}
}

154
node_modules/xml-js/types/index.d.ts generated vendored Normal file
View file

@ -0,0 +1,154 @@
export interface Attributes {
[key: string]: string | number | undefined
}
export interface DeclarationAttributes {
version?: string | number
encoding?: 'utf-8' | string
standalone?: 'yes' | 'no'
}
export interface ElementCompact {
[key: string]: any
_declaration?: {
_attributes?: DeclarationAttributes
}
_instruction?: {
[key: string]: string
}
_attributes?: Attributes
_cdata?: string
_doctype?: string
_comment?: string
_text?: string | number
}
export interface Element {
declaration?: {
attributes?: DeclarationAttributes
}
instruction?: string
attributes?: Attributes
cdata?: string
doctype?: string
comment?: string
text?: string | number | boolean
type?: string
name?: string
elements?: Array<Element>
}
declare namespace Options {
interface XML2JSON extends XML2JS {
spaces?: number | string
}
interface XML2JS extends ChangingKeyNames, IgnoreOptions {
compact?: boolean
trim?: boolean
sanitize?: boolean
nativeType?: boolean
addParent?: boolean
alwaysArray?: boolean | Array<string>
alwaysChildren?: boolean
instructionHasAttributes?: boolean
captureSpacesBetweenElements?: boolean
doctypeFn?: (value: string, parentElement: object) => void;
instructionFn?: (
instructionValue: string,
instructionName: string,
parentElement: string
) => void;
cdataFn?: (value: string, parentElement: object) => void;
commentFn?: (value: string, parentElement: object) => void;
textFn?: (value: string, parentElement: object) => void;
instructionNameFn?: (
instructionName: string,
instructionValue: string,
parentElement: string
) => void;
elementNameFn?: (value: string, parentElement: object) => void;
attributeNameFn?: (
attributeName: string,
attributeValue: string,
parentElement: string
) => void;
attributeValueFn?: (
attributeValue: string,
attributeName: string,
parentElement: string
) => void;
attributesFn?: (value: string, parentElement: string) => void;
}
interface JS2XML extends ChangingKeyNames, IgnoreOptions {
spaces?: number | string
compact?: boolean
indentText?: boolean
indentCdata?: boolean
indentAttributes?: boolean
indentInstruction?: boolean
fullTagEmptyElement?: boolean
noQuotesForNativeAttributes?: boolean
doctypeFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
instructionFn?: (
instructionValue: string,
instructionName: string,
currentElementName: string,
currentElementObj: object
) => void;
cdataFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
commentFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
textFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
instructionNameFn?: (
instructionName: string,
instructionValue: string,
currentElementName: string,
currentElementObj: object
) => void;
elementNameFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
attributeNameFn?: (
attributeName: string,
attributeValue: string,
currentElementName: string,
currentElementObj: object
) => void;
attributeValueFn?: (
attributeValue: string,
attributeName: string,
currentElementName: string,
currentElementObj: object
) => void;
attributesFn?: (value: string, currentElementName: string, currentElementObj: object) => void;
fullTagEmptyElementFn?: (currentElementName: string, currentElementObj: object) => void;
}
interface IgnoreOptions {
ignoreDeclaration?: boolean
ignoreInstruction?: boolean
ignoreAttributes?: boolean
ignoreComment?: boolean
ignoreCdata?: boolean
ignoreDoctype?: boolean
ignoreText?: boolean
}
interface ChangingKeyNames {
declarationKey?: string
instructionKey?: string
attributesKey?: string
textKey?: string
cdataKey?: string
doctypeKey?: string
commentKey?: string
parentKey?: string
typeKey?: string
nameKey?: string
elementsKey?: string
}
}
export function js2xml(obj: Element | ElementCompact, options?: Options.JS2XML): string;
export function json2xml(json: string, options?: Options.JS2XML): string;
export function xml2json(xml: string, options?: Options.XML2JSON): string;
export function xml2js(xml: string, options?: Options.XML2JS): Element | ElementCompact;

14
node_modules/xml-js/types/tsconfig.json generated vendored Normal file
View file

@ -0,0 +1,14 @@
{
"compilerOptions": {
"target": "es5",
"module": "commonjs",
"noImplicitAny": true,
"strictNullChecks": true,
"noEmit": true
},
"files": [
"./index.d.ts",
"./xml-js-tests.ts"
],
"compileOnSave": false
}

4
node_modules/xml-js/types/typings.json generated vendored Normal file
View file

@ -0,0 +1,4 @@
{
"name": "xml-js",
"main": "index.d.ts"
}

60
node_modules/xml-js/types/xml-js-tests.ts generated vendored Normal file
View file

@ -0,0 +1,60 @@
import { Element, ElementCompact } from './index'
import * as convert from './index'
// Declaration
const declarationCompact1: ElementCompact = { _declaration: { _attributes: { version: 2 } }};
const declarationCompact2: ElementCompact = { _declaration: { _attributes: { version: '1.0', encoding: 'utf-8', standalone: 'yes' }}};
const declaration1: Element = { declaration: { }};
const declaration2: Element = { declaration: { attributes: { version: '1.0', encoding: 'utf-8', standalone: 'yes', }}};
// Processing Instruction
const instructionCompact: ElementCompact = { _instruction: { go: 'there' }};
const instruction: Element = { elements:[{ type: 'instruction', name: 'go', instruction: 'there' }]};
// Comment
const commentCompact: ElementCompact = { _comment : 'Hello, World!' };
const comment: Element = { elements: [{ type: 'comment', comment: 'Hello, World!' }]};
// CDATA
const cdataCompact: ElementCompact = { _cdata: '<foo></bar>' };
const cdata: Element = { elements : [{ type: 'cdata', cdata: '<foo></bar>' }]};
// Element
const elementCompact1: ElementCompact = { a: {} };
const element1: Element = { elements:[{ type: 'element', name: 'a' }]};
const elementCompact2: ElementCompact = { a: { _attributes: { x: '1.234', y:'It\'s', z: undefined }}};
const element2: Element = { elements: [{ type: 'element', name: 'a', attributes: { x: '1.234', y: 'It\'s', z: undefined }}]};
const elementCompact3: ElementCompact = { a: { _text: ' Hi ' }};
const element3: Element = { elements:[{ type: 'element', name: 'a', elements: [{ type: 'text', text: ' Hi ' }]}]};
const elementCompact4: ElementCompact = { a: {}, b: {} };
const element4: Element = { elements:[{ type: 'element', name: 'a' }, { type: 'element', name: 'b' }]};
const elementCompact5: ElementCompact = { a: { b: {} }};
const element5: Element = { elements: [{ type: 'element', name: 'a', elements: [{ type: 'element', name: 'b' }]}]};
const xml = `
<?xml version="1.0" encoding="utf-8"?>
<note importance="high" logged="true">
<title>Happy</title>
<todo>Work</todo>
<todo>Play</todo>
</note>`;
// xml2js
let jsResult1: any = convert.xml2js(xml, {compact:true});
let jsResult2: any = convert.xml2js(xml, {compact:false});
// xml2json
let jsonResult1: string = convert.xml2json(xml, {compact:true, spaces:4});
let jsonResult2: string = convert.xml2json(xml, {compact:false});
// js2xml
let xmlResult1: string = convert.js2xml({a:{}}, { compact:true, spaces:4});
let xmlResult2: string = convert.js2xml({elements:[{type:'element', name:'a'}]}, {compact:false});
// json2xml
let xmlResult3: string = convert.json2xml('{"a":{}}', { compact:true, spaces:4});
let xmlResult4: string = convert.json2xml('{"elements":[{"type":"element","name":"a"}]}', {compact:false});

28
node_modules/xml-js/webpack.config.js generated vendored Normal file
View file

@ -0,0 +1,28 @@
const path = require('path');
const webpack = require('webpack');
const UnminifiedWebpackPlugin = require('unminified-webpack-plugin');
module.exports = {
entry: {
'dist': './lib/index.js',
'doc': './lib/index.js'
},
output: {
path: path.resolve(__dirname, '.'),
filename: '[name]/xml-js.min.js',
libraryTarget: 'window',
// library: 'xmljs' // don't specify this
},
// module: {
// rules: [
// {
// test: /\.(js)$/,
// use: 'babel-loader'
// }
// ]
// },
plugins: [
new webpack.optimize.UglifyJsPlugin(),
new UnminifiedWebpackPlugin()
]
}