vite-plugin-dts 3.1.1 → 3.3.0

package/dist/index.cjs

@@ -11,127 +11,12 @@ const vueTsc = require('vue-tsc');
 const debug = require('debug');
 const kolorist = require('kolorist');
 const apiExtractor = require('@microsoft/api-extractor');
-const Collector_js = require('@microsoft/api-extractor/lib/collector/Collector.js');
-const MessageRouter_js = require('@microsoft/api-extractor/lib/collector/MessageRouter.js');
-const SourceMapper_js = require('@microsoft/api-extractor/lib/collector/SourceMapper.js');
-const DtsRollupGenerator_js = require('@microsoft/api-extractor/lib/generators/DtsRollupGenerator.js');
-const nodeCoreLibrary = require('@rushstack/node-core-library');
 
 function _interopDefaultCompat (e) { return e && typeof e === 'object' && 'default' in e ? e.default : e; }
 
 const ts__default = /*#__PURE__*/_interopDefaultCompat(ts);
 const debug__default = /*#__PURE__*/_interopDefaultCompat(debug);
 
-const dtsRE$1 = /\.d\.tsx?$/;
-function rollupDeclarationFiles({
-  root,
-  configPath,
-  compilerOptions,
-  outDir,
-  entryPath,
-  fileName,
-  libFolder,
-  bundledPackages
-}) {
-  const configObjectFullPath = node_path.resolve(root, "api-extractor.json");
-  const packageJsonLookup = new nodeCoreLibrary.PackageJsonLookup();
-  const packageJsonFullPath = packageJsonLookup.tryGetPackageJsonFilePathFor(configObjectFullPath);
-  if (!dtsRE$1.test(fileName)) {
-    fileName += ".d.ts";
-  }
-  const extractorConfig = apiExtractor.ExtractorConfig.prepare({
-    configObject: {
-      projectFolder: root,
-      mainEntryPointFilePath: entryPath,
-      bundledPackages,
-      compiler: {
-        tsconfigFilePath: configPath,
-        overrideTsconfig: {
-          $schema: "http://json.schemastore.org/tsconfig",
-          compilerOptions: {
-            ...compilerOptions,
-            target: "ESNext"
-          }
-        }
-      },
-      apiReport: {
-        enabled: false,
-        reportFileName: "<unscopedPackageName>.api.md"
-      },
-      docModel: {
-        enabled: false
-      },
-      dtsRollup: {
-        enabled: true,
-        publicTrimmedFilePath: node_path.resolve(outDir, fileName)
-      },
-      tsdocMetadata: {
-        enabled: false
-      },
-      messages: {
-        compilerMessageReporting: {
-          default: {
-            logLevel: "none"
-          }
-        },
-        extractorMessageReporting: {
-          default: {
-            logLevel: "none"
-          }
-        }
-      }
-    },
-    configObjectFullPath,
-    packageJsonFullPath
-  });
-  const compilerState = apiExtractor.CompilerState.create(extractorConfig, {
-    localBuild: false,
-    showVerboseMessages: false,
-    typescriptCompilerFolder: libFolder ? node_path.resolve(libFolder) : void 0
-  });
-  const sourceMapper = new SourceMapper_js.SourceMapper();
-  const messageRouter = new MessageRouter_js.MessageRouter({
-    workingPackageFolder: root,
-    messageCallback: void 0,
-    messagesConfig: extractorConfig.messages,
-    showVerboseMessages: false,
-    showDiagnostics: false,
-    tsdocConfiguration: extractorConfig.tsdocConfiguration,
-    sourceMapper
-  });
-  const collector = new Collector_js.Collector({
-    program: compilerState.program,
-    messageRouter,
-    extractorConfig,
-    sourceMapper
-  });
-  collector.analyze();
-  DtsRollupGenerator_js.DtsRollupGenerator.writeTypingsFile(
-    collector,
-    extractorConfig.publicTrimmedFilePath,
-    DtsRollupGenerator_js.DtsRollupKind.PublicRelease,
-    extractorConfig.newlineKind
-  );
-}
-
-const svelteRE = /\.svelte$/;
-function SvelteResolver() {
-  return {
-    name: "svelte",
-    supports(id) {
-      return svelteRE.test(id);
-    },
-    transform({ id }) {
-      return [
-        {
-          path: `${id}.d.ts`,
-          content: "export { SvelteComponentTyped as default } from 'svelte';"
-        }
-      ];
-    }
-  };
-}
-
 const windowsSlashRE = /\\+/g;
 function slash(p) {
   return p.replace(windowsSlashRE, "/");
@@ -151,6 +36,9 @@ function isRegExp(value) {
 function isPromise(value) {
   return !!value && (typeof value === "function" || typeof value === "object") && typeof value.then === "function";
 }
+async function wrapPromise(maybePromise) {
+  return isPromise(maybePromise) ? await maybePromise : maybePromise;
+}
 function ensureAbsolute(path, root) {
   return normalizePath(path ? node_path.isAbsolute(path) ? path : resolve(root, path) : root);
 }
@@ -231,6 +119,161 @@ function removeDirIfEmpty(dir) {
   }
   return onlyHasDir;
 }
+const BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/".split("");
+function base64Encode(number) {
+  if (number >= 0 && number < BASE64_ALPHABET.length) {
+    return BASE64_ALPHABET[number];
+  }
+  throw new TypeError("Base64 integer must be between 0 and 63: " + number);
+}
+const VLQ_BASE_SHIFT = 5;
+const VLQ_BASE = 1 << VLQ_BASE_SHIFT;
+const VLQ_BASE_MASK = VLQ_BASE - 1;
+const VLQ_CONTINUATION_BIT = VLQ_BASE;
+function toVLQSigned(number) {
+  return number < 0 ? (-number << 1) + 1 : (number << 1) + 0;
+}
+function base64VLQEncode(numbers) {
+  let encoded = "";
+  for (const number of numbers) {
+    let vlq = toVLQSigned(number);
+    let digit;
+    do {
+      digit = vlq & VLQ_BASE_MASK;
+      vlq >>>= VLQ_BASE_SHIFT;
+      if (vlq > 0) {
+        digit |= VLQ_CONTINUATION_BIT;
+      }
+      encoded += base64Encode(digit);
+    } while (vlq > 0);
+  }
+  return encoded;
+}
+const pkgPathCache = /* @__PURE__ */ new Map();
+function tryGetPkgPath(beginPath) {
+  beginPath = normalizePath(beginPath);
+  if (pkgPathCache.has(beginPath)) {
+    return pkgPathCache.get(beginPath);
+  }
+  const pkgPath = resolve(beginPath, "package.json");
+  if (node_fs.existsSync(pkgPath)) {
+    pkgPathCache.set(beginPath, pkgPath);
+    return pkgPath;
+  }
+  const parentDir = normalizePath(node_path.dirname(beginPath));
+  if (!parentDir || parentDir === beginPath) {
+    pkgPathCache.set(beginPath, void 0);
+    return;
+  }
+  return tryGetPkgPath(parentDir);
+}
+
+const dtsRE$1 = /\.d\.tsx?$/;
+function rollupDeclarationFiles({
+  root,
+  configPath,
+  compilerOptions,
+  outDir,
+  entryPath,
+  fileName,
+  libFolder,
+  bundledPackages
+}) {
+  const configObjectFullPath = node_path.resolve(root, "api-extractor.json");
+  if (!dtsRE$1.test(fileName)) {
+    fileName += ".d.ts";
+  }
+  const extractorConfig = apiExtractor.ExtractorConfig.prepare({
+    configObject: {
+      projectFolder: root,
+      mainEntryPointFilePath: entryPath,
+      bundledPackages,
+      compiler: {
+        tsconfigFilePath: configPath,
+        overrideTsconfig: {
+          $schema: "http://json.schemastore.org/tsconfig",
+          compilerOptions
+        }
+      },
+      apiReport: {
+        enabled: false
+      },
+      docModel: {
+        enabled: false
+      },
+      dtsRollup: {
+        enabled: true,
+        publicTrimmedFilePath: node_path.resolve(outDir, fileName)
+      },
+      tsdocMetadata: {
+        enabled: false
+      },
+      messages: {
+        compilerMessageReporting: {
+          default: {
+            logLevel: "none"
+          }
+        },
+        extractorMessageReporting: {
+          default: {
+            logLevel: "none"
+          }
+        }
+      }
+    },
+    configObjectFullPath,
+    packageJsonFullPath: tryGetPkgPath(configObjectFullPath)
+  });
+  const result = apiExtractor.Extractor.invoke(extractorConfig, {
+    localBuild: false,
+    showVerboseMessages: false,
+    showDiagnostics: false,
+    typescriptCompilerFolder: libFolder ? node_path.resolve(libFolder) : void 0
+  });
+  return result.succeeded;
+}
+
+const jsonRE = /\.json$/;
+function JsonResolver() {
+  return {
+    name: "json",
+    supports(id) {
+      return jsonRE.test(id);
+    },
+    transform({ id, root, program }) {
+      const sourceFile = program.getSourceFile(id);
+      if (!sourceFile)
+        return [];
+      return [
+        {
+          path: node_path.relative(root, `${id}.d.ts`),
+          content: `declare const _default: ${sourceFile.text};
+
+export default _default;
+`
+        }
+      ];
+    }
+  };
+}
+
+const svelteRE = /\.svelte$/;
+function SvelteResolver() {
+  return {
+    name: "svelte",
+    supports(id) {
+      return svelteRE.test(id);
+    },
+    transform({ id, root }) {
+      return [
+        {
+          path: node_path.relative(root, `${id}.d.ts`),
+          content: "export { SvelteComponentTyped as default } from 'svelte';\n"
+        }
+      ];
+    }
+  };
+}
 
 const vueRE = /\.vue$/;
 function VueResolver() {
@@ -239,19 +282,36 @@ function VueResolver() {
     supports(id) {
       return vueRE.test(id);
     },
-    transform({ id, root, program, service }) {
-      let sourceFile = program.getSourceFile(id);
-      if (!sourceFile && vueRE.test(id)) {
-        sourceFile = program.getSourceFile(id + ".ts") || program.getSourceFile(id + ".js") || program.getSourceFile(id + ".tsx") || program.getSourceFile(id + ".jsx");
-      }
+    transform({ id, code, program, service }) {
+      const sourceFile = program.getSourceFile(id) || program.getSourceFile(id + ".ts") || program.getSourceFile(id + ".js") || program.getSourceFile(id + ".tsx") || program.getSourceFile(id + ".jsx");
       if (!sourceFile)
         return [];
-      return service.getEmitOutput(sourceFile.fileName, true).outputFiles.map((file) => {
+      const outputs = service.getEmitOutput(sourceFile.fileName, true).outputFiles.map((file) => {
         return {
-          path: resolve(root, file.name),
+          path: file.name,
           content: file.text
         };
       });
+      if (!program.getCompilerOptions().declarationMap)
+        return outputs;
+      const [beforeScript] = code.split(/\s*<script.*>/);
+      const beforeLines = beforeScript.split("\n").length;
+      for (const output of outputs) {
+        if (output.path.endsWith(".map")) {
+          try {
+            const sourceMap = JSON.parse(output.content);
+            sourceMap.sources = sourceMap.sources.map(
+              (source) => source.replace(/\.vue\.ts$/, ".vue")
+            );
+            if (beforeScript && beforeScript !== code && beforeLines) {
+              sourceMap.mappings = `${base64VLQEncode([0, 0, beforeLines, 0])};${sourceMap.mappings}`;
+            }
+            output.content = JSON.stringify(sourceMap);
+          } catch (e) {
+          }
+        }
+      }
+      return outputs;
     }
   };
 }
@@ -396,6 +456,7 @@ function dtsPlugin(options = {}) {
     insertTypesEntry = false,
     rollupTypes = false,
     bundledPackages = [],
+    pathsToAliases = true,
     aliasesExclude = [],
     copyDtsFiles = false,
     strictOutput = true,
@@ -422,7 +483,12 @@ function dtsPlugin(options = {}) {
   let filter;
   let bundled = false;
   let timeRecord = 0;
-  const resolvers = parseResolvers([VueResolver(), SvelteResolver(), ...options.resolvers || []]);
+  const resolvers = parseResolvers([
+    JsonResolver(),
+    VueResolver(),
+    SvelteResolver(),
+    ...options.resolvers || []
+  ]);
   const rootFiles = /* @__PURE__ */ new Set();
   const outputFiles = /* @__PURE__ */ new Map();
   return {
@@ -441,7 +507,7 @@ function dtsPlugin(options = {}) {
       if (aliasesExclude.length > 0) {
         aliases = aliases.filter(
           ({ find }) => !aliasesExclude.some(
-            (alias) => alias && (isRegExp(find) ? find.toString() === alias.toString() : isRegExp(alias) ? find.match(alias)?.[0] : find === alias)
+            (aliasExclude) => aliasExclude && (isRegExp(find) ? find.toString() === aliasExclude.toString() : isRegExp(aliasExclude) ? find.match(aliasExclude)?.[0] : find === aliasExclude)
           )
         );
       }
@@ -520,12 +586,28 @@ ${kolorist.cyan(
       if (!outDirs) {
         outDirs = options.outDir ? ensureArray(options.outDir).map((d) => ensureAbsolute(d, root)) : [ensureAbsolute(content?.raw.compilerOptions?.outDir || "dist", root)];
       }
+      const { baseUrl, paths } = compilerOptions;
+      if (pathsToAliases && baseUrl && paths) {
+        const basePath = ensureAbsolute(baseUrl, configPath ? node_path.dirname(configPath) : root);
+        const existsFinds = new Set(
+          aliases.map((alias) => alias.find).filter((find) => typeof find === "string")
+        );
+        for (const [findWithAsterisk, replacements] of Object.entries(paths)) {
+          const find = findWithAsterisk.replace("/*", "");
+          if (!replacements.length || existsFinds.has(find))
+            continue;
+          aliases.push({
+            find,
+            replacement: ensureAbsolute(replacements[0].replace("/*", ""), basePath)
+          });
+        }
+      }
       include = ensureArray(options.include ?? content?.raw.include ?? "**/*").map(normalizeGlob);
       exclude = ensureArray(options.exclude ?? content?.raw.exclude ?? "node_modules/**").map(
         normalizeGlob
       );
       filter = pluginutils.createFilter(include, exclude, { resolve: root });
-      const rootNames = Object.values(entries).concat(content?.fileNames.filter(filter) || []).map(normalizePath);
+      const rootNames = Object.values(entries).map((entry) => ensureAbsolute(entry, root)).concat(content?.fileNames.filter(filter) || []).map(normalizePath);
       host = ts__default.createCompilerHost(compilerOptions, true);
       program = vueTsc.createProgram({ host, rootNames, options: compilerOptions });
       libName = libName || "_default";
@@ -544,8 +626,7 @@ ${kolorist.cyan(
         logger.error(ts__default.formatDiagnostics(diagnostics, host));
       }
       if (typeof afterDiagnostic === "function") {
-        const result = afterDiagnostic(diagnostics);
-        isPromise(result) && await result;
+        await wrapPromise(afterDiagnostic(diagnostics));
       }
       rootNames.forEach((file) => {
         this.addWatchFile(file);
@@ -556,30 +637,39 @@ ${kolorist.cyan(
     },
     async transform(code, id) {
       let resolver;
-      id = normalizePath(id).split("?")[0];
+      id = normalizePath(id);
       if (!host || !program || !filter(id) || !(resolver = resolvers.find((r) => r.supports(id))) && !tjsRE.test(id)) {
         return;
       }
       const startTime = Date.now();
+      const outDir = outDirs[0];
       const service = program.__vue.languageService;
+      id = id.split("?")[0];
       rootFiles.delete(id);
       if (resolver) {
         const result = await resolver.transform({
           id,
           code,
           root: publicRoot,
+          outDir,
           host,
           program,
           service
         });
         for (const { path, content } of result) {
-          outputFiles.set(ensureAbsolute(path, publicRoot), content);
+          outputFiles.set(
+            resolve(publicRoot, node_path.relative(outDir, ensureAbsolute(path, outDir))),
+            content
+          );
         }
       } else {
         const sourceFile = program.getSourceFile(id);
         if (sourceFile) {
           for (const outputFile of service.getEmitOutput(sourceFile.fileName, true).outputFiles) {
-            outputFiles.set(resolve(publicRoot, outputFile.name), outputFile.text);
+            outputFiles.set(
+              resolve(publicRoot, node_path.relative(outDir, ensureAbsolute(outputFile.name, outDir))),
+              outputFile.text
+            );
           }
         }
       }
@@ -589,11 +679,12 @@ ${kolorist.cyan(
       timeRecord += Date.now() - startTime;
     },
     watchChange(id) {
-      id = normalizePath(id).split("?")[0];
+      id = normalizePath(id);
       if (!host || !program || !filter(id) || !resolvers.find((r) => r.supports(id)) && !tjsRE.test(id)) {
         return;
       }
-      const sourceFile = host.getSourceFile(normalizePath(id), ts__default.ScriptTarget.ESNext);
+      id = id.split("?")[0];
+      const sourceFile = host.getSourceFile(id, ts__default.ScriptTarget.ESNext);
       if (sourceFile) {
         rootFiles.add(sourceFile.fileName);
         program.__vue.projectVersion++;
@@ -611,7 +702,16 @@ ${logPrefix} Start generate declaration files...`));
       const startTime = Date.now();
       const outDir = outDirs[0];
       const emittedFiles = /* @__PURE__ */ new Map();
-      const writeOutput = async (path, content, outDir2) => {
+      const writeOutput = async (path, content, outDir2, record = true) => {
+        if (typeof beforeWriteFile === "function") {
+          const result = await wrapPromise(beforeWriteFile(path, content));
+          if (result === false)
+            return;
+          if (result) {
+            path = result.filePath || path;
+            content = result.content ?? content;
+          }
+        }
         path = normalizePath(path);
         const dir = normalizePath(node_path.dirname(path));
         if (strictOutput && !dir.startsWith(normalizePath(outDir2))) {
@@ -622,7 +722,7 @@ ${logPrefix} Start generate declaration files...`));
           await promises.mkdir(dir, { recursive: true });
         }
         await promises.writeFile(path, content, "utf-8");
-        emittedFiles.set(path, content);
+        record && emittedFiles.set(path, content);
       };
       const service = program.__vue.languageService;
       const sourceFiles = program.getSourceFiles();
@@ -634,7 +734,10 @@ ${logPrefix} Start generate declaration files...`));
         }
         if (rootFiles.has(sourceFile.fileName)) {
           for (const outputFile of service.getEmitOutput(sourceFile.fileName, true).outputFiles) {
-            outputFiles.set(resolve(publicRoot, outputFile.name), outputFile.text);
+            outputFiles.set(
+              resolve(publicRoot, node_path.relative(outDir, ensureAbsolute(outputFile.name, outDir))),
+              outputFile.text
+            );
           }
           rootFiles.delete(sourceFile.fileName);
         }
@@ -645,6 +748,7 @@ ${logPrefix} Start generate declaration files...`));
         Array.from(outputFiles.entries()),
         async ([path, content]) => {
           const isMapFile = path.endsWith(".map");
+          const baseDir = node_path.dirname(path);
           if (!isMapFile && content) {
             content = clearPureImport ? removePureImport(content) : content;
             content = transformAliasImport(path, content, aliases, aliasesExclude);
@@ -655,13 +759,15 @@ ${logPrefix} Start generate declaration files...`));
             node_path.relative(entryRoot, cleanVueFileName ? path.replace(".vue.d.ts", ".d.ts") : path)
           );
           content = cleanVueFileName ? content.replace(/['"](.+)\.vue['"]/g, '"$1"') : content;
-          if (typeof beforeWriteFile === "function") {
-            const result = beforeWriteFile(path, content);
-            if (result === false)
-              return;
-            if (result && isNativeObj(result)) {
-              path = result.filePath || path;
-              content = result.content ?? content;
+          if (isMapFile) {
+            try {
+              const sourceMap = JSON.parse(content);
+              sourceMap.sources = sourceMap.sources.map((source) => {
+                return normalizePath(node_path.relative(node_path.dirname(path), resolve(baseDir, source)));
+              });
+              content = JSON.stringify(sourceMap);
+            } catch (e) {
+              logger.warn(`${logPrefix} ${kolorist.yellow("Processing source map fail:")} ${path}`);
             }
           }
           await writeOutput(path, content, outDir);
@@ -669,14 +775,18 @@ ${logPrefix} Start generate declaration files...`));
       );
       bundleDebug("write output");
       if (insertTypesEntry || rollupTypes) {
-        const pkgPath = resolve(root, "package.json");
-        const pkg = node_fs.existsSync(pkgPath) ? JSON.parse(await promises.readFile(pkgPath, "utf-8")) : {};
+        const pkgPath = tryGetPkgPath(root);
+        let pkg;
+        try {
+          pkg = pkgPath && node_fs.existsSync(pkgPath) ? JSON.parse(await promises.readFile(pkgPath, "utf-8")) : {};
+        } catch (e) {
+        }
         const entryNames = Object.keys(entries);
         const types = pkg.types || pkg.typings || pkg.publishConfig?.types || pkg.publishConfig?.typings || (pkg.exports?.["."] || pkg.exports?.["./"])?.types;
         const multiple = entryNames.length > 1;
         const typesPath = types ? resolve(root, types) : resolve(outDir, indexName);
         for (const name of entryNames) {
-          let path = multiple ? resolve(outDir, `${name.replace(tsRE, "")}.d.ts`) : typesPath;
+          const path = multiple ? resolve(outDir, `${name.replace(tsRE, "")}.d.ts`) : typesPath;
           if (node_fs.existsSync(path))
             continue;
           const index = resolve(
@@ -696,15 +806,6 @@ export default ${libName}
 `;
             }
           }
-          if (typeof beforeWriteFile === "function") {
-            const result = beforeWriteFile(path, content);
-            if (result === false)
-              return;
-            if (result && isNativeObj(result)) {
-              path = result.filePath ?? path;
-              content = result.content ?? content;
-            }
-          }
           await writeOutput(path, content, outDir);
         }
         bundleDebug("insert index");
@@ -764,15 +865,29 @@ export default ${libName}
         await runParallel(node_os.cpus().length, Array.from(emittedFiles), async ([wroteFile, content]) => {
           const relativePath = node_path.relative(outDir, wroteFile);
           await Promise.all(
-            extraOutDirs.map(async (outDir2) => {
-              await writeOutput(resolve(outDir2, relativePath), content, outDir2);
+            extraOutDirs.map(async (targetOutDir) => {
+              const path = resolve(targetOutDir, relativePath);
+              if (wroteFile.endsWith(".map")) {
+                const relativeOutDir = node_path.relative(outDir, targetOutDir);
+                if (relativeOutDir) {
+                  try {
+                    const sourceMap = JSON.parse(content);
+                    sourceMap.sources = sourceMap.sources.map((source) => {
+                      return normalizePath(node_path.relative(relativeOutDir, source));
+                    });
+                    content = JSON.stringify(sourceMap);
+                  } catch (e) {
+                    logger.warn(`${logPrefix} ${kolorist.yellow("Processing source map fail:")} ${path}`);
+                  }
+                }
+              }
+              await writeOutput(path, content, targetOutDir, false);
             })
           );
         });
       }
       if (typeof afterBuild === "function") {
-        const result = afterBuild();
-        isPromise(result) && await result;
+        await wrapPromise(afterBuild());
       }
       bundleDebug("finish");
       logger.info(

package/dist/index.d.ts

@@ -16,11 +16,14 @@ interface Resolver {
     supports: (id: string) => void | boolean;
     /**
      * Transform source to declaration files
+     *
+     * Note that the path of the returns should base on `outDir`, or relative path to `root`
      */
     transform: (payload: {
         id: string;
         code: string;
         root: string;
+        outDir: string;
         host: ts.CompilerHost;
         program: ts.Program;
         service: ts.LanguageService;
@@ -80,6 +83,15 @@ interface PluginOptions {
      * @default []
      */
     resolvers?: Resolver[];
+    /**
+     * Parsing `paths` of tsconfig.json to aliases
+     *
+     * Note that these aliases only use for declaration files
+     *
+     * @default true
+     * @remarks Only use first replacement of each path
+     */
+    pathsToAliases?: boolean;
     /**
      * Set which paths should be excluded when transforming aliases
      *
@@ -169,14 +181,14 @@ interface PluginOptions {
      *
      * This allows you to transform the path or content
      *
-     * The file will be skipped when the return value `false`
+     * The file will be skipped when the return value `false` or `Promise<false>`
      *
      * @default () => {}
      */
-    beforeWriteFile?: (filePath: string, content: string) => void | false | {
+    beforeWriteFile?: (filePath: string, content: string) => MaybePromise<void | false | {
         filePath?: string;
         content?: string;
-    };
+    }>;
     /**
      * Hook called after all declaration files are written
      *