@atlaspack/transformer-typescript-types 2.14.0 → 2.14.1-canary.6

package/LICENSE

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright (c) 2024 Atlassian US., Inc.
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/lib/TSModule.js

@@ -0,0 +1,53 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TSModule = void 0;
+class TSModule {
+  constructor() {
+    this.imports = new Map();
+    this.exports = [];
+    this.bindings = new Map();
+    this.names = new Map();
+    this.used = new Set();
+  }
+  addImport(local, specifier, imported) {
+    this.imports.set(local, {
+      specifier,
+      imported
+    });
+    if (imported !== '*' && imported !== 'default') {
+      this.names.set(local, local);
+    }
+  }
+
+  // if not a reexport: imported = local, name = exported
+  addExport(name, imported, specifier) {
+    this.exports.push({
+      name,
+      specifier,
+      imported
+    });
+  }
+  addWildcardExport(specifier) {
+    this.exports.push({
+      specifier
+    });
+  }
+  addLocal(name, node) {
+    const bindings = this.bindings.get(name) ?? new Set();
+    bindings.add(node);
+    this.bindings.set(name, bindings);
+    if (name !== 'default') {
+      this.names.set(name, name);
+    }
+  }
+  getName(name) {
+    return this.names.get(name) || name;
+  }
+  hasBinding(name) {
+    return this.bindings.has(name);
+  }
+}
+exports.TSModule = TSModule;

package/lib/TSModuleGraph.js

@@ -0,0 +1,252 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.TSModuleGraph = void 0;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+class TSModuleGraph {
+  constructor(mainModuleName) {
+    this.modules = new Map();
+    this.mainModuleName = mainModuleName;
+    this.mainModule = null;
+    this.syntheticImportCount = 0;
+  }
+  addModule(name, module) {
+    this.modules.set(name, module);
+    if (name === this.mainModuleName) {
+      this.mainModule = module;
+    }
+  }
+  getModule(name) {
+    return this.modules.get(name);
+  }
+  markUsed(module, name, context) {
+    // If name is imported, mark used in the original module
+    if (module.imports.has(name)) {
+      module.used.add(name);
+      let resolved = this.resolveImport(module, name);
+      // Missing or external
+      if (!resolved || resolved.module === module) {
+        return;
+      }
+      return this.markUsed(resolved.module, resolved.imported, context);
+    }
+    if (module.used.has(name)) {
+      return;
+    }
+    module.used.add(name);
+
+    // Visit all child nodes of the original binding and mark any referenced types as used.
+    let visit = node => {
+      if (_typescript().default.isQualifiedName(node) && _typescript().default.isIdentifier(node.left)) {
+        let resolved = this.resolveImport(module, node.left.text, node.right.text);
+        if (resolved) {
+          this.markUsed(resolved.module, resolved.imported, context);
+        }
+      } else if (_typescript().default.isIdentifier(node)) {
+        this.markUsed(module, node.text, context);
+      }
+      return _typescript().default.visitEachChild(node, visit, context);
+    };
+    let bindings = module.bindings.get(name);
+    if (bindings) {
+      for (let node of bindings) {
+        _typescript().default.visitEachChild(node, visit, context);
+      }
+    }
+  }
+  getExport(m, e) {
+    (0, _assert().default)(e.name != null);
+    let exportName = e.name;
+
+    // Re-export
+    if (e.specifier && e.imported) {
+      let m = this.getModule(e.specifier);
+      if (!m) {
+        return null;
+      }
+      let exp = this.resolveExport(m, e.imported);
+      if (!exp) {
+        return null;
+      }
+      return {
+        module: exp.module,
+        imported: exp.imported || exp.name,
+        name: exportName
+      };
+    }
+
+    // Import and then export
+    if (m.imports.has(exportName)) {
+      let imp = this.resolveImport(m, exportName);
+      if (!imp) {
+        return null;
+      }
+      return {
+        module: imp.module,
+        imported: imp.name,
+        name: exportName
+      };
+    }
+
+    // Named export
+    return {
+      module: m,
+      name: exportName,
+      imported: e.imported != null ? m.getName(e.imported) : exportName
+    };
+  }
+  resolveImport(module, local, imported) {
+    let i = module.imports.get(local);
+    if (!i) {
+      return null;
+    }
+    let m = this.getModule(i.specifier);
+    if (!m) {
+      // External module. pass through the import.
+      return {
+        module,
+        name: local,
+        imported: imported || i.imported
+      };
+    }
+    return this.resolveExport(m, imported || i.imported);
+  }
+  resolveExport(module, name) {
+    for (let e of module.exports) {
+      if (e.name === name) {
+        return this.getExport(module, e);
+      } else if (e.specifier) {
+        const m = this.resolveExport((0, _nullthrows().default)(this.getModule(e.specifier)), name);
+        if (m) {
+          return m;
+        }
+      }
+    }
+  }
+  getAllExports(module = (0, _nullthrows().default)(this.mainModule), excludeDefault = false) {
+    let res = [];
+    for (let e of module.exports) {
+      if (e.name && (!excludeDefault || e.name !== 'default')) {
+        let exp = this.getExport(module, e);
+        if (exp) {
+          res.push(exp);
+        }
+      } else if (e.specifier) {
+        let m = this.getModule(e.specifier);
+        if (m) {
+          res.push(...this.getAllExports(m, true));
+        }
+      }
+    }
+    return res;
+  }
+  getAllImports() {
+    // Build a map of all imports for external modules
+    let importsBySpecifier = new Map();
+    for (let module of this.modules.values()) {
+      for (let [name, imp] of module.imports) {
+        if (module.used.has(name) && !this.modules.has(imp.specifier)) {
+          let importMap = importsBySpecifier.get(imp.specifier);
+          if (!importMap) {
+            importMap = new Map();
+            importsBySpecifier.set(imp.specifier, importMap);
+          }
+          name = module.getName(name);
+          importMap.set(name, imp.imported);
+        }
+      }
+    }
+    return importsBySpecifier;
+  }
+  propagate(context) {
+    // Resolve all exported values, and mark them as used.
+    let names = Object.create(null);
+    let exportedNames = new Map();
+    for (let e of this.getAllExports()) {
+      this.markUsed(e.module, e.imported, context);
+      e.module.names.set(e.imported, e.name);
+      names[e.name] = 1;
+      exportedNames.set(e.name, e.module);
+    }
+    let importedSymbolsToUpdate = [];
+
+    // Assign unique names across all modules
+    for (let m of this.modules.values()) {
+      for (let [orig, name] of m.names) {
+        if (exportedNames.has(name) && exportedNames.get(name) === m) {
+          continue;
+        }
+        if (!m.used.has(orig)) {
+          continue;
+        }
+        if (m.imports.has(orig)) {
+          // Update imports after all modules's local variables have been renamed
+          importedSymbolsToUpdate.push([m, orig]);
+          continue;
+        }
+        if (names[name]) {
+          m.names.set(name, `_${name}${names[name]++}`);
+        } else {
+          names[name] = 1;
+        }
+      }
+    }
+
+    // Map of imported specifiers -> map of imported names to local names
+    let imports = new Map();
+    for (let [m, orig] of importedSymbolsToUpdate) {
+      let imp = (0, _nullthrows().default)(m.imports.get(orig));
+      let imported = (0, _nullthrows().default)(this.resolveImport(m, orig));
+
+      // If the module is bundled, map the local name to the original exported name.
+      if (this.modules.has(imp.specifier)) {
+        m.names.set(orig, imported.imported);
+        continue;
+      }
+
+      // If it's external, then we need to dedup duplicate imported names, and ensure
+      // that they do not conflict with any exported or local names.
+      let importedNames = imports.get(imp.specifier);
+      if (!importedNames) {
+        importedNames = new Map();
+        imports.set(imp.specifier, importedNames);
+      }
+      let name = importedNames.get(imported.imported);
+      if (!name) {
+        if (names[imported.imported]) {
+          name = `_${imported.imported}${names[imported.imported]++}`;
+        } else {
+          name = imported.imported;
+          names[imported.imported] = 1;
+        }
+        importedNames.set(imported.imported, name);
+      }
+      m.names.set(orig, name);
+    }
+    return exportedNames;
+  }
+}
+exports.TSModuleGraph = TSModuleGraph;

package/lib/TSTypesTransformer.js

@@ -0,0 +1,205 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+function _plugin() {
+  const data = require("@atlaspack/plugin");
+  _plugin = function () {
+    return data;
+  };
+  return data;
+}
+function _path() {
+  const data = _interopRequireDefault(require("path"));
+  _path = function () {
+    return data;
+  };
+  return data;
+}
+function _sourceMap() {
+  const data = _interopRequireDefault(require("@parcel/source-map"));
+  _sourceMap = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _tsUtils() {
+  const data = require("@atlaspack/ts-utils");
+  _tsUtils = function () {
+    return data;
+  };
+  return data;
+}
+function _utils() {
+  const data = require("@atlaspack/utils");
+  _utils = function () {
+    return data;
+  };
+  return data;
+}
+function _diagnostic() {
+  const data = _interopRequireWildcard(require("@atlaspack/diagnostic"));
+  _diagnostic = function () {
+    return data;
+  };
+  return data;
+}
+var _TSModuleGraph = require("./TSModuleGraph");
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _collect = require("./collect");
+var _shake = require("./shake");
+function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function (e) { return e ? t : r; })(e); }
+function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != typeof e && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && Object.prototype.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+var _default = exports.default = new (_plugin().Transformer)({
+  loadConfig({
+    config,
+    options
+  }) {
+    return (0, _tsUtils().loadTSConfig)(config, options);
+  },
+  transform({
+    asset,
+    config,
+    options,
+    logger
+  }) {
+    let opts = {
+      // React is the default. Users can override this by supplying their own tsconfig,
+      // which many TypeScript users will already have for typechecking, etc.
+      jsx: _typescript().default.JsxEmit.React,
+      moduleResolution: _typescript().default.ModuleResolutionKind.NodeJs,
+      ...config,
+      // Always emit output
+      noEmit: false,
+      noEmitOnError: false,
+      declaration: true,
+      declarationMap: true,
+      isolatedModules: false,
+      emitDeclarationOnly: true,
+      outFile: 'index.d.ts',
+      // createProgram doesn't support incremental mode
+      composite: false,
+      incremental: false
+    };
+    let host = new (_tsUtils().CompilerHost)(options.inputFS, _typescript().default, logger);
+    // $FlowFixMe
+    let program = _typescript().default.createProgram([asset.filePath], opts, host);
+    for (let file of program.getSourceFiles()) {
+      if (_path().default.normalize(file.fileName) !== asset.filePath) {
+        asset.invalidateOnFileChange(host.redirectTypes.get(file.fileName) ?? file.fileName);
+      }
+    }
+    let mainModuleName = (0, _utils().normalizeSeparators)(_path().default.relative(program.getCommonSourceDirectory(), asset.filePath).slice(0, -_path().default.extname(asset.filePath).length));
+    let moduleGraph = new _TSModuleGraph.TSModuleGraph(mainModuleName);
+    let emitResult = program.emit(undefined, undefined, undefined, true, {
+      afterDeclarations: [
+      // 1. Build module graph
+      context => sourceFile => {
+        return (0, _collect.collect)(moduleGraph, context, sourceFile);
+      },
+      // 2. Tree shake and rename types
+      context => sourceFile => {
+        return (0, _shake.shake)(moduleGraph, context, sourceFile);
+      }]
+    });
+    let diagnostics = _typescript().default.getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+    let diagnosticIds = new Set();
+    let deduplicatedDiagnostics = [];
+    for (let d of diagnostics) {
+      if (d.start != null && d.length != null && d.messageText != null) {
+        let id = `${d.start}:${d.length}:${_typescript().default.flattenDiagnosticMessageText(d.messageText, '\n')}`;
+        if (!diagnosticIds.has(id)) {
+          deduplicatedDiagnostics.push(d);
+        }
+        diagnosticIds.add(id);
+      } else {
+        deduplicatedDiagnostics.push(d);
+      }
+    }
+    let parcelDiagnostics = deduplicatedDiagnostics.map(diagnostic => {
+      let filename = asset.filePath;
+      let {
+        file
+      } = diagnostic;
+      let diagnosticMessage = _typescript().default.flattenDiagnosticMessageText(diagnostic.messageText, '\n');
+      let codeframe;
+      if (file != null && diagnostic.start != null) {
+        let source = file.text || diagnostic.source;
+        if (file.fileName) {
+          filename = file.fileName;
+        }
+
+        // $FlowFixMe
+        if (source) {
+          let lineChar = file.getLineAndCharacterOfPosition(diagnostic.start);
+          let start = {
+            line: lineChar.line + 1,
+            column: lineChar.character + 1
+          };
+          let end = {
+            line: start.line,
+            column: start.column + 1
+          };
+          if (typeof diagnostic.start === 'number' && typeof diagnostic.length === 'number') {
+            let endCharPosition = file.getLineAndCharacterOfPosition(diagnostic.start + diagnostic.length);
+            end = {
+              line: endCharPosition.line + 1,
+              column: endCharPosition.character
+            };
+          }
+          codeframe = {
+            filePath: filename,
+            code: source,
+            codeHighlights: [{
+              start,
+              end,
+              message: (0, _diagnostic().escapeMarkdown)(diagnosticMessage)
+            }]
+          };
+        }
+      }
+      return {
+        message: (0, _diagnostic().escapeMarkdown)(diagnosticMessage),
+        codeFrames: codeframe ? [codeframe] : undefined
+      };
+    });
+    if (host.outputCode == null) {
+      throw new (_diagnostic().default)({
+        diagnostic: parcelDiagnostics
+      });
+    } else {
+      for (let d of parcelDiagnostics) {
+        logger.warn(d);
+      }
+    }
+    let code = (0, _nullthrows().default)(host.outputCode);
+    code = code.substring(0, code.lastIndexOf('//# sourceMappingURL'));
+    let map = JSON.parse((0, _nullthrows().default)(host.outputMap));
+    map.sources = map.sources.map(source => _path().default.join(_path().default.dirname(asset.filePath), source));
+    let sourceMap = null;
+    if (map.mappings) {
+      sourceMap = new (_sourceMap().default)(options.projectRoot);
+      sourceMap.addVLQMap(map);
+    }
+    asset.type = 'ts';
+    asset.setCode(code);
+    asset.setMap(sourceMap);
+    return [asset];
+  }
+});

package/lib/collect.js

@@ -0,0 +1,128 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.collect = collect;
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+var _TSModule = require("./TSModule");
+var _utils = require("./utils");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function collect(moduleGraph, context, sourceFile) {
+  // Factory only exists on TS >= 4.0
+  const {
+    factory = _typescript().default
+  } = context;
+
+  // When module definitions are nested inside each other (e.g with module augmentation),
+  // we want to keep track of the hierarchy so we can associated nodes with the right module.
+  const moduleStack = [];
+  let _currentModule;
+  let visit = node => {
+    if (_typescript().default.isBundle(node)) {
+      return factory.updateBundle(node, _typescript().default.visitNodes(node.sourceFiles, visit));
+    }
+    if (_typescript().default.isModuleDeclaration(node)) {
+      moduleStack.push(_currentModule);
+      _currentModule = new _TSModule.TSModule();
+      moduleGraph.addModule(node.name.text, _currentModule);
+    }
+    if (!_currentModule) {
+      return _typescript().default.visitEachChild(node, visit, context);
+    }
+    let currentModule = (0, _nullthrows().default)(_currentModule);
+    if (_typescript().default.isImportDeclaration(node) && node.importClause) {
+      if (node.importClause.namedBindings) {
+        if (node.importClause.namedBindings.elements) {
+          for (let element of node.importClause.namedBindings.elements) {
+            currentModule.addImport(element.name.text, node.moduleSpecifier.text, (element.propertyName ?? element.name).text);
+          }
+        } else if (node.importClause.namedBindings.name) {
+          currentModule.addImport(node.importClause.namedBindings.name.text, node.moduleSpecifier.text, '*');
+        }
+      }
+      if (node.importClause.name) {
+        currentModule.addImport(node.importClause.name.text, node.moduleSpecifier.text, 'default');
+      }
+    }
+    if (_typescript().default.isExportDeclaration(node)) {
+      if (node.exportClause) {
+        for (let element of node.exportClause.elements) {
+          if (node.moduleSpecifier) {
+            currentModule.addExport(element.name.text, (element.propertyName ?? element.name).text, node.moduleSpecifier.text);
+          } else {
+            currentModule.addExport(element.name.text, (element.propertyName ?? element.name).text);
+          }
+        }
+      } else {
+        currentModule.addWildcardExport(node.moduleSpecifier.text);
+      }
+    }
+    node = _typescript().default.visitEachChild(node, visit, context);
+    if (_typescript().default.isImportTypeNode(node) && _typescript().default.isLiteralTypeNode(node.argument) && _typescript().default.isStringLiteral(node.argument.literal)) {
+      let local = `$$parcel$import$${moduleGraph.syntheticImportCount++}`;
+      let [specifier, entity] = getImportName(node.qualifier, local, factory);
+      currentModule.addImport(local, node.argument.literal.text, specifier);
+      return factory.createTypeReferenceNode(entity, node.typeArguments);
+    }
+
+    // Handle `export default name;`
+    if (_typescript().default.isExportAssignment(node) && _typescript().default.isIdentifier(node.expression)) {
+      currentModule.addExport('default', node.expression.text);
+    }
+    if ((0, _utils.isDeclaration)(node)) {
+      if (node.name) {
+        currentModule.addLocal(node.name.text, node);
+      }
+      let name = (0, _utils.getExportedName)(node);
+      if (name) {
+        currentModule.addLocal(name, node);
+        currentModule.addExport(name, name);
+      }
+    }
+    if (_typescript().default.isVariableStatement(node) && node.modifiers) {
+      let isExported = node.modifiers.some(m => m.kind === _typescript().default.SyntaxKind.ExportKeyword);
+      for (let v of node.declarationList.declarations) {
+        currentModule.addLocal(v.name.text, v);
+        if (isExported) {
+          currentModule.addExport(v.name.text, v.name.text);
+        }
+      }
+    }
+
+    // After we finish traversing the children of a module definition,
+    // we need to make sure that subsequent nodes get associated with the next-highest level module.
+    if (_typescript().default.isModuleDeclaration(node)) {
+      _currentModule = moduleStack.pop();
+    }
+    return node;
+  };
+  return _typescript().default.visitNode(sourceFile, visit);
+}
+
+// Traverse down an EntityName to the root identifier. Return that to use as the named import specifier,
+// and collect the remaining parts into a new QualifiedName with the local replacement at the root.
+// import('react').JSX.Element => import {JSX} from 'react'; JSX.Element
+function getImportName(qualifier, local, factory) {
+  if (!qualifier) {
+    return ['*', factory.createIdentifier(local)];
+  }
+  if (qualifier.kind === _typescript().default.SyntaxKind.Identifier) {
+    return [qualifier.text, factory.createIdentifier(local)];
+  }
+  let [name, entity] = getImportName(qualifier.left, local, factory);
+  return [name, factory.createQualifiedName(entity, qualifier.right)];
+}

package/lib/shake.js

@@ -0,0 +1,226 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.shake = shake;
+var _TSModule = require("./TSModule");
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _nullthrows() {
+  const data = _interopRequireDefault(require("nullthrows"));
+  _nullthrows = function () {
+    return data;
+  };
+  return data;
+}
+var _utils = require("./utils");
+var _wrappers = require("./wrappers");
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function shake(moduleGraph, context, sourceFile) {
+  // Factory only exists on TS >= 4.0
+  const {
+    factory = _typescript().default
+  } = context;
+
+  // We traverse things out of order which messes with typescript's internal state.
+  // We don't rely on the lexical environment, so just overwrite with noops to avoid errors.
+  context.suspendLexicalEnvironment = () => {};
+  context.resumeLexicalEnvironment = () => {};
+
+  // Propagate exports from the main module to determine what types should be included
+  let exportedNames = moduleGraph.propagate(context);
+
+  // When module definitions are nested inside each other (e.g with module augmentation),
+  // we want to keep track of the hierarchy so we can associated nodes with the right module.
+  const moduleStack = [];
+  let addedGeneratedImports = false;
+  let _currentModule;
+  let visit = node => {
+    if (_typescript().default.isBundle(node)) {
+      return factory.updateBundle(node, _typescript().default.visitNodes(node.sourceFiles, visit));
+    }
+
+    // Flatten all module declarations into the top-level scope
+    if (_typescript().default.isModuleDeclaration(node)) {
+      // Deeply nested module declarations are assumed to be module augmentations and left alone.
+      if (moduleStack.length >= 1) {
+        var _node$modifiers$;
+        // Since we are hoisting them to the top-level scope, we need to add a "declare" keyword to make them ambient.
+        // we also want the declare keyword to come after the export keyword to guarantee a valid typings file.
+        node.modifiers ??= [];
+        const index = ((_node$modifiers$ = node.modifiers[0]) === null || _node$modifiers$ === void 0 ? void 0 : _node$modifiers$.kind) === _typescript().default.SyntaxKind.ExportKeyword ? 1 : 0;
+        node.modifiers.splice(index, 0, factory.createModifier(_typescript().default.SyntaxKind.DeclareKeyword));
+        return node;
+      }
+      moduleStack.push(_currentModule);
+      let isFirstModule = !_currentModule;
+      _currentModule = moduleGraph.getModule(node.name.text);
+      let statements = _typescript().default.visitEachChild(node, visit, context).body.statements;
+      _currentModule = moduleStack.pop();
+      if (isFirstModule && !addedGeneratedImports) {
+        statements.unshift(...generateImports(factory, moduleGraph));
+        addedGeneratedImports = true;
+      }
+      return statements;
+    }
+    if (!_currentModule) {
+      return _typescript().default.visitEachChild(node, visit, context);
+    }
+
+    // Remove inline imports. They are hoisted to the top of the output.
+    if (_typescript().default.isImportDeclaration(node)) {
+      return null;
+    }
+    let currentModule = (0, _nullthrows().default)(_currentModule);
+    // Remove exports from flattened modules
+    if (_typescript().default.isExportDeclaration(node)) {
+      if (!node.moduleSpecifier || moduleGraph.getModule(node.moduleSpecifier.text)) {
+        if (!node.moduleSpecifier && node.exportClause) {
+          // Filter exported elements to only external re-exports
+          let exported = [];
+          for (let element of node.exportClause.elements) {
+            let name = (element.propertyName ?? element.name).text;
+            if (exportedNames.get(name) === currentModule && !currentModule.hasBinding(name)) {
+              exported.push(element);
+            }
+          }
+          if (exported.length > 0) {
+            return (0, _wrappers.updateExportDeclaration)(factory, node, undefined,
+            // modifiers
+            false,
+            // isTypeOnly
+            factory.updateNamedExports(node.exportClause, exported), undefined,
+            // moduleSpecifier
+            undefined // assertClause
+            );
+          }
+        }
+
+        return null;
+      }
+    }
+
+    // Remove export assignment if unused.
+    if (_typescript().default.isExportAssignment(node)) {
+      let name = currentModule.getName('default');
+      if (exportedNames.get(name) !== currentModule) {
+        return null;
+      }
+    }
+    if ((0, _utils.isDeclaration)(node)) {
+      let name = (0, _utils.getExportedName)(node) || node.name.text;
+
+      // Remove unused declarations
+      if (!currentModule.used.has(name)) {
+        return null;
+      }
+
+      // Remove original export modifiers
+      node.modifiers = (node.modifiers || []).filter(m => m.kind !== _typescript().default.SyntaxKind.ExportKeyword && m.kind !== _typescript().default.SyntaxKind.DefaultKeyword);
+
+      // Rename declarations
+      let newName = currentModule.getName(name);
+      if (newName !== name && newName !== 'default') {
+        node.name = factory.createIdentifier(newName);
+      }
+
+      // Export declarations that should be exported
+      if (exportedNames.get(newName) === currentModule) {
+        if (newName === 'default') {
+          node.modifiers.unshift(factory.createModifier(_typescript().default.SyntaxKind.DefaultKeyword));
+        }
+        node.modifiers.unshift(factory.createModifier(_typescript().default.SyntaxKind.ExportKeyword));
+      } else if (_typescript().default.isFunctionDeclaration(node) || _typescript().default.isClassDeclaration(node)) {
+        node.modifiers.unshift(factory.createModifier(_typescript().default.SyntaxKind.DeclareKeyword));
+      }
+    }
+    if (_typescript().default.isVariableStatement(node)) {
+      node = _typescript().default.visitEachChild(node, visit, context);
+
+      // Remove empty variable statements
+      if (node.declarationList.declarations.length === 0) {
+        return null;
+      }
+
+      // Remove original export modifiers
+      node.modifiers = (node.modifiers || []).filter(m => m.kind !== _typescript().default.SyntaxKind.ExportKeyword && m.kind !== _typescript().default.SyntaxKind.DeclareKeyword);
+
+      // Add export modifier if all declarations are exported.
+      let isExported = node.declarationList.declarations.every(d => exportedNames.get(d.name.text) === currentModule);
+      if (isExported) {
+        node.modifiers.unshift(factory.createModifier(_typescript().default.SyntaxKind.ExportKeyword));
+      } else {
+        // Otherwise, add `declare` modifier (required for top-level declarations in d.ts files).
+        node.modifiers.unshift(factory.createModifier(_typescript().default.SyntaxKind.DeclareKeyword));
+      }
+      return node;
+    }
+    if (_typescript().default.isVariableDeclaration(node)) {
+      // Remove unused variables
+      if (!currentModule.used.has(node.name.text)) {
+        return null;
+      }
+    }
+
+    // Rename references
+    if (_typescript().default.isIdentifier(node) && currentModule.names.has(node.text)) {
+      let newName = (0, _nullthrows().default)(currentModule.getName(node.text));
+      if (newName !== 'default') {
+        return factory.createIdentifier(newName);
+      }
+    }
+
+    // Replace namespace references with final names
+    if (_typescript().default.isQualifiedName(node) && _typescript().default.isIdentifier(node.left)) {
+      let resolved = moduleGraph.resolveImport(currentModule, node.left.text, node.right.text);
+      if (resolved && resolved.module.hasBinding(resolved.name)) {
+        return factory.createIdentifier(resolved.name);
+      } else {
+        return factory.updateQualifiedName(node, factory.createIdentifier(currentModule.getName(node.left.text)), node.right);
+      }
+    }
+
+    // Remove private properties
+    if (_typescript().default.isPropertyDeclaration(node)) {
+      let isPrivate = node.modifiers && node.modifiers.some(m => m.kind === _typescript().default.SyntaxKind.PrivateKeyword);
+      if (isPrivate) {
+        return null;
+      }
+    }
+    return _typescript().default.visitEachChild(node, visit, context);
+  };
+  return _typescript().default.visitNode(sourceFile, visit);
+}
+function generateImports(factory, moduleGraph) {
+  let importStatements = [];
+  for (let [specifier, names] of moduleGraph.getAllImports()) {
+    let defaultSpecifier;
+    let namespaceSpecifier;
+    let namedSpecifiers = [];
+    for (let [name, imported] of names) {
+      if (imported === 'default') {
+        defaultSpecifier = factory.createIdentifier(name);
+      } else if (imported === '*') {
+        namespaceSpecifier = factory.createNamespaceImport(factory.createIdentifier(name));
+      } else {
+        namedSpecifiers.push((0, _wrappers.createImportSpecifier)(factory, false, name === imported ? undefined : factory.createIdentifier(imported), factory.createIdentifier(name)));
+      }
+    }
+    if (namespaceSpecifier) {
+      let importClause = (0, _wrappers.createImportClause)(factory, false, defaultSpecifier, namespaceSpecifier);
+      importStatements.push((0, _wrappers.createImportDeclaration)(factory, undefined, importClause, factory.createStringLiteral(specifier), undefined));
+      defaultSpecifier = undefined;
+    }
+    if (defaultSpecifier || namedSpecifiers.length > 0) {
+      let importClause = (0, _wrappers.createImportClause)(factory, false, defaultSpecifier, namedSpecifiers.length > 0 ? factory.createNamedImports(namedSpecifiers) : undefined);
+      importStatements.push((0, _wrappers.createImportDeclaration)(factory, undefined, importClause, factory.createStringLiteral(specifier), undefined));
+    }
+  }
+  return importStatements;
+}

package/lib/utils.js

@@ -0,0 +1,30 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.getExportedName = getExportedName;
+exports.isDeclaration = isDeclaration;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+function getExportedName(node) {
+  if (!node.modifiers) {
+    return null;
+  }
+  if (!node.modifiers.some(m => m.kind === _typescript().default.SyntaxKind.ExportKeyword)) {
+    return null;
+  }
+  if (node.modifiers.some(m => m.kind === _typescript().default.SyntaxKind.DefaultKeyword)) {
+    return 'default';
+  }
+  return node.name.text;
+}
+function isDeclaration(node) {
+  return _typescript().default.isFunctionDeclaration(node) || _typescript().default.isClassDeclaration(node) || _typescript().default.isInterfaceDeclaration(node) || _typescript().default.isEnumDeclaration(node) || _typescript().default.isTypeAliasDeclaration(node);
+}

package/lib/wrappers.js

@@ -0,0 +1,72 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updateExportDeclaration = exports.createImportSpecifier = exports.createImportDeclaration = exports.createImportClause = void 0;
+function _typescript() {
+  const data = _interopRequireDefault(require("typescript"));
+  _typescript = function () {
+    return data;
+  };
+  return data;
+}
+function _assert() {
+  const data = _interopRequireDefault(require("assert"));
+  _assert = function () {
+    return data;
+  };
+  return data;
+}
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+/* eslint-disable no-unused-vars */
+const [majorVersion, minorVersion] = _typescript().default.versionMajorMinor.split('.').map(num => parseInt(num, 10));
+
+// Everything below was generated using https://github.com/mischnic/tsc-version-wrapper
+
+const createImportClause = exports.createImportClause = (() => {
+  if (majorVersion > 4 || majorVersion === 4 && minorVersion >= 0) {
+    return (factory, isTypeOnly, name, namedBindings) => factory.createImportClause(isTypeOnly, name, namedBindings);
+  } else if (majorVersion > 3 || majorVersion === 3 && minorVersion >= 8) {
+    return (factory, isTypeOnly, name, namedBindings) => factory.createImportClause(name, namedBindings, isTypeOnly);
+  } else if (majorVersion > 3 || majorVersion === 3 && minorVersion >= 0) {
+    return (factory, isTypeOnly, name, namedBindings) => factory.createImportClause(name, namedBindings);
+  } else {
+    (0, _assert().default)(false);
+  }
+})();
+const createImportDeclaration = exports.createImportDeclaration = (() => {
+  if (majorVersion > 4 || majorVersion === 4 && minorVersion >= 8) {
+    return (factory, modifiers, importClause, moduleSpecifier, assertClause) => factory.createImportDeclaration(modifiers, importClause, moduleSpecifier, assertClause);
+  } else if (majorVersion > 4 || majorVersion === 4 && minorVersion >= 5) {
+    return (factory, modifiers, importClause, moduleSpecifier, assertClause) => factory.createImportDeclaration(undefined /* decorators */, modifiers, importClause, moduleSpecifier, assertClause);
+  } else if (majorVersion > 3 || majorVersion === 3 && minorVersion >= 0) {
+    return (factory, modifiers, importClause, moduleSpecifier) => factory.createImportDeclaration(undefined /* decorators */, modifiers, importClause, moduleSpecifier);
+  } else {
+    (0, _assert().default)(false);
+  }
+})();
+const createImportSpecifier = exports.createImportSpecifier = (() => {
+  if (majorVersion > 4 || majorVersion === 4 && minorVersion >= 5) {
+    return (factory, isTypeOnly, propertyName, name) => factory.createImportSpecifier(isTypeOnly, propertyName, name);
+  } else if (majorVersion > 3 || majorVersion === 3 && minorVersion >= 0) {
+    return (factory, isTypeOnly, propertyName, name) => factory.createImportSpecifier(propertyName, name);
+  } else {
+    (0, _assert().default)(false);
+  }
+})();
+const updateExportDeclaration = exports.updateExportDeclaration = (() => {
+  if (majorVersion > 4 || majorVersion === 4 && minorVersion >= 8) {
+    return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) => factory.updateExportDeclaration(node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause);
+  } else if (majorVersion > 4 || majorVersion === 4 && minorVersion >= 5) {
+    return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, isTypeOnly, exportClause, moduleSpecifier, assertClause);
+  } else if (majorVersion > 4 || majorVersion === 4 && minorVersion >= 0) {
+    return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, isTypeOnly, exportClause, moduleSpecifier);
+  } else if (majorVersion > 3 || majorVersion === 3 && minorVersion >= 8) {
+    return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, exportClause, moduleSpecifier, isTypeOnly);
+  } else if (majorVersion > 3 || majorVersion === 3 && minorVersion >= 0) {
+    return (factory, node, modifiers, isTypeOnly, exportClause, moduleSpecifier) => factory.updateExportDeclaration(node, undefined /* decorators */, modifiers, exportClause, moduleSpecifier);
+  } else {
+    (0, _assert().default)(false);
+  }
+})();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atlaspack/transformer-typescript-types",
-  "version": "2.14.0",
+  "version": "2.14.1-canary.6+57e29c592",
   "license": "(MIT OR Apache-2.0)",
   "publishConfig": {
     "access": "public"
@@ -12,15 +12,15 @@
   "main": "lib/TSTypesTransformer.js",
   "source": "src/TSTypesTransformer.js",
   "engines": {
-    "atlaspack": "^2.12.0",
+    "atlaspack": "2.14.1-canary.6+57e29c592",
     "node": ">= 16.0.0"
   },
   "dependencies": {
-    "@atlaspack/diagnostic": "2.14.0",
-    "@atlaspack/plugin": "2.14.0",
+    "@atlaspack/diagnostic": "2.14.1-canary.6+57e29c592",
+    "@atlaspack/plugin": "2.14.1-canary.6+57e29c592",
+    "@atlaspack/ts-utils": "2.14.1-canary.6+57e29c592",
+    "@atlaspack/utils": "2.14.1-canary.6+57e29c592",
     "@parcel/source-map": "^2.1.1",
-    "@atlaspack/ts-utils": "2.14.0",
-    "@atlaspack/utils": "2.14.0",
     "nullthrows": "^1.1.1"
   },
   "devDependencies": {
@@ -29,5 +29,6 @@
   "peerDependencies": {
     "typescript": ">=3.0.0"
   },
-  "type": "commonjs"
+  "type": "commonjs",
+  "gitHead": "57e29c592cff406d084b3c676a1c899f0bb6e78f"
 }