pax_global_header 0000666 0000000 0000000 00000000064 14611320214 0014504 g ustar 00root root 0000000 0000000 52 comment=c69ff0d1c585b96f093ee6323bbc5a74cc1eda58
timocov-dts-bundle-generator-c69ff0d/ 0000775 0000000 0000000 00000000000 14611320214 0017712 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/.eslintignore 0000664 0000000 0000000 00000000162 14611320214 0022414 0 ustar 00root root 0000000 0000000 *.js
/dist/**
/dts-out/**
**/node_modules
/tests/e2e/test-cases/*/**/*.ts
!/tests/e2e/test-cases/**/*.spec.js
timocov-dts-bundle-generator-c69ff0d/.eslintrc.js 0000664 0000000 0000000 00000036244 14611320214 0022162 0 ustar 00root root 0000000 0000000 module.exports = {
root: true,
plugins: [
'@typescript-eslint',
'eslint-plugin-deprecation',
'eslint-plugin-import',
'eslint-plugin-unicorn',
],
extends: [
'eslint:recommended',
],
env: {
browser: false,
es6: true,
node: true,
},
parserOptions: {
ecmaVersion: 2020,
sourceType: 'module',
},
overrides: [
{
// rules specific for js files only
files: ['**/*.js'],
rules: {
// enforces no braces where they can be omitted
// http://eslint.org/docs/rules/arrow-body-style
'arrow-body-style': ['error', 'as-needed'],
// enforce one true brace style
'brace-style': ['error', '1tbs', { allowSingleLine: true }],
// require camel case names
camelcase: 'error',
// encourages use of dot notation whenever possible
'dot-notation': ['error', { allowKeywords: true }],
// this option sets a specific tab width for your code
// https://github.com/eslint/eslint/blob/master/docs/rules/indent.md
indent: ['error', 'tab', { SwitchCase: 1, VariableDeclarator: 1 }],
// disallow creation of functions within loops
'no-loop-func': 'error',
// disallow variable declarations from shadowing variables declared in the outer scope
'no-shadow': 'error',
// disallow use of undeclared variables unless mentioned in a /*global */ block
'no-undef': 'error',
// disallow usage of expressions in statement position
'no-unused-expressions': 'error',
// disallow declaration of variables that are not used in the code
'no-unused-vars': ['error', { vars: 'local', args: 'none', ignoreRestSiblings: true }],
// specify whether double or single quotes should be used
quotes: ['error', 'single', { avoidEscape: true, allowTemplateLiterals: true }],
// require or disallow use of semicolons instead of ASI
semi: ['error', 'always'],
},
},
{
files: ['**/*.ts'],
extends: [
'plugin:@typescript-eslint/eslint-recommended',
'plugin:@typescript-eslint/recommended',
'plugin:@typescript-eslint/recommended-requiring-type-checking',
'plugin:import/typescript',
],
parser: '@typescript-eslint/parser',
parserOptions: {
project: 'tsconfig.options.json',
sourceType: 'module',
},
rules: {
'@typescript-eslint/array-type': [
'error',
{
default: 'array',
},
],
'@typescript-eslint/brace-style': ['error', '1tbs', { allowSingleLine: true }],
'@typescript-eslint/consistent-type-assertions': [
'error',
{
assertionStyle: 'as',
objectLiteralTypeAssertions: 'never',
},
],
'@typescript-eslint/consistent-type-definitions': ['error', 'interface'],
'@typescript-eslint/dot-notation': 'error',
'@typescript-eslint/explicit-member-accessibility': [
'error',
{
accessibility: 'explicit',
overrides: {
accessors: 'explicit',
constructors: 'explicit',
},
},
],
'@typescript-eslint/indent': ['error', 'tab'],
'@typescript-eslint/member-delimiter-style': 'error',
'@typescript-eslint/member-ordering': [
'error',
{
default: [
'signature',
'public-static-field',
'protected-static-field',
'private-static-field',
'public-instance-field',
'protected-instance-field',
'private-instance-field',
'constructor',
'public-instance-method',
'public-static-method',
'protected-instance-method',
'protected-static-method',
'private-instance-method',
'private-static-method',
],
},
],
'@typescript-eslint/naming-convention': [
'error',
{ selector: 'default', format: ['camelCase'], leadingUnderscore: 'forbid', trailingUnderscore: 'forbid' },
{ selector: 'typeLike', format: ['PascalCase'] },
{ selector: 'enumMember', format: ['PascalCase'] },
],
'@typescript-eslint/no-empty-interface': 'off',
'@typescript-eslint/no-empty-function': 'off',
'@typescript-eslint/no-explicit-any': 'error',
'@typescript-eslint/no-extraneous-class': 'error',
'@typescript-eslint/no-inferrable-types': [
'error',
{
ignoreParameters: true,
ignoreProperties: true,
},
],
'@typescript-eslint/no-invalid-void-type': 'error',
'@typescript-eslint/no-loop-func': 'error',
'@typescript-eslint/no-namespace': 'off',
'@typescript-eslint/no-non-null-assertion': 'error',
'@typescript-eslint/no-require-imports': 'off',
'@typescript-eslint/no-shadow': 'error',
'@typescript-eslint/no-unnecessary-boolean-literal-compare': 'off',
'@typescript-eslint/no-unnecessary-qualifier': 'error',
'@typescript-eslint/no-unnecessary-type-arguments': 'off',
'@typescript-eslint/no-unsafe-assignment': 'off',
'@typescript-eslint/no-unused-expressions': 'error',
'@typescript-eslint/no-unused-vars': 'off',
'@typescript-eslint/no-use-before-define': 'off',
'@typescript-eslint/parameter-properties': ['error', { prefer: 'class-property' }],
'@typescript-eslint/prefer-for-of': 'off',
'@typescript-eslint/prefer-function-type': 'error',
'@typescript-eslint/prefer-readonly': 'off', // TODO
'@typescript-eslint/promise-function-async': 'off',
'@typescript-eslint/quotes': ['error', 'single', { avoidEscape: true, allowTemplateLiterals: true }],
'@typescript-eslint/restrict-plus-operands': 'off',
'@typescript-eslint/restrict-template-expressions': 'off',
'@typescript-eslint/semi': [
'error',
'always',
],
'@typescript-eslint/strict-boolean-expressions': 'off',
'@typescript-eslint/triple-slash-reference': [
'off',
{
path: 'never',
types: 'prefer-import',
lib: 'never',
},
],
'@typescript-eslint/type-annotation-spacing': 'error',
'@typescript-eslint/typedef': [
'error',
{
parameter: true,
propertyDeclaration: true,
memberVariableDeclaration: true,
},
],
'@typescript-eslint/unbound-method': 'off',
'deprecation/deprecation': 'error',
},
},
],
rules: {
// enforces return statements in callbacks of array's methods
// http://eslint.org/docs/rules/array-callback-return
'array-callback-return': 'error',
'arrow-parens': ['error', 'as-needed'],
// enforce a maximum cyclomatic complexity allowed in a program
complexity: ['error', { max: 13 }],
// specify curly brace conventions for all control statements
curly: ['error', 'all'],
// require the use of === and !==
eqeqeq: ['error', 'smart'],
// require `for-in` loops to include an `if` statement
'guard-for-in': 'error',
// enforce a maximum number of classes per file
'max-classes-per-file': ['error', 5],
// disallow the use of alert, confirm, and prompt
'no-alert': 'warn',
// disallow use of arguments.caller or arguments.callee
'no-caller': 'error',
// disallow Unnecessary Labels
// http://eslint.org/docs/rules/no-extra-label
'no-extra-label': 'error',
// disallow use of eval()
'no-eval': 'error',
// disallow adding to native types
'no-extend-native': 'error',
// disallow unnecessary function binding
'no-extra-bind': 'error',
// disallow the use of leading or trailing decimal points in numeric literals
'no-floating-decimal': 'error',
// disallow use of eval()-like methods
'no-implied-eval': 'error',
// disallow usage of __iterator__ property
'no-iterator': 'error',
// disallow use of labels for anything other then loops and switches
'no-labels': ['error', { allowLoop: false, allowSwitch: false }],
// disallow unnecessary nested blocks
'no-lone-blocks': 'error',
// disallow use of multiple spaces
'no-multi-spaces': 'error',
// disallow use of multiline strings
'no-multi-str': 'error',
// disallow use of new operator when not part of the assignment or comparison
'no-new': 'error',
// disallow use of new operator for Function object
'no-new-func': 'error',
// disallows creating new instances of String, Number, and Boolean
'no-new-wrappers': 'error',
// disallow use of octal escape sequences in string literals, such as
// var foo = 'Copyright \251';
'no-octal-escape': 'error',
// disallow usage of __proto__ property
'no-proto': 'error',
// disallow use of assignment in return statement
'no-return-assign': 'error',
// disallow unnecessary `return await`
'no-return-await': 'error',
// disallow use of `javascript:` urls.
'no-script-url': 'error',
// disallow comparisons where both sides are exactly the same
'no-self-compare': 'error',
// disallow use of comma operator
'no-sequences': 'error',
// restrict what can be thrown as an exception
'no-throw-literal': 'error',
// requires to declare all vars on top of their containing scope
// 'vars-on-top': 2,
// require immediate function invocation to be wrapped in parentheses
// http://eslint.org/docs/rules/wrap-iife.html
'wrap-iife': ['error', 'inside'],
// errors
// disallow assignment in conditional expressions
'no-cond-assign': ['error', 'always'],
// disallow use of console
'no-console': 'error',
// disallow unnecessary parentheses
'no-extra-parens': ['error', 'functions'],
// disallow template literal placeholder syntax in regular strings
'no-template-curly-in-string': 'error',
// Avoid code that looks like two expressions but is actually one
'no-unexpected-multiline': 'off',
// es6
// require space before/after arrow function's arrow
// https://github.com/eslint/eslint/blob/master/docs/rules/arrow-spacing.md
'arrow-spacing': ['error', { before: true, after: true }],
// require trailing commas in multiline object literals
'comma-dangle': ['error', {
arrays: 'always-multiline',
objects: 'always-multiline',
imports: 'always-multiline',
exports: 'always-multiline',
functions: 'never',
}],
// disallow duplicate module imports
'no-duplicate-imports': 'error',
// require let or const instead of var
'no-var': 'error',
// disallow unnecessary constructor
// http://eslint.org/docs/rules/no-useless-constructor
'no-useless-constructor': 'error',
// require method and property shorthand syntax for object literals
// https://github.com/eslint/eslint/blob/master/docs/rules/object-shorthand.md
'object-shorthand': 'off',
// suggest using arrow functions as callbacks
'prefer-arrow-callback': 'error',
// suggest using of const declaration for variables that are never modified after declared
'prefer-const': 'error',
// require rest parameters instead of `arguments`
'prefer-rest-params': 'error',
// require template literals instead of string concatenation
'prefer-template': 'off', // TODO
// enforce usage of spacing in template strings
// http://eslint.org/docs/rules/template-curly-spacing
'template-curly-spacing': 'error',
// enforce spacing around the * in yield* expressions
// http://eslint.org/docs/rules/yield-star-spacing
'yield-star-spacing': ['error', 'after'],
// strict
strict: 'off',
// vars
// disallow initializing variables to `undefined`
'no-undef-init': 'error',
// style
// enforce spacing inside array brackets
'array-bracket-spacing': ['error', 'never'],
// enforce spacing before and after comma
'comma-spacing': ['error', { before: false, after: true }],
// enforce one true comma style
'comma-style': ['error', 'last'],
// disallow padding inside computed properties
'computed-property-spacing': ['error', 'never'],
// enforce newline at the end of file, with no multiple empty lines
'eol-last': 'error',
// specify whether double or single quotes should be used in JSX attributes
// http://eslint.org/docs/rules/jsx-quotes
'jsx-quotes': ['error', 'prefer-double'],
// enforces spacing between keys and values in object literal properties
'key-spacing': ['error', { beforeColon: false, afterColon: true }],
// require a space before & after certain keywords
'keyword-spacing': ['error', {
before: true,
after: true,
overrides: {
return: { after: true },
throw: { after: true },
case: { after: true },
},
}],
// enforce a maximum number of parameters in function definitions
'max-params': ['error', { max: 6 }],
// require a capital letter for constructors
'new-cap': ['error', { newIsCap: true, capIsNew: false }],
// enforce or disallow parentheses when invoking a constructor with no arguments
'new-parens': ['error', 'always'],
// disallow use of the Array constructor
'no-array-constructor': 'error',
// disallow mixed spaces and tabs for indentation
'no-mixed-spaces-and-tabs': 'error',
// disallow multiple empty lines and only one newline at the end
'no-multiple-empty-lines': ['error', { max: 1, maxEOF: 1 }],
// disallow nested ternary expressions
// 'no-nested-ternary': 2,
// disallow use of the Object constructor
'no-new-object': 'error',
// disallow specified syntax
'no-restricted-syntax': ['error', 'ForInStatement', `BinaryExpression[operator='in']`],
// disallow space between function identifier and application
'no-spaced-func': 'error',
// disallow trailing whitespace at the end of lines
'no-trailing-spaces': 'error',
// disallow the use of Boolean literals in conditional expressions
// also, prefer `a || b` over `a ? a : b`
// http://eslint.org/docs/rules/no-unneeded-ternary
'no-unneeded-ternary': ['error', { defaultAssignment: false }],
// disallow whitespace before properties
// http://eslint.org/docs/rules/no-whitespace-before-property
'no-whitespace-before-property': 'error',
// require padding inside curly braces
'object-curly-spacing': ['error', 'always'],
// allow just one var statement per function
'one-var': ['error', 'never'],
// require a newline around variable declaration
// http://eslint.org/docs/rules/one-var-declaration-per-line
'one-var-declaration-per-line': ['error', 'always'],
// enforce padding within blocks
'padded-blocks': ['error', 'never'],
// disallow using Object.assign with an object literal as the first argument and prefer the use of object spread instead.
'prefer-object-spread': 'error',
// require quotes around object literal property names
// http://eslint.org/docs/rules/quote-props.html
'quote-props': ['error', 'as-needed', { keywords: false, unnecessary: true, numbers: false }],
// enforce spacing before and after semicolons
'semi-spacing': ['error', { before: false, after: true }],
// require or disallow space before blocks
'space-before-blocks': 'error',
// require or disallow space before function opening parenthesis
// https://github.com/eslint/eslint/blob/master/docs/rules/space-before-function-paren.md
'space-before-function-paren': ['error', { anonymous: 'never', named: 'never' }],
// require or disallow spaces inside parentheses
'space-in-parens': ['error', 'never'],
// require spaces around operators
'space-infix-ops': 'error',
// require or disallow a space immediately following the // or /* in a comment
'spaced-comment': ['error', 'always', {
exceptions: ['-', '+'],
markers: ['=', '!', '/'], // space here to support sprockets directives
}],
'import/no-default-export': 'error',
'unicorn/empty-brace-spaces': ['error'],
'unicorn/filename-case': ['error', { case: 'kebabCase' }],
'unicorn/no-array-push-push': ['error'],
'unicorn/prefer-date-now': ['error'],
},
};
timocov-dts-bundle-generator-c69ff0d/.gitattributes 0000664 0000000 0000000 00000000041 14611320214 0022600 0 ustar 00root root 0000000 0000000 *.ts linguist-language=TypeScript timocov-dts-bundle-generator-c69ff0d/.github/ 0000775 0000000 0000000 00000000000 14611320214 0021252 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/.github/FUNDING.yml 0000664 0000000 0000000 00000000347 14611320214 0023073 0 ustar 00root root 0000000 0000000 github: timocov # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
patreon: # Replace with a single Patreon username
open_collective: dts-bundle-generator # Replace with a single Open Collective username
timocov-dts-bundle-generator-c69ff0d/.github/ISSUE_TEMPLATE/ 0000775 0000000 0000000 00000000000 14611320214 0023435 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/.github/ISSUE_TEMPLATE/bug_report.md 0000664 0000000 0000000 00000000515 14611320214 0026130 0 ustar 00root root 0000000 0000000 ---
name: Bug report
about: Create a report to help us improve
---
**Bug report**
**Input code**
```ts
// place your code here
```
**Expected output**
```ts
// place your code here
```
**Actual output**
```ts
// place your code here
```
**Additional context**
Add any other context about the problem here (CLI options, etc)
timocov-dts-bundle-generator-c69ff0d/.github/ISSUE_TEMPLATE/other.md 0000664 0000000 0000000 00000000101 14611320214 0025070 0 ustar 00root root 0000000 0000000 ---
name: Other
about: Any other issues/improves/features
---
timocov-dts-bundle-generator-c69ff0d/.github/logo.svg 0000664 0000000 0000000 00000012713 14611320214 0022737 0 ustar 00root root 0000000 0000000
timocov-dts-bundle-generator-c69ff0d/.github/workflows/ 0000775 0000000 0000000 00000000000 14611320214 0023307 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/.github/workflows/ci.yml 0000664 0000000 0000000 00000002313 14611320214 0024424 0 ustar 00root root 0000000 0000000 name: CI Test
on:
push:
branches:
- master
schedule:
# https://crontab.guru/#0_10_*_*_0
- cron: '0 10 * * 0'
pull_request:
jobs:
lint:
name: Lint files
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-node@v3
with:
node-version: 16
- run: npm install
- run: npm run lint
ts-min:
name: Minimal TS
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-node@v3
with:
node-version: 14
- run: npm install
- run: npm install typescript@5.0.2
- run: npm run tsc
ts-current:
name: Current TS
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-node@v3
with:
node-version: 14
- run: npm install
- run: npm run tsc
- run: npm run test
- run: npm run bundle-dts
ts-next:
name: The next TS
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-node@v3
with:
node-version: 14
- run: npm install
- run: npm install typescript@next
- run: npm run tsc
- run: npm run test
- run: npm run bundle-dts
timocov-dts-bundle-generator-c69ff0d/.github/workflows/release.yml 0000664 0000000 0000000 00000000662 14611320214 0025456 0 ustar 00root root 0000000 0000000 name: Publish new version
on:
push:
tags:
- v*
jobs:
publish:
name: Publish
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v3
- uses: actions/setup-node@v3
with:
node-version: 14
registry-url: 'https://registry.npmjs.org'
- run: npm install
- run: npm run prepare-release
- run: npm publish
env:
NODE_AUTH_TOKEN: ${{secrets.NPM_AUTH_TOKEN}}
timocov-dts-bundle-generator-c69ff0d/.gitignore 0000664 0000000 0000000 00000000151 14611320214 0021677 0 ustar 00root root 0000000 0000000 /dist/
/dts-out/
node_modules/
package-lock.json
package-lock.json.*
*.tsbuildinfo
config-schema.d.ts
timocov-dts-bundle-generator-c69ff0d/.mailmap 0000664 0000000 0000000 00000000045 14611320214 0021332 0 ustar 00root root 0000000 0000000 Evgeniy Timokhov
timocov-dts-bundle-generator-c69ff0d/.mocharc.js 0000664 0000000 0000000 00000000677 14611320214 0021754 0 ustar 00root root 0000000 0000000 const path = require('path');
// override tsconfig for tests
process.env.TS_NODE_PROJECT = path.resolve(__dirname, './tsconfig.options.json');
// just transpile in tests
process.env.TS_NODE_TRANSPILE_ONLY = 'true';
const config = {
require: [
'ts-node/register',
],
extension: ['.spec.ts', '.spec.js'],
ignore: '**/.tsc-out/**',
checkLeaks: true,
recursive: true,
diff: true,
timeout: 10000,
slow: 5000,
};
module.exports = config;
timocov-dts-bundle-generator-c69ff0d/.npmrc 0000664 0000000 0000000 00000000023 14611320214 0021025 0 ustar 00root root 0000000 0000000 package-lock=false
timocov-dts-bundle-generator-c69ff0d/.vscode/ 0000775 0000000 0000000 00000000000 14611320214 0021253 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/.vscode/launch.json 0000664 0000000 0000000 00000001430 14611320214 0023416 0 ustar 00root root 0000000 0000000 {
// Use IntelliSense to learn about possible attributes.
// Hover to view descriptions of existing attributes.
// For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
"version": "0.2.0",
"configurations": [
{
"type": "node",
"request": "launch",
"name": "Run e2e test",
"program": "${workspaceFolder}/node_modules/mocha/bin/_mocha",
"args": [
"tests/e2e/test-cases/${input:testCaseName}/index.spec.js"
],
"internalConsoleOptions": "openOnSessionStart"
},
{
"type": "node",
"request": "attach",
"name": "Attach debugger",
"skipFiles": [
"/**"
]
},
],
"inputs": [
{
"type": "promptString",
"id": "testCaseName",
"description": "Please enter a test case name (a folder name)"
}
]
}
timocov-dts-bundle-generator-c69ff0d/.vscode/settings.json 0000664 0000000 0000000 00000000452 14611320214 0024007 0 ustar 00root root 0000000 0000000 {
"files.exclude": {
"**/*.tsbuildinfo": true,
"config-schema.d.ts": true,
"dist/**": true,
"dts-out/**": true,
"tests/e2e/.tsc-out/**": true,
"tests/unittests/.tsc-out/**": true,
},
"typescript.tsdk": "./node_modules/ts-compiler/lib",
}
timocov-dts-bundle-generator-c69ff0d/LICENSE 0000664 0000000 0000000 00000002061 14611320214 0020716 0 ustar 00root root 0000000 0000000 MIT License
Copyright (c) 2017 Evgeniy Timokhov
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.
timocov-dts-bundle-generator-c69ff0d/README.md 0000664 0000000 0000000 00000016362 14611320214 0021201 0 ustar 00root root 0000000 0000000
# DTS Bundle Generator
[![GH Actions][ci-img]][ci-link]
[![npm version][npm-version-img]][npm-link]
[![Downloads][npm-downloads-img]][npm-link]
Small tool to generate a dts bundle from your ts code.
For example:
```ts
// a.ts
export class A {}
```
```ts
// b.ts
export class B {}
```
```ts
// entry.ts
import { A } from './a';
import { B } from './b';
declare function makeA(): A;
export function makeB(): B {
makeA();
return new B();
}
```
When you run `dts-bundle-generator -o my.d.ts entry.ts` in `my.d.ts` you will get the following:
```ts
declare class B {
}
export declare function makeB(): B;
```
## Installation
1. Install the package from `npm`:
```bash
npm install --save-dev dts-bundle-generator
```
or
```bash
npm install -g dts-bundle-generator
```
1. Enable `declaration` compiler option in `tsconfig.json`
## Usage
```
Usage: dts-bundle-generator [options]
Options:
--help Show help [boolean]
--out-file, -o File name of generated d.ts [string]
--verbose Enable verbose logging [boolean] [default: false]
--silent Disable any logging except errors [boolean] [default: false]
--no-check Skip validation of generated d.ts file [boolean] [default: false]
--fail-on-class Fail if generated dts contains class declaration
[boolean] [default: false]
--external-inlines Array of package names from node_modules to inline typings from.
Used types will be inlined into the output file [array]
--external-imports Array of package names from node_modules to import typings from.
Used types will be imported using "import { First, Second } from
'library-name';".
By default all libraries will be imported (except inlined libraries
and libraries from @types) [array]
--external-types Array of package names from @types to import typings from via the
triple-slash reference directive.
By default all packages are allowed and will be used according to
their usages [array]
--umd-module-name Name of the UMD module. If specified then `export as namespace
ModuleName;` will be emitted [string]
--project Path to the tsconfig.json file that will be used for the
compilation [string]
--sort Sort output nodes [boolean] [default: false]
--inline-declare-global Enables inlining of `declare global` statements contained in files
which should be inlined (all local files and packages from
`--external-inlines`) [boolean] [default: false]
--inline-declare-externals Enables inlining of `declare module` statements of the global
modules (e.g. `declare module 'external-module' {}`, but NOT
`declare module './internal-module' {}`) contained in files which
should be inlined (all local files and packages from inlined
libraries) [boolean] [default: false]
--disable-symlinks-following (EXPERIMENTAL) Disables resolving of symlinks to the original path.
See https://github.com/timocov/dts-bundle-generator/issues/39 for
more information [boolean] [default: false]
--respect-preserve-const-enum Enables stripping the `const` keyword from every direct-exported
(or re-exported) from entry file `const enum`. See
https://github.com/timocov/dts-bundle-generator/issues/110 for more
information [boolean] [default: false]
--export-referenced-types By default all interfaces, types and const enums are marked as
exported even if they aren't exported directly. This option allows
you to disable this behavior so a node will be exported if it is
exported from root source file only. [boolean] [default: true]
--config File path to the generator config file [string]
--no-banner Allows remove "Generated by dts-bundle-generator" comment from the
output [boolean] [default: false]
--version Show version number [boolean]
```
Examples:
```bash
./node_modules/.bin/dts-bundle-generator -o my.d.ts path/to/your/entry-file.ts
```
```bash
./node_modules/.bin/dts-bundle-generator path/to/your/entry-file.ts path/to/your/entry-file-2.ts
```
```bash
./node_modules/.bin/dts-bundle-generator --external-inlines=@mycompany/internal-project --external-imports=@angular/core rxjs path/to/your/entry-file.ts
```
```bash
./node_modules/.bin/dts-bundle-generator --external-types=jquery path/to/your/entry-file.ts
```
## Config file
It is unnecessary, but you can use config file for the tool. See [config documentation](src/config-file/README.md) for more information.
## Why
If you have modules then you can create definitions by default using `tsc`, but `tsc` generates them for each module separately.
Yeah, you can use `outFile` (for `amd` and `system`), but generated code looks like this:
```ts
declare module "a" {
export class A {
}
}
declare module "b" {
export class B {
}
}
declare module "entry" {
import { B } from "b";
export function makeB(): B;
}
```
but:
1. `A` is not used at all and most probably you do not want to export it.
1. If you bundle your code in a way when all modules are merged (like when using Webpack or Rollup) then there should be no such modules as `a` or `b` (actually `entry` too) in the resulting file.
[ci-img]: https://github.com/timocov/dts-bundle-generator/workflows/CI%20Test/badge.svg?branch=master
[ci-link]: https://github.com/timocov/dts-bundle-generator/actions?query=branch%3Amaster
[npm-version-img]: https://badge.fury.io/js/dts-bundle-generator.svg
[npm-downloads-img]: https://img.shields.io/npm/dm/dts-bundle-generator.svg
[npm-link]: https://www.npmjs.com/package/dts-bundle-generator
timocov-dts-bundle-generator-c69ff0d/dts-config.js 0000664 0000000 0000000 00000000657 14611320214 0022315 0 ustar 00root root 0000000 0000000 // @ts-check
/** @type import('./src/config-file/load-config-file').BundlerConfig */
const config = {
compilationOptions: {
preferredConfigPath: './tsconfig.options.json',
},
entries: [
{
filePath: './dts-out/bundle-generator.d.ts',
outFile: './dist/bundle-generator.d.ts',
},
{
filePath: './dts-out/config-file/load-config-file.d.ts',
outFile: './config-schema.d.ts',
},
],
};
module.exports = config;
timocov-dts-bundle-generator-c69ff0d/package.json 0000664 0000000 0000000 00000003644 14611320214 0022207 0 ustar 00root root 0000000 0000000 {
"private": true,
"name": "dts-bundle-generator",
"version": "9.5.1",
"description": "DTS Bundle Generator",
"main": "dist/bundle-generator.js",
"typings": "dist/bundle-generator.d.ts",
"bin": "dist/bin/dts-bundle-generator.js",
"files": [
"config-schema.d.ts",
"dist/**/*.d.ts",
"dist/**/*.js"
],
"author": "Evgeniy Timokhov",
"bugs": {
"url": "https://github.com/timocov/dts-bundle-generator/issues"
},
"homepage": "https://github.com/timocov/dts-bundle-generator",
"dependencies": {
"typescript": ">=5.0.2",
"yargs": "^17.6.0"
},
"devDependencies": {
"@types/mocha": "~10.0.0",
"@types/node": "~14.18.26",
"@types/yargs": "~17.0.13",
"@typescript-eslint/eslint-plugin": "~7.4.0",
"@typescript-eslint/parser": "~7.4.0",
"eslint": "~8.57.0",
"eslint-plugin-deprecation": "~2.0.0",
"eslint-plugin-import": "~2.29.0",
"eslint-plugin-unicorn": "~51.0.1",
"mocha": "~10.4.0",
"npm-run-all": "~4.1.5",
"rimraf": "~5.0.1",
"ts-compiler": "npm:typescript@5.4.3",
"ts-node": "~10.9.1"
},
"license": "MIT",
"readme": "README.md",
"repository": {
"type": "git",
"url": "git+https://github.com/timocov/dts-bundle-generator.git"
},
"engines": {
"node": ">=14.0.0"
},
"scripts": {
"clean": "rimraf dist/ dts-out/",
"lint": "eslint --format=unix ./",
"check-dts-config": "node ./node_modules/ts-compiler/bin/tsc -p tsconfig.dts-config.json",
"bundle-dts": "npm run check-dts-config && node ./dist/bin/dts-bundle-generator.js --config dts-config.js --silent",
"tsc": "node ./node_modules/ts-compiler/bin/tsc --version && node ./node_modules/ts-compiler/bin/tsc -b ./tsconfig.json",
"verify": "npm-run-all clean tsc -p bundle-dts lint -s test",
"prepare-release": "npm-run-all clean tsc bundle-dts && node scripts/clean-package-json.js",
"test": "mocha --recursive -p --reporter list tests/"
}
}
timocov-dts-bundle-generator-c69ff0d/scripts/ 0000775 0000000 0000000 00000000000 14611320214 0021401 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/scripts/clean-package-json.js 0000775 0000000 0000000 00000001256 14611320214 0025370 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
/**
* This script does something like https://github.com/shashkovdanil/clean-publish does
* but it seems that clean-publish isn't supported anymore and we can't use it in CI
*/
const path = require('path');
const fs = require('fs');
function main() {
const packageJsonPath = path.resolve(__dirname, '..', 'package.json');
const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, { encoding: 'utf-8' }));
delete packageJson.private;
delete packageJson.devDependencies;
delete packageJson.scripts;
fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2) + '\n', { encoding: 'utf-8' });
}
if (require.main === module) {
main();
}
timocov-dts-bundle-generator-c69ff0d/src/ 0000775 0000000 0000000 00000000000 14611320214 0020501 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/src/bin/ 0000775 0000000 0000000 00000000000 14611320214 0021251 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/src/bin/dts-bundle-generator.ts 0000664 0000000 0000000 00000022647 14611320214 0025661 0 ustar 00root root 0000000 0000000 #!/usr/bin/env node
import * as path from 'path';
import * as ts from 'typescript';
import * as yargs from 'yargs';
import { loadConfigFile, BundlerConfig, ConfigEntryPoint } from '../config-file/load-config-file';
import { generateDtsBundle } from '../bundle-generator';
import { checkProgramDiagnosticsErrors } from '../helpers/check-diagnostics-errors';
import { getCompilerOptions } from '../get-compiler-options';
import { fixPath } from '../helpers/fix-path';
import { measureTime } from '../helpers/measure-time';
import {
enableNormalLog,
enableVerbose,
errorLog,
normalLog,
verboseLog,
warnLog,
} from '../logger';
function toStringsArray(data: unknown): string[] | undefined {
if (data === undefined) {
return data;
}
if (!Array.isArray(data)) {
throw new Error(`${data} is not a array`);
}
return data.map(String);
}
/* eslint-disable @typescript-eslint/naming-convention */
interface ParsedArgs extends yargs.Arguments {
sort: boolean;
silent: boolean;
verbose: boolean;
'no-check': boolean;
'fail-on-class': boolean;
'inline-declare-global': boolean;
'inline-declare-externals': boolean;
'disable-symlinks-following': boolean;
'no-banner': boolean;
'respect-preserve-const-enum': boolean;
'export-referenced-types': boolean;
'out-file': string | undefined;
'umd-module-name': string | undefined;
project: string | undefined;
config: string | undefined;
'external-inlines': string[] | undefined;
'external-imports': string[] | undefined;
'external-types': string[] | undefined;
}
/* eslint-enable @typescript-eslint/naming-convention */
function parseArgs(): ParsedArgs {
return yargs
.parserConfiguration({
/* eslint-disable @typescript-eslint/naming-convention */
'boolean-negation': false,
'camel-case-expansion': false,
'dot-notation': false,
'short-option-groups': false,
/* eslint-enable @typescript-eslint/naming-convention */
})
.usage('Usage: $0 [options] ')
.demandCommand(0)
.option('out-file', {
alias: 'o',
type: 'string',
description: 'File name of generated d.ts',
})
.option('verbose', {
type: 'boolean',
default: false,
description: 'Enable verbose logging',
})
.option('silent', {
type: 'boolean',
default: false,
description: 'Disable any logging except errors',
})
.option('no-check', {
type: 'boolean',
default: false,
description: 'Skip validation of generated d.ts file',
})
.option('fail-on-class', {
type: 'boolean',
default: false,
description: 'Fail if generated dts contains class declaration',
})
.option('external-inlines', {
type: 'array',
description: 'Array of package names from node_modules to inline typings from.\n' +
'Used types will be inlined into the output file',
coerce: toStringsArray,
})
.option('external-imports', {
type: 'array',
description: 'Array of package names from node_modules to import typings from.\n' +
'Used types will be imported using "import { First, Second } from \'library-name\';".\n' +
'By default all libraries will be imported (except inlined libraries and libraries from @types)',
coerce: toStringsArray,
})
.option('external-types', {
type: 'array',
description: 'Array of package names from @types to import typings from via the triple-slash reference directive.\n' +
'By default all packages are allowed and will be used according to their usages',
coerce: toStringsArray,
})
.option('umd-module-name', {
type: 'string',
description: 'Name of the UMD module. If specified then `export as namespace ModuleName;` will be emitted',
})
.option('project', {
type: 'string',
description: 'Path to the tsconfig.json file that will be used for the compilation',
})
.option('sort', {
type: 'boolean',
default: false,
description: 'Sort output nodes',
})
.option('inline-declare-global', {
type: 'boolean',
default: false,
description: 'Enables inlining of `declare global` statements contained in files which should be inlined (all local files and packages from `--external-inlines`)',
})
.option('inline-declare-externals', {
type: 'boolean',
default: false,
description: 'Enables inlining of `declare module` statements of the global modules (e.g. `declare module \'external-module\' {}`, but NOT `declare module \'./internal-module\' {}`) contained in files which should be inlined (all local files and packages from inlined libraries)',
})
.option('disable-symlinks-following', {
type: 'boolean',
default: false,
description: '(EXPERIMENTAL) Disables resolving of symlinks to the original path. See https://github.com/timocov/dts-bundle-generator/issues/39 for more information',
})
.option('respect-preserve-const-enum', {
type: 'boolean',
default: false,
description: 'Enables stripping the `const` keyword from every direct-exported (or re-exported) from entry file `const enum`. See https://github.com/timocov/dts-bundle-generator/issues/110 for more information',
})
.option('export-referenced-types', {
type: 'boolean',
default: true,
description: 'By default all interfaces, types and const enums are marked as exported even if they aren\'t exported directly. This option allows you to disable this behavior so a node will be exported if it is exported from root source file only.',
})
.option('config', {
type: 'string',
description: 'File path to the generator config file',
})
.option('no-banner', {
type: 'boolean',
default: false,
description: 'Allows remove "Generated by dts-bundle-generator" comment from the output',
})
.version()
.strict()
.example('$0 path/to/your/entry-file.ts', '')
.example('$0 path/to/your/entry-file.ts path/to/your/entry-file-2.ts', '')
.example('$0 --external-types jquery react -- entry-file.ts', '')
.wrap(Math.min(100, yargs.terminalWidth()))
.argv as ParsedArgs;
}
function generateOutFileName(inputFilePath: string): string {
const inputFileName = path.parse(inputFilePath).name;
return fixPath(path.join(inputFilePath, '..', inputFileName + '.d.ts'));
}
// eslint-disable-next-line complexity
function main(): void {
const args = parseArgs();
if (args.silent && args.verbose) {
throw new Error('Cannot use both silent and verbose options at the same time');
} else if (args.verbose) {
enableVerbose();
} else if (!args.silent) {
enableNormalLog();
}
let bundlerConfig: BundlerConfig;
if (args.config !== undefined) {
verboseLog(`Trying to load config from ${args.config} file...`);
bundlerConfig = loadConfigFile(args.config);
} else {
if (args._.length < 1) {
throw new Error('No input files specified');
}
if (args._.length > 1 && args['out-file']) {
throw new Error('Cannot use outFile with multiple entries');
}
bundlerConfig = {
entries: args._.map((entryPath: string | number) => {
return {
filePath: String(entryPath),
outFile: args['out-file'],
noCheck: args['no-check'],
libraries: {
allowedTypesLibraries: args['external-types'],
importedLibraries: args['external-imports'],
inlinedLibraries: args['external-inlines'],
},
output: {
inlineDeclareExternals: args['inline-declare-externals'],
inlineDeclareGlobals: args['inline-declare-global'],
umdModuleName: args['umd-module-name'],
sortNodes: args.sort,
noBanner: args['no-banner'],
respectPreserveConstEnum: args['respect-preserve-const-enum'],
exportReferencedTypes: args['export-referenced-types'],
},
failOnClass: args['fail-on-class'],
};
}),
compilationOptions: {
preferredConfigPath: args.project,
followSymlinks: !args['disable-symlinks-following'],
},
};
}
verboseLog(`Total entries count=${bundlerConfig.entries.length}`);
const generatedDts = generateDtsBundle(bundlerConfig.entries, bundlerConfig.compilationOptions);
const outFilesToCheck: string[] = [];
for (let i = 0; i < bundlerConfig.entries.length; ++i) {
const entry = bundlerConfig.entries[i];
const outFile = entry.outFile !== undefined ? entry.outFile : generateOutFileName(entry.filePath);
normalLog(`Writing ${entry.filePath} -> ${outFile}`);
ts.sys.writeFile(outFile, generatedDts[i]);
if (!entry.noCheck) {
outFilesToCheck.push(outFile);
}
}
if (outFilesToCheck.length === 0) {
normalLog('File checking is skipped (due nothing to check)');
return;
}
normalLog('Checking generated files...');
const preferredConfigFile = bundlerConfig.compilationOptions !== undefined ? bundlerConfig.compilationOptions.preferredConfigPath : undefined;
const compilerOptions = getCompilerOptions(outFilesToCheck, preferredConfigFile);
if (compilerOptions.skipLibCheck) {
compilerOptions.skipLibCheck = false;
warnLog('Compiler option "skipLibCheck" is disabled to properly check generated output');
}
// we want to turn this option on because in this case the compile will generate declaration diagnostics out of the box
compilerOptions.declaration = true;
let checkFailed = false;
for (const outputFile of outFilesToCheck) {
const program = ts.createProgram([outputFile], compilerOptions);
try {
checkProgramDiagnosticsErrors(program);
} catch (e) {
checkFailed = true;
}
}
if (checkFailed) {
throw new Error('Failed to check some of generated bundles, check error messages above');
}
}
try {
const executionTime = measureTime(main);
normalLog(`Done in ${(executionTime / 1000).toFixed(2)}s`);
} catch (ex) {
normalLog('');
errorLog(`Error: ${(ex as Error).message}`);
process.exit(1);
}
timocov-dts-bundle-generator-c69ff0d/src/bundle-generator.ts 0000664 0000000 0000000 00000155005 14611320214 0024314 0 ustar 00root root 0000000 0000000 import * as ts from 'typescript';
import { compileDts } from './compile-dts';
import { TypesUsageEvaluator } from './types-usage-evaluator';
import {
ExportType,
getActualSymbol,
getClosestModuleLikeNode,
getClosestSourceFileLikeNode,
getDeclarationsForExportedValues,
getDeclarationsForSymbol,
getImportExportReferencedSymbol,
getExportsForSourceFile,
getExportsForStatement,
getImportModuleName,
getNodeName,
getNodeOwnSymbol,
getNodeSymbol,
getRootSourceFile,
getSymbolExportStarDeclarations,
hasNodeModifier,
isAmbientModule,
isDeclareGlobalStatement,
isDeclareModule,
isNodeNamedDeclaration,
SourceFileExport,
splitTransientSymbol,
} from './helpers/typescript';
import {
getFileModuleInfo,
getModuleLikeModuleInfo,
getReferencedModuleInfo,
ModuleCriteria,
ModuleInfo,
ModuleType,
} from './module-info';
import { generateOutput, ModuleImportsSet, OutputInputData, StatementSettings } from './generate-output';
import {
normalLog,
verboseLog,
warnLog,
} from './logger';
import { CollisionsResolver } from './collisions-resolver';
export interface CompilationOptions {
/**
* EXPERIMENTAL!
* Allows disable resolving of symlinks to the original path.
* By default following is enabled.
* @see https://github.com/timocov/dts-bundle-generator/issues/39
*/
followSymlinks?: boolean;
/**
* Path to the tsconfig file that will be used for the compilation.
*/
preferredConfigPath?: string;
}
export interface OutputOptions {
/**
* Sort output nodes in ascendant order.
*/
sortNodes?: boolean;
/**
* Name of the UMD module.
* If specified then `export as namespace ModuleName;` will be emitted.
*/
umdModuleName?: string;
/**
* Enables inlining of `declare global` statements contained in files which should be inlined (all local files and packages from inlined libraries).
*/
inlineDeclareGlobals?: boolean;
/**
* Enables inlining of `declare module` statements of the global modules
* (e.g. `declare module 'external-module' {}`, but NOT `declare module './internal-module' {}`)
* contained in files which should be inlined (all local files and packages from inlined libraries)
*/
inlineDeclareExternals?: boolean;
/**
* Allows remove "Generated by dts-bundle-generator" comment from the output
*/
noBanner?: boolean;
/**
* Enables stripping the `const` keyword from every direct-exported (or re-exported) from entry file `const enum`.
* This allows you "avoid" the issue described in https://github.com/microsoft/TypeScript/issues/37774.
*/
respectPreserveConstEnum?: boolean;
/**
* By default all interfaces, types and const enums are marked as exported even if they aren't exported directly.
* This option allows you to disable this behavior so a node will be exported if it is exported from root source file only.
*/
exportReferencedTypes?: boolean;
}
export interface LibrariesOptions {
/**
* Array of package names from node_modules to inline typings from.
* Used types will be inlined into the output file.
*/
inlinedLibraries?: string[];
/**
* Array of package names from node_modules to import typings from.
* Used types will be imported using `import { First, Second } from 'library-name';`.
* By default all libraries will be imported (except inlined libraries and libraries from @types).
*/
importedLibraries?: string[];
/**
* Array of package names from @types to import typings from via the triple-slash reference directive.
* By default all packages are allowed and will be used according to their usages.
*/
allowedTypesLibraries?: string[];
}
export interface EntryPointConfig {
/**
* Path to input file.
*/
filePath: string;
libraries?: LibrariesOptions;
/**
* Fail if generated dts contains class declaration.
*/
failOnClass?: boolean;
output?: OutputOptions;
}
export function generateDtsBundle(entries: readonly EntryPointConfig[], options: CompilationOptions = {}): string[] {
normalLog('Compiling input files...');
const { program, rootFilesRemapping } = compileDts(entries.map((entry: EntryPointConfig) => entry.filePath), options.preferredConfigPath, options.followSymlinks);
const typeChecker = program.getTypeChecker();
const typeRoots = ts.getEffectiveTypeRoots(program.getCompilerOptions(), {});
const sourceFiles = program.getSourceFiles().filter((file: ts.SourceFile) => {
return !program.isSourceFileDefaultLibrary(file);
});
const typesUsageEvaluator = new TypesUsageEvaluator(sourceFiles, typeChecker);
// eslint-disable-next-line complexity
return entries.map((entryConfig: EntryPointConfig) => {
normalLog(`Processing ${entryConfig.filePath}`);
const newRootFilePath = rootFilesRemapping.get(entryConfig.filePath);
if (newRootFilePath === undefined) {
throw new Error(`Cannot remap root source file ${entryConfig.filePath}`);
}
const rootSourceFile = getRootSourceFile(program, newRootFilePath);
const rootSourceFileSymbol = typeChecker.getSymbolAtLocation(rootSourceFile);
if (rootSourceFileSymbol === undefined) {
throw new Error(`Symbol for root source file ${newRootFilePath} not found`);
}
const librariesOptions: LibrariesOptions = entryConfig.libraries || {};
const criteria: ModuleCriteria = {
allowedTypesLibraries: librariesOptions.allowedTypesLibraries,
importedLibraries: librariesOptions.importedLibraries,
inlinedLibraries: librariesOptions.inlinedLibraries || [],
typeRoots,
};
const rootFileExports = getExportsForSourceFile(typeChecker, rootSourceFileSymbol);
const rootFileExportSymbols = rootFileExports.map((exp: SourceFileExport) => exp.symbol);
interface CollectingResult extends Omit {
statements: ts.Statement[];
}
const collectionResult: CollectingResult = {
typesReferences: new Set(),
imports: new Map(),
statements: [],
renamedExports: new Map(),
wrappedNamespaces: new Map(),
};
const outputOptions: OutputOptions = entryConfig.output || {};
const inlineDeclareGlobals = Boolean(outputOptions.inlineDeclareGlobals);
const inlineDeclareExternals = Boolean(outputOptions.inlineDeclareExternals);
const collisionsResolver = new CollisionsResolver(typeChecker);
function updateResultForAnyModule(statements: readonly ts.Statement[], currentModule: ModuleInfo): void {
// contains a set of modules that were visited already
// can be used to prevent infinite recursion in updating results in re-exports
const visitedModules = new Set();
function updateResultForExternalExport(exportAssignment: ts.ExportAssignment | ts.ExportDeclaration): void {
// if we have `export =` or `export * from` somewhere so we can decide that every declaration of exported symbol in this way
// is "part of the exported module" and we need to update result according every member of each declaration
// but treat they as current module (we do not need to update module info)
for (const declaration of getDeclarationsForExportedValues(exportAssignment, typeChecker)) {
if (ts.isVariableDeclaration(declaration)) {
// variables will be processed separately anyway so no need to process them again here
continue;
}
let exportedDeclarations: readonly ts.Statement[] = [];
if (ts.isExportDeclaration(exportAssignment) && ts.isSourceFile(declaration)) {
const referencedModule = getReferencedModuleInfo(exportAssignment, criteria, typeChecker);
if (referencedModule !== null) {
if (visitedModules.has(referencedModule.fileName)) {
continue;
}
visitedModules.add(referencedModule.fileName);
}
exportedDeclarations = declaration.statements;
} else if (ts.isModuleDeclaration(declaration)) {
if (declaration.body !== undefined && ts.isModuleBlock(declaration.body)) {
const referencedModule = getReferencedModuleInfo(declaration, criteria, typeChecker);
if (referencedModule !== null) {
if (visitedModules.has(referencedModule.fileName)) {
continue;
}
visitedModules.add(referencedModule.fileName);
}
exportedDeclarations = declaration.body.statements;
}
} else {
exportedDeclarations = [declaration as unknown as ts.Statement];
}
updateResultImpl(exportedDeclarations);
}
}
// eslint-disable-next-line complexity
function updateResultImpl(statementsToProcess: readonly ts.Statement[]): void {
for (const statement of statementsToProcess) {
// we should skip import statements
if (statement.kind === ts.SyntaxKind.ImportDeclaration || statement.kind === ts.SyntaxKind.ImportEqualsDeclaration) {
continue;
}
if (isDeclareModule(statement)) {
updateResultForModuleDeclaration(statement, currentModule);
// if a statement is `declare module "module" {}` then don't process it below
// as it is handled already in `updateResultForModuleDeclaration`
// but if it is `declare module Module {}` then it can be used in types and imports
// so in this case it needs to be checked for "usages" below
if (ts.isStringLiteral(statement.name)) {
continue;
}
}
if (currentModule.type === ModuleType.ShouldBeUsedForModulesOnly) {
continue;
}
if (isDeclareGlobalStatement(statement) && inlineDeclareGlobals && currentModule.type === ModuleType.ShouldBeInlined) {
collectionResult.statements.push(statement);
continue;
}
if (ts.isExportDeclaration(statement)) {
if (currentModule.type === ModuleType.ShouldBeInlined) {
continue;
}
// `export * from`
if (statement.exportClause === undefined) {
updateResultForExternalExport(statement);
continue;
}
// `export { val }`
if (ts.isNamedExports(statement.exportClause) && currentModule.type === ModuleType.ShouldBeImported) {
updateImportsForStatement(statement);
continue;
}
}
if (ts.isExportAssignment(statement) && statement.isExportEquals && currentModule.type !== ModuleType.ShouldBeInlined) {
updateResultForExternalExport(statement);
continue;
}
if (!isNodeUsed(statement)) {
continue;
}
switch (currentModule.type) {
case ModuleType.ShouldBeReferencedAsTypes:
// while a node might be "used" somewhere via transitive nodes
// we need to add types reference only if a node is treated as "should be imported"
// because otherwise we might have lots of false-positive references
forEachNodeThatShouldBeImported(statement, () => addTypesReference(currentModule.typesLibraryName));
break;
case ModuleType.ShouldBeImported:
updateImportsForStatement(statement);
break;
case ModuleType.ShouldBeInlined:
if (ts.isVariableStatement(statement)) {
for (const variableDeclaration of statement.declarationList.declarations) {
if (ts.isIdentifier(variableDeclaration.name)) {
collisionsResolver.addTopLevelIdentifier(variableDeclaration.name);
continue;
}
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);
if (statementName !== undefined) {
collisionsResolver.addTopLevelIdentifier(statementName as ts.Identifier | ts.DefaultKeyword);
}
}
collectionResult.statements.push(statement);
break;
}
}
}
updateResultImpl(statements);
}
function isReferencedModuleImportable(statement: ts.ExportDeclaration | ts.ImportDeclaration): boolean {
return getReferencedModuleInfo(statement, criteria, typeChecker)?.type === ModuleType.ShouldBeImported;
}
function handleExportDeclarationFromRootModule(exportDeclaration: ts.ExportDeclaration): void {
function handleExportStarStatement(exportStarStatement: ts.ExportDeclaration, visitedSymbols: Set = new Set()): void {
if (exportStarStatement.moduleSpecifier === undefined || exportStarStatement.exportClause !== undefined) {
throw new Error(`Invalid export-star declaration statement provided, ${exportStarStatement.getText()}`);
}
const importModuleSpecifier = getImportModuleName(exportStarStatement);
if (importModuleSpecifier === null) {
return;
}
const referencedModuleInfo = getReferencedModuleInfo(exportStarStatement, criteria, typeChecker);
if (referencedModuleInfo === null) {
return;
}
switch (referencedModuleInfo.type) {
case ModuleType.ShouldBeInlined: {
// `export * from './inlined-module'`
const referencedModuleSymbol = getNodeOwnSymbol(exportStarStatement.moduleSpecifier, typeChecker);
const referencedSourceFileExportStarSymbol = referencedModuleSymbol.exports?.get(ts.InternalSymbolName.ExportStar);
if (referencedSourceFileExportStarSymbol !== undefined) {
if (visitedSymbols.has(referencedSourceFileExportStarSymbol)) {
return;
}
visitedSymbols.add(referencedSourceFileExportStarSymbol);
// we need to go recursive for all `export * from` statements and add all that are from imported modules
for (const exportDecl of getSymbolExportStarDeclarations(referencedSourceFileExportStarSymbol)) {
handleExportStarStatement(exportDecl, visitedSymbols);
}
}
break;
}
case ModuleType.ShouldBeImported: {
// `export * from 'importable-package'`
collectionResult.statements.push(exportStarStatement);
break;
}
}
}
interface ExportingExportStarExport {
exportStarDeclaration: ts.ExportDeclaration;
exportedNodeSymbol: ts.Symbol;
}
/**
* This function returns an export-star object that exports given {@link nodeSymbol} symbol.
* If an exporting export declaration object is not from an importable module then `null` is returned.
* Also if the symbol is exported explicitly (i.e. via `export { Name }` or specifying `export` keyword next to the node) then `null` is returned as well.
*/
function findExportingExportStarExportFromImportableModule(referencedModuleSymbol: ts.Symbol, nodeSymbol: ts.Symbol): ExportingExportStarExport | null {
function findResultRecursively(referencedModuleSym: ts.Symbol, exportedNodeSym: ts.Symbol, visitedSymbols: Set): ExportingExportStarExport | null {
// prevent infinite recursion
if (visitedSymbols.has(referencedModuleSym)) {
return null;
}
visitedSymbols.add(referencedModuleSym);
// `export * from` exports always have less priority over explicit exports so it should go last
const exportStarExport = referencedModuleSym.exports?.get(ts.InternalSymbolName.ExportStar);
if (exportStarExport === undefined) {
return null;
}
for (const exportStarDeclaration of getDeclarationsForSymbol(exportStarExport).filter(ts.isExportDeclaration)) {
if (exportStarDeclaration.moduleSpecifier === undefined) {
// this seems impossible, but to make the compiler/types happy
continue;
}
const exportStarModuleSymbol = getNodeOwnSymbol(exportStarDeclaration.moduleSpecifier, typeChecker);
if (exportStarModuleSymbol.exports === undefined) {
continue;
}
if (isReferencedModuleImportable(exportStarDeclaration)) {
// for "importable" modules we don't need to go deeper or even check "explicit" exports
// as it doesn't matter how its done internally and we care about "public" interface only
// so we can just check whether it exports a symbol or not (irregardless of how it is exported exactly internally)
const referencedModuleExports = typeChecker.getExportsOfModule(exportStarModuleSymbol);
const exportedNodeSymbol = referencedModuleExports.find((exp: ts.Symbol) => getActualSymbol(exp, typeChecker) === nodeSymbol);
if (exportedNodeSymbol !== undefined) {
return { exportStarDeclaration, exportedNodeSymbol };
}
continue;
}
const result = findResultRecursively(exportStarModuleSymbol, exportedNodeSym, visitedSymbols);
if (result !== null) {
return result;
}
}
return null;
}
if (referencedModuleSymbol.exports === undefined) {
throw new Error(`No exports found for "${referencedModuleSymbol.getName()}" symbol`);
}
const hasExplicitExportOfSymbol = Array.from(referencedModuleSymbol.exports.values()).some((exp: ts.Symbol) => {
if (exp.escapedName === ts.InternalSymbolName.ExportStar) {
return false;
}
return getActualSymbol(exp, typeChecker) === nodeSymbol;
});
if (hasExplicitExportOfSymbol) {
// symbol is exported explicitly ¯\_(ツ)_/¯
return null;
}
return findResultRecursively(referencedModuleSymbol, nodeSymbol, new Set());
}
// `export * from 'module'`
if (exportDeclaration.exportClause === undefined) {
handleExportStarStatement(exportDeclaration);
return;
}
if (exportDeclaration.exportClause !== undefined && ts.isNamedExports(exportDeclaration.exportClause)) {
// `export { val, val2 }`
if (exportDeclaration.moduleSpecifier === undefined) {
for (const exportElement of exportDeclaration.exportClause.elements) {
const exportElementSymbol = getImportExportReferencedSymbol(exportElement, typeChecker);
const namespaceImportFromImportableModule = getDeclarationsForSymbol(exportElementSymbol).find((importDecl: ts.Declaration): importDecl is ts.NamespaceImport => {
// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
return ts.isNamespaceImport(importDecl) && isReferencedModuleImportable(importDecl.parent.parent as ts.ImportDeclaration);
});
if (namespaceImportFromImportableModule !== undefined) {
// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
const importModuleSpecifier = getImportModuleName(namespaceImportFromImportableModule.parent.parent as ts.ImportDeclaration);
if (importModuleSpecifier === null) {
throw new Error(`Cannot get import module name from '${namespaceImportFromImportableModule.parent.parent.getText()}'`);
}
addNsImport(
getImportItem(importModuleSpecifier),
namespaceImportFromImportableModule.name
);
}
}
return;
}
// `export { val, val2 } from 'module'`
if (exportDeclaration.moduleSpecifier !== undefined) {
const referencedModuleSymbol = getNodeOwnSymbol(exportDeclaration.moduleSpecifier, typeChecker);
// in this case we want to find all elements that we re-exported via `export * from` exports as they aren't handled elsewhere
for (const exportElement of exportDeclaration.exportClause.elements) {
const exportedNodeSymbol = getActualSymbol(getImportExportReferencedSymbol(exportElement, typeChecker), typeChecker);
const exportingExportStarResult = findExportingExportStarExportFromImportableModule(
referencedModuleSymbol,
exportedNodeSymbol
);
if (exportingExportStarResult === null) {
continue;
}
const importModuleSpecifier = getImportModuleName(exportingExportStarResult.exportStarDeclaration);
if (importModuleSpecifier === null) {
throw new Error(`Cannot get import module name from '${exportingExportStarResult.exportStarDeclaration.getText()}'`);
}
// technically we could use named imports and then add re-exports
// but this solution affects names scope (re-exports don't affect it)
// and also it is slightly complicated to find a name declaration (identifier) that needs to be imported
// so it feels better to go this way, but happy to change in the future if there would be any issues
addReExport(
getImportItem(importModuleSpecifier),
exportingExportStarResult.exportedNodeSymbol.getName(),
exportElement.name.text
);
}
return;
}
}
}
function updateResultForRootModule(statements: readonly ts.Statement[], currentModule: ModuleInfo): void {
updateResultForAnyModule(statements, currentModule);
// add skipped by `updateResult` exports
for (const statement of statements) {
if (ts.isExportDeclaration(statement)) {
handleExportDeclarationFromRootModule(statement);
continue;
}
if (ts.isExportAssignment(statement)) {
// `"export ="` or `export default 123` or `export default "str"`
if (statement.isExportEquals || !ts.isIdentifier(statement.expression)) {
collectionResult.statements.push(statement);
}
continue;
}
}
}
function updateResultForModuleDeclaration(moduleDecl: ts.ModuleDeclaration, currentModule: ModuleInfo): void {
if (moduleDecl.body === undefined || !ts.isModuleBlock(moduleDecl.body)) {
return;
}
const referencedModuleInfo = getModuleLikeModuleInfo(moduleDecl, criteria, typeChecker);
if (referencedModuleInfo === null) {
return;
}
// if we have declaration of external module inside internal one
if (!currentModule.isExternal && referencedModuleInfo.isExternal) {
// if it's allowed - we need to just add it to result without any processing
if (inlineDeclareExternals) {
collectionResult.statements.push(moduleDecl);
}
return;
}
updateResultForAnyModule(moduleDecl.body.statements, referencedModuleInfo);
}
function addTypesReference(library: string): void {
if (!collectionResult.typesReferences.has(library)) {
normalLog(`Library "${library}" will be added via reference directive`);
collectionResult.typesReferences.add(library);
}
}
function forEachNodeThatShouldBeImported(statement: ts.Statement | ts.SourceFile | ts.ExportSpecifier, callback: (st: ts.DeclarationStatement) => void): void {
const statementsToImport = ts.isVariableStatement(statement)
? statement.declarationList.declarations
: ts.isExportDeclaration(statement) && statement.exportClause !== undefined
? ts.isNamespaceExport(statement.exportClause)
? [statement.exportClause]
: statement.exportClause.elements
: [statement];
for (const statementToImport of statementsToImport) {
if (shouldNodeBeImported(statementToImport as ts.DeclarationStatement)) {
callback(statementToImport as ts.DeclarationStatement);
}
}
}
function updateImportsForStatement(statement: ts.Statement | ts.SourceFile | ts.ExportSpecifier): void {
forEachNodeThatShouldBeImported(statement, (statementToImport: ts.DeclarationStatement) => {
addImport(statementToImport);
// if we're going to add import of any statement in the bundle
// we should check whether the library of that statement
// could be referenced via triple-slash reference-types directive
// because the project which will use bundled declaration file
// can have `types: []` in the tsconfig and it'll fail
// this is especially related to the types packages
// which declares different modules in their declarations
// e.g. @types/node has declaration for "packages" events, fs, path and so on
const sourceFile = statementToImport.getSourceFile();
const moduleInfo = getFileModuleInfo(sourceFile.fileName, criteria);
if (moduleInfo.type === ModuleType.ShouldBeReferencedAsTypes) {
addTypesReference(moduleInfo.typesLibraryName);
}
});
}
function getDeclarationUsagesSourceFiles(declaration: ts.NamedDeclaration): Set {
return new Set(
getExportedSymbolsUsingStatement(declaration)
.map((symbol: ts.Symbol) => getDeclarationsForSymbol(symbol))
.reduce((acc: ts.Declaration[], val: ts.Declaration[]) => acc.concat(val), [])
.map(getClosestModuleLikeNode)
);
}
function getImportItem(importModuleSpecifier: string): ModuleImportsSet {
let importItem = collectionResult.imports.get(importModuleSpecifier);
if (importItem === undefined) {
importItem = {
defaultImports: new Set(),
namedImports: new Map(),
nsImport: null,
requireImports: new Set(),
reExports: new Map(),
};
collectionResult.imports.set(importModuleSpecifier, importItem);
}
return importItem;
}
function addRequireImport(importItem: ModuleImportsSet, preferredLocalName: ts.Identifier): void {
importItem.requireImports.add(collisionsResolver.addTopLevelIdentifier(preferredLocalName));
}
function addNamedImport(importItem: ModuleImportsSet, preferredLocalName: ts.Identifier, importedIdentifier: ts.Identifier): void {
const newLocalName = collisionsResolver.addTopLevelIdentifier(preferredLocalName);
const importedName = importedIdentifier.text;
importItem.namedImports.set(newLocalName, importedName);
}
function addReExport(importItem: ModuleImportsSet, moduleExportedName: string, reExportedName: string): void {
// re-exports don't affect local names scope so we don't need to register them in collisions resolver
importItem.reExports.set(reExportedName, moduleExportedName);
}
function addNsImport(importItem: ModuleImportsSet, preferredLocalName: ts.Identifier): void {
if (importItem.nsImport === null) {
importItem.nsImport = collisionsResolver.addTopLevelIdentifier(preferredLocalName);
}
}
function addDefaultImport(importItem: ModuleImportsSet, preferredLocalName: ts.Identifier): void {
importItem.defaultImports.add(collisionsResolver.addTopLevelIdentifier(preferredLocalName));
}
function addImport(statement: ts.DeclarationStatement | ts.SourceFile): void {
forEachImportOfStatement(statement, (imp: ImportOfStatement, referencedModuleInfo: ModuleInfo, importModuleSpecifier: string) => {
// if a referenced module should be inlined we can just ignore it
if (referencedModuleInfo.type !== ModuleType.ShouldBeImported) {
return;
}
const importItem = getImportItem(importModuleSpecifier);
if (ts.isImportEqualsDeclaration(imp)) {
// import x = require("mod");
addRequireImport(importItem, imp.name);
return;
}
if (ts.isExportSpecifier(imp)) {
// export { El1, El2 as ExportedName } from 'module';
addNamedImport(importItem, imp.name, imp.propertyName || imp.name);
return;
}
if (ts.isNamespaceExport(imp)) {
// export * as name from 'module';
addNsImport(importItem, imp.name);
return;
}
if (ts.isImportClause(imp) && imp.name !== undefined) {
// import name from 'module';
addDefaultImport(importItem, imp.name);
return;
}
if (ts.isImportSpecifier(imp)) {
// import { El1, El2 as ImportedName } from 'module';
addNamedImport(importItem, imp.name, imp.propertyName || imp.name);
return;
}
if (ts.isNamespaceImport(imp)) {
// import * as name from 'module';
addNsImport(importItem, imp.name);
return;
}
});
}
type ImportOfStatement = ts.ImportEqualsDeclaration | ts.ExportSpecifier | ts.NamespaceExport | ts.ImportClause | ts.ImportSpecifier | ts.NamespaceImport;
function forEachImportOfStatement(statement: ts.DeclarationStatement | ts.SourceFile, callback: (imp: ImportOfStatement, referencedModuleInfo: ModuleInfo, importModuleSpecifier: string) => void): void {
if (!ts.isSourceFile(statement) && statement.name === undefined) {
throw new Error(`Import/usage unnamed declaration: ${statement.getText()}`);
}
getDeclarationUsagesSourceFiles(statement).forEach((sourceFile: ts.SourceFile | ts.ModuleDeclaration) => {
if (getModuleLikeModuleInfo(sourceFile, criteria, typeChecker).type !== ModuleType.ShouldBeInlined) {
// we should ignore source files that aren't inlined
return;
}
const sourceFileStatements: readonly ts.Statement[] = ts.isSourceFile(sourceFile)
? sourceFile.statements
: sourceFile.body !== undefined && ts.isModuleBlock(sourceFile.body)
? sourceFile.body.statements
: []
;
// eslint-disable-next-line complexity
sourceFileStatements.forEach((st: ts.Statement) => {
if (!ts.isImportEqualsDeclaration(st) && !ts.isImportDeclaration(st) && !ts.isExportDeclaration(st)) {
return;
}
const importModuleSpecifier = getImportModuleName(st);
if (importModuleSpecifier === null) {
return;
}
const referencedModuleInfo = getReferencedModuleInfo(st, criteria, typeChecker);
// if a referenced module should be inlined we can just ignore it
if (referencedModuleInfo === null) {
return;
}
if (ts.isImportEqualsDeclaration(st)) {
if (areDeclarationSame(statement, st)) {
callback(st, referencedModuleInfo, importModuleSpecifier);
}
return;
}
if (ts.isExportDeclaration(st) && st.exportClause !== undefined) {
if (ts.isNamedExports(st.exportClause)) {
// export { El1, El2 as ExportedName } from 'module';
st.exportClause.elements
.filter(areDeclarationSame.bind(null, statement))
.forEach((specifier: ts.ExportSpecifier) => {
callback(specifier, referencedModuleInfo, importModuleSpecifier);
});
} else {
// export * as name from 'module';
if (isNodeUsed(st.exportClause)) {
callback(st.exportClause, referencedModuleInfo, importModuleSpecifier);
}
}
} else if (ts.isImportDeclaration(st) && st.importClause !== undefined) {
if (st.importClause.name !== undefined && areDeclarationSame(statement, st.importClause)) {
// import name from 'module';
callback(st.importClause, referencedModuleInfo, importModuleSpecifier);
}
if (st.importClause.namedBindings !== undefined) {
if (ts.isNamedImports(st.importClause.namedBindings)) {
// import { El1, El2 as ImportedName } from 'module';
st.importClause.namedBindings.elements
.filter(areDeclarationSame.bind(null, statement))
.forEach((specifier: ts.ImportSpecifier) => {
callback(specifier, referencedModuleInfo, importModuleSpecifier);
});
} else {
// import * as name from 'module';
if (isNodeUsed(st.importClause)) {
callback(st.importClause.namedBindings, referencedModuleInfo, importModuleSpecifier);
}
}
}
}
});
});
}
function getInlinedSymbolsUsingSymbol(symbol: ts.Symbol, predicate: (usedInSymbol: ts.Symbol) => boolean): ts.Symbol[] {
return Array.from(typesUsageEvaluator.getSymbolsUsingSymbol(symbol) ?? []).filter((usedInSymbol: ts.Symbol) => {
if (!predicate(usedInSymbol)) {
return false;
}
return getDeclarationsForSymbol(usedInSymbol).some((decl: ts.Declaration) => {
const closestModuleLike = getClosestSourceFileLikeNode(decl);
const moduleInfo = getModuleLikeModuleInfo(closestModuleLike, criteria, typeChecker);
return moduleInfo.type === ModuleType.ShouldBeInlined;
});
});
}
function isSymbolUsedByInlinedSymbols(symbol: ts.Symbol, predicate: (usedInSymbol: ts.Symbol) => boolean, visitedSymbols: Set = new Set()): boolean {
if (visitedSymbols.has(symbol)) {
return false;
}
visitedSymbols.add(symbol);
return Array.from(typesUsageEvaluator.getSymbolsUsingSymbol(symbol) ?? []).some((usedInSymbol: ts.Symbol) => {
if (!predicate(usedInSymbol)) {
return isSymbolUsedByInlinedSymbols(usedInSymbol, predicate, visitedSymbols);
}
const usedByThisSymbol = getDeclarationsForSymbol(usedInSymbol).some((decl: ts.Declaration) => {
const closestModuleLike = getClosestSourceFileLikeNode(decl);
const moduleInfo = getModuleLikeModuleInfo(closestModuleLike, criteria, typeChecker);
return moduleInfo.type === ModuleType.ShouldBeInlined;
});
if (usedByThisSymbol) {
return true;
}
return isSymbolUsedByInlinedSymbols(usedInSymbol, predicate, visitedSymbols);
});
}
function isSymbolUsedByRootFileExports(symbol: ts.Symbol): boolean {
return rootFileExportSymbols.some((rootSymbol: ts.Symbol) => typesUsageEvaluator.isSymbolUsedBySymbol(symbol, rootSymbol));
}
function isSymbolForGlobalDeclaration(symbol: ts.Symbol): boolean {
return symbol.escapedName === ts.InternalSymbolName.Global;
}
function isSymbolForDeclareModuleDeclaration(symbol: ts.Symbol): boolean {
return getDeclarationsForSymbol(symbol).some(isDeclareModule);
}
// eslint-disable-next-line complexity
function isNodeUsed(node: ts.Node): boolean {
if (isNodeNamedDeclaration(node) || ts.isSourceFile(node)) {
const nodeSymbol = getNodeSymbol(node, typeChecker);
if (nodeSymbol === null) {
return false;
}
// note we don't need a function similar to `isSymbolUsedByGlobalSymbols` or `isSymbolUsedByGlobalSymbols`
// because `TypesUsageEvaluator.isSymbolUsedBySymbol` already handles recursive checks
const nodeUsedByDirectExports = isSymbolUsedByRootFileExports(nodeSymbol);
if (nodeUsedByDirectExports) {
return true;
}
if (inlineDeclareGlobals && isSymbolUsedByInlinedSymbols(nodeSymbol, isSymbolForGlobalDeclaration)) {
return true;
}
if (inlineDeclareExternals && isSymbolUsedByInlinedSymbols(nodeSymbol, isSymbolForDeclareModuleDeclaration)) {
return true;
}
return false;
}
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);
});
}
if (ts.isExportDeclaration(node) && node.exportClause !== undefined && ts.isNamespaceExport(node.exportClause)) {
return isNodeUsed(node.exportClause);
}
if (ts.isImportClause(node) && node.namedBindings !== undefined) {
return isNodeUsed(node.namedBindings);
}
return false;
}
function shouldNodeBeImported(node: ts.NamedDeclaration): boolean {
const nodeSymbol = getNodeSymbol(node, typeChecker);
if (nodeSymbol === null) {
return false;
}
return shouldSymbolBeImported(nodeSymbol);
}
function shouldSymbolBeImported(nodeSymbol: ts.Symbol): boolean {
const isSymbolDeclaredInDefaultLibrary = getDeclarationsForSymbol(nodeSymbol).some(
(declaration: ts.Declaration) => program.isSourceFileDefaultLibrary(declaration.getSourceFile())
);
if (isSymbolDeclaredInDefaultLibrary) {
// we shouldn't import a node declared in the default library (such dom, es2015)
// yeah, actually we should check that node is declared only in the default lib
// but it seems we can check that at least one declaration is from default lib
// to treat the node as un-importable
// because we can't re-export declared somewhere else node with declaration merging
// also, if some lib file will not be added to the project
// for example like it is described in the react declaration file (e.g. React Native)
// then here we still have a bug with "importing global declaration from a package"
// (see https://github.com/timocov/dts-bundle-generator/issues/71)
// but I don't think it is a big problem for now
// and it's possible that it will be fixed in https://github.com/timocov/dts-bundle-generator/issues/59
return false;
}
const symbolsDeclarations = getDeclarationsForSymbol(nodeSymbol);
// if all declarations of the symbol are in modules that should be inlined then this symbol must be inlined, not imported
const shouldSymbolBeInlined = symbolsDeclarations.every(
(decl: ts.Declaration) => getModuleLikeModuleInfo(
getClosestSourceFileLikeNode(decl),
criteria,
typeChecker
).type === ModuleType.ShouldBeInlined
);
if (shouldSymbolBeInlined) {
return false;
}
return getExportedSymbolsUsingSymbol(nodeSymbol).length !== 0;
}
function getExportedSymbolsUsingStatement(node: ts.NamedDeclaration): readonly ts.Symbol[] {
const nodeSymbol = getNodeSymbol(node, typeChecker);
if (nodeSymbol === null) {
return [];
}
return getExportedSymbolsUsingSymbol(nodeSymbol);
}
function getExportedSymbolsUsingSymbol(nodeSymbol: ts.Symbol): readonly ts.Symbol[] {
const symbolsUsingNode = typesUsageEvaluator.getSymbolsUsingSymbol(nodeSymbol);
if (symbolsUsingNode === null) {
throw new Error(`Something went wrong - getSymbolsUsingSymbol returned null but expected to be a set of symbols (symbol=${nodeSymbol.name})`);
}
return [
...(rootFileExportSymbols.includes(nodeSymbol) ? [nodeSymbol] : []),
// symbols which are used in types directly
...getInlinedSymbolsUsingSymbol(nodeSymbol, isSymbolUsedByRootFileExports),
// symbols which are used in global types i.e. in `declare global`s
...(inlineDeclareGlobals ? getInlinedSymbolsUsingSymbol(nodeSymbol, isSymbolForGlobalDeclaration) : []),
// symbols which are used in "declare module" types
...(inlineDeclareExternals ? getInlinedSymbolsUsingSymbol(nodeSymbol, isSymbolForDeclareModuleDeclaration) : []),
];
}
function areDeclarationSame(left: ts.NamedDeclaration, right: ts.NamedDeclaration): boolean {
const leftSymbols = splitTransientSymbol(getNodeSymbol(left, typeChecker) as ts.Symbol, typeChecker);
const rightSymbols = splitTransientSymbol(getNodeSymbol(right, typeChecker) as ts.Symbol, typeChecker);
for (const leftSymbol of leftSymbols) {
if (rightSymbols.has(leftSymbol)) {
return true;
}
}
return false;
}
function createNamespaceForExports(exports: ts.SymbolTable, namespaceSymbol: ts.Symbol): string | null {
function addSymbolToNamespaceExports(namespaceExports: Map, symbol: ts.Symbol): void {
// if a symbol isn't used by the namespace symbol it might mean that it shouldn't be included into the bundle because of tree-shaking
// in this case we shouldn't even try to add such symbol to the namespace
if (!typesUsageEvaluator.isSymbolUsedBySymbol(symbol, namespaceSymbol)) {
return;
}
const symbolKnownNames = collisionsResolver.namesForSymbol(symbol);
if (symbolKnownNames.size === 0) {
throw new Error(`Cannot get local names for symbol '${symbol.getName()}' while generating namespaced export`);
}
namespaceExports.set(symbol.getName(), Array.from(symbolKnownNames)[0]);
}
function handleNamespacedImportOrExport(namespacedImportOrExport: ts.ExportDeclaration | ts.ImportDeclaration, namespaceExports: Map, symbol: ts.Symbol): void {
if (namespacedImportOrExport.moduleSpecifier === undefined) {
return;
}
if (isReferencedModuleImportable(namespacedImportOrExport)) {
// in case of an external export statement we should copy it as is
// here we assume that a namespace import will be added in other places
// so here we can just add re-export
addSymbolToNamespaceExports(namespaceExports, symbol);
return;
}
const referencedSourceFileSymbol = getNodeOwnSymbol(namespacedImportOrExport.moduleSpecifier, typeChecker);
if (referencedSourceFileSymbol.exports === undefined) {
return;
}
if (ts.isImportDeclaration(namespacedImportOrExport) && referencedSourceFileSymbol.exports.has(ts.InternalSymbolName.ExportEquals)) {
// in case of handling `import * as Ns` statements with `export =` export in a module we need to ignore it
// as that import will be renamed later
return;
}
const localNamespaceName = createNamespaceForExports(referencedSourceFileSymbol.exports, symbol);
if (localNamespaceName !== null) {
namespaceExports.set(symbol.getName(), localNamespaceName);
}
}
function processExportSymbol(namespaceExports: Map, symbol: ts.Symbol): void {
if (symbol.escapedName === ts.InternalSymbolName.ExportStar) {
// this means that an export contains `export * from 'module'` statement
for (const exportStarDeclaration of getSymbolExportStarDeclarations(symbol)) {
if (exportStarDeclaration.moduleSpecifier === undefined) {
throw new Error(`Export star declaration does not have a module specifier '${exportStarDeclaration.getText()}'`);
}
if (isReferencedModuleImportable(exportStarDeclaration)) {
// in case of re-exporting from other modules directly we should import everything and re-export manually
// but it is not supported yet so lets just fail for now
throw new Error(`Having a re-export from an importable module as a part of namespaced export is not supported yet.`);
}
const referencedSourceFileSymbol = getNodeOwnSymbol(exportStarDeclaration.moduleSpecifier, typeChecker);
referencedSourceFileSymbol.exports?.forEach(
processExportSymbol.bind(null, namespaceExports)
);
}
return;
}
symbol.declarations?.forEach((decl: ts.Declaration) => {
if (ts.isNamespaceExport(decl) && decl.parent.moduleSpecifier !== undefined) {
handleNamespacedImportOrExport(decl.parent, namespaceExports, symbol);
return;
}
if (ts.isExportSpecifier(decl)) {
const exportElementSymbol = getImportExportReferencedSymbol(decl, typeChecker);
const namespaceImport = getDeclarationsForSymbol(exportElementSymbol).find(ts.isNamespaceImport);
if (namespaceImport !== undefined) {
// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
handleNamespacedImportOrExport(namespaceImport.parent.parent as ts.ImportDeclaration, namespaceExports, symbol);
}
return;
}
});
addSymbolToNamespaceExports(namespaceExports, symbol);
}
// eslint-disable-next-line complexity
function getIdentifierOfNamespaceImportFromInlinedModule(nsSymbol: ts.Symbol): ts.Identifier | null {
// handling namespaced re-exports/imports
// e.g. `export * as NS from './local-module';` or `import * as NS from './local-module'; export { NS }`
for (const decl of getDeclarationsForSymbol(nsSymbol)) {
if (!ts.isNamespaceExport(decl) && !ts.isExportSpecifier(decl) && !ts.isNamespaceImport(decl)) {
continue;
}
// if it is namespace export then it should be from a inlined module (e.g. `export * as NS from './local-module';`)
if (ts.isNamespaceExport(decl) && !isReferencedModuleImportable(decl.parent)) {
return decl.name;
}
// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
if (ts.isNamespaceImport(decl) && !isReferencedModuleImportable(decl.parent.parent as ts.ImportDeclaration)) {
return decl.name;
}
if (ts.isExportSpecifier(decl)) {
// if it is export specifier then it should exporting a local symbol i.e. without a module specifier (e.g. `export { NS };` or `export { NS as NewNsName };`)
if (decl.parent.parent.moduleSpecifier !== undefined) {
// this means that namespace symbol is created somewhere else in the import/export chain
if (isReferencedModuleImportable(decl.parent.parent)) {
continue;
}
// in case of a chain of imports/exports we need to keep searching recursively
if (getIdentifierOfNamespaceImportFromInlinedModule(getImportExportReferencedSymbol(decl, typeChecker))) {
return decl.name;
}
}
// but also that local symbol should be a namespace imported from inlined module
// i.e. `import * as NS from './local-module'`
const result = getDeclarationsForSymbol(getImportExportReferencedSymbol(decl, typeChecker)).some((importDecl: ts.Declaration) => {
if (ts.isNamespaceImport(importDecl)) {
// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
return !isReferencedModuleImportable(importDecl.parent.parent as ts.ImportDeclaration);
}
if (ts.isImportSpecifier(importDecl)) {
// this means that namespace symbol is created somewhere else in the import/export chain
return getIdentifierOfNamespaceImportFromInlinedModule(getImportExportReferencedSymbol(importDecl, typeChecker));
}
return false;
});
if (result) {
return decl.name;
}
}
}
return null;
}
const namespaceNameIdentifier = getIdentifierOfNamespaceImportFromInlinedModule(namespaceSymbol);
if (namespaceNameIdentifier === null) {
return null;
}
const namespaceExports = new Map();
exports.forEach(
processExportSymbol.bind(null, namespaceExports)
);
if (namespaceExports.size !== 0) {
const namespaceLocalName = collisionsResolver.addTopLevelIdentifier(namespaceNameIdentifier);
collectionResult.wrappedNamespaces.set(namespaceLocalName, namespaceExports);
return namespaceLocalName;
}
return null;
}
function syncExports(): void {
for (const exp of rootFileExports) {
if (exp.type === ExportType.CommonJS) {
// commonjs will be handled separately where we handle root source files
// as the only way of adding it is to add an explicit export statement in the root source file
continue;
}
// if resolved symbol is a "synthetic" symbol already (i.e. not namespace module)
// then we should create a namespace for its exports
// otherwise most likely it will be inlined as is anyway so we don't need to do anything
const namespaceLocalName = exp.symbol.flags & ts.SymbolFlags.ValueModule && exp.symbol.exports !== undefined
? createNamespaceForExports(exp.symbol.exports, exp.originalSymbol)
: null
;
if (namespaceLocalName !== null) {
collectionResult.renamedExports.set(exp.exportedName, namespaceLocalName);
}
const symbolKnownNames = collisionsResolver.namesForSymbol(exp.symbol);
if (symbolKnownNames.size === 0) {
// that's fine if a symbol doesn't exists in collisions resolver because it operates on top-level symbols only
// in some cases a symbol can be exported but not added to the top-level scope
// for instance in case of re-export from a library `export { Foo } from 'bar'`
// in this case we'll add this re-export differently
continue;
}
if (symbolKnownNames.has(exp.exportedName)) {
// an exported symbol is already known with its "exported" name so nothing to do at this point
// but if it is re-exported from imported library then we assume it was previously imported so we should re-export it anyway
if (shouldSymbolBeImported(exp.symbol)) {
collectionResult.renamedExports.set(exp.exportedName, exp.exportedName);
}
continue;
}
// in case if this symbol isn't known yet we need to add it via renamed export
// we assume that all known names are equal so we can use any (first)
// usually all "local" names should have only one known name
// but having multiple names is possible with imports - you can import the same node with different names
// and we want to preserve the source input as much as we can that's why we re-use them
collectionResult.renamedExports.set(exp.exportedName, Array.from(symbolKnownNames)[0]);
}
}
for (const sourceFile of sourceFiles) {
verboseLog(`======= Processing ${sourceFile.fileName} =======`);
const updateFn = sourceFile === rootSourceFile ? updateResultForRootModule : updateResultForAnyModule;
const currentModule = getFileModuleInfo(sourceFile.fileName, criteria);
updateFn(sourceFile.statements, currentModule);
// handle `import * as module` usage if it's used as whole module
if (isNodeUsed(sourceFile)) {
switch (currentModule.type) {
case ModuleType.ShouldBeImported: {
updateImportsForStatement(sourceFile);
break;
}
case ModuleType.ShouldBeInlined: {
const sourceFileSymbol = getNodeSymbol(sourceFile, typeChecker);
if (sourceFileSymbol === null || sourceFileSymbol.exports === undefined) {
throw new Error(`Cannot find symbol or exports for source file ${sourceFile.fileName}`);
}
let namespaceIdentifier: ts.Identifier | null = null;
forEachImportOfStatement(sourceFile, (imp: ImportOfStatement) => {
// here we want to handle creation of artificial namespace for a inlined module
// so we don't care about other type of imports/exports - only these that create a "namespace"
if (ts.isNamespaceExport(imp) || ts.isNamespaceImport(imp)) {
namespaceIdentifier = imp.name;
}
});
if (namespaceIdentifier === null) {
break;
}
createNamespaceForExports(sourceFileSymbol.exports, getNodeOwnSymbol(namespaceIdentifier, typeChecker));
break;
}
}
}
}
if (entryConfig.failOnClass) {
const classes = collectionResult.statements.filter(ts.isClassDeclaration);
if (classes.length !== 0) {
const classesNames = classes.map((c: ts.ClassDeclaration) => c.name === undefined ? 'anonymous class' : c.name.text);
throw new Error(`${classes.length} class statement(s) are found in generated dts: ${classesNames.join(', ')}`);
}
}
syncExports();
// by default this option should be enabled
const exportReferencedTypes = outputOptions.exportReferencedTypes !== false;
function isExportedWithLocalName(namedDeclaration: ts.NamedDeclaration, exportedName: string): boolean {
const nodeName = getNodeName(namedDeclaration);
if (nodeName === undefined) {
throw new Error(`Cannot find node name ${namedDeclaration.getText()}`);
}
return collisionsResolver.resolveReferencedIdentifier(nodeName as ts.Identifier) === exportedName;
}
const renamedAndNotExplicitlyExportedTypes: ts.NamedDeclaration[] = [];
const output = generateOutput(
{
...collectionResult,
resolveIdentifierName: (identifier: ts.Identifier | ts.QualifiedName | ts.PropertyAccessEntityNameExpression): string | null => {
if (ts.isPropertyAccessOrQualifiedName(identifier)) {
return collisionsResolver.resolveReferencedQualifiedName(identifier);
} else {
return collisionsResolver.resolveReferencedIdentifier(identifier);
}
},
// eslint-disable-next-line complexity
getStatementSettings: (statement: ts.Statement): StatementSettings => {
if (isAmbientModule(statement) || ts.isExportDeclaration(statement)) {
return { shouldHaveExportKeyword: false, shouldHaveJSDoc: true };
}
const statementExports = getExportsForStatement(rootFileExports, typeChecker, statement);
// If true, then no direct export was found. That means that node might have
// an export keyword (like interface, type, etc) otherwise, if there are
// only re-exports with renaming (like export { foo as bar }) we don't need
// to put export keyword for this statement because we'll re-export it in the way
const isExplicitlyExportedWithOriginalName = statementExports.find((exp: SourceFileExport) => {
if (ts.isVariableStatement(statement)) {
for (const variableDeclaration of statement.declarationList.declarations) {
if (ts.isIdentifier(variableDeclaration.name)) {
const resolvedName = collisionsResolver.resolveReferencedIdentifier(variableDeclaration.name);
if (exp.exportedName === resolvedName) {
return true;
}
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`);
}
return false;
}
return isNodeNamedDeclaration(statement) && isExportedWithLocalName(statement, exp.exportedName);
}) !== undefined;
// "direct export" means export from the root source file
// e.g. classes/functions/etc must be exported from the root source file to have an "export" keyword
// by default interfaces/types are exported even if they aren't directly exported (e.g. when they are referenced by other types)
// but if `exportReferencedTypes` option is disabled we have to check direct export for them either
const onlyExplicitlyExportedShouldBeExported = !exportReferencedTypes
|| ts.isClassDeclaration(statement)
|| (ts.isEnumDeclaration(statement) && !hasNodeModifier(statement, ts.SyntaxKind.ConstKeyword))
|| ts.isFunctionDeclaration(statement)
|| ts.isVariableStatement(statement)
|| ts.isModuleDeclaration(statement);
if (onlyExplicitlyExportedShouldBeExported) {
// "valuable" statements must be re-exported from root source file
// to having export keyword in declaration file
return { shouldHaveExportKeyword: isExplicitlyExportedWithOriginalName, shouldHaveJSDoc: statementExports.length !== 0 };
}
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
if (isNodeNamedDeclaration(statement) && !isExportedWithLocalName(statement, getNodeName(statement)!.getText())) {
// if a type node was renamed because of name collisions it shouldn't be exported with its new name
renamedAndNotExplicitlyExportedTypes.push(statement);
return { shouldHaveExportKeyword: false, shouldHaveJSDoc: statementExports.length !== 0 };
}
// at this point a statement of a type (interface, const enum, etc) will be exported 100% (it's just a matter of a name)
// so it must have jsdoc comment
return { shouldHaveExportKeyword: isExplicitlyExportedWithOriginalName || statementExports.length === 0, shouldHaveJSDoc: true };
},
needStripConstFromConstEnum: (constEnum: ts.EnumDeclaration) => {
if (!program.getCompilerOptions().preserveConstEnums || !outputOptions.respectPreserveConstEnum) {
return false;
}
const enumSymbol = getNodeSymbol(constEnum, typeChecker);
if (enumSymbol === null) {
return false;
}
return rootFileExportSymbols.includes(enumSymbol);
},
needStripImportFromImportTypeNode: (node: ts.ImportTypeNode) => {
if (node.qualifier === undefined) {
return false;
}
if (!ts.isLiteralTypeNode(node.argument) || !ts.isStringLiteral(node.argument.literal)) {
return false;
}
return getReferencedModuleInfo(node, criteria, typeChecker)?.type === ModuleType.ShouldBeInlined;
},
},
{
sortStatements: outputOptions.sortNodes,
umdModuleName: outputOptions.umdModuleName,
noBanner: outputOptions.noBanner,
}
);
if (renamedAndNotExplicitlyExportedTypes.length !== 0) {
warnLog(`The following type nodes were renamed because of the name collisions and will not be exported from the generated bundle:\n- ${
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
renamedAndNotExplicitlyExportedTypes.map(node => `${getNodeName(node)!.getText()} (from ${node.getSourceFile().fileName})`).join('\n- ')
}${
'\n'
}This might lead to unpredictable and unexpected output, and possible breaking changes to your API.${
'\n'
}Consider either (re-)exporting them explicitly from the entry point, or disable --export-referenced-types option ('output.exportReferencedTypes' in the config).`);
}
return output;
});
}
timocov-dts-bundle-generator-c69ff0d/src/collisions-resolver.ts 0000664 0000000 0000000 00000025536 14611320214 0025101 0 ustar 00root root 0000000 0000000 import * as ts from 'typescript';
import {
getActualSymbol,
getClosestModuleLikeNode,
getDeclarationNameSymbol,
getDeclarationsForSymbol,
resolveGlobalName,
} from './helpers/typescript';
import { verboseLog } from './logger';
const renamingSupportedSymbols: readonly ts.SymbolFlags[] = [
ts.SymbolFlags.Alias,
ts.SymbolFlags.Variable,
ts.SymbolFlags.Class,
ts.SymbolFlags.Enum,
ts.SymbolFlags.Function,
ts.SymbolFlags.Interface,
ts.SymbolFlags.NamespaceModule,
ts.SymbolFlags.TypeAlias,
ts.SymbolFlags.ValueModule,
];
export interface ResolverIdentifier {
name: string;
identifier?: ts.Identifier;
}
/**
* A class that holds information about top-level scoped names and allows to get collision-free names in one occurred.
*/
export class CollisionsResolver {
private typeChecker: ts.TypeChecker;
private collisionsMap: Map> = new Map();
private generatedNames: Map> = new Map();
public constructor(typeChecker: ts.TypeChecker) {
this.typeChecker = typeChecker;
}
/**
* Adds (or "registers") a top-level {@link identifier} (which takes a top-level scope name to use).
*/
public addTopLevelIdentifier(identifier: ts.Identifier | ts.DefaultKeyword): string {
const symbol = getDeclarationNameSymbol(identifier, this.typeChecker);
if (symbol === null) {
throw new Error(`Something went wrong - cannot find a symbol for top-level identifier ${identifier.getText()} (from ${identifier.parent.parent.getText()})`);
}
const newLocalName = this.registerSymbol(symbol, identifier.getText());
if (newLocalName === null) {
throw new Error(`Something went wrong - a symbol ${symbol.name} for top-level identifier ${identifier.getText()} cannot be renamed`);
}
return newLocalName;
}
/**
* Returns a set of all already registered names for a given {@link symbol}.
*/
public namesForSymbol(symbol: ts.Symbol): Set {
return this.generatedNames.get(getActualSymbol(symbol, this.typeChecker)) || new Set();
}
/**
* Resolves given {@link referencedIdentifier} to a name.
* It assumes that a symbol for this identifier has been registered before by calling {@link addTopLevelIdentifier} method.
* Otherwise it will return `null`.
*
* Note that a returned value might be of a different type of the identifier (e.g. {@link ts.QualifiedName} for a given {@link ts.Identifier})
*/
public resolveReferencedIdentifier(referencedIdentifier: ts.Identifier): string | null {
const identifierSymbol = getDeclarationNameSymbol(referencedIdentifier, this.typeChecker);
if (identifierSymbol === null) {
// that's fine if an identifier doesn't have a symbol
// it could be in cases like for `prop` in `declare function func({ prop: prop3 }?: InterfaceName): TypeName;`
return null;
}
const symbolScopePath = this.getSymbolScope(identifierSymbol);
// this scope defines where the current identifier is located
const currentIdentifierScope = this.getNodeScope(referencedIdentifier);
if (symbolScopePath.length > 0 && currentIdentifierScope.length > 0 && symbolScopePath[0] === currentIdentifierScope[0]) {
// if a referenced symbol is declared in the same scope where it is located
// then just return its reference as is without any modification
// also note that in this method we're working with identifiers only (i.e. it cannot be a qualified name)
return referencedIdentifier.getText();
}
const topLevelIdentifierSymbol = symbolScopePath.length === 0 ? identifierSymbol : symbolScopePath[0];
const namesForTopLevelSymbol = this.namesForSymbol(topLevelIdentifierSymbol);
if (namesForTopLevelSymbol.size === 0) {
return null;
}
let topLevelName = symbolScopePath.length === 0 ? referencedIdentifier.getText() : topLevelIdentifierSymbol.getName();
if (!namesForTopLevelSymbol.has(topLevelName)) {
// if the set of already registered names does not contain the one that is requested
const topLevelNamesArray = Array.from(namesForTopLevelSymbol);
// lets find more suitable name for a top level symbol
let suitableTopLevelName = topLevelNamesArray[0];
for (const name of topLevelNamesArray) {
// attempt to find a generated name first to provide identifiers close to the original code as much as possible
if (name.startsWith(`${topLevelName}$`)) {
suitableTopLevelName = name;
break;
}
}
topLevelName = suitableTopLevelName;
}
const newIdentifierParts = [
...symbolScopePath.map((symbol: ts.Symbol) => symbol.getName()),
referencedIdentifier.getText(),
];
// we don't need to rename any symbol but top level only as only it can collide with other symbols
newIdentifierParts[0] = topLevelName;
return newIdentifierParts.join('.');
}
/**
* Similar to {@link resolveReferencedIdentifier}, but works with qualified names (Ns.Ns1.Interface).
* The main point of this resolver is that it might change the first part of the qualifier only (as it drives uniqueness of a name).
*/
public resolveReferencedQualifiedName(referencedIdentifier: ts.QualifiedName | ts.PropertyAccessEntityNameExpression): string | null {
let topLevelIdentifier: ts.Identifier | ts.QualifiedName | ts.PropertyAccessEntityNameExpression = referencedIdentifier;
if (ts.isQualifiedName(topLevelIdentifier) || ts.isPropertyAccessExpression(topLevelIdentifier)) {
let leftmostIdentifier = ts.isQualifiedName(topLevelIdentifier) ? topLevelIdentifier.left : topLevelIdentifier.expression;
while (ts.isQualifiedName(leftmostIdentifier) || ts.isPropertyAccessExpression(leftmostIdentifier)) {
leftmostIdentifier = ts.isQualifiedName(leftmostIdentifier) ? leftmostIdentifier.left : leftmostIdentifier.expression;
}
topLevelIdentifier = leftmostIdentifier;
}
const topLevelName = this.resolveReferencedIdentifier(topLevelIdentifier);
if (topLevelName === null) {
// that's fine if we don't have a name for this top-level symbol
// it simply means that this symbol type might not be supported for renaming
// at this point the top-level identifier isn't registered yet
// but it is possible that the full qualified name is registered so we can use its replacement instead
// it is possible in cases where you use `import * as nsName` for internal modules
// so `nsName.Interface` will be resolved to `Interface` (or any other name that `Interface` was registered with)
const identifierSymbol = getDeclarationNameSymbol(referencedIdentifier, this.typeChecker);
if (identifierSymbol === null) {
// that's fine if an identifier doesn't have a symbol
// it could be in cases like for `prop` in `declare function func({ prop: prop3 }?: InterfaceName): TypeName;`
return null;
}
const namesForSymbol = this.namesForSymbol(identifierSymbol);
if (namesForSymbol.size !== 0) {
// if the set of already registered names contains the one that is requested then lets use it
return Array.from(namesForSymbol)[0];
}
// if it is not registered - just skip it
return null;
}
// for nodes that we have to import we need to add an imported value to the collisions map
// so it will not overlap with other imports/inlined nodes
const identifierParts = referencedIdentifier.getText().split('.');
// update top level part as it could get renamed above
// note that `topLevelName` might be a qualified name (e.g. with `.` in the name)
// but this is fine as we join with `.` below anyway
// but it is worth it to mention here ¯\_(ツ)_/¯
identifierParts[0] = topLevelName;
return identifierParts.join('.');
}
private getSymbolScope(identifierSymbol: ts.Symbol): ts.Symbol[] {
const identifierDeclarations = getDeclarationsForSymbol(identifierSymbol);
// not all symbols have declarations, e.g. `globalThis` or `undefined` (not type but value e.g. in `typeof undefined`)
// they are "fake" symbols that exist only at the compiler level (see checker.ts file in in the compiler or `globals.set()` calls)
if (identifierDeclarations.length === 0) {
return [];
}
// we assume that all symbols for a given identifier will be in the same scope (i.e. defined in the same namespaces-chain)
// so we can use any declaration to find that scope as they all will have the same scope
return this.getNodeScope(identifierDeclarations[0]);
}
/**
* Returns a node's scope where it is located in terms of namespaces/modules.
* E.g. A scope for `Opt` in `declare module foo { type Opt = number; }` is `[Symbol(foo)]`
*/
private getNodeScope(node: ts.Node): ts.Symbol[] {
const scopeIdentifiersPath: ts.Symbol[] = [];
let currentNode: ts.Node = getClosestModuleLikeNode(node);
while (ts.isModuleDeclaration(currentNode) && ts.isIdentifier(currentNode.name)) {
const nameSymbol = getDeclarationNameSymbol(currentNode.name, this.typeChecker);
if (nameSymbol === null) {
throw new Error(`Cannot find symbol for identifier '${currentNode.name.getText()}'`);
}
scopeIdentifiersPath.push(nameSymbol);
currentNode = getClosestModuleLikeNode(currentNode.parent);
}
return scopeIdentifiersPath.reverse();
}
private registerSymbol(identifierSymbol: ts.Symbol, preferredName: string): string | null {
if (!renamingSupportedSymbols.some((flag: ts.SymbolFlags) => identifierSymbol.flags & flag)) {
// if a symbol for something else that we don't support yet - skip
verboseLog(`Symbol ${identifierSymbol.name} cannot be renamed because its flag (${identifierSymbol.flags}) isn't supported`);
return null;
}
if (identifierSymbol.flags & ts.SymbolFlags.NamespaceModule && identifierSymbol.escapedName === ts.InternalSymbolName.Global) {
// no need to rename `declare global` namespaces
return null;
}
let symbolName = preferredName;
if (symbolName === 'default') {
// this is special case as an identifier cannot be named `default` because of es6 syntax
// so lets fallback to some valid name
symbolName = '_default';
}
const collisionsKey = symbolName;
let collisionSymbols = this.collisionsMap.get(collisionsKey);
if (collisionSymbols === undefined) {
collisionSymbols = new Map();
this.collisionsMap.set(collisionsKey, collisionSymbols);
}
const storedSymbolName = collisionSymbols.get(identifierSymbol);
if (storedSymbolName !== undefined) {
return storedSymbolName;
}
let nameIndex = collisionSymbols.size;
let newName = collisionSymbols.size === 0 ? symbolName : `${symbolName}$${nameIndex}`;
let resolvedGlobalSymbol = resolveGlobalName(this.typeChecker, newName);
while (resolvedGlobalSymbol !== undefined && resolvedGlobalSymbol !== identifierSymbol) {
nameIndex += 1;
newName = `${symbolName}$${nameIndex}`;
resolvedGlobalSymbol = resolveGlobalName(this.typeChecker, newName);
}
collisionSymbols.set(identifierSymbol, newName);
let symbolNames = this.generatedNames.get(identifierSymbol);
if (symbolNames === undefined) {
symbolNames = new Set();
this.generatedNames.set(identifierSymbol, symbolNames);
}
symbolNames.add(newName);
return newName;
}
}
timocov-dts-bundle-generator-c69ff0d/src/compile-dts.ts 0000664 0000000 0000000 00000020744 14611320214 0023300 0 ustar 00root root 0000000 0000000 import * as ts from 'typescript';
import { verboseLog, warnLog } from './logger';
import { getCompilerOptions } from './get-compiler-options';
import { checkProgramDiagnosticsErrors, checkDiagnosticsErrors } from './helpers/check-diagnostics-errors';
export interface CompileDtsResult {
program: ts.Program;
rootFilesRemapping: Map;
}
const declarationExtsRemapping: Partial> = {
[ts.Extension.Js]: ts.Extension.Js,
[ts.Extension.Jsx]: ts.Extension.Jsx,
[ts.Extension.Json]: ts.Extension.Json,
[ts.Extension.TsBuildInfo]: ts.Extension.TsBuildInfo,
[ts.Extension.Mjs]: ts.Extension.Mjs,
[ts.Extension.Cjs]: ts.Extension.Cjs,
[ts.Extension.Ts]: ts.Extension.Dts,
[ts.Extension.Tsx]: ts.Extension.Dts,
[ts.Extension.Dts]: ts.Extension.Dts,
[ts.Extension.Mts]: ts.Extension.Dmts,
[ts.Extension.Dmts]: ts.Extension.Dmts,
[ts.Extension.Cts]: ts.Extension.Dcts,
[ts.Extension.Dcts]: ts.Extension.Dcts,
} satisfies Record;
export function compileDts(rootFiles: readonly string[], preferredConfigPath?: string, followSymlinks: boolean = true): CompileDtsResult {
const compilerOptions = getCompilerOptions(rootFiles, preferredConfigPath);
// currently we don't support these compiler options
// and removing them shouldn't affect generated code
// so let's just remove them for this run
compilerOptions.outDir = undefined;
compilerOptions.incremental = undefined;
compilerOptions.tsBuildInfoFile = undefined;
compilerOptions.declarationDir = undefined;
// we want to turn this option on because in this case the compile will generate declaration diagnostics out of the box
compilerOptions.declaration = true;
if (compilerOptions.composite) {
warnLog(`Composite projects aren't supported at the time. Prefer to use non-composite project to generate declarations instead or just ignore this message if everything works fine. See https://github.com/timocov/dts-bundle-generator/issues/93`);
compilerOptions.composite = undefined;
}
const host = createCachingCompilerHost(compilerOptions);
const dtsFiles = getDeclarationFiles(rootFiles, compilerOptions, host);
if (!followSymlinks) {
// note that this shouldn't affect the previous call as there we actually want to use actual path in order to compile files
// and avoid issues like "you have .ts files in node_modules"
host.realpath = (p: string) => p;
}
const moduleResolutionCache = ts.createModuleResolutionCache(host.getCurrentDirectory(), host.getCanonicalFileName, compilerOptions);
host.resolveModuleNameLiterals = (moduleLiterals: readonly ts.StringLiteralLike[], containingFile: string): ts.ResolvedModuleWithFailedLookupLocations[] => {
return moduleLiterals.map((moduleLiteral: ts.StringLiteralLike): ts.ResolvedModuleWithFailedLookupLocations => {
const resolvedModule = ts.resolveModuleName(moduleLiteral.text, containingFile, compilerOptions, host, moduleResolutionCache).resolvedModule;
if (resolvedModule && !resolvedModule.isExternalLibraryImport) {
const newExt = declarationExtsRemapping[resolvedModule.extension];
if (newExt === undefined) {
verboseLog(`Skipping module ${resolvedModule.resolvedFileName} because it has unsupported extension "${resolvedModule.extension}"`);
return { resolvedModule };
}
// eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
if (newExt !== resolvedModule.extension) {
verboseLog(`Changing module from ${resolvedModule.extension} to ${newExt} for ${resolvedModule.resolvedFileName}`);
resolvedModule.extension = newExt;
resolvedModule.resolvedFileName = changeExtensionToDts(resolvedModule.resolvedFileName);
}
}
return { resolvedModule };
});
};
const originalGetSourceFile = host.getSourceFile;
host.getSourceFile = (fileName: string, languageVersion: ts.ScriptTarget, onError?: (message: string) => void) => {
const storedValue = dtsFiles.get(host.getCanonicalFileName(fileName));
if (storedValue !== undefined) {
return ts.createSourceFile(fileName, storedValue, languageVersion);
}
return originalGetSourceFile(fileName, languageVersion, onError);
};
const rootFilesRemapping = new Map();
const inputFiles = rootFiles.map((rootFile: string) => {
const rootDtsFile = changeExtensionToDts(rootFile);
rootFilesRemapping.set(rootFile, rootDtsFile);
return rootDtsFile;
});
const program = ts.createProgram(inputFiles, compilerOptions, host);
checkProgramDiagnosticsErrors(program);
warnAboutTypeScriptFilesInProgram(program);
return { program, rootFilesRemapping };
}
function createCachingCompilerHost(compilerOptions: ts.CompilerOptions): ts.CompilerHost {
const host = ts.createIncrementalCompilerHost(compilerOptions);
const sourceFilesCache = new Map();
const originalGetSourceFile = host.getSourceFile;
host.getSourceFile = (fileName: string, languageVersion: ts.ScriptTarget, onError?: (message: string) => void): ts.SourceFile | undefined => {
const key = host.getCanonicalFileName(fileName);
let cacheValue = sourceFilesCache.get(key);
if (cacheValue === undefined) {
cacheValue = originalGetSourceFile(fileName, languageVersion, onError);
sourceFilesCache.set(key, cacheValue);
}
return cacheValue;
};
return host;
}
function changeExtensionToDts(fileName: string): string {
let ext: ts.Extension | undefined;
// `path.extname` doesn't handle `.d.ts` cases (it returns `.ts` instead of `.d.ts`)
if (fileName.endsWith(ts.Extension.Dts)) {
return fileName;
}
if (fileName.endsWith(ts.Extension.Cts)) {
ext = ts.Extension.Cts;
} else if (fileName.endsWith(ts.Extension.Mts)) {
ext = ts.Extension.Mts;
} else if (fileName.endsWith(ts.Extension.Ts)) {
ext = ts.Extension.Ts;
} else if (fileName.endsWith(ts.Extension.Tsx)) {
ext = ts.Extension.Tsx;
}
if (ext === undefined) {
return fileName;
}
return fileName.slice(0, -ext.length) + declarationExtsRemapping[ext];
}
/**
* @description Compiles source files into d.ts files and returns map of absolute path to file content
*/
function getDeclarationFiles(rootFiles: readonly string[], compilerOptions: ts.CompilerOptions, host: ts.CompilerHost): Map {
// we must pass `declaration: true` and `noEmit: false` if we want to generate declaration files
// see https://github.com/microsoft/TypeScript/issues/24002#issuecomment-550549393
// also, we don't want to generate anything apart from declarations so that's why `emitDeclarationOnly: true` is here
// it allows to run the tool for projects with allowJs flag enabled to avoid errors like:
// error TS5055: Cannot write file '' because it would overwrite input file.
compilerOptions = {
...compilerOptions,
noEmit: false,
declaration: true,
emitDeclarationOnly: true,
};
// theoretically this could be dangerous because the compiler host is created with compiler options
// so technically `compilerOptions` and ones that were used to create the host might be different (and most likely will be)
// but apparently a compiler host doesn't use compiler options that much, just a few encoding/newLine oriented
// so hopefully it should be fine
const program = ts.createProgram(rootFiles, compilerOptions, host);
const allFilesAreDeclarations = program.getSourceFiles().every((s: ts.SourceFile) => s.isDeclarationFile);
const declarations = new Map();
if (allFilesAreDeclarations) {
// if all files are declarations we don't need to compile the project twice
// so let's just return empty map to speed up
verboseLog('Skipping compiling the project to generate d.ts because all files in it are d.ts already');
return declarations;
}
checkProgramDiagnosticsErrors(program);
const emitResult = program.emit(
undefined,
(fileName: string, data: string) => declarations.set(host.getCanonicalFileName(fileName), data),
undefined,
true
);
checkDiagnosticsErrors(emitResult.diagnostics, 'Errors while emitting declarations');
return declarations;
}
function warnAboutTypeScriptFilesInProgram(program: ts.Program): void {
const nonDeclarationFiles = program.getSourceFiles().filter((file: ts.SourceFile) => !file.isDeclarationFile);
if (nonDeclarationFiles.length !== 0) {
warnLog(`WARNING: It seems that some files in the compilation still are not declaration files.
For more information see https://github.com/timocov/dts-bundle-generator/issues/53.
If you think this is a mistake, feel free to open new issue or just ignore this warning.
${nonDeclarationFiles.map((file: ts.SourceFile) => file.fileName).join('\n ')}
`);
}
}
timocov-dts-bundle-generator-c69ff0d/src/config-file/ 0000775 0000000 0000000 00000000000 14611320214 0022663 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/src/config-file/README.md 0000664 0000000 0000000 00000015205 14611320214 0024145 0 ustar 00root root 0000000 0000000 # Config file
Config file might be either JSON file or JS file with CommonJS export of the config.
## Schema
```js
{
compilationOptions: {
/**
* EXPERIMENTAL!
* Allows disable resolving of symlinks to the original path.
* By default following is enabled.
* @see https://github.com/timocov/dts-bundle-generator/issues/39
* Optional. Default value is `true`.
*/
followSymlinks: true,
/**
* Path to the tsconfig file that will be used for the compilation.
* Must be set if entries count more than 1.
*/
preferredConfigPath: './tsconfig.json',
},
// non-empty array of entries
entries: [
{
/**
* Path to input file (absolute or relative to config file).
* Required.
*/
filePath: './src/index.ts',
/**
* Path of generated d.ts.
* If not specified - the path will be input file with replaced extension to `.d.ts`.
*/
outFile: './out/index.d.ts',
/**
* Fail if generated dts contains class declaration.
* Optional. Default value is `false`.
*/
failOnClass: false,
/**
* Skip validation of generated d.ts file.
* Optional. Default value is `false`.
*/
noCheck: false,
libraries: {
/**
* Array of package names from @types to import typings from via the triple-slash reference directive.
* By default all packages are allowed and will be used according to their usages.
* Optional. Default value is `undefined`.
*/
allowedTypesLibraries: ['jquery', 'react'],
/**
* Array of package names from node_modules to import typings from.
* Used types will be imported using `import { First, Second } from 'library-name';`.
* By default all libraries will be imported (except inlined libraries and libraries from @types).
* Optional. Default value is `undefined`.
*/
importedLibraries: ['rxjs', 'typescript'],
/**
* Array of package names from node_modules to inline typings from.
* Used types will be inlined into the output file.
* Optional. Default value is `[]`.
*/
inlinedLibraries: ['@my-company/package'],
},
output: {
/**
* Enables inlining of `declare global` statements contained in files which should be inlined (all local files and packages from inlined libraries).
* Optional. Default value is `false`.
*/
inlineDeclareGlobals: false,
/**
* Sort output nodes in ascendant order.
* Optional. Default value is `false`.
*/
sortNodes: false,
/**
* Name of the UMD module.
* If specified then `export as namespace ModuleName;` will be emitted.
* Optional. Default value is `undefined`.
*/
umdModuleName: 'MyModuleName',
/**
* Enables inlining of `declare module` statements of the global modules
* (e.g. `declare module 'external-module' {}`, but NOT `declare module './internal-module' {}`)
* contained in files which should be inlined (all local files and packages from inlined libraries)
*/
inlineDeclareExternals: false,
/**
* Allows remove "Generated by dts-bundle-generator" comment from the output
*/
noBanner: false,
/**
* Enables stripping the `const` keyword from every direct-exported (or re-exported) from entry file `const enum`.
* This allows you "avoid" the issue described in https://github.com/microsoft/TypeScript/issues/37774.
*/
respectPreserveConstEnum: false,
/**
* By default all interfaces, types and const enums are marked as exported even if they aren't exported directly.
* This option allows you to disable this behavior so a node will be exported if it is exported from root source file only.
*/
exportReferencedTypes: true,
},
},
],
}
```
## Tips
1. You can use `@ts-check` for your JS config-file to check that your config has correct schema.
1. Also you can write your config in TS and before run dts-bundle-generator compile it in JS.
## Examples
*JSON file*:
```json
{
"compilationOptions": {
"preferredConfigPath": "./tsconfig.json"
},
"entries": [
{
"filePath": "./src/index.ts",
"outFile": "./out/index.d.ts",
"libraries": {
"inlinedLibraries": ["@my-company/package"]
},
"output": {
"inlineDeclareGlobals": false,
"sortNodes": true,
"umdModuleName": "MyModuleName"
}
},
{
"filePath": "./src/second.ts",
"outFile": "./out/second.d.ts",
"failOnClass": true,
"libraries": {
"allowedTypesLibraries": [],
"importedLibraries": [],
"inlinedLibraries": []
}
},
{
"filePath": "./src/third.ts"
}
]
}
```
*JS file*:
```js
// @ts-check
// If won't use `@ts-check` - just remove that comments (with `@type` JSDoc below).
/** @type import('dts-bundle-generator/config-schema').OutputOptions */
const commonOutputParams = {
inlineDeclareGlobals: false,
sortNodes: true,
};
/** @type import('dts-bundle-generator/config-schema').BundlerConfig */
const config = {
compilationOptions: {
preferredConfigPath: './tsconfig.json',
},
entries: [
{
filePath: './src/index.ts',
outFile: './out/index.d.ts',
noCheck: false,
output: commonOutputParams,
},
{
filePath: './src/second.ts',
outFile: './out/second.d.ts',
failOnClass: true,
libraries: {
inlinedLibraries: ['@my-company/package'],
},
output: commonOutputParams,
},
],
};
module.exports = config;
```
timocov-dts-bundle-generator-c69ff0d/src/config-file/check-schema-match.ts 0000664 0000000 0000000 00000005024 14611320214 0026641 0 ustar 00root root 0000000 0000000 export interface PrimitiveValues {
boolean: false;
requiredBoolean: true;
string: '';
requiredString: 'REQUIRED';
}
export type SchemeDescriptor = {
[P in keyof T]-?: T[P] extends unknown[] ? [SchemeDescriptor] : SchemeDescriptor;
};
export const schemaPrimitiveValues: Readonly = {
boolean: false,
requiredBoolean: true,
string: '',
requiredString: 'REQUIRED',
};
const schemaRequiredValues = new Set([
schemaPrimitiveValues.requiredBoolean,
schemaPrimitiveValues.requiredString,
]);
export function checkSchemaMatch(value: unknown, schema: SchemeDescriptor, errors: string[]): value is T {
if (value === undefined) {
errors.push('Root value is undefined');
return false;
}
return checkSchemaMatchRecursively(value, schema, '', errors);
}
// eslint-disable-next-line complexity
function checkSchemaMatchRecursively(value: unknown, schema: SchemeDescriptor | [SchemeDescriptor], prefix: string, errors: string[]): value is T {
if (typeof schema === 'boolean' || typeof schema === 'string') {
const schemeType = typeof schema;
if (value === undefined && schemaRequiredValues.has(schema)) {
errors.push(`Value for "${prefix}" is required and must have type "${schemeType}"`);
return false;
}
const valueType = typeof value;
if (value !== undefined && typeof schema !== valueType) {
errors.push(`Type of values for "${prefix}" is not the same, expected=${schemeType}, actual=${valueType}`);
return false;
}
return true;
}
if (value === undefined) {
return true;
}
if (Array.isArray(schema)) {
if (!Array.isArray(value)) {
return false;
}
let result = true;
for (let i = 0; i < value.length; ++i) {
if (!checkSchemaMatchRecursively(value[i], schema[0], `${prefix}[${i}]`, errors)) {
result = false;
}
}
return result;
}
type SchemeKey = keyof SchemeDescriptor;
type SchemeSubValue = SchemeDescriptor;
let result = true;
for (const valueKey of Object.keys(value as object)) {
if (schema[valueKey as keyof T] === undefined) {
errors.push(`Exceeded property "${valueKey}" found in ${prefix.length === 0 ? 'the root' : prefix}`);
result = false;
}
}
for (const schemaKey of Object.keys(schema)) {
const isSubValueSchemeMatched = checkSchemaMatchRecursively(
(value as Record)[schemaKey],
schema[schemaKey as SchemeKey] as SchemeSubValue,
prefix.length === 0 ? schemaKey : `${prefix}.${schemaKey}`,
errors
);
result = result && isSubValueSchemeMatched;
}
return result;
}
timocov-dts-bundle-generator-c69ff0d/src/config-file/load-config-file.ts 0000664 0000000 0000000 00000005447 14611320214 0026344 0 ustar 00root root 0000000 0000000 import * as path from 'path';
import { errorLog } from '../logger';
import { EntryPointConfig, CompilationOptions } from '../bundle-generator';
import { getAbsolutePath } from '../helpers/get-absolute-path';
import { checkSchemaMatch, SchemeDescriptor, schemaPrimitiveValues } from './check-schema-match';
export interface ConfigEntryPoint extends EntryPointConfig {
/**
* Path of generated d.ts.
* If not specified - the path will be input file with replaced extension to `.d.ts`.
*/
outFile?: string;
/**
* Skip validation of generated d.ts file
*/
noCheck?: boolean;
}
export interface BundlerConfig {
entries: ConfigEntryPoint[];
compilationOptions?: CompilationOptions;
}
/**
* @internal Do not output this function in generated dts for the npm package
*/
export function loadConfigFile(configPath: string): BundlerConfig {
// eslint-disable-next-line @typescript-eslint/no-var-requires
const possibleConfig = require(getAbsolutePath(configPath));
const errors: string[] = [];
if (!checkSchemaMatch(possibleConfig, configScheme, errors)) {
errorLog(errors.join('\n'));
throw new Error('Cannot parse config file');
}
if (!Array.isArray(possibleConfig.entries) || possibleConfig.entries.length === 0) {
throw new Error('No entries found');
}
const configFolder = path.dirname(configPath);
possibleConfig.entries.forEach((entry: ConfigEntryPoint) => {
entry.filePath = getAbsolutePath(entry.filePath, configFolder);
if (entry.outFile !== undefined) {
entry.outFile = getAbsolutePath(entry.outFile, configFolder);
}
});
if (possibleConfig.compilationOptions !== undefined && possibleConfig.compilationOptions.preferredConfigPath !== undefined) {
possibleConfig.compilationOptions.preferredConfigPath = getAbsolutePath(possibleConfig.compilationOptions.preferredConfigPath, configFolder);
}
return possibleConfig;
}
const configScheme: SchemeDescriptor = {
compilationOptions: {
followSymlinks: schemaPrimitiveValues.boolean,
preferredConfigPath: schemaPrimitiveValues.string,
},
entries: [
{
filePath: schemaPrimitiveValues.requiredString,
outFile: schemaPrimitiveValues.string,
failOnClass: schemaPrimitiveValues.boolean,
noCheck: schemaPrimitiveValues.boolean,
libraries: {
allowedTypesLibraries: [schemaPrimitiveValues.string],
importedLibraries: [schemaPrimitiveValues.string],
inlinedLibraries: [schemaPrimitiveValues.string],
},
output: {
inlineDeclareGlobals: schemaPrimitiveValues.boolean,
inlineDeclareExternals: schemaPrimitiveValues.boolean,
sortNodes: schemaPrimitiveValues.boolean,
umdModuleName: schemaPrimitiveValues.string,
noBanner: schemaPrimitiveValues.boolean,
respectPreserveConstEnum: schemaPrimitiveValues.boolean,
exportReferencedTypes: schemaPrimitiveValues.boolean,
},
},
],
};
timocov-dts-bundle-generator-c69ff0d/src/generate-output.ts 0000664 0000000 0000000 00000027766 14611320214 0024223 0 ustar 00root root 0000000 0000000 import * as ts from 'typescript';
import { packageVersion } from './helpers/package-version';
import { getModifiers, getNodeName, modifiersToMap, recreateRootLevelNodeWithModifiers } from './helpers/typescript';
export interface ModuleImportsSet {
defaultImports: Set;
nsImport: string | null;
namedImports: Map;
requireImports: Set;
reExports: Map;
}
export interface OutputInputData {
typesReferences: Set;
imports: Map;
statements: readonly ts.Statement[];
renamedExports: Map;
wrappedNamespaces: Map>;
}
export interface NeedStripDefaultKeywordResult {
needStrip: boolean;
newName?: string;
}
export interface StatementSettings {
shouldHaveExportKeyword: boolean;
shouldHaveJSDoc: boolean;
}
export interface OutputHelpers {
getStatementSettings(statement: ts.Statement): StatementSettings;
needStripConstFromConstEnum(constEnum: ts.EnumDeclaration): boolean;
needStripImportFromImportTypeNode(importType: ts.ImportTypeNode): boolean;
resolveIdentifierName(identifier: ts.Identifier | ts.QualifiedName | ts.PropertyAccessEntityNameExpression): string | null;
}
export type OutputParams = OutputHelpers & OutputInputData;
export interface OutputOptions {
umdModuleName?: string;
sortStatements?: boolean;
noBanner?: boolean;
}
export function generateOutput(params: OutputParams, options: OutputOptions = {}): string {
const resultOutputParts: string[] = [];
if (!options.noBanner) {
resultOutputParts.push(`// Generated by dts-bundle-generator v${packageVersion()}`);
}
if (params.typesReferences.size !== 0) {
const header = generateReferenceTypesDirective(Array.from(params.typesReferences));
resultOutputParts.push(header);
}
if (params.imports.size !== 0) {
// we need to have sorted imports of libraries to have more "stable" output
const sortedEntries = Array.from(params.imports.entries()).sort((firstEntry: [string, ModuleImportsSet], secondEntry: [string, ModuleImportsSet]) => {
return firstEntry[0].localeCompare(secondEntry[0]);
});
const importsArray: string[] = [];
for (const [libraryName, libraryImports] of sortedEntries) {
importsArray.push(...generateImports(libraryName, libraryImports));
}
if (importsArray.length !== 0) {
resultOutputParts.push(importsArray.join('\n'));
}
}
const statements = params.statements.map((statement: ts.Statement) => getStatementText(
statement,
Boolean(options.sortStatements),
params
));
if (options.sortStatements) {
statements.sort(compareStatementText);
}
if (statements.length !== 0) {
resultOutputParts.push(statementsTextToString(statements));
}
if (params.wrappedNamespaces.size !== 0) {
resultOutputParts.push(
Array.from(params.wrappedNamespaces.entries())
.map(([namespaceName, exportedNames]: [string, Map]) => {
return `declare namespace ${namespaceName} {\n\texport { ${
Array.from(exportedNames.entries())
.map(([exportedName, localName]: [string, string]) => renamedExportValue(exportedName, localName))
.sort()
.join(', ')
} };\n}`;
})
.join('\n')
);
}
if (params.renamedExports.size !== 0) {
resultOutputParts.push(`export {\n\t${
Array.from(params.renamedExports.entries())
.map(([exportedName, localName]: [string, string]) => renamedExportValue(exportedName, localName))
.sort()
.join(',\n\t')
},\n};`);
}
if (options.umdModuleName !== undefined) {
resultOutputParts.push(`export as namespace ${options.umdModuleName};`);
}
// this is used to prevent importing non-exported nodes
// see https://stackoverflow.com/questions/52583603/intentional-that-export-shuts-off-automatic-export-of-all-symbols-from-a-ty
resultOutputParts.push(`export {};\n`);
return resultOutputParts.join('\n\n');
}
interface StatementText {
text: string;
sortingValue: string;
}
function statementsTextToString(statements: StatementText[]): string {
const statementsText = statements.map(statement => statement.text).join('\n');
return spacesToTabs(prettifyStatementsText(statementsText));
}
function renamedExportValue(exportedName: string, localName: string): string {
return exportedName !== localName ? `${localName} as ${exportedName}` : exportedName;
}
function renamedImportValue(importedName: string, localName: string): string {
return importedName !== localName ? `${importedName} as ${localName}` : importedName;
}
function prettifyStatementsText(statementsText: string): string {
const sourceFile = ts.createSourceFile('output.d.ts', statementsText, ts.ScriptTarget.Latest, false, ts.ScriptKind.TS);
const printer = ts.createPrinter(
{
newLine: ts.NewLineKind.LineFeed,
removeComments: false,
}
);
return printer.printFile(sourceFile).trim();
}
function compareStatementText(a: StatementText, b: StatementText): number {
if (a.sortingValue > b.sortingValue) {
return 1;
} else if (a.sortingValue < b.sortingValue) {
return -1;
}
return 0;
}
function recreateEntityName(node: ts.EntityName, helpers: OutputHelpers): ts.EntityName {
const resolvedName = helpers.resolveIdentifierName(node);
if (resolvedName !== null && resolvedName !== node.getText()) {
const identifiers = resolvedName.split('.');
let result: ts.EntityName = ts.factory.createIdentifier(identifiers[0]);
for (let index = 1; index < identifiers.length; index += 1) {
result = ts.factory.createQualifiedName(
result,
ts.factory.createIdentifier(identifiers[index])
);
}
return result;
}
return node;
}
function getStatementText(statement: ts.Statement, includeSortingValue: boolean, helpers: OutputHelpers): StatementText {
const { shouldHaveExportKeyword, shouldHaveJSDoc } = helpers.getStatementSettings(statement);
// re-export statements do not contribute to top-level names scope so we don't need to resolve their identifiers
const needResolveIdentifiers = !ts.isExportDeclaration(statement) || statement.moduleSpecifier === undefined;
const printer = ts.createPrinter(
{
newLine: ts.NewLineKind.LineFeed,
removeComments: false,
},
{
// eslint-disable-next-line complexity
substituteNode: (hint: ts.EmitHint, node: ts.Node) => {
if (node.parent === undefined) {
return node;
}
if (needResolveIdentifiers) {
if (ts.isPropertyAccessExpression(node)) {
const resolvedName = helpers.resolveIdentifierName(node as ts.PropertyAccessEntityNameExpression);
if (resolvedName !== null && resolvedName !== node.getText()) {
const identifiers = resolvedName.split('.');
let result: ts.PropertyAccessExpression | ts.Identifier = ts.factory.createIdentifier(identifiers[0]);
for (let index = 1; index < identifiers.length; index += 1) {
result = ts.factory.createPropertyAccessExpression(
result as ts.PropertyAccessExpression,
ts.factory.createIdentifier(identifiers[index])
);
}
return result;
}
return node;
}
if (ts.isIdentifier(node) || ts.isQualifiedName(node)) {
// QualifiedName and PropertyAccessExpression are handled separately
if (ts.isIdentifier(node) && (ts.isQualifiedName(node.parent) || ts.isPropertyAccessExpression(node.parent))) {
return node;
}
if (ts.isIdentifier(node) && ts.isImportTypeNode(node.parent) && node.parent.qualifier === node) {
// identifiers in dynamic imports should be ignored as they don't use local scope
return node;
}
return recreateEntityName(node, helpers);
}
}
// `import('module').Qualifier` or `typeof import('module').Qualifier`
if (ts.isImportTypeNode(node) && node.qualifier !== undefined && helpers.needStripImportFromImportTypeNode(node)) {
const newQualifier = recreateEntityName(node.qualifier, helpers);
if (node.isTypeOf) {
return ts.factory.createTypeQueryNode(newQualifier);
}
return ts.factory.createTypeReferenceNode(newQualifier, node.typeArguments);
}
if (node !== statement) {
return node;
}
const modifiersMap = modifiersToMap(getModifiers(node));
if (
ts.isEnumDeclaration(node)
&& modifiersMap[ts.SyntaxKind.ConstKeyword]
&& helpers.needStripConstFromConstEnum(node)
) {
modifiersMap[ts.SyntaxKind.ConstKeyword] = false;
}
const nodeName = getNodeName(node);
const resolvedStatementName = nodeName !== undefined ? helpers.resolveIdentifierName(nodeName as ts.Identifier) || undefined : undefined;
// strip the `default` keyword from node regardless
if (modifiersMap[ts.SyntaxKind.DefaultKeyword]) {
modifiersMap[ts.SyntaxKind.DefaultKeyword] = false;
if (ts.isClassDeclaration(node)) {
// for classes we need to replace `default` with `declare` instead otherwise it will produce an invalid syntax
modifiersMap[ts.SyntaxKind.DeclareKeyword] = true;
}
}
if (!shouldHaveExportKeyword) {
modifiersMap[ts.SyntaxKind.ExportKeyword] = false;
} else {
modifiersMap[ts.SyntaxKind.ExportKeyword] = true;
}
// for some reason TypeScript allows to not write `declare` keyword for ClassDeclaration, FunctionDeclaration and VariableDeclaration
// if it already has `export` keyword - so we need to add it
// to avoid TS1046: Top-level declarations in .d.ts files must start with either a 'declare' or 'export' modifier.
if (!modifiersMap[ts.SyntaxKind.ExportKeyword] &&
(ts.isClassDeclaration(node)
|| ts.isFunctionDeclaration(node)
|| ts.isVariableStatement(node)
|| ts.isEnumDeclaration(node)
|| ts.isModuleDeclaration(node)
)
) {
modifiersMap[ts.SyntaxKind.DeclareKeyword] = true;
}
return recreateRootLevelNodeWithModifiers(node, modifiersMap, resolvedStatementName, shouldHaveJSDoc);
},
}
);
const statementText = printer.printNode(ts.EmitHint.Unspecified, statement, statement.getSourceFile()).trim();
let sortingValue = '';
if (includeSortingValue) {
// it looks like there is no way to get node's text without a comment at the same time as printing it
// so to get the actual node text we have to parse it again
// hopefully it shouldn't take too long (we don't need to do type check, just parse the AST)
// also let's do it opt-in so if someone isn't using node sorting it won't affect them
const tempSourceFile = ts.createSourceFile('temp.d.ts', statementText, ts.ScriptTarget.ESNext);
// we certainly know that there should be 1 statement at the root level (the printed statement)
sortingValue = tempSourceFile.getChildren()[0].getText();
}
return { text: statementText, sortingValue };
}
function generateImports(libraryName: string, imports: ModuleImportsSet): string[] {
const fromEnding = `from '${libraryName}';`;
const result: string[] = [];
// sort to make output more "stable"
if (imports.nsImport !== null) {
result.push(`import * as ${imports.nsImport} ${fromEnding}`);
}
Array.from(imports.requireImports).sort().forEach((importName: string) => result.push(`import ${importName} = require('${libraryName}');`));
Array.from(imports.defaultImports).sort().forEach((importName: string) => result.push(`import ${importName} ${fromEnding}`));
if (imports.namedImports.size !== 0) {
result.push(`import { ${
Array.from(imports.namedImports.entries())
.map(([localName, importedName]: [string, string]) => renamedImportValue(importedName, localName))
.sort()
.join(', ')
} } ${fromEnding}`);
}
if (imports.reExports.size !== 0) {
result.push(`export { ${
Array.from(imports.reExports.entries())
.map(([localName, importedName]: [string, string]) => renamedImportValue(importedName, localName))
.sort()
.join(', ')
} } ${fromEnding}`);
}
return result;
}
function generateReferenceTypesDirective(libraries: string[]): string {
return libraries.sort().map((library: string) => {
return `/// `;
}).join('\n');
}
function spacesToTabs(text: string): string {
// eslint-disable-next-line no-regex-spaces
return text.replace(/^( )+/gm, (substring: string) => {
return '\t'.repeat(substring.length / 4);
});
}
timocov-dts-bundle-generator-c69ff0d/src/get-compiler-options.ts 0000664 0000000 0000000 00000004520 14611320214 0025132 0 ustar 00root root 0000000 0000000 import * as ts from 'typescript';
import * as path from 'path';
import { getAbsolutePath } from './helpers/get-absolute-path';
import { checkDiagnosticsErrors } from './helpers/check-diagnostics-errors';
import { verboseLog } from './logger';
const enum Constants {
NoInputsWereFoundDiagnosticCode = 18003,
}
const parseConfigHost: ts.ParseConfigHost = {
useCaseSensitiveFileNames: ts.sys.useCaseSensitiveFileNames,
readDirectory: ts.sys.readDirectory,
fileExists: ts.sys.fileExists,
readFile: ts.sys.readFile,
};
export function getCompilerOptions(inputFileNames: readonly string[], preferredConfigPath?: string): ts.CompilerOptions {
const configFileName = preferredConfigPath !== undefined ? preferredConfigPath : findConfig(inputFileNames);
verboseLog(`Using config: ${configFileName}`);
const configParseResult = ts.readConfigFile(configFileName, ts.sys.readFile);
checkDiagnosticsErrors(configParseResult.error !== undefined ? [configParseResult.error] : [], 'Error while processing tsconfig file');
const compilerOptionsParseResult = ts.parseJsonConfigFileContent(
configParseResult.config,
parseConfigHost,
path.resolve(path.dirname(configFileName)),
undefined,
getAbsolutePath(configFileName)
);
// we don't want to raise an error if no inputs found in a config file
// because this error is mostly for CLI, but we'll pass an inputs in createProgram
// eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison
const diagnostics = compilerOptionsParseResult.errors.filter((d: ts.Diagnostic) => d.code !== Constants.NoInputsWereFoundDiagnosticCode);
checkDiagnosticsErrors(diagnostics, 'Error while processing tsconfig compiler options');
return compilerOptionsParseResult.options;
}
function findConfig(inputFiles: readonly string[]): string {
if (inputFiles.length !== 1) {
throw new Error('Cannot find tsconfig for multiple files. Please specify preferred tsconfig file');
}
// input file could be a relative path to the current path
// and desired config could be outside of current cwd folder
// so we have to provide absolute path to find config until the root
const searchPath = getAbsolutePath(inputFiles[0]);
const configFileName = ts.findConfigFile(searchPath, ts.sys.fileExists);
if (!configFileName) {
throw new Error(`Cannot find config file for file ${searchPath}`);
}
return configFileName;
}
timocov-dts-bundle-generator-c69ff0d/src/helpers/ 0000775 0000000 0000000 00000000000 14611320214 0022143 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/src/helpers/check-diagnostics-errors.ts 0000664 0000000 0000000 00000001617 14611320214 0027414 0 ustar 00root root 0000000 0000000 import * as ts from 'typescript';
import { errorLog } from '../logger';
const formatDiagnosticsHost: ts.FormatDiagnosticsHost = {
getCanonicalFileName: (fileName: string) => ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase(),
getCurrentDirectory: ts.sys.getCurrentDirectory,
getNewLine: () => ts.sys.newLine,
};
export function checkProgramDiagnosticsErrors(program: ts.Program): void {
if (!program.getCompilerOptions().declaration) {
throw new Error(`Something went wrong - the program doesn't have declaration option enabled`);
}
checkDiagnosticsErrors(ts.getPreEmitDiagnostics(program), 'Compiled with errors');
}
export function checkDiagnosticsErrors(diagnostics: readonly ts.Diagnostic[], failMessage: string): void {
if (diagnostics.length === 0) {
return;
}
errorLog(ts.formatDiagnostics(diagnostics, formatDiagnosticsHost).trim());
throw new Error(failMessage);
}
timocov-dts-bundle-generator-c69ff0d/src/helpers/fix-path.ts 0000664 0000000 0000000 00000000161 14611320214 0024231 0 ustar 00root root 0000000 0000000 export function fixPath(path: string): string {
// special case for windows
return path.replace(/\\/g, '/');
}
timocov-dts-bundle-generator-c69ff0d/src/helpers/get-absolute-path.ts 0000664 0000000 0000000 00000000503 14611320214 0026036 0 ustar 00root root 0000000 0000000 import * as path from 'path';
import * as process from 'process';
import { fixPath } from './fix-path';
export function getAbsolutePath(fileName: string, cwd?: string): string {
if (!path.isAbsolute(fileName)) {
fileName = path.join(cwd !== undefined ? cwd : process.cwd(), fileName);
}
return fixPath(fileName);
}
timocov-dts-bundle-generator-c69ff0d/src/helpers/measure-time.ts 0000664 0000000 0000000 00000000711 14611320214 0025107 0 ustar 00root root 0000000 0000000 /**
* @param param function to execute
* @returns execution time (in milliseconds)
*/
export function measureTime(func: () => void): number {
const startAt = process.hrtime();
func();
const resultValue = process.hrtime(startAt);
return secondsToMs(resultValue[0]) + nanosecondsToMs(resultValue[1]);
}
function secondsToMs(value: number): number {
return value * 1000;
}
function nanosecondsToMs(value: number): number {
return value / 1000000;
}
timocov-dts-bundle-generator-c69ff0d/src/helpers/node-modules.ts 0000664 0000000 0000000 00000001416 14611320214 0025110 0 ustar 00root root 0000000 0000000 const nodeModulesFolderName = 'node_modules/';
const libraryNameRegex = /node_modules\/((?:(?=@)[^/]+\/[^/]+|[^/]+))\//;
export function getLibraryName(fileName: string): string | null {
const lastNodeModulesIndex = fileName.lastIndexOf(nodeModulesFolderName);
if (lastNodeModulesIndex === -1) {
return null;
}
const match = libraryNameRegex.exec(fileName.slice(lastNodeModulesIndex));
if (match === null) {
return null;
}
return match[1];
}
export function getTypesLibraryName(path: string): string | null {
const libraryName = getLibraryName(path);
if (libraryName === null) {
return null;
}
const typesFolderPrefix = '@types/';
if (!libraryName.startsWith(typesFolderPrefix)) {
return null;
}
return libraryName.substring(typesFolderPrefix.length);
}
timocov-dts-bundle-generator-c69ff0d/src/helpers/package-version.ts 0000664 0000000 0000000 00000001045 14611320214 0025571 0 ustar 00root root 0000000 0000000 import * as fs from 'fs';
import * as path from 'path';
export function packageVersion(): string {
let dirName = __dirname;
while (dirName.length !== 0) {
const packageJsonFilePath = path.join(dirName, 'package.json');
if (fs.existsSync(packageJsonFilePath)) {
// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access,@typescript-eslint/no-var-requires
return require(packageJsonFilePath).version as string;
}
dirName = path.join(dirName, '..');
}
throw new Error(`Cannot find up package.json in ${__dirname}`);
}
timocov-dts-bundle-generator-c69ff0d/src/helpers/typescript.ts 0000664 0000000 0000000 00000054101 14611320214 0024722 0 ustar 00root root 0000000 0000000 import * as ts from 'typescript';
import { warnLog } from '../logger';
const namedDeclarationKinds = [
ts.SyntaxKind.InterfaceDeclaration,
ts.SyntaxKind.ClassDeclaration,
ts.SyntaxKind.EnumDeclaration,
ts.SyntaxKind.TypeAliasDeclaration,
ts.SyntaxKind.ModuleDeclaration,
ts.SyntaxKind.FunctionDeclaration,
ts.SyntaxKind.VariableDeclaration,
ts.SyntaxKind.PropertySignature,
ts.SyntaxKind.NamespaceExport,
ts.SyntaxKind.NamespaceImport,
ts.SyntaxKind.ExportSpecifier,
ts.SyntaxKind.BindingElement,
];
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;
}
export function hasNodeModifier(node: ts.Node, modifier: ts.SyntaxKind): boolean {
const modifiers = getModifiers(node);
return Boolean(modifiers && modifiers.some((nodeModifier: ts.Modifier) => nodeModifier.kind === modifier));
}
export function getNodeName(node: ts.Node): NodeName | undefined {
const nodeName = (node as unknown as ts.NamedDeclaration).name;
if (nodeName === undefined) {
const modifiers = getModifiers(node);
const defaultModifier = modifiers?.find((mod: ts.Modifier) => mod.kind === ts.SyntaxKind.DefaultKeyword);
if (defaultModifier !== undefined) {
return defaultModifier as NodeName;
}
}
return nodeName;
}
interface TypeCheckerCompat extends ts.TypeChecker {
// this method will be added in the further typescript releases
// see https://github.com/microsoft/TypeScript/pull/56193
getMergedSymbol(symbol: ts.Symbol): ts.Symbol;
}
export function getActualSymbol(symbol: ts.Symbol, typeChecker: ts.TypeChecker): ts.Symbol {
if (symbol.flags & ts.SymbolFlags.Alias) {
symbol = typeChecker.getAliasedSymbol(symbol);
}
return (typeChecker as TypeCheckerCompat).getMergedSymbol(symbol);
}
export function getDeclarationNameSymbol(name: NodeName, typeChecker: ts.TypeChecker): ts.Symbol | null {
const symbol = typeChecker.getSymbolAtLocation(name);
if (symbol === undefined) {
return null;
}
return getActualSymbol(symbol, typeChecker);
}
export function splitTransientSymbol(symbol: ts.Symbol, typeChecker: ts.TypeChecker): Set {
// actually I think we even don't need to operate/use "Transient" symbols anywhere
// it's kind of aliased symbol, but just merged
// but it's hard to refractor everything to use array of symbols instead of just symbol
// so let's fix it for some places
if ((symbol.flags & ts.SymbolFlags.Transient) === 0) {
return new Set([symbol]);
}
// "Transient" symbol is kinda "merged" symbol
// I don't really know is this way to "split" is correct
// but it seems that it works for now ¯\_(ツ)_/¯
const declarations = getDeclarationsForSymbol(symbol);
const result = new Set();
for (const declaration of declarations) {
if (!isNodeNamedDeclaration(declaration) || declaration.name === undefined) {
continue;
}
const sym = typeChecker.getSymbolAtLocation(declaration.name);
if (sym === undefined) {
continue;
}
result.add(getActualSymbol(sym, typeChecker));
}
return result;
}
/**
* @see https://github.com/Microsoft/TypeScript/blob/f7c4fefeb62416c311077a699cc15beb211c25c9/src/compiler/utilities.ts#L626-L628
*/
function isGlobalScopeAugmentation(module: ts.ModuleDeclaration): boolean {
return Boolean(module.flags & ts.NodeFlags.GlobalAugmentation);
}
/**
* Returns whether node is ambient module declaration (declare module "name" or declare global)
* @see https://github.com/Microsoft/TypeScript/blob/f7c4fefeb62416c311077a699cc15beb211c25c9/src/compiler/utilities.ts#L588-L590
*/
export function isAmbientModule(node: ts.Node): boolean {
return ts.isModuleDeclaration(node) && (node.name.kind === ts.SyntaxKind.StringLiteral || isGlobalScopeAugmentation(node));
}
/**
* Returns whether node is `declare module` ModuleDeclaration (not `declare global` or `namespace`)
*/
export function isDeclareModule(node: ts.Node): node is ts.ModuleDeclaration {
// `declare module ""`, `declare global` and `namespace {}` are ModuleDeclaration
// but here we need to check only `declare module` statements
return ts.isModuleDeclaration(node) && !(node.flags & ts.NodeFlags.Namespace) && !isGlobalScopeAugmentation(node);
}
/**
* Returns whether statement is `declare global` ModuleDeclaration
*/
export function isDeclareGlobalStatement(statement: ts.Statement): statement is ts.ModuleDeclaration {
return ts.isModuleDeclaration(statement) && isGlobalScopeAugmentation(statement);
}
export function getDeclarationsForSymbol(symbol: ts.Symbol): ts.Declaration[] {
const result: ts.Declaration[] = [];
if (symbol.declarations !== undefined) {
result.push(...symbol.declarations);
}
if (symbol.valueDeclaration !== undefined) {
// push valueDeclaration might be already in declarations array
// so let's check first to avoid duplication nodes
if (!result.includes(symbol.valueDeclaration)) {
result.push(symbol.valueDeclaration);
}
}
return result;
}
export const enum ExportType {
CommonJS,
ES6Named,
ES6Default,
}
export interface SourceFileExport {
exportedName: string;
symbol: ts.Symbol;
originalSymbol: ts.Symbol;
type: ExportType;
}
export function getExportsForSourceFile(typeChecker: ts.TypeChecker, sourceFileSymbol: ts.Symbol): SourceFileExport[] {
if (sourceFileSymbol.exports !== undefined) {
const commonJsExport = sourceFileSymbol.exports.get(ts.InternalSymbolName.ExportEquals);
if (commonJsExport !== undefined) {
const symbol = getActualSymbol(commonJsExport, typeChecker);
return [
{
symbol,
originalSymbol: commonJsExport,
type: ExportType.CommonJS,
exportedName: '',
},
];
}
}
const result = typeChecker
.getExportsOfModule(sourceFileSymbol)
.map((symbol: ts.Symbol) => ({ symbol, originalSymbol: symbol, exportedName: symbol.name, type: ExportType.ES6Named }));
if (sourceFileSymbol.exports !== undefined) {
const defaultExportSymbol = sourceFileSymbol.exports.get(ts.InternalSymbolName.Default);
if (defaultExportSymbol !== undefined) {
const defaultExport = result.find((exp: SourceFileExport) => exp.symbol === defaultExportSymbol);
if (defaultExport !== undefined) {
defaultExport.type = ExportType.ES6Default;
} else {
// it seems that default export is always returned by getExportsOfModule
// but let's add it to be sure add if there is no such export
result.push({
symbol: defaultExportSymbol,
originalSymbol: defaultExportSymbol,
type: ExportType.ES6Default,
exportedName: 'default',
});
}
}
}
const symbolsMergingResolvedExports: SourceFileExport[] = [];
result.forEach((exp: SourceFileExport) => {
exp.symbol = getActualSymbol(exp.symbol, typeChecker);
const symbolsDeclarations = getDeclarationsForSymbol(exp.symbol);
const importSpecifierDeclaration = symbolsDeclarations.find(ts.isImportSpecifier);
if (symbolsDeclarations.length > 1 && importSpecifierDeclaration !== undefined) {
// most likely this export is part of the symbol merging situation
// where one of the declarations is the imported value but the other is declared locally
// in this case we need to add an extra export to the exports list to make sure that it is marked as "exported"
// eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
const referencedModule = resolveReferencedModule(importSpecifierDeclaration.parent.parent.parent as ts.ImportDeclaration, typeChecker);
if (referencedModule !== null) {
const referencedModuleSymbol = getNodeSymbol(referencedModule, typeChecker);
if (referencedModuleSymbol !== null) {
const importedName = (importSpecifierDeclaration.propertyName ?? importSpecifierDeclaration.name).getText();
const exportedItemSymbol = typeChecker.getExportsOfModule(referencedModuleSymbol).find((exportSymbol: ts.Symbol) => exportSymbol.getName() === importedName);
if (exportedItemSymbol !== undefined) {
symbolsMergingResolvedExports.push({
...exp,
symbol: getActualSymbol(exportedItemSymbol, typeChecker),
});
}
}
}
}
});
return [...result, ...symbolsMergingResolvedExports];
}
export function resolveIdentifier(typeChecker: ts.TypeChecker, identifier: ts.Identifier): ts.NamedDeclaration | undefined {
const symbol = getDeclarationNameSymbol(identifier, typeChecker);
if (symbol === null) {
return undefined;
}
return resolveDeclarationByIdentifierSymbol(symbol);
}
function resolveDeclarationByIdentifierSymbol(identifierSymbol: ts.Symbol): ts.NamedDeclaration | undefined {
const declarations = getDeclarationsForSymbol(identifierSymbol);
if (declarations.length === 0) {
return undefined;
}
const decl = declarations[0];
if (!isNodeNamedDeclaration(decl)) {
return undefined;
}
return decl;
}
export function getExportsForStatement(
exportedSymbols: readonly SourceFileExport[],
typeChecker: ts.TypeChecker,
statement: ts.Statement | ts.NamedDeclaration
): SourceFileExport[] {
if (ts.isVariableStatement(statement)) {
if (statement.declarationList.declarations.length === 0) {
return [];
}
const firstDeclarationExports = getExportsForName(
exportedSymbols,
typeChecker,
statement.declarationList.declarations[0].name
);
const allDeclarationsHaveSameExportType = statement.declarationList.declarations.every((variableDecl: ts.VariableDeclaration) => {
// all declaration should have the same export type
// TODO: for now it's not supported to have different type of exports
return getExportsForName(exportedSymbols, typeChecker, variableDecl.name)[0]?.type === firstDeclarationExports[0]?.type;
});
if (!allDeclarationsHaveSameExportType) {
// log warn?
return [];
}
return firstDeclarationExports;
}
const nodeName = getNodeName(statement);
if (nodeName === undefined) {
return [];
}
return getExportsForName(exportedSymbols, typeChecker, nodeName);
}
function getExportsForName(
exportedSymbols: readonly SourceFileExport[],
typeChecker: ts.TypeChecker,
name: NodeName
): SourceFileExport[] {
if (ts.isArrayBindingPattern(name) || ts.isObjectBindingPattern(name)) {
// TODO: binding patterns in variable declarations are not supported for now
// see https://github.com/microsoft/TypeScript/issues/30598 also
return [];
}
const declarationSymbol = typeChecker.getSymbolAtLocation(name);
return exportedSymbols.filter((rootExport: SourceFileExport) => rootExport.symbol === declarationSymbol);
}
export type ModifiersMap = Record;
const modifiersPriority: Partial> = {
[ts.SyntaxKind.ExportKeyword]: 4,
[ts.SyntaxKind.DefaultKeyword]: 3,
[ts.SyntaxKind.DeclareKeyword]: 2,
[ts.SyntaxKind.AsyncKeyword]: 1,
[ts.SyntaxKind.ConstKeyword]: 1,
};
export function modifiersToMap(modifiers: (readonly ts.Modifier[]) | undefined | null): ModifiersMap {
modifiers = modifiers || [];
return modifiers.reduce(
(result: ModifiersMap, modifier: ts.Modifier) => {
result[modifier.kind] = true;
return result;
},
// eslint-disable-next-line @typescript-eslint/consistent-type-assertions
{} as Record
);
}
export function modifiersMapToArray(modifiersMap: ModifiersMap): ts.Modifier[] {
return Object.entries(modifiersMap)
.filter(([kind, include]) => include)
.map(([kind]) => {
// we don't care about decorators here as it is not possible to have them in declaration files
return ts.factory.createModifier(Number(kind));
})
.sort((a: ts.Modifier, b: ts.Modifier) => {
// note `|| 0` is here as a fallback in the case if the compiler adds a new modifier
// but the tool isn't updated yet
const aValue = modifiersPriority[a.kind as ts.ModifierSyntaxKind] || 0;
const bValue = modifiersPriority[b.kind as ts.ModifierSyntaxKind] || 0;
return bValue - aValue;
});
}
export function recreateRootLevelNodeWithModifiers(node: ts.Node, modifiersMap: ModifiersMap, newName?: string, keepComments: boolean = true): ts.Node {
const newNode = recreateRootLevelNodeWithModifiersImpl(node, modifiersMap, newName);
if (keepComments) {
ts.setCommentRange(newNode, ts.getCommentRange(node));
}
return newNode;
}
// eslint-disable-next-line complexity
function recreateRootLevelNodeWithModifiersImpl(node: ts.Node, modifiersMap: ModifiersMap, newName?: string): ts.Node {
const modifiers = modifiersMapToArray(modifiersMap);
if (ts.isArrowFunction(node)) {
return ts.factory.createArrowFunction(
modifiers,
node.typeParameters,
node.parameters,
node.type,
node.equalsGreaterThanToken,
node.body
);
}
if (ts.isClassDeclaration(node)) {
return ts.factory.createClassDeclaration(
modifiers,
newName || node.name,
node.typeParameters,
node.heritageClauses,
node.members
);
}
if (ts.isClassExpression(node)) {
return ts.factory.createClassExpression(
modifiers,
newName || node.name,
node.typeParameters,
node.heritageClauses,
node.members
);
}
if (ts.isEnumDeclaration(node)) {
return ts.factory.createEnumDeclaration(
modifiers,
newName || node.name,
node.members
);
}
if (ts.isExportAssignment(node)) {
return ts.factory.createExportAssignment(
modifiers,
node.isExportEquals,
node.expression
);
}
if (ts.isExportDeclaration(node)) {
interface Ts53CompatExportDeclaration extends ts.ExportDeclaration {
attributes?: ts.ExportDeclaration['assertClause'];
}
return ts.factory.createExportDeclaration(
modifiers,
node.isTypeOnly,
node.exportClause,
node.moduleSpecifier,
// eslint-disable-next-line deprecation/deprecation
(node as Ts53CompatExportDeclaration).attributes || node.assertClause
);
}
if (ts.isFunctionDeclaration(node)) {
return ts.factory.createFunctionDeclaration(
modifiers,
node.asteriskToken,
newName || node.name,
node.typeParameters,
node.parameters,
node.type,
node.body
);
}
if (ts.isFunctionExpression(node)) {
return ts.factory.createFunctionExpression(
modifiers,
node.asteriskToken,
newName || node.name,
node.typeParameters,
node.parameters,
node.type,
node.body
);
}
if (ts.isImportDeclaration(node)) {
interface Ts53CompatImportDeclaration extends ts.ImportDeclaration {
attributes?: ts.ImportDeclaration['assertClause'];
}
return ts.factory.createImportDeclaration(
modifiers,
node.importClause,
node.moduleSpecifier,
// eslint-disable-next-line deprecation/deprecation
(node as Ts53CompatImportDeclaration).attributes || node.assertClause
);
}
if (ts.isImportEqualsDeclaration(node)) {
return ts.factory.createImportEqualsDeclaration(
modifiers,
node.isTypeOnly,
newName || node.name,
node.moduleReference
);
}
if (ts.isInterfaceDeclaration(node)) {
return ts.factory.createInterfaceDeclaration(
modifiers,
newName || node.name,
node.typeParameters,
node.heritageClauses,
node.members
);
}
if (ts.isModuleDeclaration(node)) {
return ts.factory.createModuleDeclaration(
modifiers,
node.name,
node.body,
node.flags
);
}
if (ts.isTypeAliasDeclaration(node)) {
return ts.factory.createTypeAliasDeclaration(
modifiers,
newName || node.name,
node.typeParameters,
node.type
);
}
if (ts.isVariableStatement(node)) {
return ts.factory.createVariableStatement(
modifiers,
node.declarationList
);
}
throw new Error(`Unknown top-level node kind (with modifiers): ${ts.SyntaxKind[node.kind]}.
If you're seeing this error, please report a bug on https://github.com/timocov/dts-bundle-generator/issues`);
}
export function getModifiers(node: ts.Node): readonly ts.Modifier[] | undefined {
if (!ts.canHaveModifiers(node)) {
return undefined;
}
return ts.getModifiers(node);
}
export function getRootSourceFile(program: ts.Program, rootFileName: string): ts.SourceFile {
if (program.getRootFileNames().indexOf(rootFileName) === -1) {
throw new Error(`There is no such root file ${rootFileName}`);
}
const sourceFile = program.getSourceFile(rootFileName);
if (sourceFile === undefined) {
throw new Error(`Cannot get source file for root file ${rootFileName}`);
}
return sourceFile;
}
export function getNodeOwnSymbol(node: ts.Node, typeChecker: ts.TypeChecker): ts.Symbol {
const nodeSymbol = typeChecker.getSymbolAtLocation(node);
if (nodeSymbol === undefined) {
throw new Error(`Cannot find symbol for node "${node.getText()}" in "${node.parent.getText()}" from "${node.getSourceFile().fileName}"`);
}
return nodeSymbol;
}
export function getNodeSymbol(node: ts.Node, typeChecker: ts.TypeChecker): ts.Symbol | null {
if (ts.isSourceFile(node)) {
const fileSymbol = typeChecker.getSymbolAtLocation(node);
// a source file might not have a symbol in case of no exports in that file
if (fileSymbol === undefined) {
return null;
}
return getActualSymbol(fileSymbol, typeChecker);
}
const nodeName = getNodeName(node);
if (nodeName === undefined) {
return null;
}
return getDeclarationNameSymbol(nodeName, typeChecker);
}
export function getClosestModuleLikeNode(node: ts.Node): ts.SourceFile | ts.ModuleDeclaration {
// we need to find a module block and return its module declaration
// we don't need to handle empty modules/modules with jsdoc/etc
while (!ts.isModuleBlock(node) && !ts.isSourceFile(node)) {
node = node.parent;
}
return ts.isSourceFile(node) ? node : node.parent;
}
export function getClosestSourceFileLikeNode(node: ts.Node): ts.SourceFile | ts.ModuleDeclaration {
// we need to find a module block and return its module declaration
// we don't need to handle empty modules/modules with jsdoc/etc
while (!(ts.isModuleBlock(node) && ts.isStringLiteral(node.parent.name)) && !ts.isSourceFile(node)) {
node = node.parent;
}
return ts.isSourceFile(node) ? node : node.parent;
}
export type NodeWithReferencedModule =
| ts.ExportDeclaration
| ts.ImportDeclaration
| ts.ImportEqualsDeclaration
| ts.ImportTypeNode
| ts.ModuleDeclaration
;
export function resolveReferencedModule(node: NodeWithReferencedModule, typeChecker: ts.TypeChecker): ts.SourceFile | ts.ModuleDeclaration | null {
let moduleName: ts.Expression | ts.LiteralTypeNode | undefined;
if (ts.isExportDeclaration(node) || ts.isImportDeclaration(node)) {
moduleName = node.moduleSpecifier;
} else if (ts.isModuleDeclaration(node)) {
moduleName = node.name;
} else if (ts.isImportEqualsDeclaration(node)) {
if (ts.isExternalModuleReference(node.moduleReference)) {
moduleName = node.moduleReference.expression;
}
} else if (ts.isLiteralTypeNode(node.argument) && ts.isStringLiteral(node.argument.literal)) {
moduleName = node.argument.literal;
}
if (moduleName === undefined) {
return null;
}
const moduleSymbol = typeChecker.getSymbolAtLocation(moduleName);
if (moduleSymbol === undefined) {
return null;
}
const symbol = getActualSymbol(moduleSymbol, typeChecker);
if (symbol.valueDeclaration === undefined) {
return null;
}
return ts.isSourceFile(symbol.valueDeclaration) || ts.isModuleDeclaration(symbol.valueDeclaration)
? symbol.valueDeclaration
: null;
}
export function getImportModuleName(imp: ts.ImportEqualsDeclaration | ts.ImportDeclaration | ts.ExportDeclaration): string | null {
if (ts.isImportDeclaration(imp)) {
return imp.importClause === undefined
? null
: (imp.moduleSpecifier as ts.StringLiteral).text
;
}
if (ts.isExportDeclaration(imp)) {
return imp.moduleSpecifier === undefined
? null
: (imp.moduleSpecifier as ts.StringLiteral).text
;
}
if (ts.isExternalModuleReference(imp.moduleReference)) {
if (!ts.isStringLiteral(imp.moduleReference.expression)) {
warnLog(`Cannot handle non string-literal-like import expression: ${imp.moduleReference.expression.getText()}`);
return null;
}
return imp.moduleReference.expression.text;
}
return null;
}
/**
* Returns a symbol that an {@link importExportSpecifier} node references to.
*
* For example, for given `export { Value }` it returns a declaration of `Value` whatever it is (import statement, interface declaration, etc).
*/
export function getImportExportReferencedSymbol(importExportSpecifier: ts.ExportSpecifier | ts.ImportSpecifier, typeChecker: ts.TypeChecker): ts.Symbol {
return importExportSpecifier.propertyName !== undefined
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
? typeChecker.getSymbolAtLocation(importExportSpecifier.propertyName)!
// eslint-disable-next-line @typescript-eslint/no-non-null-assertion
: typeChecker.getImmediateAliasedSymbol(typeChecker.getSymbolAtLocation(importExportSpecifier.name)!)!
;
}
export function getSymbolExportStarDeclarations(symbol: ts.Symbol): ts.ExportDeclaration[] {
if (symbol.escapedName !== ts.InternalSymbolName.ExportStar) {
throw new Error(`Only ExportStar symbol can have export star declaration, but got ${symbol.escapedName}`);
}
// this means that an export contains `export * from 'module'` statement
return getDeclarationsForSymbol(symbol).filter((decl: ts.Declaration): decl is ts.ExportDeclaration => ts.isExportDeclaration(decl) && decl.moduleSpecifier !== undefined);
}
export function getDeclarationsForExportedValues(exp: ts.ExportAssignment | ts.ExportDeclaration, typeChecker: ts.TypeChecker): ts.Declaration[] {
const nodeForSymbol = ts.isExportAssignment(exp) ? exp.expression : exp.moduleSpecifier;
if (nodeForSymbol === undefined) {
return [];
}
const symbolForExpression = typeChecker.getSymbolAtLocation(nodeForSymbol);
if (symbolForExpression === undefined) {
return [];
}
const symbol = getActualSymbol(symbolForExpression, typeChecker);
return getDeclarationsForSymbol(symbol);
}
export function resolveGlobalName(typeChecker: ts.TypeChecker, name: string): ts.Symbol | undefined {
interface Ts54CompatTypeChecker extends ts.TypeChecker {
resolveName(name: string, location: ts.Node | undefined, meaning: ts.SymbolFlags, excludeGlobals: boolean): ts.Symbol | undefined;
}
// this value isn't available in all typescript versions so lets assign its value here instead
const tsSymbolFlagsAll = /* ts.SymbolFlags.All */ -1 as ts.SymbolFlags;
// see https://github.com/microsoft/TypeScript/pull/56932
return (typeChecker as Ts54CompatTypeChecker).resolveName(name, undefined, tsSymbolFlagsAll, false);
}
timocov-dts-bundle-generator-c69ff0d/src/logger.ts 0000664 0000000 0000000 00000002261 14611320214 0022331 0 ustar 00root root 0000000 0000000 const enum LogLevel {
Verbose,
Normal,
Warning,
Error,
}
export function verboseLog(message: string): void {
logMessage(message, LogLevel.Verbose);
}
export function normalLog(message: string): void {
logMessage(message, LogLevel.Normal);
}
export function warnLog(message: string): void {
logMessage(message, LogLevel.Warning);
}
export function errorLog(message: string): void {
logMessage(message, LogLevel.Error);
}
let currentLogLevel = LogLevel.Error;
export function enableVerbose(): void {
currentLogLevel = LogLevel.Verbose;
normalLog('Verbose log enabled');
}
export function enableNormalLog(): void {
currentLogLevel = LogLevel.Normal;
}
function logMessage(message: string, level: LogLevel = LogLevel.Verbose): void {
if (level < currentLogLevel) {
return;
}
switch (level) {
case LogLevel.Error:
// print red
// eslint-disable-next-line no-console
console.error(`\x1b[0;31m${message}\x1b[0m`);
break;
case LogLevel.Warning:
// eslint-disable-next-line no-console
console.warn(`\x1b[1;33m${message}\x1b[0m`);
break;
case LogLevel.Normal:
case LogLevel.Verbose:
// eslint-disable-next-line no-console
console.log(message);
}
}
timocov-dts-bundle-generator-c69ff0d/src/module-info.ts 0000664 0000000 0000000 00000013375 14611320214 0023300 0 ustar 00root root 0000000 0000000 import * as path from 'path';
import * as ts from 'typescript';
import {
getLibraryName,
getTypesLibraryName,
} from './helpers/node-modules';
import { fixPath } from './helpers/fix-path';
import { NodeWithReferencedModule, resolveReferencedModule } from './helpers/typescript';
export const enum ModuleType {
ShouldBeInlined,
ShouldBeImported,
ShouldBeReferencedAsTypes,
ShouldBeUsedForModulesOnly,
}
export interface UsedModuleInfoCommon {
fileName: string;
isExternal: boolean;
}
export interface InlinedModuleInfo extends UsedModuleInfoCommon {
type: ModuleType.ShouldBeInlined;
}
export interface ImportedModuleInfo extends UsedModuleInfoCommon {
type: ModuleType.ShouldBeImported;
isExternal: true;
}
export interface ReferencedModuleInfo extends UsedModuleInfoCommon {
type: ModuleType.ShouldBeReferencedAsTypes;
typesLibraryName: string;
isExternal: true;
}
export interface UsedForModulesModuleInfo extends UsedModuleInfoCommon {
type: ModuleType.ShouldBeUsedForModulesOnly;
isExternal: true;
}
export type ModuleInfo = InlinedModuleInfo | ImportedModuleInfo | ReferencedModuleInfo | UsedForModulesModuleInfo;
export interface ModuleCriteria {
inlinedLibraries: string[];
importedLibraries: string[] | undefined;
allowedTypesLibraries: string[] | undefined;
typeRoots?: string[];
}
export function getFileModuleInfo(fileName: string, criteria: ModuleCriteria): ModuleInfo {
return getModuleInfoImpl(fileName, fileName, criteria);
}
export function getReferencedModuleInfo(moduleDecl: NodeWithReferencedModule, criteria: ModuleCriteria, typeChecker: ts.TypeChecker): ModuleInfo | null {
const referencedModule = resolveReferencedModule(moduleDecl, typeChecker);
if (referencedModule === null) {
return null;
}
const moduleFilePath = ts.isSourceFile(referencedModule)
? referencedModule.fileName
: resolveModuleFileName(referencedModule.getSourceFile().fileName, referencedModule.name.text);
return getFileModuleInfo(moduleFilePath, criteria);
}
export function getModuleLikeModuleInfo(moduleLike: ts.SourceFile | ts.ModuleDeclaration, criteria: ModuleCriteria, typeChecker: ts.TypeChecker): ModuleInfo {
const resolvedModuleLike = ts.isSourceFile(moduleLike) ? moduleLike : resolveReferencedModule(moduleLike, typeChecker) ?? moduleLike;
const fileName = ts.isSourceFile(resolvedModuleLike)
? resolvedModuleLike.fileName
: resolveModuleFileName(resolvedModuleLike.getSourceFile().fileName, resolvedModuleLike.name.text);
return getFileModuleInfo(fileName, criteria);
}
function resolveModuleFileName(currentFileName: string, moduleName: string): string {
return moduleName.startsWith('.') ? fixPath(path.join(currentFileName, '..', moduleName)) : `node_modules/${moduleName}/`;
}
/**
* @param currentFilePath Current file path - can be used to override actual path of module (e.g. with `typeRoots`)
* @param originalFileName Original file name of the module
* @param criteria Criteria of module info
*/
function getModuleInfoImpl(currentFilePath: string, originalFileName: string, criteria: ModuleCriteria): ModuleInfo {
const npmLibraryName = getLibraryName(currentFilePath);
if (npmLibraryName === null) {
if (criteria.typeRoots !== undefined) {
for (const root of criteria.typeRoots) {
const relativePath = fixPath(path.relative(root, originalFileName));
if (!relativePath.startsWith('../')) {
// relativePath is path relative to type root
// so we should treat it as "library from node_modules/@types/"
return getModuleInfoImpl(remapToTypesFromNodeModules(relativePath), originalFileName, criteria);
}
}
}
return { type: ModuleType.ShouldBeInlined, fileName: originalFileName, isExternal: false };
}
const typesLibraryName = getTypesLibraryName(currentFilePath);
if (shouldLibraryBeInlined(npmLibraryName, typesLibraryName, criteria.inlinedLibraries)) {
return { type: ModuleType.ShouldBeInlined, fileName: originalFileName, isExternal: true };
}
if (shouldLibraryBeImported(npmLibraryName, typesLibraryName, criteria.importedLibraries, criteria.allowedTypesLibraries)) {
return { type: ModuleType.ShouldBeImported, fileName: originalFileName, isExternal: true };
}
if (typesLibraryName !== null && isLibraryAllowed(typesLibraryName, criteria.allowedTypesLibraries)) {
return { type: ModuleType.ShouldBeReferencedAsTypes, fileName: originalFileName, typesLibraryName, isExternal: true };
}
return { type: ModuleType.ShouldBeUsedForModulesOnly, fileName: originalFileName, isExternal: true };
}
function shouldLibraryBeInlined(npmLibraryName: string, typesLibraryName: string | null, inlinedLibraries: string[]): boolean {
return isLibraryAllowed(npmLibraryName, inlinedLibraries) || typesLibraryName !== null && isLibraryAllowed(typesLibraryName, inlinedLibraries);
}
function shouldLibraryBeImported(
npmLibraryName: string,
typesLibraryName: string | null,
importedLibraries: string[] | undefined,
allowedTypesLibraries: string[] | undefined
): boolean {
if (typesLibraryName === null) {
return isLibraryAllowed(npmLibraryName, importedLibraries);
}
// to be imported a library from types shouldn't be allowed to be references as types
// thus by default we treat all libraries as "should be imported"
// but if it is a @types library then it should be imported only if it is not marked as "should be referenced as types" explicitly
if (allowedTypesLibraries === undefined || !isLibraryAllowed(typesLibraryName, allowedTypesLibraries)) {
return isLibraryAllowed(typesLibraryName, importedLibraries);
}
return false;
}
function isLibraryAllowed(libraryName: string, allowedArray?: string[]): boolean {
return allowedArray === undefined || allowedArray.indexOf(libraryName) !== -1;
}
function remapToTypesFromNodeModules(pathRelativeToTypesRoot: string): string {
return `node_modules/@types/${pathRelativeToTypesRoot}`;
}
timocov-dts-bundle-generator-c69ff0d/src/tsconfig.json 0000664 0000000 0000000 00000000307 14611320214 0023210 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.options.json",
"compilerOptions": {
"composite": true,
"declarationDir": "../dts-out",
"incremental": true,
"outDir": "../dist"
},
"include": [
"**/*.ts"
]
}
timocov-dts-bundle-generator-c69ff0d/src/types-usage-evaluator.ts 0000664 0000000 0000000 00000030165 14611320214 0025324 0 ustar 00root root 0000000 0000000 import * as ts from 'typescript';
import {
getActualSymbol,
getDeclarationsForExportedValues,
getDeclarationsForSymbol,
getImportExportReferencedSymbol,
getNodeName,
getNodeOwnSymbol,
getSymbolExportStarDeclarations,
isDeclareModule,
isNodeNamedDeclaration,
splitTransientSymbol,
} from './helpers/typescript';
export class TypesUsageEvaluator {
private readonly typeChecker: ts.TypeChecker;
private readonly nodesParentsMap: Map> = new Map();
private readonly usageResultCache: Map> = new Map();
public constructor(files: ts.SourceFile[], typeChecker: ts.TypeChecker) {
this.typeChecker = typeChecker;
this.computeUsages(files);
}
public isSymbolUsedBySymbol(symbol: ts.Symbol, by: ts.Symbol): boolean {
return this.isSymbolUsedBySymbolImpl(this.getActualSymbol(symbol), this.getActualSymbol(by), new Set());
}
public getSymbolsUsingSymbol(symbol: ts.Symbol): Set | null {
return this.nodesParentsMap.get(this.getActualSymbol(symbol)) || null;
}
private isSymbolUsedBySymbolImpl(fromSymbol: ts.Symbol, toSymbol: ts.Symbol, visitedSymbols: Set): boolean {
if (fromSymbol === toSymbol) {
return this.setUsageCacheValue(fromSymbol, toSymbol, true);
}
const cacheResult = this.usageResultCache.get(fromSymbol)?.get(toSymbol);
if (cacheResult !== undefined) {
return cacheResult;
}
const reachableNodes = this.nodesParentsMap.get(fromSymbol);
if (reachableNodes !== undefined) {
for (const symbol of reachableNodes) {
if (visitedSymbols.has(symbol)) {
continue;
}
visitedSymbols.add(symbol);
if (this.isSymbolUsedBySymbolImpl(symbol, toSymbol, visitedSymbols)) {
return this.setUsageCacheValue(fromSymbol, toSymbol, true);
}
}
}
visitedSymbols.add(fromSymbol);
// note that we can't save negative result here because it might be not a final one
// because we might ended up here because of `visitedSymbols.has(symbol)` check above
// while actually checking that `symbol` symbol and we will store all its "children" as `false`
// while in reality some of them might be `true` because of cross-references or using the same children symbols
return false;
}
private setUsageCacheValue(fromSymbol: ts.Symbol, toSymbol: ts.Symbol, value: boolean): boolean {
let fromSymbolCacheMap = this.usageResultCache.get(fromSymbol);
if (fromSymbolCacheMap === undefined) {
fromSymbolCacheMap = new Map();
this.usageResultCache.set(fromSymbol, fromSymbolCacheMap);
}
fromSymbolCacheMap.set(toSymbol, value);
return value;
}
private computeUsages(files: ts.SourceFile[]): void {
this.nodesParentsMap.clear();
for (const file of files) {
ts.forEachChild(file, this.computeUsageForNode.bind(this));
}
}
// eslint-disable-next-line complexity
private computeUsageForNode(node: ts.Node): void {
if (isDeclareModule(node) && node.body !== undefined && ts.isModuleBlock(node.body)) {
const moduleSymbol = this.getSymbol(node.name);
for (const statement of node.body.statements) {
this.computeUsageForNode(statement);
if (isNodeNamedDeclaration(statement)) {
const nodeName = getNodeName(statement);
if (nodeName !== undefined) {
// a node declared in `declare module` should adds "usage" to that module
// so we can track its usage later if needed
const statementSymbol = this.getSymbol(nodeName);
this.addUsages(statementSymbol, moduleSymbol);
}
}
}
}
if (isNodeNamedDeclaration(node)) {
const nodeName = getNodeName(node);
if (nodeName !== undefined) {
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);
}
}
}
}
if (ts.isVariableStatement(node)) {
for (const varDeclaration of node.declarationList.declarations) {
this.computeUsageForNode(varDeclaration);
}
}
// `export * as ns from 'mod'`
if (ts.isExportDeclaration(node) && node.moduleSpecifier !== undefined && node.exportClause !== undefined && ts.isNamespaceExport(node.exportClause)) {
this.addUsagesForNamespacedModule(node.exportClause, node.moduleSpecifier as ts.StringLiteral);
}
// `import * as ns from 'mod'`
if (ts.isImportDeclaration(node) && node.moduleSpecifier !== undefined && node.importClause?.namedBindings !== undefined && ts.isNamespaceImport(node.importClause.namedBindings)) {
// for namespaced imports we don't want to include module's exports into usage
// because only exports actually "assign" all exports to a namespace node
// namespaced imports affect only local scope (unless it is exported, but it handled elsewhere)
this.addUsagesForNamespacedModule(node.importClause.namedBindings, node.moduleSpecifier as ts.StringLiteral, false);
}
// `export {}` or `export {} from 'mod'`
if (ts.isExportDeclaration(node) && node.exportClause !== undefined && ts.isNamedExports(node.exportClause)) {
for (const exportElement of node.exportClause.elements) {
const exportElementSymbol = getImportExportReferencedSymbol(exportElement, this.typeChecker);
// i.e. `import * as NS from './local-module'`
const namespaceImportForElement = getDeclarationsForSymbol(exportElementSymbol).find(ts.isNamespaceImport);
if (namespaceImportForElement !== undefined) {
// the namespaced import itself doesn't add a "usage", but re-export of that imported namespace does
// so here we're handling the case where previously imported namespace import has been re-exported from a module
this.addUsagesForNamespacedModule(namespaceImportForElement, namespaceImportForElement.parent.parent.moduleSpecifier as ts.StringLiteral);
}
// "link" referenced symbol with its import
const exportElementOwnSymbol = this.getNodeOwnSymbol(exportElement.name);
this.addUsages(exportElementSymbol, exportElementOwnSymbol);
this.addUsages(this.getActualSymbol(exportElementSymbol), exportElementOwnSymbol);
}
}
// `export =`
if (ts.isExportAssignment(node) && node.isExportEquals) {
this.addUsagesForExportAssignment(node);
}
}
private addUsagesForExportAssignment(exportAssignment: ts.ExportAssignment): void {
for (const declaration of getDeclarationsForExportedValues(exportAssignment, this.typeChecker)) {
// `declare module foobar {}` or `namespace foobar {}`
if (ts.isModuleDeclaration(declaration) && ts.isIdentifier(declaration.name) && declaration.body !== undefined && ts.isModuleBlock(declaration.body)) {
const moduleSymbol = this.getSymbol(declaration.name);
for (const statement of declaration.body.statements) {
if (isNodeNamedDeclaration(statement) && statement.name !== undefined) {
const statementSymbol = this.getSymbol(statement.name);
if (statementSymbol !== null) {
// this feels counter-intuitive that we assign a statement as a parent of a module
// but this is what happens when you have `export=` statements
// you can import an interface declared in `export=` exported namespace
// via named import statement
// e.g. lets say you have `namespace foo { export interface Interface {} }; export = foo;`
// then you can import it like `import { Interface } from 'module'`
// in this case only `Interface` is used, but it is part of module `foo`
// which means that `foo` is used via using `Interface`
// if you're reading this - please stop using `export=` exports asap!
this.addUsages(moduleSymbol, statementSymbol);
}
}
}
}
}
}
private addUsagesForNamespacedModule(namespaceNode: ts.NamespaceImport | ts.NamespaceExport, moduleSpecifier: ts.StringLiteral, includeExports: boolean = true): void {
// note that we shouldn't resolve the actual symbol for the namespace
// as in some circumstances it will be resolved to the source file
// i.e. namespaceSymbol would become referencedModuleSymbol so it would be no-op
// but we want to add this module's usage to the map
const namespaceSymbol = this.getNodeOwnSymbol(namespaceNode.name);
const referencedSourceFileSymbol = this.getSymbol(moduleSpecifier);
this.addUsages(referencedSourceFileSymbol, namespaceSymbol);
// but in case it is not resolved to the source file we need to link them
const resolvedNamespaceSymbol = this.getSymbol(namespaceNode.name);
this.addUsages(resolvedNamespaceSymbol, namespaceSymbol);
if (includeExports) {
// if a referenced source file has any exports, they should be added "to the usage" as they all are re-exported/imported
this.addExportsToSymbol(referencedSourceFileSymbol.exports, referencedSourceFileSymbol);
}
}
private addExportsToSymbol(exports: ts.SymbolTable | undefined, parentSymbol: ts.Symbol, visitedSymbols: Set = new Set()): void {
exports?.forEach((moduleExportedSymbol: ts.Symbol, name: ts.__String) => {
if (name === ts.InternalSymbolName.ExportStar) {
// this means that an export contains `export * from 'module'` statement
for (const exportStarDeclaration of getSymbolExportStarDeclarations(moduleExportedSymbol)) {
if (exportStarDeclaration.moduleSpecifier === undefined) {
throw new Error(`Export star declaration does not have a module specifier '${exportStarDeclaration.getText()}'`);
}
const referencedSourceFileSymbol = this.getSymbol(exportStarDeclaration.moduleSpecifier);
if (visitedSymbols.has(referencedSourceFileSymbol)) {
continue;
}
visitedSymbols.add(referencedSourceFileSymbol);
this.addExportsToSymbol(referencedSourceFileSymbol.exports, parentSymbol, visitedSymbols);
}
return;
}
this.addUsages(moduleExportedSymbol, parentSymbol);
});
}
private computeUsagesRecursively(parent: ts.Node, parentSymbol: ts.Symbol): void {
ts.forEachChild(parent, (child: ts.Node) => {
if (child.kind === ts.SyntaxKind.JSDoc) {
return;
}
this.computeUsagesRecursively(child, parentSymbol);
if (ts.isIdentifier(child) || child.kind === ts.SyntaxKind.DefaultKeyword) {
// identifiers in labelled tuples don't have symbols for their labels
// so let's just skip them from collecting
if (ts.isNamedTupleMember(child.parent) && child.parent.name === child) {
return;
}
// `{ propertyName: name }` - in this case we don't need to handle `propertyName` as it has no symbol
if (ts.isBindingElement(child.parent) && child.parent.propertyName === child) {
return;
}
this.addUsages(this.getSymbol(child), parentSymbol);
if (!ts.isQualifiedName(child.parent)) {
const childOwnSymbol = this.getNodeOwnSymbol(child);
// i.e. `import * as NS from './local-module'`
const namespaceImport = getDeclarationsForSymbol(childOwnSymbol).find(ts.isNamespaceImport);
if (namespaceImport !== undefined) {
// if a node is an identifier and not part of a qualified name
// and it was created as part of namespaced import
// then we need to assign all exports of referenced module into that namespace
// because they might not be added previously while processing imports/exports
this.addUsagesForNamespacedModule(namespaceImport, namespaceImport.parent.parent.moduleSpecifier as ts.StringLiteral, true);
}
}
}
});
}
private addUsages(childSymbol: ts.Symbol, parentSymbol: ts.Symbol): void {
const childSymbols = splitTransientSymbol(childSymbol, this.typeChecker);
for (const childSplitSymbol of childSymbols) {
let symbols = this.nodesParentsMap.get(childSplitSymbol);
if (symbols === undefined) {
symbols = new Set();
this.nodesParentsMap.set(childSplitSymbol, symbols);
}
// to avoid infinite recursion
if (childSplitSymbol !== parentSymbol) {
symbols.add(parentSymbol);
}
}
}
private getSymbol(node: ts.Node): ts.Symbol {
return this.getActualSymbol(this.getNodeOwnSymbol(node));
}
private getNodeOwnSymbol(node: ts.Node): ts.Symbol {
return getNodeOwnSymbol(node, this.typeChecker);
}
private getActualSymbol(symbol: ts.Symbol): ts.Symbol {
return getActualSymbol(symbol, this.typeChecker);
}
}
timocov-dts-bundle-generator-c69ff0d/tests/ 0000775 0000000 0000000 00000000000 14611320214 0021054 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/ 0000775 0000000 0000000 00000000000 14611320214 0021527 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/.gitignore 0000664 0000000 0000000 00000000013 14611320214 0023511 0 ustar 00root root 0000000 0000000 /.tsc-out/
timocov-dts-bundle-generator-c69ff0d/tests/e2e/README.md 0000664 0000000 0000000 00000001416 14611320214 0023010 0 ustar 00root root 0000000 0000000 # e2e tests
## Create new test case
To create new test case you need to create new folder in [test-cases](./test-cases) (as a sample you may use [test-case-sample](./test-case-sample) folder).
New folder's name will be used as name of test case.
Each test case must have at least 3 files:
1. `input.ts` or `input.d.ts` - the entry point of test case (this file will used to generate typings).
1. `output.d.ts` - file with expected output - it will be used to compare with just generated (actual) typings.
1. `config.ts` - file with test case config (e.g. generator options). It must export test case config (see [test-case-config.ts](./test-cases/test-case-config.ts) for type) via `export =`.
## Run tests
```bash
# the command should be run in project root
npm run test
```
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-case-sample/ 0000775 0000000 0000000 00000000000 14611320214 0024676 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-case-sample/config.ts 0000664 0000000 0000000 00000000214 14611320214 0026510 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-cases/test-case-config';
const config: TestCaseConfig = {
failOnClass: true,
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-case-sample/input.ts 0000664 0000000 0000000 00000000030 14611320214 0026376 0 ustar 00root root 0000000 0000000 // place your code here
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-case-sample/output.d.ts 0000664 0000000 0000000 00000000036 14611320214 0027027 0 ustar 00root root 0000000 0000000 // place expected output here
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases-validation.spec.ts 0000664 0000000 0000000 00000002160 14611320214 0027232 0 ustar 00root root 0000000 0000000 import * as fs from 'fs';
import * as path from 'path';
import * as assert from 'assert';
const testCasesDir = path.resolve(__dirname, 'test-cases');
function isDirectory(filePath: string): boolean {
return fs.lstatSync(path.resolve(testCasesDir, filePath)).isDirectory();
}
function findTestCaseFolders(): string[] {
return fs.readdirSync(testCasesDir)
.filter((filePath: string) => isDirectory(filePath) && path.basename(filePath) !== 'node_modules')
.map((directoryName: string) => path.resolve(testCasesDir, directoryName));
}
describe(`e2e test cases validation`, () => {
for (const testCaseFolder of findTestCaseFolders()) {
it(path.basename(testCaseFolder), () => {
const testCaseSpecFilePath = path.join(testCaseFolder, 'index.spec.js');
assert.strictEqual(fs.existsSync(testCaseSpecFilePath), true, `Spec file '${testCaseSpecFilePath}' should exist`);
assert.strictEqual(
fs.readFileSync(testCaseSpecFilePath, { encoding: 'utf-8' }).trim(),
`require('../run-test-case').runTestCase(__dirname);`,
'Every test case spec file content should match expected value to run tests'
);
});
}
});
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/ 0000775 0000000 0000000 00000000000 14611320214 0023602 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/.gitignore 0000664 0000000 0000000 00000000044 14611320214 0025570 0 ustar 00root root 0000000 0000000 !/**/output.d.ts
!/**/node_modules/
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-arbitrary-extensions/ 0000775 0000000 0000000 00000000000 14611320214 0031112 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-arbitrary-extensions/config.ts 0000664 0000000 0000000 00000000172 14611320214 0032727 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-arbitrary-extensions/hello.d.json.ts0000664 0000000 0000000 00000000076 14611320214 0033762 0 ustar 00root root 0000000 0000000 declare const hello: Record;
export default hello;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-arbitrary-extensions/hello.json 0000664 0000000 0000000 00000000017 14611320214 0033106 0 ustar 00root root 0000000 0000000 {
"test": 1
} timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-arbitrary-extensions/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033510 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-arbitrary-extensions/input.d.ts 0000664 0000000 0000000 00000000111 14611320214 0033034 0 ustar 00root root 0000000 0000000 import hello from './hello.json';
export function test(): typeof hello;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-arbitrary-extensions/output.d.ts 0000664 0000000 0000000 00000000131 14611320214 0033237 0 ustar 00root root 0000000 0000000 declare const hello: Record;
export function test(): typeof hello;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-arbitrary-extensions/tsconfig.json 0000664 0000000 0000000 00000000230 14611320214 0033614 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"allowArbitraryExtensions": true,
"esModuleInterop": true,
"resolveJsonModule": true
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-js/ 0000775 0000000 0000000 00000000000 14611320214 0025332 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-js/config.ts 0000664 0000000 0000000 00000000172 14611320214 0027147 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-js/hello.js 0000664 0000000 0000000 00000000055 14611320214 0026773 0 ustar 00root root 0000000 0000000 const hello = { test: 1 };
export { hello }
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-js/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0027730 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-js/input.ts 0000664 0000000 0000000 00000000116 14611320214 0027037 0 ustar 00root root 0000000 0000000 import { hello } from "./hello.js";
export function test() {
return hello
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-js/output.d.ts 0000664 0000000 0000000 00000000100 14611320214 0027453 0 ustar 00root root 0000000 0000000 export declare function test(): {
test: number;
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/allow-js/tsconfig.json 0000664 0000000 0000000 00000000117 14611320214 0030040 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"allowJs": true
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/ambient-redeclare-types/ 0000775 0000000 0000000 00000000000 14611320214 0030307 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/ambient-redeclare-types/config.ts 0000664 0000000 0000000 00000000154 14611320214 0032124 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/ambient-redeclare-types/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032705 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/ambient-redeclare-types/input.d.ts 0000664 0000000 0000000 00000000563 14611320214 0032244 0 ustar 00root root 0000000 0000000 // see https://github.com/dexie/Dexie.js/blob/f6a6f29183c7a05f732397524c48ce4c1236bd6e/src/public/index.d.ts#L34-L47
import { ExportedType, Type1, Type2 } from './type';
interface _Type1 extends Type1 {}
interface _Type2 extends Type2 {}
declare module ExportedType {
interface Type1 extends _Type1 {}
interface Type2 extends _Type2 {}
}
export { ExportedType };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/ambient-redeclare-types/output.d.ts 0000664 0000000 0000000 00000000565 14611320214 0032447 0 ustar 00root root 0000000 0000000 export interface Type1 {
}
export interface Type2 {
}
export declare interface ExportedType {
Type1: {
prototype: Type1;
};
Type2: {
prototype: Type2;
};
}
export interface _Type1 extends Type1 {
}
export interface _Type2 extends Type2 {
}
export declare module ExportedType {
interface Type1 extends _Type1 {
}
interface Type2 extends _Type2 {
}
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/ambient-redeclare-types/type.d.ts 0000664 0000000 0000000 00000000233 14611320214 0032060 0 ustar 00root root 0000000 0000000 export interface Type1 {}
export interface Type2 {}
export declare interface ExportedType {
Type1: { prototype: Type1 };
Type2: { prototype: Type2 };
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/banner/ 0000775 0000000 0000000 00000000000 14611320214 0025047 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/banner/config.ts 0000664 0000000 0000000 00000000217 14611320214 0026664 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
output: {
noBanner: false,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/banner/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0027445 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/banner/input.ts 0000664 0000000 0000000 00000000050 14611320214 0026551 0 ustar 00root root 0000000 0000000 export type TypeName = string | number;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/banner/output.d.ts 0000664 0000000 0000000 00000000164 14611320214 0027202 0 ustar 00root root 0000000 0000000 // Generated by dts-bundle-generator v$PACKAGE_CURRENT_VERSION
export type TypeName = string | number;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/binding-patterns-without-initializer/ 0000775 0000000 0000000 00000000000 14611320214 0033074 5 ustar 00root root 0000000 0000000 array-const.d.ts 0000664 0000000 0000000 00000000055 14611320214 0036051 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/binding-patterns-without-initializer export const [
FOO = '321',
BAR = 1337,
];
config.ts 0000664 0000000 0000000 00000000154 14611320214 0034632 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/binding-patterns-without-initializer import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035413 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/binding-patterns-without-initializer require('../run-test-case').runTestCase(__dirname);
input.d.ts 0000664 0000000 0000000 00000000355 14611320214 0034751 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/binding-patterns-without-initializer 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;
obj-const.d.ts 0000664 0000000 0000000 00000000061 14611320214 0035502 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/binding-patterns-without-initializer export declare const {
FOO = 123,
BAR = 42,
};
output.d.ts 0000664 0000000 0000000 00000000304 14611320214 0035144 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/binding-patterns-without-initializer 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 {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/cts-extension/ 0000775 0000000 0000000 00000000000 14611320214 0026405 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/cts-extension/config.ts 0000664 0000000 0000000 00000000172 14611320214 0030222 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/cts-extension/decl.d.cts 0000664 0000000 0000000 00000000033 14611320214 0030245 0 ustar 00root root 0000000 0000000 export type Decl = string;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/cts-extension/file.cts 0000664 0000000 0000000 00000000036 14611320214 0030036 0 ustar 00root root 0000000 0000000 export interface Interface {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/cts-extension/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031003 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/cts-extension/input.cts 0000664 0000000 0000000 00000000221 14611320214 0030252 0 ustar 00root root 0000000 0000000 import { Interface } from './file.cjs';
import { Decl } from './decl.cjs';
export interface ExportedInterface extends Interface {
foo: Decl;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/cts-extension/output.d.ts 0000664 0000000 0000000 00000000213 14611320214 0030533 0 ustar 00root root 0000000 0000000 export interface Interface {
}
export type Decl = string;
export interface ExportedInterface extends Interface {
foo: Decl;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/custom-types-folder/ 0000775 0000000 0000000 00000000000 14611320214 0027527 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/custom-types-folder/config.ts 0000664 0000000 0000000 00000000252 14611320214 0031343 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
importedLibraries: ['fake-types-lib-2'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/custom-types-folder/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032125 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/custom-types-folder/input.ts 0000664 0000000 0000000 00000000123 14611320214 0031232 0 ustar 00root root 0000000 0000000 import { Data } from 'fake-types-lib-2/data';
export type MyData = Data | string;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/custom-types-folder/output.d.ts 0000664 0000000 0000000 00000000137 14611320214 0031662 0 ustar 00root root 0000000 0000000 import { Data } from 'fake-types-lib-2/data';
export type MyData = Data | string;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/custom-types-folder/tsconfig.json 0000664 0000000 0000000 00000000232 14611320214 0032233 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"types": ["fake-types-lib-2"],
"typeRoots": [
"node_modules/@types",
"./types"
]
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/custom-types-folder/types/ 0000775 0000000 0000000 00000000000 14611320214 0030673 5 ustar 00root root 0000000 0000000 fake-types-lib-2/ 0000775 0000000 0000000 00000000000 14611320214 0033567 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/custom-types-folder/types index.d.ts 0000664 0000000 0000000 00000000125 14611320214 0035466 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/custom-types-folder/types/fake-types-lib-2 declare module 'fake-types-lib-2/data' {
export { Data } from 'fake-types-lib-2';
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-and-imports/ 0000775 0000000 0000000 00000000000 14611320214 0030717 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-and-imports/config.ts 0000664 0000000 0000000 00000000252 14611320214 0032533 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {
output: {
inlineDeclareExternals: true,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-and-imports/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033315 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-and-imports/input.d.ts 0000664 0000000 0000000 00000000156 14611320214 0032652 0 ustar 00root root 0000000 0000000 import { Barfoo } from 'package-with-re-exports';
declare module 'fake-package' {
export type A = Barfoo;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-and-imports/output.d.ts 0000664 0000000 0000000 00000000172 14611320214 0033051 0 ustar 00root root 0000000 0000000 import { Barfoo } from 'package-with-re-exports';
declare module "fake-package" {
export type A = Barfoo;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-in-internal-files/ 0000775 0000000 0000000 00000000000 14611320214 0032002 5 ustar 00root root 0000000 0000000 .gitignore 0000664 0000000 0000000 00000000042 14611320214 0033707 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-in-internal-files !/ambient-module-declaration.d.ts
ambient-module-declaration.d.ts 0000664 0000000 0000000 00000000044 14611320214 0037700 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-in-internal-files declare module 'ambient-module' {
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-in-internal-files/config.ts0000664 0000000 0000000 00000000252 14611320214 0033616 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {
output: {
inlineDeclareExternals: true,
},
};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0034321 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-in-internal-files require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-in-internal-files/input.ts 0000664 0000000 0000000 00000001016 14611320214 0033507 0 ustar 00root root 0000000 0000000 // this test case comes from Dexie.js
///
import { ModuleWithoutQuotes } from 'fake-package';
import { Interface, ExportedModule } from './interface';
export interface InterfaceInternal extends Interface {}
declare module ModuleName {
export interface Interface extends InterfaceInternal {}
export type Bar = ExportedModule.Foo;
export type Foo = ModuleWithoutQuotes.A;
}
declare var ModuleName: { prototype: Interface };
export { ModuleName };
interface.ts 0000664 0000000 0000000 00000000157 14611320214 0034236 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-in-internal-files export interface Interface {
field: Interface;
}
export module ExportedModule {
export type Foo = string;
}
output.d.ts 0000664 0000000 0000000 00000000743 14611320214 0034061 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-module-in-internal-files import { ModuleWithoutQuotes } from 'fake-package';
declare module "ambient-module" {
}
export interface Interface {
field: Interface;
}
declare namespace ExportedModule {
type Foo = string;
}
export interface InterfaceInternal extends Interface {
}
export declare namespace ModuleName {
interface Interface extends InterfaceInternal {
}
type Bar = ExportedModule.Foo;
type Foo = ModuleWithoutQuotes.A;
}
export declare var ModuleName: {
prototype: Interface;
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-unknown-modules/ 0000775 0000000 0000000 00000000000 14611320214 0030344 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-unknown-modules/config.ts 0000664 0000000 0000000 00000000252 14611320214 0032160 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {
output: {
inlineDeclareExternals: true,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-unknown-modules/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032742 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-unknown-modules/input.d.ts 0000664 0000000 0000000 00000000104 14611320214 0032270 0 ustar 00root root 0000000 0000000 ///
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-unknown-modules/modules.d.ts 0000664 0000000 0000000 00000000124 14611320214 0032603 0 ustar 00root root 0000000 0000000 declare module '*.css' {}
declare module 'module-that-does-not-exist-actually' {
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/declare-unknown-modules/output.d.ts 0000664 0000000 0000000 00000000140 14611320214 0032471 0 ustar 00root root 0000000 0000000 declare module "*.css" { }
declare module "module-that-does-not-exist-actually" {
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/default-export-of-default-export/ 0000775 0000000 0000000 00000000000 14611320214 0032110 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/default-export-of-default-export/class.ts 0000664 0000000 0000000 00000000040 14611320214 0033557 0 ustar 00root root 0000000 0000000 export default class MyClass {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/default-export-of-default-export/config.ts0000664 0000000 0000000 00000000172 14611320214 0033725 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0034427 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/default-export-of-default-export require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/default-export-of-default-export/input.ts 0000664 0000000 0000000 00000000043 14611320214 0033614 0 ustar 00root root 0000000 0000000 export { default } from './class';
output.d.ts 0000664 0000000 0000000 00000000110 14611320214 0034153 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/default-export-of-default-export declare class MyClass {
}
export {
MyClass as default,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/different-default-export-names-in-project/0000775 0000000 0000000 00000000000 14611320214 0033662 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000172 14611320214 0035420 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/different-default-export-names-in-project import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0036201 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/different-default-export-names-in-project require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000327 14611320214 0035314 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/different-default-export-names-in-project import DefaultClassOriginal from 'package-with-default-export';
import { ExportedInterface } from './my-file';
export interface ExportInterface {
field1: typeof DefaultClassOriginal;
field2: ExportedInterface;
}
my-file.ts 0000664 0000000 0000000 00000000232 14611320214 0035512 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/different-default-export-names-in-project import DefaultClassRenamed from 'package-with-default-export';
export interface ExportedInterface {}
export class FooBar extends DefaultClassRenamed {}
output.d.ts 0000664 0000000 0000000 00000000333 14611320214 0035734 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/different-default-export-names-in-project import DefaultClassOriginal from 'package-with-default-export';
export interface ExportedInterface {
}
export interface ExportInterface {
field1: typeof DefaultClassOriginal;
field2: ExportedInterface;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/disable-non-direct-exports/ 0000775 0000000 0000000 00000000000 14611320214 0030747 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/disable-non-direct-exports/config.ts 0000664 0000000 0000000 00000000252 14611320214 0032563 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {
output: {
exportReferencedTypes: false,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/disable-non-direct-exports/enums.d.ts 0000664 0000000 0000000 00000000212 14611320214 0032663 0 ustar 00root root 0000000 0000000 // note it doesn't have `declare` keyword
export const enum ConstEnum2 {}
// note it doesn't have `declare` keyword
export enum Enum2 {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/disable-non-direct-exports/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033345 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/disable-non-direct-exports/input.ts 0000664 0000000 0000000 00000000540 14611320214 0032455 0 ustar 00root root 0000000 0000000 import {
Class,
ConstEnum,
Enum,
func,
Interface,
Type,
variable,
} from './module';
import { Enum2, ConstEnum2 } from './enums';
export interface ExportedInterface {
class: Class;
constEnum: ConstEnum;
constEnum2: ConstEnum2;
enum: Enum;
enum2: Enum2;
func: typeof func;
interface: Interface;
type: Type;
variable: typeof variable;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/disable-non-direct-exports/module.ts 0000664 0000000 0000000 00000000311 14611320214 0032577 0 ustar 00root root 0000000 0000000 export class Class {}
export const enum ConstEnum {}
export const variable: string = '123';
export enum Enum {}
export function func(): void {}
export interface Interface {}
export type Type = string;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/disable-non-direct-exports/output.d.ts 0000664 0000000 0000000 00000000725 14611320214 0033105 0 ustar 00root root 0000000 0000000 declare class Class {
}
declare const enum ConstEnum {
}
declare const variable: string;
declare enum Enum {
}
declare function func(): void;
interface Interface {
}
type Type = string;
declare const enum ConstEnum2 {
}
declare enum Enum2 {
}
export interface ExportedInterface {
class: Class;
constEnum: ConstEnum;
constEnum2: ConstEnum2;
enum: Enum;
enum2: Enum2;
func: typeof func;
interface: Interface;
type: Type;
variable: typeof variable;
}
export {};
dont-inline-declare-extenal-modules-in-internal-files/ 0000775 0000000 0000000 00000000000 14611320214 0035762 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases .gitignore 0000664 0000000 0000000 00000000042 14611320214 0037746 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-extenal-modules-in-internal-files !/ambient-module-declaration.d.ts
ambient-module-declaration.d.ts 0000664 0000000 0000000 00000000044 14611320214 0043737 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-extenal-modules-in-internal-files declare module 'ambient-module' {
}
config.ts 0000664 0000000 0000000 00000000172 14611320214 0037577 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-extenal-modules-in-internal-files import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0040360 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-extenal-modules-in-internal-files require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000550 14611320214 0037471 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-extenal-modules-in-internal-files // this test case comes from Dexie.js
///
import { Interface } from './interface';
export interface InterfaceInternal extends Interface {}
declare module ModuleName {
export interface Interface extends InterfaceInternal {}
}
declare var ModuleName: { prototype: Interface };
export { ModuleName };
interface.ts 0000664 0000000 0000000 00000000062 14611320214 0040270 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-extenal-modules-in-internal-files export interface Interface {
field: Interface;
}
output.d.ts 0000664 0000000 0000000 00000000416 14611320214 0040115 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-extenal-modules-in-internal-files export interface Interface {
field: Interface;
}
export interface InterfaceInternal extends Interface {
}
export declare namespace ModuleName {
interface Interface extends InterfaceInternal {
}
}
export declare var ModuleName: {
prototype: Interface;
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-global/ 0000775 0000000 0000000 00000000000 14611320214 0030655 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-global/config.ts 0000664 0000000 0000000 00000000251 14611320214 0032470 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {
output: {
inlineDeclareGlobals: false,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-global/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033253 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-global/input.ts 0000664 0000000 0000000 00000000150 14611320214 0032360 0 ustar 00root root 0000000 0000000 declare global {
interface ArrayConstructor {
field: string;
}
}
export const field = Array.field;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/dont-inline-declare-global/output.d.ts 0000664 0000000 0000000 00000000060 14611320214 0033003 0 ustar 00root root 0000000 0000000 export declare const field: string;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/double-re-export-from-node_modules/ 0000775 0000000 0000000 00000000000 14611320214 0032413 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000172 14611320214 0034151 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/double-re-export-from-node_modules import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0034732 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/double-re-export-from-node_modules require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000112 14611320214 0034035 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/double-re-export-from-node_modules export { DefaultClass, DefaultClass1, DefaultClass2 } from './re-export';
output.d.ts 0000664 0000000 0000000 00000000303 14611320214 0034462 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/double-re-export-from-node_modules import { default as DefaultClass, default as DefaultClass1, default as DefaultClass2 } from 'package-with-default-export';
export {
DefaultClass,
DefaultClass1,
DefaultClass2,
};
export {};
re-export.ts 0000664 0000000 0000000 00000000304 14611320214 0034626 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/double-re-export-from-node_modules export { default as DefaultClass, default as DefaultClass1 } from 'package-with-default-export';
import { default as DefaultClass2 } from 'package-with-default-export';
export { DefaultClass2 };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-declaration-merging/ 0000775 0000000 0000000 00000000000 14611320214 0031034 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-declaration-merging/bar.ts 0000664 0000000 0000000 00000000027 14611320214 0032147 0 ustar 00root root 0000000 0000000 export const Bar = 12;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-declaration-merging/config.ts 0000664 0000000 0000000 00000000234 14611320214 0032650 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
output: {
exportReferencedTypes: false,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-declaration-merging/foo.ts 0000664 0000000 0000000 00000000131 14611320214 0032162 0 ustar 00root root 0000000 0000000 import { Bar } from './bar';
export interface Foo {}
interface Bar {}
export { Bar };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-declaration-merging/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033432 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-declaration-merging/input.ts 0000664 0000000 0000000 00000000107 14611320214 0032541 0 ustar 00root root 0000000 0000000 import { Foo, Bar } from './foo';
const Foo = 2;
export { Foo, Bar };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-declaration-merging/output.d.ts 0000664 0000000 0000000 00000000173 14611320214 0033167 0 ustar 00root root 0000000 0000000 export declare const Bar = 12;
export interface Foo {
}
export interface Bar {
}
export declare const Foo = 2;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-exist-class/ 0000775 0000000 0000000 00000000000 14611320214 0031002 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-exist-class/config.ts 0000664 0000000 0000000 00000000172 14611320214 0032617 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-exist-class/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033400 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-exist-class/input.ts 0000664 0000000 0000000 00000000076 14611320214 0032514 0 ustar 00root root 0000000 0000000 export class MyAwesomeClass {}
export default MyAwesomeClass;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-exist-class/output.d.ts 0000664 0000000 0000000 00000000135 14611320214 0033133 0 ustar 00root root 0000000 0000000 export declare class MyAwesomeClass {
}
export {
MyAwesomeClass as default,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-entry/ 0000775 0000000 0000000 00000000000 14611320214 0030645 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-entry/config.ts 0000664 0000000 0000000 00000000172 14611320214 0032462 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-entry/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033243 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-entry/input.ts 0000664 0000000 0000000 00000000217 14611320214 0032354 0 ustar 00root root 0000000 0000000 export interface MyInterface {}
export type MyType = {
[K in keyof T]: string;
};
export default class NewClass implements MyInterface {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-entry/output.d.ts 0000664 0000000 0000000 00000000270 14611320214 0032776 0 ustar 00root root 0000000 0000000 export interface MyInterface {
}
export type MyType = {
[K in keyof T]: string;
};
declare class NewClass implements MyInterface {
}
export {
NewClass as default,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-non-entry/ 0000775 0000000 0000000 00000000000 14611320214 0031435 5 ustar 00root root 0000000 0000000 another-class.ts 0000664 0000000 0000000 00000000077 14611320214 0034475 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-non-entry export class MyAnotherClass {}
export default MyAnotherClass;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-non-entry/class.ts 0000664 0000000 0000000 00000000040 14611320214 0033104 0 ustar 00root root 0000000 0000000 export default class MyClass {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-non-entry/config.ts 0000664 0000000 0000000 00000000172 14611320214 0033252 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033754 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-non-entry require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-non-entry/input.ts 0000664 0000000 0000000 00000000364 14611320214 0033147 0 ustar 00root root 0000000 0000000 import MyInterface from './interface';
import MyClass from './class';
import MyAnotherClass from './another-class';
export default class MyNewClass extends MyClass implements MyInterface {}
export class MyNewClass2 extends MyAnotherClass { }
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-non-entry/interface.ts0000664 0000000 0000000 00000000050 14611320214 0033740 0 ustar 00root root 0000000 0000000 export default interface MyInterface {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-from-non-entry/output.d.ts 0000664 0000000 0000000 00000000415 14611320214 0033567 0 ustar 00root root 0000000 0000000 export interface MyInterface {
}
declare class MyClass {
}
declare class MyAnotherClass {
}
declare class MyNewClass extends MyClass implements MyInterface {
}
export declare class MyNewClass2 extends MyAnotherClass {
}
export {
MyNewClass as default,
};
export {};
export-default-just-declared-class-from-entry/ 0000775 0000000 0000000 00000000000 14611320214 0034415 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000172 14611320214 0036232 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-just-declared-class-from-entry import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0037013 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-just-declared-class-from-entry require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000051 14611320214 0036120 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-just-declared-class-from-entry class MyClass {}
export default MyClass;
output.d.ts 0000664 0000000 0000000 00000000110 14611320214 0036537 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-just-declared-class-from-entry declare class MyClass {
}
export {
MyClass as default,
};
export {};
export-default-just-declared-fns-from-entry/ 0000775 0000000 0000000 00000000000 14611320214 0034076 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000154 14611320214 0035713 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-just-declared-fns-from-entry import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0036474 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-just-declared-fns-from-entry require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000115 14611320214 0035602 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-just-declared-fns-from-entry import fns, { fooBar as fooBaz } from './some-fns';
export { fns, fooBaz };
output.d.ts 0000664 0000000 0000000 00000000205 14611320214 0036225 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-just-declared-fns-from-entry declare function name(a: number): number;
declare function fooBar(): void;
export {
fooBar as fooBaz,
name as fns,
};
export {};
some-fns.ts 0000664 0000000 0000000 00000000151 14611320214 0036172 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-just-declared-fns-from-entry export default function name (a: number): number {
return a + 1;
};
export function fooBar(): void {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-no-export-referenced-types/0000775 0000000 0000000 00000000000 14611320214 0033740 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000234 14611320214 0035475 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-no-export-referenced-types import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
output: {
exportReferencedTypes: false,
},
};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0036257 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-no-export-referenced-types require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000050 14611320214 0035363 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-no-export-referenced-types const foo = "bar";
export default foo;
output.d.ts 0000664 0000000 0000000 00000000105 14611320214 0036007 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-no-export-referenced-types declare const foo = "bar";
export {
foo as default,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement/ 0000775 0000000 0000000 00000000000 14611320214 0032174 5 ustar 00root root 0000000 0000000 another-class.ts 0000664 0000000 0000000 00000000056 14611320214 0035231 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement export default class {
second: number = 1;
}
another-func.ts 0000664 0000000 0000000 00000000053 14611320214 0035054 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement export default function(second: number) {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement/class.ts 0000664 0000000 0000000 00000000055 14611320214 0033651 0 ustar 00root root 0000000 0000000 export default class {
first: number = 1;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement/config.ts0000664 0000000 0000000 00000000172 14611320214 0034011 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement/func.ts 0000664 0000000 0000000 00000000052 14611320214 0033474 0 ustar 00root root 0000000 0000000 export default function(first: number) {}
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0034513 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement/input.ts 0000664 0000000 0000000 00000001140 14611320214 0033677 0 ustar 00root root 0000000 0000000 export { default as myFunc1 } from './func';
export { default as myFunc2 } from './func';
export { default as myFunc3 } from './another-func';
export { default as myFunc4 } from './another-func';
export { default as myClass1 } from './class';
export { default as myClass2 } from './class';
export { default as myClass3 } from './another-class';
export { default as myClass4 } from './another-class';
export { default as number } from './number';
export { default as string } from './string';
export { default as object } from './object';
export { default as myClass5 } from 'package-with-default-export';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement/number.ts0000664 0000000 0000000 00000000022 14611320214 0034026 0 ustar 00root root 0000000 0000000 export default 0;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement/object.ts0000664 0000000 0000000 00000000046 14611320214 0034012 0 ustar 00root root 0000000 0000000 export default {
type: 'object',
};
output.d.ts 0000664 0000000 0000000 00000001224 14611320214 0034246 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement import { default as myClass5 } from 'package-with-default-export';
declare function _default(first: number): void;
declare function _default$1(second: number): void;
declare class _default$2 {
first: number;
}
declare class _default$3 {
second: number;
}
declare const _default$4: 0;
declare const _default$5: "";
declare const _default$6: {
type: string;
};
export {
_default as myFunc1,
_default as myFunc2,
_default$1 as myFunc3,
_default$1 as myFunc4,
_default$2 as myClass1,
_default$2 as myClass2,
_default$3 as myClass3,
_default$3 as myClass4,
_default$4 as number,
_default$5 as string,
_default$6 as object,
myClass5,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-default-unnamed-statement/string.ts0000664 0000000 0000000 00000000023 14611320214 0034045 0 ustar 00root root 0000000 0000000 export default '';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-eq-from-entry/ 0000775 0000000 0000000 00000000000 14611320214 0027626 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-eq-from-entry/config.ts 0000664 0000000 0000000 00000000172 14611320214 0031443 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-eq-from-entry/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032224 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-eq-from-entry/input.ts 0000664 0000000 0000000 00000000077 14611320214 0031341 0 ustar 00root root 0000000 0000000 import { SomeClass } from './some-class';
export = SomeClass;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-eq-from-entry/output.d.ts 0000664 0000000 0000000 00000000074 14611320214 0031761 0 ustar 00root root 0000000 0000000 declare class SomeClass {
}
export = SomeClass;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-eq-from-entry/some-class.ts 0000664 0000000 0000000 00000000032 14611320214 0032237 0 ustar 00root root 0000000 0000000 export class SomeClass {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-keyof-typeof-var-type/ 0000775 0000000 0000000 00000000000 14611320214 0031307 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-keyof-typeof-var-type/config.ts 0000664 0000000 0000000 00000000154 14611320214 0033124 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-keyof-typeof-var-type/index.spec.js0000664 0000000 0000000 00000000064 14611320214 0033705 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-keyof-typeof-var-type/input.ts 0000664 0000000 0000000 00000000147 14611320214 0033020 0 ustar 00root root 0000000 0000000 const variableName = {
a: 123,
b: 'string',
};
export type TypeOfConst = keyof typeof variableName;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-keyof-typeof-var-type/output.d.ts 0000664 0000000 0000000 00000000172 14611320214 0033441 0 ustar 00root root 0000000 0000000 declare const variableName: {
a: number;
b: string;
};
export type TypeOfConst = keyof typeof variableName;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-namespaces/ 0000775 0000000 0000000 00000000000 14611320214 0027240 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-namespaces/config.ts 0000664 0000000 0000000 00000000154 14611320214 0031055 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-namespaces/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031636 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-namespaces/input.ts 0000664 0000000 0000000 00000000344 14611320214 0030750 0 ustar 00root root 0000000 0000000 import { InternalModule, InternalNamespace, ExportedModule, ExportedNamespace } from './internals';
export type A = InternalModule.MType;
export type B = InternalNamespace.NSType;
export { ExportedModule, ExportedNamespace };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-namespaces/internals.ts 0000664 0000000 0000000 00000000411 14611320214 0031603 0 ustar 00root root 0000000 0000000 export namespace InternalNamespace {
export type NSType = string;
}
export module InternalModule {
export type MType = number;
}
export namespace ExportedNamespace {
export type ENSType = 1 | 2;
}
export module ExportedModule {
export type EMType = 3 | 4;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-namespaces/output.d.ts 0000664 0000000 0000000 00000000536 14611320214 0031376 0 ustar 00root root 0000000 0000000 declare namespace InternalNamespace {
type NSType = string;
}
declare namespace InternalModule {
type MType = number;
}
export declare namespace ExportedNamespace {
type ENSType = 1 | 2;
}
export declare namespace ExportedModule {
type EMType = 3 | 4;
}
export type A = InternalModule.MType;
export type B = InternalNamespace.NSType;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-object-with-destructuring/ 0000775 0000000 0000000 00000000000 14611320214 0032240 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-object-with-destructuring/config.ts0000664 0000000 0000000 00000000172 14611320214 0034055 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0034557 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-object-with-destructuring require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-object-with-destructuring/input.ts 0000664 0000000 0000000 00000000227 14611320214 0033750 0 ustar 00root root 0000000 0000000 export const queryDict: Record = {
param: '123',
otherParam: '456',
};
export const {
param,
otherParam,
} = queryDict;
output.d.ts 0000664 0000000 0000000 00000000232 14611320214 0034310 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-object-with-destructuring export declare const queryDict: Record;
export declare const param: string | boolean, otherParam: string | boolean;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-variables-list/ 0000775 0000000 0000000 00000000000 14611320214 0030042 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-variables-list/config.ts 0000664 0000000 0000000 00000000154 14611320214 0031657 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-variables-list/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032440 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-variables-list/input.ts 0000664 0000000 0000000 00000000567 14611320214 0031561 0 ustar 00root root 0000000 0000000 // not supported for now - if variable declarations have different exports - then all aren't exported
const defaultExportedString = 'str', justExportedNumber = 123;
export default defaultExportedString;
export { justExportedNumber };
const exportedString = 'str', nonExportedNum = 123;
export { exportedString };
// fix unused expression error
console.log(nonExportedNum);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-variables-list/output.d.ts 0000664 0000000 0000000 00000000260 14611320214 0032172 0 ustar 00root root 0000000 0000000 declare const defaultExportedString = "str", justExportedNumber = 123;
export declare const exportedString = "str";
export {
defaultExportedString as default,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-variables-list/tsconfig.json 0000664 0000000 0000000 00000000121 14611320214 0032543 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"types": ["node"]
}
}
export-via-global-declaration-but-inlineDeclareGlobals-disabled/ 0000775 0000000 0000000 00000000000 14611320214 0037737 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000172 14611320214 0041554 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration-but-inlineDeclareGlobals-disabled import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0042335 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration-but-inlineDeclareGlobals-disabled require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000273 14611320214 0041450 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration-but-inlineDeclareGlobals-disabled import { FooOptions } from './options';
import './other-global';
declare global {
export namespace Cypress {
export interface Chainable {
foo(options?: FooOptions): void;
}
}
}
options.ts 0000664 0000000 0000000 00000000037 14611320214 0042002 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration-but-inlineDeclareGlobals-disabled export interface FooOptions {}
other-global.ts 0000664 0000000 0000000 00000000243 14611320214 0042665 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration-but-inlineDeclareGlobals-disabled import { Interface } from 'fake-package';
declare global {
export namespace Cypress {
export interface Chainable {
bar(options?: Interface): void;
}
}
}
output.d.ts 0000664 0000000 0000000 00000000013 14611320214 0042063 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration-but-inlineDeclareGlobals-disabled export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration/ 0000775 0000000 0000000 00000000000 14611320214 0031421 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration/config.ts 0000664 0000000 0000000 00000000250 14611320214 0033233 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {
output: {
inlineDeclareGlobals: true,
},
};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033740 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration/input.ts 0000664 0000000 0000000 00000000273 14611320214 0033132 0 ustar 00root root 0000000 0000000 import { FooOptions } from './options';
import './other-global';
declare global {
export namespace Cypress {
export interface Chainable {
foo(options?: FooOptions): void;
}
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration/options.ts 0000664 0000000 0000000 00000000124 14611320214 0033461 0 ustar 00root root 0000000 0000000 export interface SubOptions {}
export interface FooOptions {
field: SubOptions;
}
other-global.ts 0000664 0000000 0000000 00000000243 14611320214 0034270 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration import { Interface } from 'fake-package';
declare global {
export namespace Cypress {
export interface Chainable {
bar(options?: Interface): void;
}
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-via-global-declaration/output.d.ts 0000664 0000000 0000000 00000000556 14611320214 0033561 0 ustar 00root root 0000000 0000000 import { Interface } from 'fake-package';
export interface SubOptions {
}
export interface FooOptions {
field: SubOptions;
}
declare global {
export namespace Cypress {
interface Chainable {
bar(options?: Interface): void;
}
}
}
declare global {
export namespace Cypress {
interface Chainable {
foo(options?: FooOptions): void;
}
}
}
export {};
export-wrapped-with-namespace-chain-but-via-imports/ 0000775 0000000 0000000 00000000000 14611320214 0035527 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000234 14611320214 0037343 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-but-via-imports import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
output: {
exportReferencedTypes: false,
},
};
export = config;
first.ts 0000664 0000000 0000000 00000000117 14611320214 0037225 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-but-via-imports import * as FirstNamespaceName from './second';
export { FirstNamespaceName };
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0040125 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-but-via-imports require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000112 14611320214 0037230 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-but-via-imports import * as TopNamespaceName from './first';
export { TopNamespaceName };
output.d.ts 0000664 0000000 0000000 00000000545 14611320214 0037665 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-but-via-imports import * as Ns from 'fake-package';
import * as Ns1 from 'package-with-export-eq';
type A = string;
declare namespace SecondNamespaceName {
export { A, Ns, Ns1 };
}
declare namespace FirstNamespaceName {
export { SecondNamespaceName };
}
declare namespace TopNamespaceName {
export { FirstNamespaceName };
}
export {
TopNamespaceName,
};
export {};
second.ts 0000664 0000000 0000000 00000000120 14611320214 0037343 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-but-via-imports import * as SecondNamespaceName from './third';
export { SecondNamespaceName };
third.ts 0000664 0000000 0000000 00000000334 14611320214 0037211 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-but-via-imports import * as Ns1 from 'package-with-export-eq';
export type A = string;
export * as Ns from 'fake-package';
export { Ns1 };
// this is not supported yet, uncomment once it is possible
// export * from 'fake-package';
export-wrapped-with-namespace-chain-inline/ 0000775 0000000 0000000 00000000000 14611320214 0033743 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000336 14611320214 0035562 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-inline import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
inlinedLibraries: ['package-with-export-eq'],
},
output: {
exportReferencedTypes: false,
},
};
export = config;
first.ts 0000664 0000000 0000000 00000000060 14611320214 0035436 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-inline export * as FirstNamespaceName from './second';
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0036341 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-inline require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000055 14611320214 0035452 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-inline export * as TopNamespaceName from './first';
output.d.ts 0000664 0000000 0000000 00000000542 14611320214 0036076 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-inline import * as Ns from 'fake-package';
declare namespace MyModule {
export interface SomeCoolInterface {
field: string;
field2: number;
}
}
type A = string;
declare namespace FirstNamespaceName {
export { A, MyModule as Ns1, Ns };
}
declare namespace TopNamespaceName {
export { FirstNamespaceName };
}
export {
TopNamespaceName,
};
export {};
second.ts 0000664 0000000 0000000 00000000176 14611320214 0035572 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain-inline import * as Ns1 from 'package-with-export-eq';
export type A = string;
export * as Ns from 'fake-package';
export { Ns1 };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain/ 0000775 0000000 0000000 00000000000 14611320214 0032546 5 ustar 00root root 0000000 0000000 another-ns.ts 0000664 0000000 0000000 00000000046 14611320214 0035115 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain export * as AnotherNs from './types';
config.ts 0000664 0000000 0000000 00000000234 14611320214 0034303 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
output: {
exportReferencedTypes: false,
},
};
export = config;
first.ts 0000664 0000000 0000000 00000000060 14611320214 0034162 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain export * as FirstNamespaceName from './second';
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035065 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000156 14611320214 0034200 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain export * as TopNamespaceName from './first';
export { AnotherNs as AnotherNsButRenamed } from './another-ns';
output.d.ts 0000664 0000000 0000000 00000000711 14611320214 0034620 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain import * as Ns from 'fake-package';
import * as Ns1 from 'package-with-export-eq';
type A = string;
type Str = string;
declare namespace SecondNamespaceName {
export { A, Ns, Ns1 };
}
declare namespace FirstNamespaceName {
export { SecondNamespaceName };
}
declare namespace TopNamespaceName {
export { FirstNamespaceName };
}
declare namespace AnotherNsButRenamed {
export { Str };
}
export {
AnotherNsButRenamed,
TopNamespaceName,
};
export {};
second.ts 0000664 0000000 0000000 00000000060 14611320214 0034306 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain export * as SecondNamespaceName from './third';
third.ts 0000664 0000000 0000000 00000000334 14611320214 0034151 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain import * as Ns1 from 'package-with-export-eq';
export type A = string;
export * as Ns from 'fake-package';
export { Ns1 };
// this is not supported yet, uncomment once it is possible
// export * from 'fake-package';
types.ts 0000664 0000000 0000000 00000000032 14611320214 0034176 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-chain export type Str = string;
export-wrapped-with-namespace-export-eq-export/ 0000775 0000000 0000000 00000000000 14611320214 0034650 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000234 14611320214 0036464 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-export-eq-export import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
output: {
exportReferencedTypes: false,
},
};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0037246 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-export-eq-export require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000211 14611320214 0036351 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-export-eq-export import * as newName from 'package-with-export-eq';
import * as myLib from 'package-with-export-eq-variable';
export { newName, myLib };
output.d.ts 0000664 0000000 0000000 00000000230 14611320214 0036775 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-export-eq-export import * as newName from 'package-with-export-eq';
import * as myLib from 'package-with-export-eq-variable';
export {
myLib,
newName,
};
export {};
export-wrapped-with-namespace-export-eq-inline/ 0000775 0000000 0000000 00000000000 14611320214 0034605 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000401 14611320214 0036415 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-export-eq-inline import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
inlinedLibraries: ['package-with-export-eq', 'package-with-export-eq-variable'],
},
output: {
exportReferencedTypes: false,
},
};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0037203 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-export-eq-inline require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000211 14611320214 0036306 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-export-eq-inline import * as newName from 'package-with-export-eq';
import * as myLib from 'package-with-export-eq-variable';
export { newName, myLib };
output.d.ts 0000664 0000000 0000000 00000000347 14611320214 0036743 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace-export-eq-inline declare namespace MyModule {
export interface SomeCoolInterface {
field: string;
field2: number;
}
}
interface LibInterface {
field: number;
}
export const myLib: LibInterface;
export {
MyModule as newName,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace/ 0000775 0000000 0000000 00000000000 14611320214 0031466 5 ustar 00root root 0000000 0000000 another-exports.ts 0000664 0000000 0000000 00000000176 14611320214 0035125 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace export type MyString = string;
export interface MyInt {}
export function func() {}
export { Interface } from 'fake-package';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace/config.ts 0000664 0000000 0000000 00000000234 14611320214 0033302 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
output: {
exportReferencedTypes: false,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace/exports.ts 0000664 0000000 0000000 00000000176 14611320214 0033546 0 ustar 00root root 0000000 0000000 export type MyString = string;
export interface MyInt {}
export function func() {}
export { Interface } from 'fake-package';
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0034005 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace/input.ts 0000664 0000000 0000000 00000000652 14611320214 0033200 0 ustar 00root root 0000000 0000000 export * as MyNamespace from './exports';
export * as MyNamespace1 from './another-exports';
export * as MyNamespace2 from './another-exports';
import * as SomeLocalNsName from './one-more-exports';
import * as MyNamespace4 from './one-more-exports';
import { MyInt } from './exports';
export interface MyNamespace2 {
field: MyInt;
}
export type Type = MyInt;
export {
SomeLocalNsName as MyNamespace3,
MyNamespace4,
};
one-more-exports.ts 0000664 0000000 0000000 00000000322 14611320214 0035177 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace export type MyString = string;
export interface MyInt {}
export function func() {}
export { Interface } from 'fake-package';
export * from './type';
export * from './type2';
export * as subNs from './type2';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace/output.d.ts 0000664 0000000 0000000 00000002156 14611320214 0033624 0 ustar 00root root 0000000 0000000 import { Interface } from 'fake-package';
type MyString = string;
interface MyInt {
}
declare function func(): void;
type MyString$1 = string;
interface MyInt$1 {
}
declare function func$1(): void;
type MyType = string;
type MyType2 = string;
type MyString$2 = string;
interface MyInt$2 {
}
declare function func$2(): void;
interface MyNamespace2 {
field: MyInt;
}
export type Type = MyInt;
declare namespace MyNamespace4 {
export { Interface, MyInt$2 as MyInt, MyString$2 as MyString, MyType, MyType2, func$2 as func, subNs };
}
declare namespace subNs {
export { MyType2 };
}
declare namespace MyNamespace {
export { Interface, MyInt, MyString, func };
}
declare namespace MyNamespace1 {
export { Interface, MyInt$1 as MyInt, MyString$1 as MyString, func$1 as func };
}
declare namespace MyNamespace2 {
export { Interface, MyInt$1 as MyInt, MyString$1 as MyString, func$1 as func };
}
declare namespace MyNamespace3 {
export { Interface, MyInt$2 as MyInt, MyString$2 as MyString, MyType, MyType2, func$2 as func, subNs };
}
export {
MyNamespace,
MyNamespace1,
MyNamespace2,
MyNamespace3,
MyNamespace4,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace/type.ts 0000664 0000000 0000000 00000000035 14611320214 0033015 0 ustar 00root root 0000000 0000000 export type MyType = string;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/export-wrapped-with-namespace/type2.ts 0000664 0000000 0000000 00000000036 14611320214 0033100 0 ustar 00root root 0000000 0000000 export type MyType2 = string;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module-complex/ 0000775 0000000 0000000 00000000000 14611320214 0031140 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module-complex/config.ts 0000664 0000000 0000000 00000000172 14611320214 0032755 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
extendable-module.ts 0000664 0000000 0000000 00000000161 14611320214 0035025 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module-complex export function getRandom(): number {
return 4;
}
export interface SomeInterface {
field: typeof getRandom;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module-complex/extender.ts 0000664 0000000 0000000 00000000255 14611320214 0033330 0 ustar 00root root 0000000 0000000 export function justFunction(input: boolean): void {
// do nothing
}
declare module './extendable-module' {
interface SomeInterface {
field2: typeof justFunction;
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module-complex/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033536 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module-complex/input.ts 0000664 0000000 0000000 00000000604 14611320214 0032647 0 ustar 00root root 0000000 0000000 // we need to add this to add `extender.d.ts` to list of files to bundle the types after compilation for dts
///
///
import { SomeInterface } from './extendable-module';
import { justFunction } from './extender';
justFunction(true);
export default SomeInterface;
internal-extender/ 0000775 0000000 0000000 00000000000 14611320214 0034511 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module-complex extender.d.ts 0000664 0000000 0000000 00000000221 14611320214 0037114 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module-complex/internal-extender export function justFunction2(): void;
declare module '..\\extendable-module' {
interface SomeInterface {
field3: typeof justFunction2;
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module-complex/output.d.ts 0000664 0000000 0000000 00000000542 14611320214 0033273 0 ustar 00root root 0000000 0000000 declare function justFunction(input: boolean): void;
interface SomeInterface {
field2: typeof justFunction;
}
declare function justFunction2(): void;
interface SomeInterface {
field3: typeof justFunction2;
}
declare function getRandom(): number;
interface SomeInterface {
field: typeof getRandom;
}
export {
SomeInterface as default,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module/ 0000775 0000000 0000000 00000000000 14611320214 0027473 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module/config.ts 0000664 0000000 0000000 00000000252 14611320214 0031307 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {
output: {
inlineDeclareExternals: true,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module/extendable-module.ts 0000664 0000000 0000000 00000000161 14611320214 0033437 0 ustar 00root root 0000000 0000000 export function getRandom(): number {
return 4;
}
export interface SomeInterface {
field: typeof getRandom;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032071 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module/input.ts 0000664 0000000 0000000 00000000523 14611320214 0031202 0 ustar 00root root 0000000 0000000 import { SomeInterface } from './extendable-module';
export function justFunction(input: SomeInterface): void {
// do nothing
}
declare module './extendable-module' {
interface SomeInterface {
field2: typeof justFunction;
}
}
declare module '@app/extendable-module' {
interface SomeInterface {
field3: typeof justFunction;
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module/output.d.ts 0000664 0000000 0000000 00000000463 14611320214 0031630 0 ustar 00root root 0000000 0000000 declare function getRandom(): number;
export interface SomeInterface {
field: typeof getRandom;
}
export declare function justFunction(input: SomeInterface): void;
export interface SomeInterface {
field2: typeof justFunction;
}
export interface SomeInterface {
field3: typeof justFunction;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/extend-other-module/tsconfig.json 0000664 0000000 0000000 00000000143 14611320214 0032200 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"paths": {
"@app/*": ["./*"]
}
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/external-types/ 0000775 0000000 0000000 00000000000 14611320214 0026566 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/external-types/config.ts 0000664 0000000 0000000 00000000243 14611320214 0030402 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
allowedTypesLibraries: ['mocha'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/external-types/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031164 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/external-types/input.ts 0000664 0000000 0000000 00000000111 14611320214 0030266 0 ustar 00root root 0000000 0000000 import 'mocha';
export interface InterfaceName {
prop: BrowserMocha;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/external-types/output.d.ts 0000664 0000000 0000000 00000000145 14611320214 0030720 0 ustar 00root root 0000000 0000000 ///
export interface InterfaceName {
prop: BrowserMocha;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/globalThis/ 0000775 0000000 0000000 00000000000 14611320214 0025672 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/globalThis/config.ts 0000664 0000000 0000000 00000000154 14611320214 0027507 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/globalThis/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0030270 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/globalThis/input.ts 0000664 0000000 0000000 00000000156 14611320214 0027403 0 ustar 00root root 0000000 0000000 export declare function getGlobal(): typeof globalThis;
export declare function getUndef(): typeof undefined;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/globalThis/output.d.ts 0000664 0000000 0000000 00000000172 14611320214 0030024 0 ustar 00root root 0000000 0000000 export declare function getGlobal(): typeof globalThis;
export declare function getUndef(): typeof undefined;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/handle-export-eq-from-npm/ 0000775 0000000 0000000 00000000000 14611320214 0030510 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/handle-export-eq-from-npm/config.ts 0000664 0000000 0000000 00000000252 14611320214 0032324 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {
libraries: {
allowedTypesLibraries: [],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/handle-export-eq-from-npm/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033106 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/handle-export-eq-from-npm/input.ts 0000664 0000000 0000000 00000000533 14611320214 0032220 0 ustar 00root root 0000000 0000000 import { SomeCoolInterface } from 'package-with-export-eq';
import { NamedDeclaration } from 'typescript';
import { EventEmitter } from 'events';
export class StoppableEventEmitter extends EventEmitter {
public emitStoppableEvent(error: Error): this {
return this;
}
}
export type ExportType = SomeCoolInterface | NamedDeclaration | string;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/handle-export-eq-from-npm/output.d.ts 0000664 0000000 0000000 00000000524 14611320214 0032643 0 ustar 00root root 0000000 0000000 import { EventEmitter } from 'events';
import { SomeCoolInterface } from 'package-with-export-eq';
import { NamedDeclaration } from 'typescript';
export declare class StoppableEventEmitter extends EventEmitter {
emitStoppableEvent(error: Error): this;
}
export type ExportType = SomeCoolInterface | NamedDeclaration | string;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/handle-export-eq-from-npm/tsconfig.json 0000664 0000000 0000000 00000000121 14611320214 0033211 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"types": ["node"]
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import()-type/ 0000775 0000000 0000000 00000000000 14611320214 0026214 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import()-type/config.ts 0000664 0000000 0000000 00000000245 14611320214 0030032 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
inlinedLibraries: ['fake-package'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import()-type/custom-type.d.ts 0000664 0000000 0000000 00000000244 14611320214 0031277 0 ustar 00root root 0000000 0000000 export interface CustomType {
foo: number;
bar: string;
}
export namespace Namespace {
export const baz: number;
}
export declare type GenericType = {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import()-type/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0030612 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import()-type/input.ts 0000664 0000000 0000000 00000000241 14611320214 0027720 0 ustar 00root root 0000000 0000000 import { MyType } from './my-type';
import { NonDefaultInterface as DFI } from 'package-with-default-export';
export type MySecondType = MyType | number | DFI;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import()-type/my-type.d.ts 0000664 0000000 0000000 00000000571 14611320214 0030415 0 ustar 00root root 0000000 0000000 export interface MyType {
field: import('./custom-type').CustomType;
field2: typeof import('./custom-type').Namespace;
field3: import('ora').Options;
field4: import('./custom-type').GenericType;
field5: import('fake-package').Interface;
field6: typeof import('./namespace').Namespace;
field7: import('package-with-default-export').NonDefaultInterface;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import()-type/namespace.d.ts 0000664 0000000 0000000 00000000072 14611320214 0030741 0 ustar 00root root 0000000 0000000 export namespace Namespace {
export const baz: number;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import()-type/output.d.ts 0000664 0000000 0000000 00000001216 14611320214 0030346 0 ustar 00root root 0000000 0000000 import { NonDefaultInterface as DFI } from 'package-with-default-export';
export interface CustomType {
foo: number;
bar: string;
}
declare namespace Namespace {
export const baz: number;
}
export declare type GenericType = {};
export interface Interface {
}
declare namespace Namespace$1 {
export const baz: number;
}
export interface MyType {
field: CustomType;
field2: typeof Namespace;
field3: import("ora").Options;
field4: GenericType;
field5: Interface;
field6: typeof Namespace$1;
field7: import("package-with-default-export").NonDefaultInterface;
}
export type MySecondType = MyType | number | DFI;
export {};
import-compound-type-from-npm-cause-unnecessary-import/ 0000775 0000000 0000000 00000000000 14611320214 0036332 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000154 14611320214 0040147 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-compound-type-from-npm-cause-unnecessary-import import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0040730 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-compound-type-from-npm-cause-unnecessary-import require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000146 14611320214 0040042 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-compound-type-from-npm-cause-unnecessary-import import { InterfaceWithFields } from 'fake-package';
export type MyType = InterfaceWithFields | null;
output.d.ts 0000664 0000000 0000000 00000000162 14611320214 0040463 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-compound-type-from-npm-cause-unnecessary-import import { InterfaceWithFields } from 'fake-package';
export type MyType = InterfaceWithFields | null;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-default-from-node-modules/ 0000775 0000000 0000000 00000000000 14611320214 0032070 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-default-from-node-modules/config.ts0000664 0000000 0000000 00000000172 14611320214 0033705 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0034407 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-default-from-node-modules require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-default-from-node-modules/input.ts 0000664 0000000 0000000 00000000154 14611320214 0033577 0 ustar 00root root 0000000 0000000 import DefaultClass from 'package-with-default-export';
export class MyCustomClass extends DefaultClass {}
output.d.ts 0000664 0000000 0000000 00000000201 14611320214 0034134 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-default-from-node-modules import DefaultClass from 'package-with-default-export';
export declare class MyCustomClass extends DefaultClass {
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq-with-interop/ 0000775 0000000 0000000 00000000000 14611320214 0030146 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq-with-interop/config.ts 0000664 0000000 0000000 00000000172 14611320214 0031763 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq-with-interop/export-eq.ts 0000664 0000000 0000000 00000000050 14611320214 0032435 0 ustar 00root root 0000000 0000000 class ClassName {}
export = ClassName;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq-with-interop/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032544 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq-with-interop/input.ts 0000664 0000000 0000000 00000000344 14611320214 0031656 0 ustar 00root root 0000000 0000000 import MyModule from 'package-with-export-eq';
import ClassName from './export-eq';
export class ExportedClass extends ClassName implements MyModule.SomeCoolInterface {
public field: string = '';
public field2: number = 0;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq-with-interop/output.d.ts 0000664 0000000 0000000 00000000330 14611320214 0032274 0 ustar 00root root 0000000 0000000 import MyModule from 'package-with-export-eq';
declare class ClassName {
}
export declare class ExportedClass extends ClassName implements MyModule.SomeCoolInterface {
field: string;
field2: number;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq-with-interop/tsconfig.json 0000664 0000000 0000000 00000000177 14611320214 0032662 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"allowSyntheticDefaultImports": true,
"esModuleInterop": true
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq/ 0000775 0000000 0000000 00000000000 14611320214 0025517 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq/config.ts 0000664 0000000 0000000 00000000172 14611320214 0027334 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq/export-eq.ts 0000664 0000000 0000000 00000000050 14611320214 0030006 0 ustar 00root root 0000000 0000000 class ClassName {}
export = ClassName;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0030115 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq/input.ts 0000664 0000000 0000000 00000000360 14611320214 0027225 0 ustar 00root root 0000000 0000000 import MyModule = require('package-with-export-eq');
import ClassName = require('./export-eq');
export class ExportedClass extends ClassName implements MyModule.SomeCoolInterface {
public field: string = '';
public field2: number = 0;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-eq/output.d.ts 0000664 0000000 0000000 00000000336 14611320214 0027653 0 ustar 00root root 0000000 0000000 import MyModule = require('package-with-export-eq');
declare class ClassName {
}
export declare class ExportedClass extends ClassName implements MyModule.SomeCoolInterface {
field: string;
field2: number;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-deps/ 0000775 0000000 0000000 00000000000 14611320214 0027006 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-deps/config.ts 0000664 0000000 0000000 00000000246 14611320214 0030625 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
importedLibraries: ['fake-package'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-deps/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031404 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-deps/input.ts 0000664 0000000 0000000 00000000132 14611320214 0030511 0 ustar 00root root 0000000 0000000 import { Interface, Type } from 'fake-package';
export type TestType = Interface | Type;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-deps/output.d.ts 0000664 0000000 0000000 00000000146 14611320214 0031141 0 ustar 00root root 0000000 0000000 import { Interface, Type } from 'fake-package';
export type TestType = Interface | Type;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-interface-with-export-eq/ 0000775 0000000 0000000 00000000000 14611320214 0032706 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000243 14611320214 0034443 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-interface-with-export-eq import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
importedLibraries: ['commander'],
},
};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035225 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-interface-with-export-eq require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000131 14611320214 0034331 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-interface-with-export-eq import { Command } from 'commander';
export function someFunction(program: Command) { }
output.d.ts 0000664 0000000 0000000 00000000160 14611320214 0034756 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-interface-with-export-eq import { Command } from 'commander';
export declare function someFunction(program: Command): void;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-namespace-in-cjs/ 0000775 0000000 0000000 00000000000 14611320214 0031170 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-namespace-in-cjs/config.ts 0000664 0000000 0000000 00000000234 14611320214 0033004 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
inlinedLibraries: ['ora'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-namespace-in-cjs/index.spec.js0000664 0000000 0000000 00000000064 14611320214 0033566 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-namespace-in-cjs/input.ts 0000664 0000000 0000000 00000000161 14611320214 0032675 0 ustar 00root root 0000000 0000000 import { Options } from 'ora';
export declare const ExportedValue: Options;
export type ExportedType = Options;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-namespace-in-cjs/output.d.ts 0000664 0000000 0000000 00000000315 14611320214 0033321 0 ustar 00root root 0000000 0000000 declare namespace ora {
interface Options {
}
}
declare const ora: {
(options: ora.Options): any;
};
export declare const ExportedValue: ora.Options;
export type ExportedType = ora.Options;
export {};
import-from-non-relative-path-inferred-type/ 0000775 0000000 0000000 00000000000 14611320214 0034104 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000172 14611320214 0035721 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-non-relative-path-inferred-type import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0036502 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-non-relative-path-inferred-type require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000136 14611320214 0035613 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-non-relative-path-inferred-type import { returnMyType } from "field/type";
export function test() {
return returnMyType()
}
output.d.ts 0000664 0000000 0000000 00000000140 14611320214 0036231 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-non-relative-path-inferred-type export interface MyType {
field: string;
}
export declare function test(): MyType;
export {};
src/ 0000775 0000000 0000000 00000000000 14611320214 0034673 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-non-relative-path-inferred-type field/ 0000775 0000000 0000000 00000000000 14611320214 0035756 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-non-relative-path-inferred-type/src type.ts 0000664 0000000 0000000 00000000165 14611320214 0037311 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-non-relative-path-inferred-type/src/field export interface MyType {
field: string;
}
export function returnMyType(): MyType {
return {
field: "test"
}
}
tsconfig.json 0000664 0000000 0000000 00000000122 14611320214 0036606 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-non-relative-path-inferred-type {
"extends": "../tsconfig.json",
"compilerOptions": {
"baseUrl": "./src"
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types-cause-reference-types/ 0000775 0000000 0000000 00000000000 14611320214 0033413 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000355 14611320214 0035154 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types-cause-reference-types import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
allowedTypesLibraries: ['node', 'fake-types-lib-2'],
importedLibraries: ['events', 'fake-types-lib-2.5'],
},
};
export = config;
extended-data.ts 0000664 0000000 0000000 00000000226 14611320214 0036413 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types-cause-reference-types ///
import { Data } from 'fake-types-lib-2.5';
export interface ExtendedData extends Data {}
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035732 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types-cause-reference-types require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000276 14611320214 0035050 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types-cause-reference-types ///
import { EventEmitter } from 'events';
export class MyEventEmitter extends EventEmitter { }
export { ExtendedData } from './extended-data';
output.d.ts 0000664 0000000 0000000 00000000426 14611320214 0035470 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types-cause-reference-types ///
///
import { EventEmitter } from 'events';
import { Data } from 'fake-types-lib-2.5';
export interface ExtendedData extends Data {
}
export declare class MyEventEmitter extends EventEmitter {
}
export {};
tsconfig.json 0000664 0000000 0000000 00000000211 14611320214 0036035 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types-cause-reference-types {
"extends": "../tsconfig.json",
"compilerOptions": {
"types": []
},
"include": [
"inputs.ts"
],
"exclude": [
"**/*.js"
]
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types/ 0000775 0000000 0000000 00000000000 14611320214 0027217 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types/config.ts 0000664 0000000 0000000 00000000256 14611320214 0031037 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
importedLibraries: ['fs', 'fake-types-lib'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031615 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types/input.ts 0000664 0000000 0000000 00000000255 14611320214 0030730 0 ustar 00root root 0000000 0000000 import { InterfaceFromTypesPackage } from 'fake-types-lib';
import { Stats } from 'fs';
export interface InterfaceName {
prop: Stats;
field: InterfaceFromTypesPackage;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types/output.d.ts 0000664 0000000 0000000 00000000331 14611320214 0031346 0 ustar 00root root 0000000 0000000 ///
import { InterfaceFromTypesPackage } from 'fake-types-lib';
import { Stats } from 'fs';
export interface InterfaceName {
prop: Stats;
field: InterfaceFromTypesPackage;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-from-types/tsconfig.json 0000664 0000000 0000000 00000000121 14611320214 0031720 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"types": ["node"]
}
}
import-package-with-declaration-merging-with-default-lib/ 0000775 0000000 0000000 00000000000 14611320214 0036447 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000252 14611320214 0040263 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-package-with-declaration-merging-with-default-lib import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
importedLibraries: ['fake-types-lib-3'],
},
};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0041045 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-package-with-declaration-merging-with-default-lib require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000130 14611320214 0040150 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-package-with-declaration-merging-with-default-lib import { FooBar } from 'fake-types-lib-3';
export type Baz = FooBar;
output.d.ts 0000664 0000000 0000000 00000000144 14611320214 0040600 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-package-with-declaration-merging-with-default-lib import { FooBar } from 'fake-types-lib-3';
export type Baz = FooBar;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-star-from-local-module/ 0000775 0000000 0000000 00000000000 14611320214 0031377 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-star-from-local-module/config.ts 0000664 0000000 0000000 00000000172 14611320214 0033214 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-star-from-local-module/func.ts 0000664 0000000 0000000 00000000040 14611320214 0032674 0 ustar 00root root 0000000 0000000 export function func(): void {}
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033716 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-star-from-local-module require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-star-from-local-module/input.ts 0000664 0000000 0000000 00000000067 14611320214 0033111 0 ustar 00root root 0000000 0000000 import * as lib from './func';
export const Lib = lib;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-star-from-local-module/output.d.ts 0000664 0000000 0000000 00000000176 14611320214 0033535 0 ustar 00root root 0000000 0000000 declare function func(): void;
export declare const Lib: typeof lib;
declare namespace lib {
export { func };
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-type-from-deps/ 0000775 0000000 0000000 00000000000 14611320214 0027765 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-type-from-deps/config.ts 0000664 0000000 0000000 00000000155 14611320214 0031603 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-type-from-deps/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032363 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-type-from-deps/input.ts 0000664 0000000 0000000 00000000260 14611320214 0031472 0 ustar 00root root 0000000 0000000 import { InterfaceWithFields } from 'fake-package';
import { FakePackageType } from './module-with-import-type';
export type TestType = InterfaceWithFields | FakePackageType;
module-with-import-type.d.ts 0000664 0000000 0000000 00000000250 14611320214 0035222 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-type-from-deps // yes, these tabs are here on purpose
import { type InterfaceWithFields } from 'fake-package';
export declare type FakePackageType = InterfaceWithFields | string;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-type-from-deps/output.d.ts 0000664 0000000 0000000 00000000303 14611320214 0032113 0 ustar 00root root 0000000 0000000 import { InterfaceWithFields } from 'fake-package';
export declare type FakePackageType = InterfaceWithFields | string;
export type TestType = InterfaceWithFields | FakePackageType;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-variables/ 0000775 0000000 0000000 00000000000 14611320214 0027062 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-variables/config.ts 0000664 0000000 0000000 00000000172 14611320214 0030677 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-variables/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031460 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-variables/input.ts 0000664 0000000 0000000 00000000356 14611320214 0030575 0 ustar 00root root 0000000 0000000 import { declaredVariable, declaredVariable2, variable, variable2 } from 'package-with-typings';
export const myVar: typeof variable | typeof variable2 = 1;
export const myVar2: typeof declaredVariable | typeof declaredVariable2 = null;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-variables/output.d.ts 0000664 0000000 0000000 00000000377 14611320214 0031223 0 ustar 00root root 0000000 0000000 import { declaredVariable, declaredVariable2, variable, variable2 } from 'package-with-typings';
export declare const myVar: typeof variable | typeof variable2;
export declare const myVar2: typeof declaredVariable | typeof declaredVariable2;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-with-different-names/ 0000775 0000000 0000000 00000000000 14611320214 0031132 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-with-different-names/config.ts 0000664 0000000 0000000 00000000300 14611320214 0032740 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
importedLibraries: ['fake-package', 'package-with-export-eq'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-with-different-names/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033530 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-with-different-names/input.ts 0000664 0000000 0000000 00000000605 14611320214 0032642 0 ustar 00root root 0000000 0000000 import fakePackage1 from 'fake-package';
import * as fakePackage2 from 'fake-package';
import fakePackage3 = require('fake-package');
import { ExposedInterface } from './other-module';
export interface First extends fakePackage1.Interface {}
export interface Second extends fakePackage2.Interface {}
export interface Third extends fakePackage3.Interface {}
export { ExposedInterface };
other-module.ts 0000664 0000000 0000000 00000000536 14611320214 0034033 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-with-different-names import fakePackageDifferentNameThatShouldNotBeAddedToOutput = require('fake-package');
import PackageWithExportEq = require('package-with-export-eq');
export interface OtherInternalInterface extends fakePackageDifferentNameThatShouldNotBeAddedToOutput.Interface {}
export interface ExposedInterface extends PackageWithExportEq.SomeCoolInterface {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-with-different-names/output.d.ts 0000664 0000000 0000000 00000000726 14611320214 0033271 0 ustar 00root root 0000000 0000000 import * as fakePackage2 from 'fake-package';
import fakePackage3 = require('fake-package');
import fakePackage1 from 'fake-package';
import PackageWithExportEq = require('package-with-export-eq');
export interface ExposedInterface extends PackageWithExportEq.SomeCoolInterface {
}
export interface First extends fakePackage1.Interface {
}
export interface Second extends fakePackage2.Interface {
}
export interface Third extends fakePackage3.Interface {
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/import-with-different-names/tsconfig.json 0000664 0000000 0000000 00000000177 14611320214 0033646 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"allowSyntheticDefaultImports": true,
"esModuleInterop": true
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/include-exclude-in-tsconfig/ 0000775 0000000 0000000 00000000000 14611320214 0031072 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/include-exclude-in-tsconfig/config.ts 0000664 0000000 0000000 00000000154 14611320214 0032707 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/include-exclude-in-tsconfig/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033470 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/include-exclude-in-tsconfig/input.ts 0000664 0000000 0000000 00000000035 14611320214 0032577 0 ustar 00root root 0000000 0000000 export type FooBar = number;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/include-exclude-in-tsconfig/output.d.ts 0000664 0000000 0000000 00000000051 14611320214 0033220 0 ustar 00root root 0000000 0000000 export type FooBar = number;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/include-exclude-in-tsconfig/tsconfig.json 0000664 0000000 0000000 00000000230 14611320214 0033574 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"preserveConstEnums": true
},
"include": [
"inputs.ts"
],
"exclude": [
"**/*.js"
]
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-declare-global/ 0000775 0000000 0000000 00000000000 14611320214 0027713 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-declare-global/config.ts 0000664 0000000 0000000 00000000250 14611320214 0031525 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {
output: {
inlineDeclareGlobals: true,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-declare-global/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032311 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-declare-global/input.ts 0000664 0000000 0000000 00000000322 14611320214 0031417 0 ustar 00root root 0000000 0000000 // this case comes from rxjs
declare global {
interface SymbolConstructor {
readonly observable: symbol;
}
}
export const observable = typeof Symbol === 'function' && Symbol.observable || '@@observable';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-declare-global/output.d.ts 0000664 0000000 0000000 00000000244 14611320214 0032045 0 ustar 00root root 0000000 0000000 declare global {
interface SymbolConstructor {
readonly observable: symbol;
}
}
export declare const observable: string | typeof Symbol.observable;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps-transitive/ 0000775 0000000 0000000 00000000000 14611320214 0031140 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps-transitive/config.ts 0000664 0000000 0000000 00000000321 14611320214 0032751 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
inlinedLibraries: ['fake-package', 'fake-fs'],
},
output: {
sortNodes: true,
}
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps-transitive/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033536 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps-transitive/input.ts 0000664 0000000 0000000 00000000124 14611320214 0032644 0 ustar 00root root 0000000 0000000 export { InterfaceWithFields } from 'fake-package';
export { File } from 'fake-fs';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps-transitive/output.d.ts 0000664 0000000 0000000 00000000504 14611320214 0033271 0 ustar 00root root 0000000 0000000 import { Path } from 'fake-path';
import { InterfaceFromTypesPackage } from 'fake-types-lib';
export interface File {
path: Path;
}
export interface Interface {
}
export interface InterfaceWithFields {
field: Type;
field2: Interface;
field3: InterfaceFromTypesPackage;
}
export type Type = number | string;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps-transitive/tsconfig.json 0000664 0000000 0000000 00000000126 14611320214 0033646 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"types": ["fake-node"]
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps/ 0000775 0000000 0000000 00000000000 14611320214 0026752 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps/config.ts 0000664 0000000 0000000 00000000271 14611320214 0030567 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
inlinedLibraries: ['fake-package', 'fake-types-lib-2'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031350 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps/input.ts 0000664 0000000 0000000 00000000510 14611320214 0030455 0 ustar 00root root 0000000 0000000 import { Interface, Type, ModuleWithoutQuotes } from 'fake-package';
import { Derived } from 'fake-types-lib-2';
import { SomeClass } from 'fake-package/some-class';
export type TestType = Interface | Type;
export class MyClass extends SomeClass {}
export type ReExportedTypes = Derived;
export type T = ModuleWithoutQuotes.A;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-from-deps/output.d.ts 0000664 0000000 0000000 00000000730 14611320214 0031104 0 ustar 00root root 0000000 0000000 export interface Interface {
}
export type Type = number | string;
declare module ModuleWithoutQuotes {
export type A = string;
}
export interface Base {
id: string;
}
export interface Derived extends Base {
name: string;
}
declare class SomeClass {
private x;
public constructor();
}
export type TestType = Interface | Type;
export declare class MyClass extends SomeClass {
}
export type ReExportedTypes = Derived;
export type T = ModuleWithoutQuotes.A;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-package-with-namespaced-import/ 0000775 0000000 0000000 00000000000 14611320214 0033030 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000263 14611320214 0034567 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-package-with-namespaced-import import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {
libraries: {
inlinedLibraries: ['fake-package'],
},
};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035347 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-package-with-namespaced-import require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000131 14611320214 0034453 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-package-with-namespaced-import import { namespacedImportTypes } from 'fake-package';
export { namespacedImportTypes };
output.d.ts 0000664 0000000 0000000 00000000175 14611320214 0035106 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/inline-package-with-namespaced-import import * as namespacedImportTypes from 'package-with-namespaced-re-export';
export {
namespacedImportTypes,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/labelled-tuples/ 0000775 0000000 0000000 00000000000 14611320214 0026660 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/labelled-tuples/config.ts 0000664 0000000 0000000 00000000154 14611320214 0030475 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/labelled-tuples/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031256 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/labelled-tuples/input.ts 0000664 0000000 0000000 00000000144 14611320214 0030366 0 ustar 00root root 0000000 0000000 interface Interface {
foo: number;
}
export const a: [x: Interface, y: number] = [{ foo: 1 }, 2];
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/labelled-tuples/output.d.ts 0000664 0000000 0000000 00000000160 14611320214 0031007 0 ustar 00root root 0000000 0000000 export interface Interface {
foo: number;
}
export declare const a: [
x: Interface,
y: number
];
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-namespaces/ 0000775 0000000 0000000 00000000000 14611320214 0027162 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-namespaces/config.ts 0000664 0000000 0000000 00000000253 14611320214 0030777 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
inlinedLibraries: ['extensions-package'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-namespaces/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031560 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-namespaces/input.ts 0000664 0000000 0000000 00000000422 14611320214 0030667 0 ustar 00root root 0000000 0000000 import { Ns1 as F1Ns1 } from './ns1';
import { Ns1 as F2Ns1 } from './ns2';
export {
Ns1 as F1Ns1,
Ns2 as F1Ns2,
} from './ns1';
export {
Ns1 as F2Ns1,
Ns2 as F2Ns2,
} from './ns2';
export interface Int {
f1: F1Ns1.SubNs1.Interface1;
f2: F2Ns1.SubNs1.Interface1;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-namespaces/ns1.ts 0000664 0000000 0000000 00000000753 14611320214 0030240 0 ustar 00root root 0000000 0000000 export type FooBar = string;
export namespace Ns1 {
export namespace SubNs1 {
export interface Interface1 {
field1: FooBar;
}
}
}
export namespace Ns1 {
export namespace SubNs1 {
export interface Interface2 {
field1: FooBar;
}
}
}
export module Ns2 {
export module SubNs1 {
export interface Interface1 {
field1: Ns1.SubNs1.Interface1;
}
}
}
export module Ns2 {
export module SubNs1 {
export interface Interface2 {
field1: Ns1.SubNs1.Interface2;
}
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-namespaces/ns2.ts 0000664 0000000 0000000 00000000753 14611320214 0030241 0 ustar 00root root 0000000 0000000 export type FooBar = number;
export namespace Ns1 {
export namespace SubNs1 {
export interface Interface1 {
field1: FooBar;
}
}
}
export namespace Ns1 {
export namespace SubNs1 {
export interface Interface2 {
field1: FooBar;
}
}
}
export module Ns2 {
export module SubNs1 {
export interface Interface1 {
field1: Ns1.SubNs1.Interface1;
}
}
}
export module Ns2 {
export module SubNs1 {
export interface Interface2 {
field1: Ns1.SubNs1.Interface2;
}
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-namespaces/output.d.ts 0000664 0000000 0000000 00000002065 14611320214 0031317 0 ustar 00root root 0000000 0000000 export type FooBar = string;
declare namespace Ns1 {
namespace SubNs1 {
interface Interface1 {
field1: FooBar;
}
}
}
declare namespace Ns1 {
namespace SubNs1 {
interface Interface2 {
field1: FooBar;
}
}
}
declare namespace Ns2 {
namespace SubNs1 {
interface Interface1 {
field1: Ns1.SubNs1.Interface1;
}
}
}
declare namespace Ns2 {
namespace SubNs1 {
interface Interface2 {
field1: Ns1.SubNs1.Interface2;
}
}
}
type FooBar$1 = number;
declare namespace Ns1$1 {
namespace SubNs1 {
interface Interface1 {
field1: FooBar$1;
}
}
}
declare namespace Ns1$1 {
namespace SubNs1 {
interface Interface2 {
field1: FooBar$1;
}
}
}
declare namespace Ns2$1 {
namespace SubNs1 {
interface Interface1 {
field1: Ns1$1.SubNs1.Interface1;
}
}
}
declare namespace Ns2$1 {
namespace SubNs1 {
interface Interface2 {
field1: Ns1$1.SubNs1.Interface2;
}
}
}
export interface Int {
f1: Ns1.SubNs1.Interface1;
f2: Ns1$1.SubNs1.Interface1;
}
export {
Ns1 as F1Ns1,
Ns1$1 as F2Ns1,
Ns2 as F1Ns2,
Ns2$1 as F2Ns2,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-symbols/ 0000775 0000000 0000000 00000000000 14611320214 0026533 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-symbols/config.ts 0000664 0000000 0000000 00000000253 14611320214 0030350 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
inlinedLibraries: ['extensions-package'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-symbols/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031131 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-symbols/input.ts 0000664 0000000 0000000 00000000044 14611320214 0030240 0 ustar 00root root 0000000 0000000 export * from 'extensions-package';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/merged-symbols/output.d.ts 0000664 0000000 0000000 00000000013 14611320214 0030657 0 ustar 00root root 0000000 0000000 export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mixed-imports/ 0000775 0000000 0000000 00000000000 14611320214 0026403 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mixed-imports/config.ts 0000664 0000000 0000000 00000000172 14611320214 0030220 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mixed-imports/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031001 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mixed-imports/input.ts 0000664 0000000 0000000 00000001556 14611320214 0030121 0 ustar 00root root 0000000 0000000 import DefaultClass, { NonDefaultInterface } from 'package-with-default-export';
import { default as RenamedDefaultClass, NonDefaultInterface as RenamedInterface } from 'package-with-default-export';
import * as wholePackage from 'package-with-default-export';
import defaultImportedNamespace from 'package-with-default-export/namespace';
import defaultImportedNamespace2, * as starImportNameModule from 'package-with-default-export/namespace';
import * as unusedStarImport from 'package-with-default-export/namespace';
console.log(typeof unusedStarImport);
export interface ExportedInterface {
field1: typeof DefaultClass;
field2: NonDefaultInterface;
field3: typeof RenamedDefaultClass;
field4: RenamedInterface;
field5: typeof wholePackage;
field6: defaultImportedNamespace.Options;
field7: defaultImportedNamespace2.Options;
field8: typeof starImportNameModule;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mixed-imports/output.d.ts 0000664 0000000 0000000 00000001470 14611320214 0030537 0 ustar 00root root 0000000 0000000 import * as wholePackage from 'package-with-default-export';
import DefaultClass from 'package-with-default-export';
import { NonDefaultInterface, NonDefaultInterface as RenamedInterface, default as RenamedDefaultClass } from 'package-with-default-export';
import * as starImportNameModule from 'package-with-default-export/namespace';
import defaultImportedNamespace from 'package-with-default-export/namespace';
import defaultImportedNamespace2 from 'package-with-default-export/namespace';
export interface ExportedInterface {
field1: typeof DefaultClass;
field2: NonDefaultInterface;
field3: typeof RenamedDefaultClass;
field4: RenamedInterface;
field5: typeof wholePackage;
field6: defaultImportedNamespace.Options;
field7: defaultImportedNamespace2.Options;
field8: typeof starImportNameModule;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mixed-imports/tsconfig.json 0000664 0000000 0000000 00000000121 14611320214 0031104 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"types": ["node"]
}
}
modules-in-internal-files-without-inline-declare-globals/ 0000775 0000000 0000000 00000000000 14611320214 0036504 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases .gitignore 0000664 0000000 0000000 00000000042 14611320214 0040470 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/modules-in-internal-files-without-inline-declare-globals !/ambient-module-declaration.d.ts
ambient-module-declaration.d.ts 0000664 0000000 0000000 00000000044 14611320214 0044461 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/modules-in-internal-files-without-inline-declare-globals declare module 'ambient-module' {
}
config.ts 0000664 0000000 0000000 00000000172 14611320214 0040321 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/modules-in-internal-files-without-inline-declare-globals import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0041102 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/modules-in-internal-files-without-inline-declare-globals require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000637 14611320214 0040221 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/modules-in-internal-files-without-inline-declare-globals // this test case comes from Dexie.js
///
import { Interface, ExportedModule } from './interface';
export interface InterfaceInternal extends Interface {}
declare module ModuleName {
export interface Interface extends InterfaceInternal {}
export type Bar = ExportedModule.Foo;
}
declare var ModuleName: { prototype: Interface };
export { ModuleName };
interface.ts 0000664 0000000 0000000 00000000157 14611320214 0041017 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/modules-in-internal-files-without-inline-declare-globals export interface Interface {
field: Interface;
}
export module ExportedModule {
export type Foo = string;
}
output.d.ts 0000664 0000000 0000000 00000000547 14611320214 0040644 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/modules-in-internal-files-without-inline-declare-globals export interface Interface {
field: Interface;
}
declare namespace ExportedModule {
type Foo = string;
}
export interface InterfaceInternal extends Interface {
}
export declare namespace ModuleName {
interface Interface extends InterfaceInternal {
}
type Bar = ExportedModule.Foo;
}
export declare var ModuleName: {
prototype: Interface;
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mts-extension/ 0000775 0000000 0000000 00000000000 14611320214 0026417 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mts-extension/config.ts 0000664 0000000 0000000 00000000172 14611320214 0030234 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mts-extension/decl.d.mts 0000664 0000000 0000000 00000000033 14611320214 0030271 0 ustar 00root root 0000000 0000000 export type Decl = string;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mts-extension/file.mts 0000664 0000000 0000000 00000000036 14611320214 0030062 0 ustar 00root root 0000000 0000000 export interface Interface {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mts-extension/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031015 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mts-extension/input.mts 0000664 0000000 0000000 00000000221 14611320214 0030276 0 ustar 00root root 0000000 0000000 import { Interface } from './file.mjs';
import { Decl } from './decl.mjs';
export interface ExportedInterface extends Interface {
foo: Decl;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/mts-extension/output.d.ts 0000664 0000000 0000000 00000000213 14611320214 0030545 0 ustar 00root root 0000000 0000000 export interface Interface {
}
export type Decl = string;
export interface ExportedInterface extends Interface {
foo: Decl;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/ 0000775 0000000 0000000 00000000000 14611320214 0031266 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/config.ts 0000664 0000000 0000000 00000000155 14611320214 0033104 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/export-eq.ts 0000664 0000000 0000000 00000001324 14611320214 0033562 0 ustar 00root root 0000000 0000000 namespace ExportEqNs {
export namespace InternalNs {
export type NewType = string;
}
export type Bar = ExportEqNs.Foo;
export type Foo = String;
export namespace InternalNs2 {
export type Type21 = InternalNs3.Type31;
export type Type22 = InternalNs2.InternalNs3.Type31;
export type Type23 = ExportEqNs.InternalNs2.InternalNs3.Type31;
export namespace InternalNs3 {
export type Type31 = InternalNs4.Type;
export type Type32 = InternalNs3.InternalNs4.Type;
export type Type33 = InternalNs2.InternalNs3.InternalNs4.Type;
export type Type34 = ExportEqNs.InternalNs2.InternalNs3.InternalNs4.Type;
export namespace InternalNs4 {
export type Type = string;
}
}
}
}
export = ExportEqNs;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/file1.ts 0000664 0000000 0000000 00000000737 14611320214 0032645 0 ustar 00root root 0000000 0000000 const TEMPLATE = 'template1';
export default TEMPLATE;
export const MergedSymbol = '';
export var Variable = 1;
export interface MergedSymbol {
test(): void
};
export interface Interface {
field1: number;
}
export function func(one: number) {}
export type TypeName = Pick;
export interface AnotherInterface {
field1: number;
}
export function anotherFunc(one: NamespaceName.Local) {}
export namespace NamespaceName {
export interface Local {}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/file2.ts 0000664 0000000 0000000 00000001124 14611320214 0032635 0 ustar 00root root 0000000 0000000 const TEMPLATE = 'template2';
export default TEMPLATE;
export const MergedSymbol = '';
export var Variable = '';
export interface MergedSymbol {
test(): void
};
export interface Interface {
field2: number;
}
export function func(two: number) {}
export type TypeName = Pick;
/** Another interface doc string */
export interface AnotherInterface {
field2: number;
}
/** Another func doc string */
export function anotherFunc(two: NamespaceName.Local) {}
export namespace NamespaceName {
export interface Local {}
}
export interface ExportedButNotUsedInterface {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/file3.ts 0000664 0000000 0000000 00000000123 14611320214 0032634 0 ustar 00root root 0000000 0000000 interface DefaultInterface {
field10: number;
}
export default DefaultInterface;
import-star-1.ts 0000664 0000000 0000000 00000000754 14611320214 0034204 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files import * as fakePackage from 'fake-package';
import { Interface as FPI1, Interface } from 'fake-package';
import * as file1 from './file1';
import * as file1ButDifferent from './file1';
import { AnotherInterface as AiFromFile1 } from './file1';
import * as file2 from './file2';
export interface Inter {
field: file1.Interface;
field2: file2.AnotherInterface;
field3: file1ButDifferent.TypeName;
field4: AiFromFile1;
field5: fakePackage.Interface;
field6: FPI1;
field7: Interface;
}
import-star-2.ts 0000664 0000000 0000000 00000001077 14611320214 0034204 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files import * as fakePackageButDifferent from 'fake-package';
import { Interface as FPI2, Interface } from 'fake-package';
import * as file1 from './file1';
import * as file1ButDifferent from './file1';
import { AnotherInterface as AiFromFile1 } from './file1';
import * as file2 from './file2';
import * as file3 from './file3';
export interface Inter2 {
field: file1.Interface;
field2: file2.AnotherInterface;
field3: file1ButDifferent.TypeName;
field4: AiFromFile1;
field5: fakePackageButDifferent.Interface;
field6: FPI2;
field7: Interface;
field8: file3.default;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/index.spec.js0000664 0000000 0000000 00000000064 14611320214 0033664 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/input.ts 0000664 0000000 0000000 00000001457 14611320214 0033004 0 ustar 00root root 0000000 0000000 import { ExportEqNs } from './ns';
import { InternalNs } from './export-eq';
export type ExportedNsType = InternalNs.NewType;
export {
default as TEMPLATE1,
MergedSymbol as MS1,
Interface as I1,
TypeName as T1,
func as f1,
NamespaceName as NS1,
Variable as V1,
// rename these to include them into import
AnotherInterface as AI1,
anotherFunc as af1,
} from './file1';
export {
default as TEMPLATE2,
MergedSymbol as MS2,
Interface as I2,
TypeName as T2,
func as f2,
NamespaceName as NS2,
Variable as V2,
// yes, keep these without renaming so we can check that these aren't exported with wrong names
AnotherInterface,
anotherFunc,
} from './file2';
export { Inter } from './import-star-1';
export { Inter2 } from './import-star-2';
export { MyType } from './type';
export { ExportEqNs };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/ns.ts 0000664 0000000 0000000 00000000041 14611320214 0032251 0 ustar 00root root 0000000 0000000 export type ExportEqNs = string;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/output.d.ts 0000664 0000000 0000000 00000005256 14611320214 0033430 0 ustar 00root root 0000000 0000000 import * as fakePackage from 'fake-package';
import { Interface as FPI1, Interface as FPI2, Interface as Interface$2 } from 'fake-package';
export type ExportEqNs = string;
declare namespace ExportEqNs$1 {
namespace InternalNs {
type NewType = string;
}
type Bar = ExportEqNs$1.Foo;
type Foo = String;
namespace InternalNs2 {
type Type21 = InternalNs3.Type31;
type Type22 = InternalNs2.InternalNs3.Type31;
type Type23 = ExportEqNs$1.InternalNs2.InternalNs3.Type31;
namespace InternalNs3 {
type Type31 = InternalNs4.Type;
type Type32 = InternalNs3.InternalNs4.Type;
type Type33 = InternalNs2.InternalNs3.InternalNs4.Type;
type Type34 = ExportEqNs$1.InternalNs2.InternalNs3.InternalNs4.Type;
namespace InternalNs4 {
type Type = string;
}
}
}
}
declare const TEMPLATE = "template1";
declare const MergedSymbol = "";
declare var Variable: number;
interface MergedSymbol {
test(): void;
}
interface Interface {
field1: number;
}
declare function func(one: number): void;
type TypeName = Pick;
interface AnotherInterface {
field1: number;
}
declare function anotherFunc(one: NamespaceName.Local): void;
declare namespace NamespaceName {
interface Local {
}
}
declare const TEMPLATE$1 = "template2";
declare const MergedSymbol$1 = "";
declare var Variable$1: string;
interface MergedSymbol$1 {
test(): void;
}
interface Interface$1 {
field2: number;
}
declare function func$1(two: number): void;
type TypeName$1 = Pick;
/** Another interface doc string */
interface AnotherInterface$1 {
field2: number;
}
/** Another func doc string */
declare function anotherFunc$1(two: NamespaceName$1.Local): void;
declare namespace NamespaceName$1 {
interface Local {
}
}
export interface Inter {
field: Interface;
field2: AnotherInterface$1;
field3: TypeName;
field4: AnotherInterface;
field5: fakePackage.Interface;
field6: FPI1;
field7: Interface$2;
}
export interface DefaultInterface {
field10: number;
}
export interface Inter2 {
field: Interface;
field2: AnotherInterface$1;
field3: TypeName;
field4: AnotherInterface;
field5: fakePackage.Interface;
field6: FPI2;
field7: Interface$2;
field8: DefaultInterface;
}
export type MyType = Interface$2;
export type ExportedNsType = ExportEqNs$1.InternalNs.NewType;
export {
AnotherInterface as AI1,
AnotherInterface$1 as AnotherInterface,
Interface as I1,
Interface$1 as I2,
MergedSymbol as MS1,
MergedSymbol$1 as MS2,
NamespaceName as NS1,
NamespaceName$1 as NS2,
TEMPLATE as TEMPLATE1,
TEMPLATE$1 as TEMPLATE2,
TypeName as T1,
TypeName$1 as T2,
Variable as V1,
Variable$1 as V2,
anotherFunc as af1,
anotherFunc$1 as anotherFunc,
func as f1,
func$1 as f2,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-across-files/type.ts 0000664 0000000 0000000 00000000113 14611320214 0032612 0 ustar 00root root 0000000 0000000 import { Interface } from 'fake-package';
export type MyType = Interface;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-with-globals/ 0000775 0000000 0000000 00000000000 14611320214 0031270 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-with-globals/config.ts 0000664 0000000 0000000 00000000155 14611320214 0033106 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-with-globals/index.spec.js0000664 0000000 0000000 00000000064 14611320214 0033666 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-with-globals/input.ts 0000664 0000000 0000000 00000000275 14611320214 0033003 0 ustar 00root root 0000000 0000000 import { Date as LocalDate, Promise as LocalPromise } from './local-types';
export interface Int {
localD: LocalDate;
globalD: Date;
localP: LocalPromise;
globalP: Promise;
}
local-types.ts 0000664 0000000 0000000 00000000333 14611320214 0034014 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-with-globals declare global {
// adding some global types to check that collisions mechanism works
type Promise$1 = string;
type Promise$2 = string;
type Date$1 = string;
}
export interface Promise {}
export interface Date {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/names-collision-with-globals/output.d.ts 0000664 0000000 0000000 00000000242 14611320214 0033420 0 ustar 00root root 0000000 0000000 interface Promise$3 {
}
interface Date$2 {
}
export interface Int {
localD: Date$2;
globalD: Date;
localP: Promise$3;
globalP: Promise;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/namespaced-import/ 0000775 0000000 0000000 00000000000 14611320214 0027212 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/namespaced-import/config.ts 0000664 0000000 0000000 00000000172 14611320214 0031027 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/namespaced-import/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031610 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/namespaced-import/input.ts 0000664 0000000 0000000 00000000246 14611320214 0030723 0 ustar 00root root 0000000 0000000 import * as fakePackage from 'fake-package';
export declare class MyClass {
static func(): fakePackage.InterfaceWithFields;
static field: fakePackage.Interface;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/namespaced-import/output.d.ts 0000664 0000000 0000000 00000000262 14611320214 0031344 0 ustar 00root root 0000000 0000000 import * as fakePackage from 'fake-package';
export declare class MyClass {
static func(): fakePackage.InterfaceWithFields;
static field: fakePackage.Interface;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/namespaced-import/tsconfig.json 0000664 0000000 0000000 00000000121 14611320214 0031713 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"types": ["node"]
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/ 0000775 0000000 0000000 00000000000 14611320214 0026257 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/ 0000775 0000000 0000000 00000000000 14611320214 0027523 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/commander/ 0000775 0000000 0000000 00000000000 14611320214 0031470 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/commander/index.d.ts 0000664 0000000 0000000 00000000553 14611320214 0033374 0 ustar 00root root 0000000 0000000 declare namespace commander {
interface Option {}
interface OptionConstructor {
new(): Option;
}
interface Command {}
interface CommandConstructor {
new (): Command;
}
interface CommanderStatic extends Command {
Command: CommandConstructor;
Option: OptionConstructor;
}
}
declare const commander: commander.CommanderStatic;
export = commander;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/fake-node/ 0000775 0000000 0000000 00000000000 14611320214 0031354 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/fake-node/index.d.ts 0000664 0000000 0000000 00000000247 14611320214 0033260 0 ustar 00root root 0000000 0000000 declare module 'fake-fs' {
import { Path } from 'fake-path';
export interface File {
path: Path;
}
}
declare module 'fake-path' {
export type Path = string;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/fake-types-lib-2/ 0000775 0000000 0000000 00000000000 14611320214 0032476 5 ustar 00root root 0000000 0000000 index.d.ts 0000664 0000000 0000000 00000000506 14611320214 0034321 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/fake-types-lib-2 declare module 'fake-types-lib-2' {
export interface Data {
field: number;
method(): void;
}
export interface Base {
id: string;
}
export interface Derived extends Base {
name: string;
}
export function getData(): Data;
}
declare module 'fake-types-lib-2.5' {
export interface Data {
field: number;
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/fake-types-lib-3/ 0000775 0000000 0000000 00000000000 14611320214 0032477 5 ustar 00root root 0000000 0000000 global.d.ts 0000664 0000000 0000000 00000000036 14611320214 0034451 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/fake-types-lib-3 interface ArrayConstructor {}
index.d.ts 0000664 0000000 0000000 00000000273 14611320214 0034323 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/fake-types-lib-3 ///
declare namespace FakePackage3 {
export interface FooBar {}
}
export = FakePackage3;
export as namespace FakePackage3;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/fake-types-lib/ 0000775 0000000 0000000 00000000000 14611320214 0032337 5 ustar 00root root 0000000 0000000 index.d.ts 0000664 0000000 0000000 00000000152 14611320214 0034157 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/fake-types-lib export interface InterfaceFromTypesPackage {
field: string;
field2: number;
field3: string | number;
}
package-that-defines-other-packages/ 0000775 0000000 0000000 00000000000 14611320214 0036303 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types index.d.ts 0000664 0000000 0000000 00000003315 14611320214 0040206 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/package-that-defines-other-packages declare module 're-export-via-eq-internal' {
export interface FooBar {}
export namespace FooBar {
export type Type = number;
}
}
declare module 're-export-via-eq' {
import types = require('re-export-via-eq-internal');
export = types;
}
// -----------------------------------------------------------------------------
declare module 're-export-via-eq-v2-internal' {
interface FooBar {}
namespace FooBar {
export type Type = number;
}
export = FooBar;
}
declare module 're-export-via-eq-v2' {
import types = require('re-export-via-eq-v2-internal');
export = types;
}
// -----------------------------------------------------------------------------
declare module 're-export-via-star-internal' {
export interface FooBar {}
}
declare module 're-export-via-star' {
export * from 're-export-via-star-internal';
}
// -----------------------------------------------------------------------------
declare module 're-export-via-star-with-rename-internal' {
export interface FooBar {}
}
declare module 're-export-via-star-with-rename' {
export * as NsName from 're-export-via-star-with-rename-internal';
}
// -----------------------------------------------------------------------------
declare module 're-export-via-import-internal' {
export interface FooBar {}
}
declare module 're-export-via-import' {
import { FooBar } from 're-export-via-import-internal';
export { FooBar };
}
// -----------------------------------------------------------------------------
declare module 're-export-cycle-dependency-1' {
export interface FooBar {}
export * from 're-export-cycle-dependency-2';
}
declare module 're-export-cycle-dependency-2' {
export interface BarFoo {}
export * from 're-export-cycle-dependency-1';
}
package-with-export-eq-variable/ 0000775 0000000 0000000 00000000000 14611320214 0035515 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types index.d.ts 0000664 0000000 0000000 00000000216 14611320214 0037415 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/@types/package-with-export-eq-variable interface LibInterface {
field: number;
}
declare module 'package-with-export-eq-variable' {
const myLib: LibInterface;
export = myLib;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/README.md 0000664 0000000 0000000 00000000245 14611320214 0027537 0 ustar 00root root 0000000 0000000 # BEWARE
Actually this folder is **not** node_modules from `npm` - it is just mock to use modules from "node_modules" without installing any additional package(s).
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/extensions-package/ 0000775 0000000 0000000 00000000000 14611320214 0032047 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/extensions-package/index.d.ts0000664 0000000 0000000 00000000024 14611320214 0033744 0 ustar 00root root 0000000 0000000 import './plugins';
node_modules/ 0000775 0000000 0000000 00000000000 14611320214 0034445 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/extensions-package plugins-package/ 0000775 0000000 0000000 00000000000 14611320214 0037517 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/extensions-package/node_modules index.d.ts 0000664 0000000 0000000 00000000254 14611320214 0041421 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/extensions-package/node_modules/plugins-package declare const mergeName: mergeName.mergedName;
declare namespace mergeName {
export interface mergedName {}
export interface OtherType {}
}
export { mergeName };
plugins.d.ts 0000664 0000000 0000000 00000000346 14611320214 0034246 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/extensions-package import { mergeName } from 'plugins-package';
declare module 'plugins-package' {
namespace mergeName {
type A = string;
}
}
declare module 'plugins-package/foobar' {
export function foobar(val: mergeName.OtherType): void;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/fake-package/ 0000775 0000000 0000000 00000000000 14611320214 0030556 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/fake-package/index.d.ts 0000664 0000000 0000000 00000000637 14611320214 0032465 0 ustar 00root root 0000000 0000000 import { InterfaceFromTypesPackage } from 'fake-types-lib';
import * as namespacedImportTypes from 'package-with-namespaced-re-export';
export interface Interface {}
export type Type = number | string;
export interface InterfaceWithFields {
field: Type;
field2: Interface;
field3: InterfaceFromTypesPackage;
}
export module ModuleWithoutQuotes {
export type A = string;
}
export { namespacedImportTypes };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/fake-package/some-class.d.ts 0000664 0000000 0000000 00000000076 14611320214 0033421 0 ustar 00root root 0000000 0000000 export class SomeClass {
private x;
public constructor();
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/ora/ 0000775 0000000 0000000 00000000000 14611320214 0027040 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/ora/index.d.ts 0000664 0000000 0000000 00000000167 14611320214 0030745 0 ustar 00root root 0000000 0000000 declare namespace ora {
interface Options { }
}
declare const ora: {
(options: ora.Options): any;
};
export = ora;
package-with-cyclic-re-export-1/ 0000775 0000000 0000000 00000000000 14611320214 0034071 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules index.d.ts 0000664 0000000 0000000 00000000130 14611320214 0035764 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-cyclic-re-export-1 export interface Package1Interface {}
export * from 'package-with-cyclic-re-export-2';
package-with-cyclic-re-export-2/ 0000775 0000000 0000000 00000000000 14611320214 0034072 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules index.d.ts 0000664 0000000 0000000 00000000130 14611320214 0035765 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-cyclic-re-export-2 export interface Package2Interface {}
export * from 'package-with-cyclic-re-export-1';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-default-export/ 0000775 0000000 0000000 00000000000 14611320214 0033564 5 ustar 00root root 0000000 0000000 index.d.ts 0000664 0000000 0000000 00000000157 14611320214 0035411 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-default-export export default class DefaultClass {
}
export interface NonDefaultInterface {}
export type JustType = string;
namespace.d.ts 0000664 0000000 0000000 00000000131 14611320214 0036226 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-default-export declare namespace NamespaceName {
interface Options {}
}
export default NamespaceName;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-export-eq/ 0000775 0000000 0000000 00000000000 14611320214 0032545 5 ustar 00root root 0000000 0000000 index.d.ts 0000664 0000000 0000000 00000000177 14611320214 0034374 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-export-eq declare namespace MyModule {
export interface SomeCoolInterface {
field: string;
field2: number;
}
}
export = MyModule;
package-with-namespaced-import-export/ 0000775 0000000 0000000 00000000000 14611320214 0035471 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules index.d.ts 0000664 0000000 0000000 00000000153 14611320214 0037371 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-namespaced-import-export import * as fp1 from 'package-with-default-export';
export { fp1 };
export * as fp2 from 'fake-package';
package-with-namespaced-re-export/ 0000775 0000000 0000000 00000000000 14611320214 0034565 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules index.d.ts 0000664 0000000 0000000 00000000130 14611320214 0036460 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-namespaced-re-export import * as types from './types';
export { types };
export * as types2 from './types';
types.d.ts 0000664 0000000 0000000 00000000052 14611320214 0036520 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-namespaced-re-export export interface Type {
field: number;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-re-exports/ 0000775 0000000 0000000 00000000000 14611320214 0032731 5 ustar 00root root 0000000 0000000 content.d.ts 0000664 0000000 0000000 00000000033 14611320214 0035112 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-re-exports export interface Foobar {}
index.d.ts 0000664 0000000 0000000 00000000250 14611320214 0034550 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-re-exports export * from './content';
export * as content from './content';
export { JustType as ReExportedName } from 'package-with-default-export';
export interface Barfoo {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-typings/ 0000775 0000000 0000000 00000000000 14611320214 0032316 5 ustar 00root root 0000000 0000000 index.d.ts 0000664 0000000 0000000 00000000275 14611320214 0034144 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/node_modules/package-with-typings export const variable: number, variable2: string, variable3: string | number;
export declare const declaredVariable: null, declaredVariable2: undefined, declaredVariable3: string | number;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/non-exported-abstract-class/ 0000775 0000000 0000000 00000000000 14611320214 0031130 5 ustar 00root root 0000000 0000000 abstract-class.d.ts 0000664 0000000 0000000 00000000050 14611320214 0034544 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/non-exported-abstract-class export abstract class AbstractClass {
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/non-exported-abstract-class/config.ts 0000664 0000000 0000000 00000000154 14611320214 0032745 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/non-exported-abstract-class/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033526 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/non-exported-abstract-class/input.ts 0000664 0000000 0000000 00000000147 14611320214 0032641 0 ustar 00root root 0000000 0000000 import { AbstractClass } from './abstract-class';
export class NormalClass extends AbstractClass {
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/non-exported-abstract-class/output.d.ts 0000664 0000000 0000000 00000000160 14611320214 0033257 0 ustar 00root root 0000000 0000000 declare abstract class AbstractClass {
}
export declare class NormalClass extends AbstractClass {
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/primitive-generation/ 0000775 0000000 0000000 00000000000 14611320214 0027743 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/primitive-generation/config.ts 0000664 0000000 0000000 00000000154 14611320214 0031560 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/primitive-generation/func.d.ts 0000664 0000000 0000000 00000000270 14611320214 0031467 0 ustar 00root root 0000000 0000000 export type TypeName = string | number;
export interface InterfaceName {
prop: number;
prop2: TypeName;
}
export declare function func2({ prop: prop3 }?: InterfaceName): TypeName;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/primitive-generation/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032341 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/primitive-generation/input.ts 0000664 0000000 0000000 00000000320 14611320214 0031445 0 ustar 00root root 0000000 0000000 import { InterfaceName, TypeName, func2 } from './func';
export function func({ prop }: InterfaceName = { prop: 1, prop2: 1 }): TypeName {
throw new Error('it does not matter' + prop);
}
export { func2 };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/primitive-generation/output.d.ts 0000664 0000000 0000000 00000000404 14611320214 0032073 0 ustar 00root root 0000000 0000000 export type TypeName = string | number;
export interface InterfaceName {
prop: number;
prop2: TypeName;
}
export declare function func2({ prop: prop3 }?: InterfaceName): TypeName;
export declare function func({ prop }?: InterfaceName): TypeName;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-default-of-unnamed-class/ 0000775 0000000 0000000 00000000000 14611320214 0032704 5 ustar 00root root 0000000 0000000 class.ts 0000664 0000000 0000000 00000000030 14611320214 0034273 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-default-of-unnamed-class export default class {}
config.ts 0000664 0000000 0000000 00000000172 14611320214 0034442 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-default-of-unnamed-class import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035223 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-default-of-unnamed-class require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000043 14611320214 0034331 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-default-of-unnamed-class export { default } from './class';
output.d.ts 0000664 0000000 0000000 00000000112 14611320214 0034751 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-default-of-unnamed-class declare class _default {
}
export {
_default as default,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-named-and-default/ 0000775 0000000 0000000 00000000000 14611320214 0031374 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-named-and-default/config.ts 0000664 0000000 0000000 00000000154 14611320214 0033211 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033713 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-named-and-default require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-named-and-default/input.ts 0000664 0000000 0000000 00000000103 14611320214 0033075 0 ustar 00root root 0000000 0000000 export { default } from './lib';
export { sayHello } from './lib';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-named-and-default/lib.ts 0000664 0000000 0000000 00000000157 14611320214 0032515 0 ustar 00root root 0000000 0000000 export const sayHello = (name: string) => {
console.log(`Hello there, ${name}!`);
}
export default sayHello;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-named-and-default/output.d.ts0000664 0000000 0000000 00000000146 14611320214 0033527 0 ustar 00root root 0000000 0000000 export declare const sayHello: (name: string) => void;
export {
sayHello as default,
};
export {};
tsconfig.json 0000664 0000000 0000000 00000000121 14611320214 0034016 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-named-and-default {
"extends": "../tsconfig.json",
"compilerOptions": {
"types": ["node"]
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-namespace/ 0000775 0000000 0000000 00000000000 14611320214 0030062 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-namespace/config.ts 0000664 0000000 0000000 00000000154 14611320214 0031677 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-namespace/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032460 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-namespace/input.ts 0000664 0000000 0000000 00000000101 14611320214 0031561 0 ustar 00root root 0000000 0000000 export * as Foobar from 'package-with-namespaced-import-export';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-as-namespace/output.d.ts 0000664 0000000 0000000 00000000143 14611320214 0032212 0 ustar 00root root 0000000 0000000 import * as Foobar from 'package-with-namespaced-import-export';
export {
Foobar,
};
export {};
re-export-default-export-as-default-export/ 0000775 0000000 0000000 00000000000 14611320214 0033753 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases config.ts 0000664 0000000 0000000 00000000154 14611320214 0035570 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-as-default-export import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0036351 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-as-default-export require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000045 14611320214 0035461 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-as-default-export export { default } from './math.js';
math.ts 0000664 0000000 0000000 00000000123 14611320214 0035250 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-as-default-export const subtract = (a: number, b: number): number => a - b;
export default subtract;
output.d.ts 0000664 0000000 0000000 00000000151 14611320214 0036102 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-as-default-export declare const subtract: (a: number, b: number) => number;
export {
subtract as default,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name/ 0000775 0000000 0000000 00000000000 14611320214 0033302 5 ustar 00root root 0000000 0000000 class-names/ 0000775 0000000 0000000 00000000000 14611320214 0035431 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name class-names.ts 0000664 0000000 0000000 00000000132 14611320214 0040203 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name/class-names export type ClassNamesFn = () => void;
export const classNames: ClassNamesFn = () => { };
index.ts 0000664 0000000 0000000 00000000107 14611320214 0037106 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name/class-names import { classNames } from './class-names';
export default classNames;
config.ts 0000664 0000000 0000000 00000000172 14611320214 0035040 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035621 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000154 14611320214 0034732 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name export { default as classNames } from './class-names';
export { default as isPromise } from './is-promise';
is-promise/ 0000775 0000000 0000000 00000000000 14611320214 0035312 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name index.ts 0000664 0000000 0000000 00000000104 14611320214 0036764 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name/is-promise import { isPromise } from './is-promise';
export default isPromise;
is-promise.ts 0000664 0000000 0000000 00000000117 14611320214 0037750 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name/is-promise export const isPromise: (value: unknown) => boolean = () => {
return false;
}
output.d.ts 0000664 0000000 0000000 00000000237 14611320214 0035357 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-default-export-with-same-name export type ClassNamesFn = () => void;
export declare const classNames: ClassNamesFn;
export declare const isPromise: (value: unknown) => boolean;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-importable-module/ 0000775 0000000 0000000 00000000000 14611320214 0032107 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-importable-module/class.ts 0000664 0000000 0000000 00000000040 14611320214 0033556 0 ustar 00root root 0000000 0000000 export default class MyClass {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-importable-module/config.ts0000664 0000000 0000000 00000000172 14611320214 0033724 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0034426 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-importable-module require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-importable-module/input.ts 0000664 0000000 0000000 00000001000 14611320214 0033605 0 ustar 00root root 0000000 0000000 export { Server } from 'http';
export * from 'fs';
export { SomeInterface } from './interface';
export { SomeInterface as Int1, AnotherInterface as Int2, default as DefInterface } from './interface';
export { constName as cName, letName as lName, funcName as fName, default as defFunction } from './variables';
export { default as MyClass } from './class';
export { default } from 'package-with-default-export';
import { NonDefaultInterface } from 'package-with-default-export';
export { NonDefaultInterface };
interface.ts 0000664 0000000 0000000 00000000252 14611320214 0034337 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-importable-module export interface SomeInterface {
field: string;
}
export interface AnotherInterface {
field: number;
}
export default interface DefaultInterface {
field: boolean;
}
output.d.ts 0000664 0000000 0000000 00000001315 14611320214 0034162 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-importable-module import { Server } from 'http';
import { NonDefaultInterface, default as _default } from 'package-with-default-export';
export interface SomeInterface {
field: string;
}
interface AnotherInterface {
field: number;
}
interface DefaultInterface {
field: boolean;
}
declare let letName: number;
declare const constName = "const";
declare function funcName(): void;
declare function defaultFunction(): void;
export declare class MyClass {
}
export * from "fs";
export {
AnotherInterface as Int2,
DefaultInterface as DefInterface,
NonDefaultInterface,
Server,
SomeInterface as Int1,
_default as default,
constName as cName,
defaultFunction as defFunction,
funcName as fName,
letName as lName,
};
export {};
tsconfig.json 0000664 0000000 0000000 00000000121 14611320214 0034531 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-importable-module {
"extends": "../tsconfig.json",
"compilerOptions": {
"types": ["node"]
}
}
variables.ts 0000664 0000000 0000000 00000000224 14611320214 0034346 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-importable-module export let letName = 123;
export const constName = 'const';
export function funcName(): void {}
export default function defaultFunction(): void {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-paths-module/ 0000775 0000000 0000000 00000000000 14611320214 0031070 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-paths-module/config.ts 0000664 0000000 0000000 00000000155 14611320214 0032706 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-paths-module/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033466 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-paths-module/input.ts 0000664 0000000 0000000 00000000032 14611320214 0032572 0 ustar 00root root 0000000 0000000 export * from '@/module';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-paths-module/module.ts 0000664 0000000 0000000 00000000042 14611320214 0032721 0 ustar 00root root 0000000 0000000 export interface InterfaceName {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-paths-module/output.d.ts 0000664 0000000 0000000 00000000057 14611320214 0033224 0 ustar 00root root 0000000 0000000 export interface InterfaceName {
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-from-paths-module/tsconfig.json 0000664 0000000 0000000 00000000225 14611320214 0033576 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"paths": {
"@/*": [
"./*"
],
},
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-modules/ 0000775 0000000 0000000 00000000000 14611320214 0027601 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-modules/config.ts 0000664 0000000 0000000 00000000724 14611320214 0031421 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
allowedTypesLibraries: [],
importedLibraries: [
'package-with-cyclic-re-export-1',
'package-with-cyclic-re-export-2',
're-export-cycle-dependency-1',
're-export-cycle-dependency-2',
're-export-via-eq-v2',
're-export-via-eq',
're-export-via-import',
're-export-via-star-with-rename',
're-export-via-star',
],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-modules/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032177 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-modules/input.ts 0000664 0000000 0000000 00000001357 14611320214 0031316 0 ustar 00root root 0000000 0000000 import { FooBar as EqFooBar } from 're-export-via-eq';
import { FooBar as ImportFooBar } from 're-export-via-import';
import { FooBar as StartFooBar } from 're-export-via-star';
import { NsName } from 're-export-via-star-with-rename';
import EqFooBarV2 from 're-export-via-eq-v2';
import { BarFoo } from 're-export-cycle-dependency-1';
import { FooBar } from 're-export-cycle-dependency-2';
import { Package2Interface } from 'package-with-cyclic-re-export-1';
import { Package1Interface } from 'package-with-cyclic-re-export-2';
export interface Interface {
eq: EqFooBar;
eqV2: EqFooBarV2;
star: StartFooBar;
ns: typeof NsName;
cycle1: BarFoo;
cycle2: FooBar;
cycle3: Package2Interface;
cycle4: Package1Interface;
}
export { ImportFooBar };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-modules/output.d.ts 0000664 0000000 0000000 00000001375 14611320214 0031741 0 ustar 00root root 0000000 0000000 import { Package2Interface } from 'package-with-cyclic-re-export-1';
import { Package1Interface } from 'package-with-cyclic-re-export-2';
import { BarFoo } from 're-export-cycle-dependency-1';
import { FooBar } from 're-export-cycle-dependency-2';
import { FooBar as EqFooBar } from 're-export-via-eq';
import EqFooBarV2 from 're-export-via-eq-v2';
import { FooBar as ImportFooBar } from 're-export-via-import';
import { FooBar as StartFooBar } from 're-export-via-star';
import { NsName } from 're-export-via-star-with-rename';
export interface Interface {
eq: EqFooBar;
eqV2: EqFooBarV2;
star: StartFooBar;
ns: typeof NsName;
cycle1: BarFoo;
cycle2: FooBar;
cycle3: Package2Interface;
cycle4: Package1Interface;
}
export {
ImportFooBar,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-modules/tsconfig.json 0000664 0000000 0000000 00000000213 14611320214 0032304 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"esModuleInterop": true,
"types": ["package-that-defines-other-packages"]
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-node_modules/ 0000775 0000000 0000000 00000000000 14611320214 0030606 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-node_modules/config.ts 0000664 0000000 0000000 00000000260 14611320214 0032421 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
inlinedLibraries: ['package-with-re-exports'],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-node_modules/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033204 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-node_modules/input.ts 0000664 0000000 0000000 00000000170 14611320214 0032313 0 ustar 00root root 0000000 0000000 import { Barfoo, Foobar, content } from 'package-with-re-exports';
export type Baz = Barfoo | Foobar | content.Foobar;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-in-node_modules/output.d.ts 0000664 0000000 0000000 00000000253 14611320214 0032740 0 ustar 00root root 0000000 0000000 export interface Foobar {
}
export interface Barfoo {
}
export type Baz = Barfoo | Foobar | content.Foobar;
declare namespace content {
export { Foobar };
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star-with-selection/ 0000775 0000000 0000000 00000000000 14611320214 0031432 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star-with-selection/config.ts 0000664 0000000 0000000 00000000172 14611320214 0033247 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033751 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star-with-selection require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star-with-selection/input.ts 0000664 0000000 0000000 00000000333 14611320214 0033140 0 ustar 00root root 0000000 0000000 export { Interface as Interface2, InterfaceWithFields, NonDefaultInterface, Type, Bar, ReExportedName as NewReExportedName } from './re-export';
export { NonDefaultInterface as Foo } from 'package-with-default-export';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star-with-selection/output.d.ts 0000664 0000000 0000000 00000000641 14611320214 0033565 0 ustar 00root root 0000000 0000000 export { Interface as Interface2, InterfaceWithFields } from 'fake-package';
import { NonDefaultInterface, NonDefaultInterface as Foo, NonDefaultInterface as Type, NonDefaultInterface as Type2 } from 'package-with-default-export';
export { ReExportedName as NewReExportedName } from 'package-with-re-exports';
type Foo$1 = string;
export type Bar = Foo$1;
export {
Foo,
NonDefaultInterface,
Type,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star-with-selection/re-export.ts0000664 0000000 0000000 00000000527 14611320214 0033733 0 ustar 00root root 0000000 0000000 export * from 'fake-package';
export { NonDefaultInterface } from 'package-with-default-export';
export { NonDefaultInterface as Type } from 'package-with-default-export';
export * from 'package-with-re-exports';
export * from 'package-with-cyclic-re-export-1';
export * from './re-export2';
export type Foo = string;
export type Bar = Foo;
re-export2.ts 0000664 0000000 0000000 00000000152 14611320214 0033730 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star-with-selection export { NonDefaultInterface as Type2 } from 'package-with-default-export';
export * from 'fake-package';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star/ 0000775 0000000 0000000 00000000000 14611320214 0026476 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star/config.ts 0000664 0000000 0000000 00000000172 14611320214 0030313 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031074 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star/input.ts 0000664 0000000 0000000 00000000035 14611320214 0030203 0 ustar 00root root 0000000 0000000 export * from './re-export';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star/output.d.ts 0000664 0000000 0000000 00000000127 14611320214 0030630 0 ustar 00root root 0000000 0000000 export * from "fake-package";
export * from "package-with-default-export";
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-star/re-export.ts 0000664 0000000 0000000 00000000144 14611320214 0030772 0 ustar 00root root 0000000 0000000 export * from 'fake-package';
export * from 'package-with-default-export';
export * from './input';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-with-paths/ 0000775 0000000 0000000 00000000000 14611320214 0027615 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-with-paths/config.ts 0000664 0000000 0000000 00000000154 14611320214 0031432 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-with-paths/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032213 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-with-paths/input.ts 0000664 0000000 0000000 00000000065 14611320214 0031325 0 ustar 00root root 0000000 0000000 export { DefaultClass } from '@test-case/re-export';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-with-paths/output.d.ts 0000664 0000000 0000000 00000000157 14611320214 0031752 0 ustar 00root root 0000000 0000000 import { default as DefaultClass } from 'package-with-default-export';
export {
DefaultClass,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-with-paths/re-export.ts 0000664 0000000 0000000 00000000107 14611320214 0032110 0 ustar 00root root 0000000 0000000 export { default as DefaultClass } from 'package-with-default-export';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-with-paths/tsconfig.json 0000664 0000000 0000000 00000000205 14611320214 0032321 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"paths": {
"@test-case/re-export": [
"./re-export.ts"
]
}
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-without-statements/ 0000775 0000000 0000000 00000000000 14611320214 0031415 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-without-statements/config.ts 0000664 0000000 0000000 00000000154 14611320214 0033232 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-without-statements/index.spec.js0000664 0000000 0000000 00000000064 14611320214 0034013 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-without-statements/input.ts 0000664 0000000 0000000 00000000064 14611320214 0033124 0 ustar 00root root 0000000 0000000 import * as FP from 'fake-package';
export { FP };
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/re-export-without-statements/output.d.ts 0000664 0000000 0000000 00000000102 14611320214 0033540 0 ustar 00root root 0000000 0000000 import * as FP from 'fake-package';
export {
FP,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/recursive-types/ 0000775 0000000 0000000 00000000000 14611320214 0026753 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/recursive-types/config.ts 0000664 0000000 0000000 00000000172 14611320214 0030570 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/recursive-types/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031351 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/recursive-types/input.ts 0000664 0000000 0000000 00000000116 14611320214 0030460 0 ustar 00root root 0000000 0000000 import { FirstType } from './types';
export type MyType = FirstType;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/recursive-types/output.d.ts 0000664 0000000 0000000 00000000312 14611320214 0031101 0 ustar 00root root 0000000 0000000 export type ThirdType = number;
export type SecondType = T extends any ? V : FirstType;
export type FirstType = SecondType;
export type MyType = FirstType;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/recursive-types/types.ts 0000664 0000000 0000000 00000000212 14611320214 0030462 0 ustar 00root root 0000000 0000000 type ThirdType = number;
type SecondType = T extends any ? V : FirstType;
export type FirstType = SecondType;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-imports/ 0000775 0000000 0000000 00000000000 14611320214 0026544 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-imports/config.ts 0000664 0000000 0000000 00000000172 14611320214 0030361 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-imports/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031142 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-imports/input.ts 0000664 0000000 0000000 00000000313 14611320214 0030250 0 ustar 00root root 0000000 0000000 import { InterfaceWithFields as FakePackageInterface } from 'fake-package';
export const myVar: FakePackageInterface = {
field: 2,
field2: {},
field3: {
field: '',
field2: 0,
field3: 0,
},
};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-imports/output.d.ts 0000664 0000000 0000000 00000000213 14611320214 0030672 0 ustar 00root root 0000000 0000000 import { InterfaceWithFields as FakePackageInterface } from 'fake-package';
export declare const myVar: FakePackageInterface;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-local-class/ 0000775 0000000 0000000 00000000000 14611320214 0027244 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-local-class/class-rename-1.ts 0000664 0000000 0000000 00000000166 14611320214 0032327 0 ustar 00root root 0000000 0000000 import { OriginalClassName as LocalClassName1 } from './class';
export class ClassRename1 extends LocalClassName1 {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-local-class/class-rename-2.ts 0000664 0000000 0000000 00000000166 14611320214 0032330 0 ustar 00root root 0000000 0000000 import { OriginalClassName as LocalClassName2 } from './class';
export class ClassRename2 extends LocalClassName2 {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-local-class/class.ts 0000664 0000000 0000000 00000000042 14611320214 0030715 0 ustar 00root root 0000000 0000000 export class OriginalClassName {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-local-class/config.ts 0000664 0000000 0000000 00000000172 14611320214 0031061 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-local-class/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031642 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-local-class/input.ts 0000664 0000000 0000000 00000000142 14611320214 0030750 0 ustar 00root root 0000000 0000000 export { ClassRename1 } from './class-rename-1';
export { ClassRename2 } from './class-rename-2';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/rename-local-class/output.d.ts 0000664 0000000 0000000 00000000260 14611320214 0031374 0 ustar 00root root 0000000 0000000 declare class OriginalClassName {
}
export declare class ClassRename1 extends OriginalClassName {
}
export declare class ClassRename2 extends OriginalClassName {
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/respect-preserve-const-enum/ 0000775 0000000 0000000 00000000000 14611320214 0031166 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/respect-preserve-const-enum/config.ts 0000664 0000000 0000000 00000000236 14611320214 0033004 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
output: {
respectPreserveConstEnum: true,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/respect-preserve-const-enum/const-enum.ts 0000664 0000000 0000000 00000000167 14611320214 0033632 0 ustar 00root root 0000000 0000000 export const enum NonDirectlyExportedConstEnum {
FooBar,
}
export const enum DirectlyReExportedConstEnum {
BarFoo,
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/respect-preserve-const-enum/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0033564 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/respect-preserve-const-enum/input.ts 0000664 0000000 0000000 00000000420 14611320214 0032671 0 ustar 00root root 0000000 0000000 import { NonDirectlyExportedConstEnum } from './const-enum';
export const enum DirectlyExportedConstEnum {
FirstItem = 'const enum',
SecondItem = 1,
}
export const foo = NonDirectlyExportedConstEnum.FooBar;
export { DirectlyReExportedConstEnum } from './const-enum';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/respect-preserve-const-enum/output.d.ts 0000664 0000000 0000000 00000000460 14611320214 0033320 0 ustar 00root root 0000000 0000000 export declare const enum NonDirectlyExportedConstEnum {
FooBar = 0
}
export declare enum DirectlyReExportedConstEnum {
BarFoo = 0
}
export declare enum DirectlyExportedConstEnum {
FirstItem = "const enum",
SecondItem = 1
}
export declare const foo = NonDirectlyExportedConstEnum.FooBar;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/respect-preserve-const-enum/tsconfig.json 0000664 0000000 0000000 00000000132 14611320214 0033671 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"preserveConstEnums": true
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/run-test-case.ts 0000664 0000000 0000000 00000004740 14611320214 0026651 0 ustar 00root root 0000000 0000000 import * as fs from 'fs';
import * as path from 'path';
import * as assert from 'assert';
import { generateDtsBundle } from '../../../src/bundle-generator';
import { TestCaseConfig } from './test-case-config';
interface TestCase {
inputFileName: string;
outputFileContent: string;
config: TestCaseConfig;
}
// eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
const currentPackageVersion = JSON.parse(fs.readFileSync(path.join(__dirname, '../../../package.json'), { encoding: 'utf-8' })).version as string;
function prepareString(str: string): string {
return str.replace(/\r\n/g, '\n');
}
function findInputFile(testCaseDir: string): string {
const tsFilePath = path.join(testCaseDir, 'input.ts');
if (fs.existsSync(tsFilePath)) {
return tsFilePath;
}
const dtsFilePath = path.join(testCaseDir, 'input.d.ts');
if (fs.existsSync(dtsFilePath)) {
return dtsFilePath;
}
const mtsFilePath = path.join(testCaseDir, 'input.mts');
if (fs.existsSync(mtsFilePath)) {
return mtsFilePath;
}
const ctsFilePath = path.join(testCaseDir, 'input.cts');
if (fs.existsSync(ctsFilePath)) {
return ctsFilePath;
}
throw new Error(`Cannot find input file in ${testCaseDir}`);
}
function getTestCaseConfig(testCaseDir: string): TestCase {
const inputFileName = findInputFile(testCaseDir);
const outputFileName = path.resolve(testCaseDir, 'output.d.ts');
assert(fs.existsSync(outputFileName), `Output file doesn't exist for ${testCaseDir}`);
return {
inputFileName,
// eslint-disable-next-line @typescript-eslint/no-var-requires
config: require(path.resolve(testCaseDir, 'config.ts')) as TestCaseConfig,
outputFileContent: prepareString(fs.readFileSync(outputFileName, 'utf-8')).replace(/\$PACKAGE_CURRENT_VERSION/g, currentPackageVersion),
};
}
export function runTestCase(testCaseDirPath: string): void {
const testCaseName = path.basename(testCaseDirPath);
it(`e2e | ${testCaseName}`, () => {
const testCase = getTestCaseConfig(testCaseDirPath);
const outputOptions = testCase.config.output || {};
if (outputOptions.noBanner === undefined) {
// hide banner by default for all tests except these who set it explicitly
outputOptions.noBanner = true;
}
const dtsResult = generateDtsBundle(
[
{
...testCase.config,
output: outputOptions,
filePath: testCase.inputFileName,
},
]
)[0];
const result = prepareString(dtsResult);
assert.strictEqual(result, testCase.outputFileContent, 'Output should be the same as expected');
});
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/save-jsdoc/ 0000775 0000000 0000000 00000000000 14611320214 0025640 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/save-jsdoc/config.ts 0000664 0000000 0000000 00000000154 14611320214 0027455 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/save-jsdoc/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0030236 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/save-jsdoc/input.ts 0000664 0000000 0000000 00000000776 14611320214 0027361 0 ustar 00root root 0000000 0000000 import { NonExportedClass } from './some-class';
/**
* ExportedInterface JSDoc
*/
export interface ExportedInterface {}
/**
* ExportedType JSDoc
*/
export type ExportedType = string | number;
/**
* ExportedConstEnum JSDoc
*/
export const enum ExportedConstEnum {
/** Item description */
Item,
}
/**
* ExportedEnum JSDoc
*/
export enum ExportedEnum { Item }
/**
* const JSDoc
*/
export const constItem = 1;
/**
* ExportedClass JSDoc
*/
export class ExportedClass extends NonExportedClass {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/save-jsdoc/output.d.ts 0000664 0000000 0000000 00000001411 14611320214 0027767 0 ustar 00root root 0000000 0000000 declare enum NonExportedEnum {
First = 0
}
/**
* NonExportedConstEnum JSDoc
*/
export declare const enum NonExportedConstEnum {
First = 0
}
declare class NonExportedClass {
method(): NonExportedEnum;
/** Method description */
method2(): NonExportedConstEnum;
}
/**
* ExportedInterface JSDoc
*/
export interface ExportedInterface {
}
/**
* ExportedType JSDoc
*/
export type ExportedType = string | number;
/**
* ExportedConstEnum JSDoc
*/
export declare const enum ExportedConstEnum {
/** Item description */
Item = 0
}
/**
* ExportedEnum JSDoc
*/
export declare enum ExportedEnum {
Item = 0
}
/**
* const JSDoc
*/
export declare const constItem = 1;
/**
* ExportedClass JSDoc
*/
export declare class ExportedClass extends NonExportedClass {
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/save-jsdoc/some-class.ts 0000664 0000000 0000000 00000000735 14611320214 0030263 0 ustar 00root root 0000000 0000000 /**
* NonExportedEnum JSDoc must be removed from result dts
*/
export enum NonExportedEnum {
First,
}
/**
* NonExportedConstEnum JSDoc
*/
export const enum NonExportedConstEnum {
First,
}
/**
* NonExportedClass JSDoc must be removed from result dts
*/
export class NonExportedClass {
public method(): NonExportedEnum {
return NonExportedEnum.First;
}
/** Method description */
public method2(): NonExportedConstEnum {
return NonExportedConstEnum.First;
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-default-from-one-package/ 0000775 0000000 0000000 00000000000 14611320214 0033306 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000172 14611320214 0035044 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-default-from-one-package import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035625 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-default-from-one-package require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000510 14611320214 0034732 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-default-from-one-package import DefaultClass from 'package-with-default-export';
import DefaultClassRenamed from 'package-with-default-export';
import DefaultClassRenamed2 from 'package-with-default-export';
export interface ExportedInterface {
field1: typeof DefaultClass;
field2: typeof DefaultClassRenamed;
field3: typeof DefaultClassRenamed2;
}
output.d.ts 0000664 0000000 0000000 00000000524 14611320214 0035362 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-default-from-one-package import DefaultClass from 'package-with-default-export';
import DefaultClassRenamed from 'package-with-default-export';
import DefaultClassRenamed2 from 'package-with-default-export';
export interface ExportedInterface {
field1: typeof DefaultClass;
field2: typeof DefaultClassRenamed;
field3: typeof DefaultClassRenamed2;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-star-from-one-package/ 0000775 0000000 0000000 00000000000 14611320214 0032633 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000172 14611320214 0034371 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-star-from-one-package import { TestCaseConfig } from '../../test-cases/test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035152 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-star-from-one-package require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000634 14611320214 0034266 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-star-from-one-package import * as firstImport from 'package-with-default-export';
import * as secondImport from 'package-with-default-export';
import * as thirdImportWholeModule from 'package-with-default-export';
import { ExportedType } from './module';
export interface ExportedInterface {
field1: typeof firstImport.default;
field2: typeof secondImport.default;
field3: typeof thirdImportWholeModule;
field4: ExportedType;
}
module.ts 0000664 0000000 0000000 00000000276 14611320214 0034416 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-star-from-one-package import * as firstImportInModule from 'package-with-default-export';
export interface ExportedInterface {
field1: typeof firstImportInModule;
}
export type ExportedType = string | number;
output.d.ts 0000664 0000000 0000000 00000000432 14611320214 0034705 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/several-import-star-from-one-package import * as firstImport from 'package-with-default-export';
export type ExportedType = string | number;
export interface ExportedInterface {
field1: typeof firstImport.default;
field2: typeof firstImport.default;
field3: typeof firstImport;
field4: ExportedType;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/simple-tree-shaking/ 0000775 0000000 0000000 00000000000 14611320214 0027452 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/simple-tree-shaking/config.ts 0000664 0000000 0000000 00000000154 14611320214 0031267 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/simple-tree-shaking/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032050 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/simple-tree-shaking/input.ts 0000664 0000000 0000000 00000000144 14611320214 0031160 0 ustar 00root root 0000000 0000000 import { UsedInterface } from './input2';
export interface InterfaceName {
prop: UsedInterface;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/simple-tree-shaking/input2.ts 0000664 0000000 0000000 00000000152 14611320214 0031241 0 ustar 00root root 0000000 0000000 export interface NotUsedInterface {
field: string;
}
export interface UsedInterface {
field: number;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/simple-tree-shaking/output.d.ts 0000664 0000000 0000000 00000000170 14611320214 0031602 0 ustar 00root root 0000000 0000000 export interface UsedInterface {
field: number;
}
export interface InterfaceName {
prop: UsedInterface;
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/sort-nodes/ 0000775 0000000 0000000 00000000000 14611320214 0025677 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/sort-nodes/config.ts 0000664 0000000 0000000 00000000217 14611320214 0027514 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
output: {
sortNodes: true,
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/sort-nodes/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0030275 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/sort-nodes/input.ts 0000664 0000000 0000000 00000000364 14611320214 0027411 0 ustar 00root root 0000000 0000000 export interface CInterfaceName {}
export interface BInterfaceName {
prop: number;
prop2: ATypeName;
}
export type BType = number;
export type ATypeName = string | number;
/**
* Some description
*/
export type ZTypeName = string | null;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/sort-nodes/output.d.ts 0000664 0000000 0000000 00000000376 14611320214 0030037 0 ustar 00root root 0000000 0000000 export interface BInterfaceName {
prop: number;
prop2: ATypeName;
}
export interface CInterfaceName {
}
export type ATypeName = string | number;
export type BType = number;
/**
* Some description
*/
export type ZTypeName = string | null;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-class/ 0000775 0000000 0000000 00000000000 14611320214 0032746 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000154 14611320214 0034504 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-class import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035265 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-class require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000151 14611320214 0034373 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-class import { NonExportedClass } from './some-class';
export class ExportedClass extends NonExportedClass {}
output.d.ts 0000664 0000000 0000000 00000000201 14611320214 0035012 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-class declare class NonExportedClass {
getThis(): this;
}
export declare class ExportedClass extends NonExportedClass {
}
export {};
some-class.ts 0000664 0000000 0000000 00000000116 14611320214 0035303 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-class export class NonExportedClass {
public getThis(): this {
return this;
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-enum/ 0000775 0000000 0000000 00000000000 14611320214 0032605 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000154 14611320214 0034343 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-enum import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0035124 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-enum require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000151 14611320214 0034232 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-enum import { NonExportedClass } from './some-class';
export class ExportedClass extends NonExportedClass {}
output.d.ts 0000664 0000000 0000000 00000000427 14611320214 0034663 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-enum declare enum NonExportedEnum {
First = 0
}
export declare const enum NonExportedConstEnum {
First = 0
}
declare class NonExportedClass {
method(): NonExportedEnum;
method2(): NonExportedConstEnum;
}
export declare class ExportedClass extends NonExportedClass {
}
export {};
some-class.ts 0000664 0000000 0000000 00000000431 14611320214 0035142 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-enum export enum NonExportedEnum {
First,
}
export const enum NonExportedConstEnum {
First,
}
export class NonExportedClass {
public method(): NonExportedEnum {
return NonExportedEnum.First;
}
public method2(): NonExportedConstEnum {
return NonExportedConstEnum.First;
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-function/ 0000775 0000000 0000000 00000000000 14611320214 0033466 5 ustar 00root root 0000000 0000000 config.ts 0000664 0000000 0000000 00000000154 14611320214 0035224 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-function import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0036005 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-function require('../run-test-case').runTestCase(__dirname);
input.ts 0000664 0000000 0000000 00000000147 14611320214 0035120 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-function import { getRandom } from './some-function';
export interface Interface {
field: typeof getRandom;
}
output.d.ts 0000664 0000000 0000000 00000000153 14611320214 0035540 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-function declare function getRandom(): number;
export interface Interface {
field: typeof getRandom;
}
export {};
some-function.ts 0000664 0000000 0000000 00000000063 14611320214 0036544 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/strip-export-from-non-exported-function export function getRandom(): number {
return 4;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/test-case-config.ts 0000664 0000000 0000000 00000000240 14611320214 0027301 0 ustar 00root root 0000000 0000000 import { EntryPointConfig } from '../../../src/bundle-generator';
export type TestCaseConfig = Pick;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/top-level-declarations/ 0000775 0000000 0000000 00000000000 14611320214 0030157 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/top-level-declarations/.gitignore 0000664 0000000 0000000 00000000034 14611320214 0032144 0 ustar 00root root 0000000 0000000 !input.d.ts
!library.d.ts
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/top-level-declarations/config.ts 0000664 0000000 0000000 00000000154 14611320214 0031774 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/top-level-declarations/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0032555 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/top-level-declarations/input.d.ts 0000664 0000000 0000000 00000000356 14611320214 0032114 0 ustar 00root root 0000000 0000000 import { variable, SampleClass, ISample, SampleNS, functionName } from './library';
export namespace Sample {
export { functionName };
export { variable };
export { SampleClass };
export { ISample };
export { SampleNS };
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/top-level-declarations/library.d.ts 0000664 0000000 0000000 00000000247 14611320214 0032420 0 ustar 00root root 0000000 0000000 export function functionName(): void;
export const variable: string;
export class SampleClass {}
export interface ISample {}
export namespace SampleNS {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/top-level-declarations/output.d.ts 0000664 0000000 0000000 00000000475 14611320214 0032317 0 ustar 00root root 0000000 0000000 declare function functionName(): void;
declare const variable: string;
declare class SampleClass {
}
export interface ISample {
}
declare namespace SampleNS { }
export namespace Sample {
export { functionName };
export { variable };
export { SampleClass };
export { ISample };
export { SampleNS };
}
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/tsconfig.json 0000664 0000000 0000000 00000000317 14611320214 0026312 0 ustar 00root root 0000000 0000000 {
"extends": "../../../tsconfig.options.json",
"compilerOptions": {
// we especially set it to false to test that the tool set it to true inside and won't fail
"declaration": false,
"types": []
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/umd-module-name/ 0000775 0000000 0000000 00000000000 14611320214 0026570 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/umd-module-name/config.ts 0000664 0000000 0000000 00000000234 14611320214 0030404 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
output: {
umdModuleName: 'MyUmdModule',
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/umd-module-name/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031166 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/umd-module-name/input.ts 0000664 0000000 0000000 00000000062 14611320214 0030275 0 ustar 00root root 0000000 0000000 export interface InterfaceName {
prop: number;
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/umd-module-name/output.d.ts 0000664 0000000 0000000 00000000140 14611320214 0030715 0 ustar 00root root 0000000 0000000 export interface InterfaceName {
prop: number;
}
export as namespace MyUmdModule;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/underscore-in-name/ 0000775 0000000 0000000 00000000000 14611320214 0027275 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/underscore-in-name/config.ts 0000664 0000000 0000000 00000000154 14611320214 0031112 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/underscore-in-name/func.ts 0000664 0000000 0000000 00000000043 14611320214 0030575 0 ustar 00root root 0000000 0000000 export function __index(): void {}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/underscore-in-name/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031673 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/underscore-in-name/input.ts 0000664 0000000 0000000 00000000175 14611320214 0031007 0 ustar 00root root 0000000 0000000 export function __global(): void {}
export {
__index as __index,
__index as ___index,
__index as index,
} from './func';
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/underscore-in-name/output.d.ts 0000664 0000000 0000000 00000000225 14611320214 0031426 0 ustar 00root root 0000000 0000000 export declare function __index(): void;
export declare function __global(): void;
export {
__index as ___index,
__index as index,
};
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/using-custom-types/ 0000775 0000000 0000000 00000000000 14611320214 0027401 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/using-custom-types/config.ts 0000664 0000000 0000000 00000000234 14611320214 0031215 0 ustar 00root root 0000000 0000000 import { TestCaseConfig } from '../test-case-config';
const config: TestCaseConfig = {
libraries: {
allowedTypesLibraries: [],
},
};
export = config;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/using-custom-types/custom-types/ 0000775 0000000 0000000 00000000000 14611320214 0032055 5 ustar 00root root 0000000 0000000 my-library/ 0000775 0000000 0000000 00000000000 14611320214 0034065 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/using-custom-types/custom-types index.d.ts 0000664 0000000 0000000 00000000150 14611320214 0035762 0 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/using-custom-types/custom-types/my-library declare module 'my-library' {
export interface InterfaceName {
field: string;
field2: number;
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/using-custom-types/index.spec.js 0000664 0000000 0000000 00000000064 14611320214 0031777 0 ustar 00root root 0000000 0000000 require('../run-test-case').runTestCase(__dirname);
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/using-custom-types/input.ts 0000664 0000000 0000000 00000000132 14611320214 0031104 0 ustar 00root root 0000000 0000000 import { InterfaceName } from 'my-library';
export type MyType = InterfaceName | string;
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/using-custom-types/output.d.ts 0000664 0000000 0000000 00000000146 14611320214 0031534 0 ustar 00root root 0000000 0000000 import { InterfaceName } from 'my-library';
export type MyType = InterfaceName | string;
export {};
timocov-dts-bundle-generator-c69ff0d/tests/e2e/test-cases/using-custom-types/tsconfig.json 0000664 0000000 0000000 00000000176 14611320214 0032114 0 ustar 00root root 0000000 0000000 {
"extends": "../tsconfig.json",
"compilerOptions": {
"typeRoots": [
"node_modules/@types",
"custom-types"
]
}
}
timocov-dts-bundle-generator-c69ff0d/tests/e2e/tsconfig.json 0000664 0000000 0000000 00000000510 14611320214 0024232 0 ustar 00root root 0000000 0000000 {
"extends": "../../tsconfig.options.json",
"compilerOptions": {
"composite": true,
"incremental": true,
"outDir": "./.tsc-out"
},
"references": [
{ "path": "../../src" },
],
"include": [
"./all-test-cases.ts",
"./test-case-config.ts",
"./test-cases/**/config.ts",
"./test-cases/test-case-config.ts",
]
}
timocov-dts-bundle-generator-c69ff0d/tests/tsconfig.json 0000664 0000000 0000000 00000000240 14611320214 0023557 0 ustar 00root root 0000000 0000000 {
"compilerOptions": {
"composite": true,
"incremental": true
},
"references": [
{ "path": "./e2e" },
{ "path": "./unittests" }
],
"include": []
}
timocov-dts-bundle-generator-c69ff0d/tests/unittests/ 0000775 0000000 0000000 00000000000 14611320214 0023116 5 ustar 00root root 0000000 0000000 timocov-dts-bundle-generator-c69ff0d/tests/unittests/.gitignore 0000664 0000000 0000000 00000000013 14611320214 0025100 0 ustar 00root root 0000000 0000000 /.tsc-out/
timocov-dts-bundle-generator-c69ff0d/tests/unittests/check-schema-match.spec.ts 0000664 0000000 0000000 00000010333 14611320214 0030024 0 ustar 00root root 0000000 0000000 import * as assert from 'assert';
import { checkSchemaMatch, schemaPrimitiveValues, SchemeDescriptor } from '../../src/config-file/check-schema-match';
interface TestObj {
foo: string;
}
interface TestInterface {
booleanProp?: boolean;
requiredBooleanProp: boolean;
stringProp?: string;
requiredStringProp: string;
testArray?: TestObj[];
stringArray?: string[];
}
const testSchema: SchemeDescriptor = {
booleanProp: schemaPrimitiveValues.boolean,
requiredBooleanProp: schemaPrimitiveValues.requiredBoolean,
stringProp: schemaPrimitiveValues.string,
requiredStringProp: schemaPrimitiveValues.requiredString,
testArray: [{
foo: schemaPrimitiveValues.requiredString,
}],
stringArray: [schemaPrimitiveValues.string],
};
function formatErrors(errors: string[]): string {
return `errors: ${errors.join(' | ')}`;
}
describe('checkSchemaMatch', () => {
it('should return true if object is fully matched', () => {
const obj: TestInterface = {
booleanProp: true,
requiredBooleanProp: false,
stringProp: 'test',
requiredStringProp: 'test',
};
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(obj, testSchema, errors), true, formatErrors(errors));
});
it('should return true if object is matched partially', () => {
const obj: TestInterface = {
booleanProp: false,
requiredBooleanProp: false,
requiredStringProp: 'test',
};
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(obj, testSchema, errors), true, formatErrors(errors));
});
it('should return true if object contains only required values', () => {
const obj: TestInterface = {
requiredBooleanProp: false,
requiredStringProp: 'test',
};
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(obj, testSchema, errors), true, formatErrors(errors));
});
it('should return false if object contains exceeded property', () => {
const obj = {
requiredBooleanProp: false,
requiredStringProp: 'test',
fooBar: 123,
};
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(obj, testSchema, errors), false, formatErrors(errors));
});
it('should return false if does not have required property', () => {
const obj = {
requiredBooleanProp: false,
};
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(obj, testSchema, errors), false, formatErrors(errors));
});
it('should return false if both does not have required property and have exceeded property', () => {
const obj = {
requiredBooleanProp: false,
fooBar: 123,
};
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(obj, testSchema, errors), false, formatErrors(errors));
});
it('should return true for if value is empty array', () => {
const obj: TestInterface = {
requiredBooleanProp: false,
requiredStringProp: 'test',
stringArray: [],
testArray: [],
};
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(obj, testSchema, errors), true, formatErrors(errors));
});
it('should return true if array contains only valid values', () => {
const obj: TestInterface = {
requiredBooleanProp: false,
requiredStringProp: 'test',
stringArray: ['string1', 'string2'],
testArray: [
{ foo: '3' },
{ foo: '2' },
],
};
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(obj, testSchema, errors), true, formatErrors(errors));
});
it('should return false if array contains invalid primitive values', () => {
const obj = {
requiredBooleanProp: false,
requiredStringProp: 'test',
stringArray: ['', false, 123],
};
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(obj, testSchema, errors), false, formatErrors(errors));
});
it('should return false if array contains invalid objects', () => {
const obj = {
requiredBooleanProp: false,
requiredStringProp: 'test',
testArray: [
{ bar: '3' },
{ foo: '2' },
{ check: 123 },
],
};
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(obj, testSchema, errors), false, formatErrors(errors));
});
it('should return false if root object is undefined', () => {
const errors: string[] = [];
assert.strictEqual(checkSchemaMatch(undefined, testSchema, errors), false, formatErrors(errors));
});
});
timocov-dts-bundle-generator-c69ff0d/tests/unittests/node-modules-helpres.spec.ts 0000664 0000000 0000000 00000003465 14611320214 0030462 0 ustar 00root root 0000000 0000000 import * as assert from 'assert';
import { getTypesLibraryName, getLibraryName } from '../../src/helpers/node-modules';
describe('getLibraryName', () => {
it('should return correct library name', () => {
assert.strictEqual(getLibraryName('node_modules/typescript/index.js'), 'typescript');
assert.strictEqual(getLibraryName('./node_modules/typescript/index.js'), 'typescript');
assert.strictEqual(getLibraryName('./src/index.js'), null, 'Not node_modules folder');
assert.strictEqual(getLibraryName('node_modules/@types/fake-package/index.d.ts'), '@types/fake-package', 'fake-package package');
assert.strictEqual(getLibraryName('node_modules/some-package/node_modules/@types/fake-inside-package/index.d.ts'), '@types/fake-inside-package', 'node_modules inside other node_modules');
assert.strictEqual(getLibraryName('node_modules/@types/some-package/node_modules/not-types-package/index.d.ts'), 'not-types-package', 'node_modules inside node_modules/@types');
});
});
describe('getTypesLibraryName', () => {
it('should return correct library types name', () => {
assert.strictEqual(getTypesLibraryName('node_modules/typescript/index.js'), null);
assert.strictEqual(getTypesLibraryName('./node_modules/typescript/index.js'), null);
assert.strictEqual(getTypesLibraryName('./src/index.js'), null, 'Not node_modules folder');
assert.strictEqual(getTypesLibraryName('node_modules/@types/fake-package/index.d.ts'), 'fake-package', 'fake-package package');
assert.strictEqual(getTypesLibraryName('node_modules/some-package/node_modules/@types/fake-inside-package/index.d.ts'), 'fake-inside-package', 'node_modules inside other node_modules');
assert.strictEqual(getTypesLibraryName('node_modules/@types/some-package/node_modules/not-types-package/index.d.ts'), null, 'node_modules inside node_modules/@types');
});
});
timocov-dts-bundle-generator-c69ff0d/tests/unittests/tsconfig.json 0000664 0000000 0000000 00000000333 14611320214 0025624 0 ustar 00root root 0000000 0000000 {
"extends": "../../tsconfig.options.json",
"compilerOptions": {
"composite": true,
"incremental": true,
"outDir": "./.tsc-out"
},
"references": [
{ "path": "../../src" },
],
"include": [
"**/*.ts"
]
}
timocov-dts-bundle-generator-c69ff0d/tsconfig.dts-config.json 0000664 0000000 0000000 00000000216 14611320214 0024454 0 ustar 00root root 0000000 0000000 {
"extends": "./tsconfig.options.json",
"compilerOptions": {
"allowJs": true,
"noEmit": true
},
"include": [
"./dts-config.js"
]
}
timocov-dts-bundle-generator-c69ff0d/tsconfig.json 0000664 0000000 0000000 00000000234 14611320214 0022420 0 ustar 00root root 0000000 0000000 {
"compilerOptions": {
"composite": true,
"incremental": true
},
"references": [
{ "path": "./src" },
{ "path": "./tests" }
],
"include": []
}
timocov-dts-bundle-generator-c69ff0d/tsconfig.options.json 0000664 0000000 0000000 00000000452 14611320214 0024114 0 ustar 00root root 0000000 0000000 {
"compilerOptions": {
"declaration": true,
"lib": ["es2020"],
"module": "commonjs",
"newLine": "LF",
"noEmitOnError": true,
"noFallthroughCasesInSwitch": true,
"noImplicitReturns": true,
"noUnusedLocals": true,
"strict": true,
"stripInternal": true,
"target": "es2020"
}
}