[Fixed] Solve issue #26, support export { variables as var } statem…

…ent.

[Added] now interface `SvelteDataItem` provides a new property `localName` with information about internal name of component property.

CHANGELOG.md

@@ -5,6 +5,11 @@ Check [Keep a Changelog](http://keepachangelog.com/) for recommendations on how
 
 ## UNRELEASED
 
+## [3.0.1] 17.08.2020
+
+- [Fixed] Solve issue #26, support `export { variables as var }` statement.
+- [Added] now interface `SvelteDataItem` provides a new property `localName` with information about internal name of component property.
+
 ## [3.0.0] 08.08.2020
 
 - [Fixed] Solve vulnerability issues:

README.md

@@ -7,6 +7,11 @@ Generate a JSON documentation for a Svelte file
 
 ## Changelog 
 
+### [3.0.1] 17.08.2020
+
+- [Fixed] Solve issue #26, support `export { variables as var }` statement.
+- [Added] now interface `SvelteDataItem` provides a new property `localName` with information about internal name of component property.
+
 ### [3.0.0] 08.08.2020
 
 - [Fixed] Solve vulnerability issues:

index.js

@@ -74,24 +74,32 @@ function convertVisibilityToLevel(visibility) {
  return 0;
 }
 
-function mergeItems(itemType, currentItem, newItem) {
+function mergeItems(itemType, currentItem, newItem, ignoreLocations) {
  if (convertVisibilityToLevel(currentItem.visibility) < convertVisibilityToLevel(newItem.visibility)) {
  currentItem.visibility = newItem.visibility;
  }
 
  if (!currentItem.description && newItem.description) {
- currentItem.description = newItem;
+ currentItem.description = newItem.description;
+ }
+
+ if (!currentItem.type || currentItem.type.type === 'any') {
+ if (newItem.type && newItem.type.type !== 'any') {
+ currentItem.type = newItem.type;
+ }
  }
 
  if (!currentItem.keywords && newItem.keywords) {
  currentItem.keywords = newItem.keywords;
  }
 
- if (newItem.locations && newItem.locations.length > 0) {
- if (currentItem.locations) {
- currentItem.locations.push(...newItem.locations);
- } else {
- currentItem.locations = [...newItem.locations];
+ if (!ignoreLocations) {
+ if (newItem.locations && newItem.locations.length > 0) {
+ if (currentItem.locations) {
+ currentItem.locations.push(...newItem.locations);
+ } else {
+ currentItem.locations = [...newItem.locations];
+ }
  }
  }
 
@@ -134,6 +142,14 @@ function subscribeOnParserEvents(parser, options, version, resolve, reject) {
  parser.on(eventName, (value) => {
  const itemIndex = component[feature].findIndex(item => item.name === value.name);
 
+ if (value.localName) {
+ const localItem = component[feature].find(item => item.name === value.localName);
+
+ if (localItem) {
+ value = mergeItems(feature, value, localItem, true);
+ }
+ }
+
  if (itemIndex < 0) {
  component[feature].push(value);
  } else {

lib/v3/parser.js

@@ -121,6 +121,7 @@ class Parser extends EventEmitter {
  type: utils.inferTypeFromVariableDeclaration(variable),
  importPath: variable.importPath,
  originalName: variable.originalName,
+ localName: variable.localName
  });
 
  if (variable.declarator && variable.declarator.init) {
@@ -330,6 +331,7 @@ class Parser extends EventEmitter {
 
  if (node.type === 'ExportNamedDeclaration' && level === 0 && parseContext.scopeType !== SCOPE_MARKUP) {
  const declaration = node.declaration;
+ const specifiers = node.specifiers;
 
  if (declaration) {
  const exportNodeComment = utils.getCommentFromSourceCode(node, parseContext.sourceCode, { defaultVisibility: 'public', useLeading: true, useTrailing: false });
@@ -352,6 +354,27 @@ class Parser extends EventEmitter {
  return;
  }
  }
+
+ if (specifiers) {
+ specifiers.forEach(specifier => {
+ if (specifier.type === 'ExportSpecifier') {
+ const exportedOrLocalName = specifier.exported
+ ? specifier.exported.name
+ : specifier.local.name;
+
+ this.emitDataItem({
+ node: specifier,
+ name: exportedOrLocalName,
+ localName: specifier.local.name,
+ kind: 'const',
+ location: {
+ start: specifier.exported ? specifier.exported.start : specifier.local.start,
+ end: specifier.exported ? specifier.exported.end : specifier.local.end
+ }
+ }, parseContext, 'public');
+ }
+ });
+ }
  }
 
  if (node.type === 'LabeledStatement' && level === 0 && parseContext.scopeType !== SCOPE_MARKUP) {

package.json

@@ -1,6 +1,6 @@
 {
  "name": "sveltedoc-parser",
- "version": "3.0.0",
+ "version": "3.0.1",
  "description": "Generate a JSON documentation for a Svelte file",
  "main": "index.js",
  "scripts": {

test/svelte3/integration/data/data.export.aliace.svelte

@@ -0,0 +1,11 @@
+<script>
+ /** 
+ * Description for variable that must be exported later 
+ * @type {Array<string>}
+ */
+ const classes = [ 'btn' ];
+
+ export { 
+ classes as class
+ };
+</script>

test/svelte3/integration/data/data.export.many.svelte

@@ -0,0 +1,7 @@
+<script>
+ /* The `a` variable description */
+ let a = 1;
+ let b = 'Test';
+
+ export { a, b };
+</script>

test/svelte3/integration/data/data.spec.js

@@ -247,4 +247,78 @@ describe('SvelteDoc v3 - Props', () => {
  done(e);
  });
  });
+
+ it('Export object statement with multiple variables should be parsed as public props', done => {
+ parser.parse({
+ version: 3,
+ filename: path.resolve(__dirname, 'data.export.many.svelte'),
+ features: ['data'],
+ includeSourceLocations: true,
+ ignoredVisibilities: []
+ }).then((doc) => {
+ expect(doc, 'Document should be provided').to.exist;
+ expect(doc.data, 'Document data should be parsed').to.exist;
+
+ expect(doc.data.length).to.equal(2);
+
+ const prop1 = doc.data.find(d => d.name === 'a');
+
+ expect(prop1.name).to.equal('a');
+ expect(prop1.visibility).to.equal('public');
+ expect(prop1.static).to.be.false;
+ expect(prop1.description).to.be.equal('The `a` variable description');
+ expect(prop1.type).to.eql({ kind: 'type', type: 'number', text: 'number' });
+
+ expect(prop1.locations, 'Code location should be parsed').to.be.exist;
+ expect(prop1.locations[0]).is.deep.equals({ start: 58, end: 59 });
+ expect(prop1.locations[1]).is.deep.equals({ start: 102, end: 103 });
+
+ const prop2 = doc.data.find(d => d.name === 'b');
+
+ expect(prop2.name).to.equal('b');
+ expect(prop2.visibility).to.equal('public');
+ expect(prop2.static).to.be.false;
+ expect(prop2.type).to.eql({ kind: 'type', type: 'string', text: 'string' });
+
+ done();
+ }).catch(e => {
+ done(e);
+ });
+ });
+
+ it('Export object statement with variable and aliace for that should be parsed as public prop', done => {
+ parser.parse({
+ version: 3,
+ filename: path.resolve(__dirname, 'data.export.aliace.svelte'),
+ features: ['data'],
+ includeSourceLocations: true,
+ ignoredVisibilities: []
+ }).then((doc) => {
+ expect(doc, 'Document should be provided').to.exist;
+ expect(doc.data, 'Document data should be parsed').to.exist;
+
+ expect(doc.data.length).to.equal(2);
+
+ const prop = doc.data.find(d => d.name === 'class');
+
+ expect(prop).to.exist;
+ expect(prop.name, 'Aliace name must be exposed instead of original name').to.equal('class');
+ expect(prop.localName, 'Local name must be stored').to.equal('classes');
+ expect(prop.visibility).to.equal('public');
+ expect(prop.static).to.be.false;
+ expect(prop.description).to.be.equal('Description for variable that must be exported later');
+ expect(prop.type).to.eql({ kind: 'type', type: 'Array<string>', text: 'Array<string>' });
+
+ expect(prop.locations, 'Code location should be parsed').to.be.exist;
+ expect(prop.locations[0]).is.deep.equals({ start: 189, end: 194 });
+
+ const localProp = doc.data.find(d => d.name === 'classes');
+
+ expect(localProp, 'Local prop definition also must be provided').to.exist;
+
+ done();
+ }).catch(e => {
+ done(e);
+ });
+ });
 });

typings.d.ts

@@ -137,6 +137,20 @@ export interface SvelteDataItem extends ISvelteItem {
  * @since {2.2.0}
  */
  originalName?: string;
+
+ /**
+ * The local name of the prop that was exported with aliace statement
+ * @example
+ * ```js
+ * const local = 1;
+ * export { local as public };
+ * // `name` of this item will be `'public'`
+ * // `localName` of this item will be `'local'`
+ * ```
+ * @since {3.0.1}
+ */
+ localName?: string;
+
  /**
  * The relative path of importing of this object.
  * When not defined, so variable is not provided.