@sanity/pkg-utils 1.4.0 → 1.5.1

package/dist/index.js

@@ -11,6 +11,7 @@ import { Observable, switchMap } from 'rxjs';
 import { promisify } from 'util';
 import rimrafCallback from 'rimraf';
 import { ExtractorConfig, Extractor } from '@microsoft/api-extractor';
+import mkdirp from 'mkdirp';
 import prettier from 'prettier';
 import { TSDocConfigFile } from '@microsoft/tsdoc-config';
 import { parse } from 'jsonc-parser';
@@ -25,8 +26,9 @@ import treeify from 'treeify';
 import prettyBytes from 'pretty-bytes';
 import browserslist from 'browserslist';
 import ora from 'ora';
+import esbuild$1 from 'esbuild';
 import { scan, startWith, distinctUntilChanged } from 'rxjs/operators';
-import { globby } from 'globby';
+import globby from 'globby';
 import chokidar from 'chokidar';
 
 const _DEFAULTS = {
@@ -96,6 +98,7 @@ const pkgSchema = z.object({
   main: z.optional(z.string()),
   browser: z.optional(z.record(z.string())),
   module: z.optional(z.string()),
+  types: z.optional(z.string()),
   exports: z.optional(
     z.record(
       z.object({
@@ -196,9 +199,31 @@ async function _loadTSConfig(options) {
   return ts.parseJsonConfigFileContent(configFile.config, ts.sys, cwd);
 }
 
+const TS_TARGETS = {
+  0: "es3",
+  1: "es5",
+  2: "es2015",
+  3: "es2016",
+  4: "es2017",
+  5: "es2018",
+  6: "es2019",
+  7: "es2020",
+  8: "es2021",
+  9: "es2022",
+  99: "esnext",
+  100: "esnext"
+};
+function _resolveEsTarget(ctx) {
+  var _a;
+  const { ts } = ctx;
+  const tsTarget = ((_a = ts.config) == null ? void 0 : _a.options.target) || 99;
+  return TS_TARGETS[tsTarget] || "esnext";
+}
+
 function _resolveBuildTasks(ctx) {
   var _a, _b, _c, _d, _e;
   const { cwd, pkg, target } = ctx;
+  const esTarget = _resolveEsTarget(ctx);
   const tasks = [];
   const exports = Object.entries(ctx.exports || {}).map(
     ([_path, exp]) => ({ _path, ...exp })
@@ -214,7 +239,7 @@ function _resolveBuildTasks(ctx) {
         entries: [entry],
         runtime,
         format,
-        target: target[runtime]
+        target: [esTarget].concat(target[runtime])
       };
     } else {
       rollupTasks[buildId].entries.push(entry);
@@ -228,8 +253,8 @@ function _resolveBuildTasks(ctx) {
           type: "build:dts",
           importId,
           exportPath: exp._path,
-          source: exp.source,
-          output: exp.types
+          sourcePath: exp.source,
+          targetPath: exp.types
         };
       }
     }
@@ -285,7 +310,6 @@ function _resolveBuildTasks(ctx) {
           [
             `// AUTO-GENERATED \u2013 DO NOT EDIT`,
             ``,
-            `export {default} from '${relativeTargetPath}'`,
             `export * from '${relativeTargetPath}'`,
             ``
           ].join("\n")
@@ -355,6 +379,10 @@ async function _buildTypes(options) {
     noEmit: false,
     outDir
   };
+  const rootDir = path.relative(
+    cwd,
+    compilerOptions.rootDir ? path.resolve(cwd, compilerOptions.rootDir) : path.dirname(path.resolve(cwd, sourcePath))
+  ) || ".";
   const program = ts.createProgram(tsconfig.fileNames, compilerOptions);
   const sourceFiles = program.getSourceFiles();
   const sourceFile = sourceFiles.find((f) => f.fileName === path.resolve(cwd, sourcePath));
@@ -380,7 +408,7 @@ ${message}`);
       throw new Error("failed to compile");
     }
   }
-  const typesPath = path.resolve(outDir, sourcePath.replace(/\.ts$/, ".d.ts"));
+  const typesPath = path.resolve(outDir, path.relative(rootDir, path.resolve(cwd, sourcePath))).replace(/\.[jt]sx?$/, ".d.ts");
   return { path: typesPath };
 }
 
@@ -523,9 +551,10 @@ async function _extractTypes(options) {
       message.handled = true;
     }
   });
-  const typesPath = path.resolve(distPath, `${exportPath}.d.ts`);
+  const typesPath = path.resolve(distPath, filePath);
   const typesBuf = await fs.readFile(typesPath);
   const prettierConfig = await prettier.resolveConfig(typesPath);
+  await mkdirp(path.dirname(typesPath));
   await fs.writeFile(
     typesPath,
     prettier.format(typesBuf.toString(), {
@@ -542,27 +571,37 @@ async function _extractTypes(options) {
 
 const rimraf = promisify(rimrafCallback);
 async function _doExtract(ctx, task) {
-  var _a, _b;
+  var _a;
   const { config, cwd, dist, files, ts } = ctx;
   if (!ts.config || !ts.configPath)
     return { type: "dts", messages: [] };
-  const sourcePath = task.source;
+  const sourcePath = task.sourcePath;
   const exportPath = task.exportPath === "." ? "./index" : task.exportPath;
   const distPath = path.resolve(cwd, dist);
-  const outDir = ((_a = ts.config) == null ? void 0 : _a.options.outDir) || path.resolve(cwd, dist);
-  const types = await _buildTypes({ cwd, outDir, sourcePath, tsconfig: ts.config });
+  const filePath = path.relative(distPath, path.resolve(cwd, task.targetPath));
+  const tmpDirPath = path.resolve(distPath, "__dts__");
+  const tmpDir = {
+    path: tmpDirPath,
+    removeCallback: () => rimraf(tmpDirPath)
+  };
+  const types = await _buildTypes({
+    cwd,
+    outDir: tmpDir.path,
+    sourcePath,
+    tsconfig: ts.config
+  });
   const { messages } = await _extractTypes({
     cwd,
     exportPath,
     files,
-    filePath: path.relative(distPath, path.resolve(cwd, task.output)),
+    filePath,
     projectPath: cwd,
-    rules: (_b = config == null ? void 0 : config.extract) == null ? void 0 : _b.rules,
+    rules: (_a = config == null ? void 0 : config.extract) == null ? void 0 : _a.rules,
     sourcePath: types.path,
     tsconfigPath: path.resolve(cwd, ts.configPath),
     distPath
   });
-  await rimraf(outDir);
+  await tmpDir.removeCallback();
   if (messages.some((msg) => msg.logLevel === "error")) {
     throw new _DtsError("encountered errors when extracting types", messages);
   }
@@ -572,14 +611,16 @@ async function _doExtract(ctx, task) {
 const _dtsTask = {
   name: (_ctx, task) => [
     `build type definitions`,
-    `       ${chalk.blue(task.importId)}: ${task.source} -> ${task.output}`
+    `       ${chalk.blue(task.importId)}: ${task.sourcePath} -> ${task.targetPath}`
   ].join("\n"),
   exec: (ctx, task) => {
     return new Observable((observer) => {
       _doExtract(ctx, task).then((result) => {
         observer.next(result);
         observer.complete();
-      }).catch(observer.error);
+      }).catch((err) => {
+        observer.error(err);
+      });
     });
   },
   complete: (ctx, _task, result) => {
@@ -598,14 +639,14 @@ const _dtsTask = {
 const _dtsWatchTask = {
   name: (_ctx, task) => [
     `build type definitions`,
-    `       ${chalk.blue(task.importId)}: ${task.source} -> ${task.output}`
+    `       ${chalk.blue(task.importId)}: ${task.sourcePath} -> ${task.targetPath}`
   ].join("\n"),
   exec: (ctx, task) => {
     return new Observable((observer) => {
       _doExtract(ctx, task).then((result) => {
         observer.next(result);
         observer.complete();
-      }).catch(observer.error);
+      }).catch((err) => observer.error(err));
     });
   },
   complete: (ctx, _task, result) => {
@@ -625,7 +666,7 @@ const _dtsWatchTask = {
 };
 
 function _resolveRollupConfig(ctx, buildTask) {
-  var _a;
+  var _a, _b, _c;
   const { format, runtime, target } = buildTask;
   const { config, cwd, external, dist: outDir, pkg, ts } = ctx;
   const outputExt = format === "commonjs" ? ".cjs" : pkg.type === "module" ? ".mjs" : ".js";
@@ -695,7 +736,7 @@ function _resolveRollupConfig(ctx, buildTask) {
         }),
         json(),
         esbuild({
-          minify: (config == null ? void 0 : config.minify) ?? true,
+          minify: (_b = config == null ? void 0 : config.minify) != null ? _b : true,
           jsx: "transform",
           jsxFactory: "React.createElement",
           jsxFragment: "React.Fragment",
@@ -713,7 +754,7 @@ function _resolveRollupConfig(ctx, buildTask) {
       entryFileNames: () => `[name]${outputExt}`,
       format,
       exports: "auto",
-      sourcemap: (config == null ? void 0 : config.sourcemap) ?? true
+      sourcemap: (_c = config == null ? void 0 : config.sourcemap) != null ? _c : true
     }
   };
 }
@@ -726,7 +767,7 @@ const _rollupTask = {
       _execPromise(ctx, task).then((result) => {
         observer.next(result);
         observer.complete();
-      }, observer.error);
+      }).catch((err) => observer.error(err));
     });
   },
   complete: () => {
@@ -824,7 +865,7 @@ function _getFilesize(file) {
   return prettyBytes(stats.size);
 }
 
-function _getFileExists(file) {
+function _fileExists(file) {
   try {
     fs$1.accessSync(file);
     return true;
@@ -834,7 +875,7 @@ function _getFileExists(file) {
 }
 function _getFileInfo(cwd, filePath) {
   const p = path.resolve(cwd, filePath);
-  const exists = _getFileExists(p);
+  const exists = _fileExists(p);
   const size = exists ? _getFilesize(p) : void 0;
   return { exists, size };
 }
@@ -850,7 +891,7 @@ function _printPackageTree(ctx) {
   function _fileInfo(file) {
     const info = _getFileInfo(cwd, file);
     if (!info.size) {
-      return chalk.gray(file);
+      return `${chalk.gray(file)} ${chalk.red("does not exist")}`;
     }
     return `${file} ${chalk.gray(info.size)}`;
   }
@@ -953,6 +994,7 @@ function _resolveNodeTarget(versions) {
 }
 
 async function _resolveBuildContext(options) {
+  var _a;
   const { config, cwd, pkg, tsconfig: tsconfigPath } = options;
   const tsconfig = await _loadTSConfig({ cwd, tsconfigPath });
   const targetVersions = _resolveBrowserslistVersions(pkg.browserslist || _DEFAULTS.browserslist);
@@ -1007,7 +1049,7 @@ async function _resolveBuildContext(options) {
     },
     pkg,
     src: path.relative(cwd, srcPath),
-    runtime: (config == null ? void 0 : config.runtime) ?? "*",
+    runtime: (_a = config == null ? void 0 : config.runtime) != null ? _a : "*",
     target,
     ts: {
       config: tsconfig,
@@ -1055,7 +1097,8 @@ async function build(options) {
     } catch (err) {
       spinner.error();
       if (err instanceof Error) {
-        ctx.logger.error(err.message.replaceAll(cwd, "."));
+        const RE_CWD = new RegExp(`${cwd}`, "g");
+        ctx.logger.error(err.message.replace(RE_CWD, "."));
         ctx.logger.log();
       }
       handler.error(ctx, task, err);
@@ -1066,16 +1109,110 @@ async function build(options) {
 }
 
 async function check(options) {
-  const { cwd, tsconfig = "tsconfig.json" } = options;
+  const { cwd, strict, tsconfig = "tsconfig.json" } = options;
   const pkg = await _loadPkgWithReporting({ cwd });
   const config = await _loadConfig({ cwd });
   const ctx = await _resolveBuildContext({ config, cwd, pkg, tsconfig });
   _printPackageTree(ctx);
+  if (strict) {
+    const missingFiles = [];
+    for (const [, exp] of Object.entries(ctx.exports || {})) {
+      if (exp.source && !_fileExists(path.resolve(cwd, exp.source))) {
+        missingFiles.push(exp.source);
+      }
+      if (exp.require && !_fileExists(path.resolve(cwd, exp.require))) {
+        missingFiles.push(exp.require);
+      }
+      if (exp.import && !_fileExists(path.resolve(cwd, exp.import))) {
+        missingFiles.push(exp.import);
+      }
+      if (exp.types && !_fileExists(path.resolve(cwd, exp.types))) {
+        missingFiles.push(exp.types);
+      }
+    }
+    if (missingFiles.length) {
+      throw new Error("missing files");
+    }
+    const _paths = {
+      require: [],
+      import: []
+    };
+    for (const [exportPath, exp] of Object.entries(ctx.exports || {})) {
+      if (!exp._exported)
+        continue;
+      if (exp.require)
+        _paths.require.push(exportPath);
+      if (exp.import)
+        _paths.import.push(exportPath);
+    }
+    const external = Object.keys(pkg.dependencies || {}).concat(
+      Object.keys(pkg.devDependencies || {})
+    );
+    if (_paths.import.length) {
+      const code = _paths.import.map((id) => `import('${id}')`).join("\n");
+      try {
+        const esbuildResult = await esbuild$1.build({
+          external,
+          stdin: {
+            contents: code,
+            loader: "js",
+            resolveDir: cwd
+          },
+          format: "esm",
+          bundle: true,
+          logLevel: "silent",
+          outfile: "/dev/null",
+          platform: "node"
+        });
+        if (esbuildResult.warnings.length > 0) {
+          console.warn(...esbuildResult.warnings);
+        }
+      } catch (err) {
+        const { errors } = err;
+        for (const _err of errors) {
+          if (_err.location) {
+            console.log(chalk.red("error"), _err.detail || _err.text);
+            console.log(`${_err.location.line} | ${_err.location.lineText}`);
+            console.log(
+              "in",
+              `./${_err.location.file}:${_err.location.line}:${_err.location.column}`
+            );
+          } else {
+            console.log(_err.detail || _err.text);
+          }
+          console.log();
+        }
+        process.exit(1);
+      }
+    }
+    if (_paths.require.length) {
+      const code = _paths.require.map((id) => `require('${id}')`).join("\n");
+      const esbuildResult = await esbuild$1.build({
+        external,
+        stdin: {
+          contents: code,
+          loader: "js",
+          resolveDir: cwd
+        },
+        format: "cjs",
+        bundle: true,
+        outfile: "/dev/null",
+        platform: "node"
+      });
+      if (esbuildResult.errors.length > 0) {
+        throw new Error(esbuildResult.errors.join(", "));
+      }
+      if (esbuildResult.warnings.length > 0) {
+        console.warn(...esbuildResult.warnings);
+      }
+    }
+  }
 }
 
 function _resolveWatchTasks(ctx) {
   var _a, _b, _c, _d, _e;
   const { cwd, pkg, target } = ctx;
+  const esTarget = _resolveEsTarget(ctx);
   const tasks = [];
   const exports = Object.entries(ctx.exports || {}).map(
     ([_path, exp]) => ({ _path, ...exp })
@@ -1091,7 +1228,7 @@ function _resolveWatchTasks(ctx) {
         entries: [entry],
         runtime,
         format,
-        target: target[runtime]
+        target: [esTarget].concat(target[runtime])
       };
     } else {
       rollupTasks[buildId].entries.push(entry);
@@ -1105,8 +1242,8 @@ function _resolveWatchTasks(ctx) {
           type: "watch:dts",
           importId,
           exportPath: exp._path,
-          source: exp.source,
-          output: exp.types
+          sourcePath: exp.source,
+          targetPath: exp.types
         };
       }
     }