Added support for variable declarations with binding patterns

src/bundle-generator.ts

@@ -323,12 +323,11 @@ export function generateDtsBundle(entries: readonly EntryPointConfig[], options:
 										continue;
 									}
 
-									// it seems that the compiler doesn't produce anything else (e.g. binding elements) in declaration files
-									// but it is still possible to write such code manually
-									// this feels like quite rare case so no support for now
-									warnLog(`Unhandled variable identifier type detected (${
-										ts.SyntaxKind[variableDeclaration.name.kind]
-									}). Please report this issue to https://github.com/timocov/dts-bundle-generator`);
+									for (const element of variableDeclaration.name.elements) {
+										if (!ts.isOmittedExpression(element) && ts.isIdentifier(element.name)) {
+											collisionsResolver.addTopLevelIdentifier(element.name);
+										}
+									}
 								}
 							} else if (isNodeNamedDeclaration(statement)) {
 								const statementName = getNodeName(statement);
@@ -894,6 +893,10 @@ export function generateDtsBundle(entries: readonly EntryPointConfig[], options:
 
 			if (ts.isVariableStatement(node)) {
 				return node.declarationList.declarations.some((declaration: ts.VariableDeclaration) => {
+					if (ts.isObjectBindingPattern(declaration.name) || ts.isArrayBindingPattern(declaration.name)) {
+						return declaration.name.elements.some(isNodeUsed);
+					}
+
 					return isNodeUsed(declaration);
 				});
 			}

src/helpers/typescript.ts

@@ -14,9 +14,10 @@ const namedDeclarationKinds = [
 	ts.SyntaxKind.NamespaceExport,
 	ts.SyntaxKind.NamespaceImport,
 	ts.SyntaxKind.ExportSpecifier,
+	ts.SyntaxKind.BindingElement,
 ];
 
-export type NodeName = ts.DeclarationName | ts.DefaultKeyword | ts.QualifiedName | ts.PropertyAccessExpression;
+export type NodeName = ts.DeclarationName | ts.DefaultKeyword | ts.QualifiedName | ts.PropertyAccessExpression | ts.BindingPattern;
 
 export function isNodeNamedDeclaration(node: ts.Node): node is ts.NamedDeclaration {
 	return namedDeclarationKinds.indexOf(node.kind) !== -1;

src/types-usage-evaluator.ts

@@ -106,9 +106,15 @@ export class TypesUsageEvaluator {
 		if (isNodeNamedDeclaration(node)) {
 			const nodeName = getNodeName(node);
 			if (nodeName !== undefined) {
-				const childSymbol = this.getSymbol(nodeName);
-				if (childSymbol !== null) {
-					this.computeUsagesRecursively(node, childSymbol);
+				if (ts.isObjectBindingPattern(nodeName) || ts.isArrayBindingPattern(nodeName)) {
+					for (const element of nodeName.elements) {
+						this.computeUsageForNode(element);
+					}
+				} else {
+					const childSymbol = this.getSymbol(nodeName);
+					if (childSymbol !== null) {
+						this.computeUsagesRecursively(node, childSymbol);
+					}
 				}
 			}
 		}

tests/e2e/test-cases/binding-patterns-without-initializer/array-const.d.ts

@@ -0,0 +1,4 @@
+export const [
+	FOO = '321',
+	BAR = 1337,
+];

tests/e2e/test-cases/binding-patterns-without-initializer/config.ts

@@ -0,0 +1,5 @@
+import { TestCaseConfig } from '../test-case-config';
+
+const config: TestCaseConfig = {};
+
+export = config;

tests/e2e/test-cases/binding-patterns-without-initializer/index.spec.js

@@ -0,0 +1 @@
+require('../run-test-case').runTestCase(__dirname);

tests/e2e/test-cases/binding-patterns-without-initializer/input.d.ts

@@ -0,0 +1,5 @@
+import { BAR as ARR_BAR, FOO as ARR_FOO } from './array-const';
+import { BAR as OBJ_BAR, FOO as OBJ_FOO } from './obj-const';
+
+export type BarType = typeof ARR_BAR | typeof OBJ_BAR;
+export type FooType = typeof ARR_FOO | typeof OBJ_FOO;

tests/e2e/test-cases/binding-patterns-without-initializer/obj-const.d.ts

@@ -0,0 +1,4 @@
+export declare const {
+	FOO = 123,
+	BAR = 42,
+};

tests/e2e/test-cases/binding-patterns-without-initializer/output.d.ts

@@ -0,0 +1,6 @@
+declare const [FOO = "321", BAR = 1337,];
+declare const { FOO$1 = 123, BAR$1 = 42, };
+export type BarType = typeof BAR | typeof BAR$1;
+export type FooType = typeof FOO | typeof FOO$1;
+
+export {};