@sanity/pkg-utils 1.12.0 → 1.13.0

package/dist/_chunks/index-340fbb6a.js

@@ -0,0 +1,774 @@
+'use strict';
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+var chalk = require('chalk');
+
+var rxjs = require('rxjs');
+
+var path = require('path');
+
+var util = require('util');
+
+var rimrafCallback = require('rimraf');
+
+var ts = require('typescript');
+
+var fs = require('fs/promises');
+
+var apiExtractor = require('@microsoft/api-extractor');
+
+var mkdirp = require('mkdirp');
+
+var prettier = require('prettier');
+
+var tsdocConfig = require('@microsoft/tsdoc-config');
+
+var jsoncParser = require('jsonc-parser');
+
+var rollup = require('rollup');
+
+var alias = require('@rollup/plugin-alias');
+
+var pluginBabel = require('@rollup/plugin-babel');
+
+var commonjs = require('@rollup/plugin-commonjs');
+
+var json = require('@rollup/plugin-json');
+
+var pluginNodeResolve = require('@rollup/plugin-node-resolve');
+
+var replace = require('@rollup/plugin-replace');
+
+var esbuild = require('rollup-plugin-esbuild');
+
+var rollupPluginTerser = require('rollup-plugin-terser');
+
+var _resolveBuildContext = require('./_resolveBuildContext-ef196a3e.js');
+
+require('esbuild-register/dist/node');
+
+require('pkg-up');
+
+require('find-config');
+
+require('zod');
+
+function _interopDefaultLegacy(e) {
+  return e && typeof e === 'object' && 'default' in e ? e : {
+    'default': e
+  };
+}
+
+var chalk__default = /*#__PURE__*/_interopDefaultLegacy(chalk);
+
+var path__default = /*#__PURE__*/_interopDefaultLegacy(path);
+
+var rimrafCallback__default = /*#__PURE__*/_interopDefaultLegacy(rimrafCallback);
+
+var ts__default = /*#__PURE__*/_interopDefaultLegacy(ts);
+
+var fs__default = /*#__PURE__*/_interopDefaultLegacy(fs);
+
+var mkdirp__default = /*#__PURE__*/_interopDefaultLegacy(mkdirp);
+
+var prettier__default = /*#__PURE__*/_interopDefaultLegacy(prettier);
+
+var alias__default = /*#__PURE__*/_interopDefaultLegacy(alias);
+
+var commonjs__default = /*#__PURE__*/_interopDefaultLegacy(commonjs);
+
+var json__default = /*#__PURE__*/_interopDefaultLegacy(json);
+
+var replace__default = /*#__PURE__*/_interopDefaultLegacy(replace);
+
+var esbuild__default = /*#__PURE__*/_interopDefaultLegacy(esbuild);
+
+function _printExtractMessages(ctx, messages) {
+  const {
+    cwd,
+    logger
+  } = ctx;
+  const warnings = messages.filter(msg => msg.logLevel === "warning");
+
+  if (warnings.length) {
+    logger.log();
+  }
+
+  for (const msg of warnings) {
+    const sourceFilePath = msg.sourceFilePath && path__default["default"].relative(cwd, msg.sourceFilePath);
+
+    if (msg.messageId === "TS6307") {
+      continue;
+    }
+
+    logger.log(["".concat(chalk__default["default"].cyan(sourceFilePath || "?")), ":".concat(chalk__default["default"].yellow(msg.sourceFileLine), ":").concat(chalk__default["default"].yellow(msg.sourceFileColumn)), " - ".concat(chalk__default["default"].yellow("warning"), " ").concat(chalk__default["default"].gray(msg.messageId), "\n"), msg.text, "\n"].join(""));
+  }
+
+  const errors = messages.filter(msg => msg.logLevel === "error");
+
+  if (!warnings.length && errors.length) {
+    logger.log("");
+  }
+
+  for (const msg of errors) {
+    const sourceFilePath = msg.sourceFilePath && path__default["default"].relative(cwd, msg.sourceFilePath);
+    logger.log(["".concat(chalk__default["default"].cyan(sourceFilePath || "?")), ":".concat(chalk__default["default"].yellow(msg.sourceFileLine), ":").concat(chalk__default["default"].yellow(msg.sourceFileColumn)), " - ".concat(chalk__default["default"].red("error"), " ").concat(chalk__default["default"].gray(msg.messageId), "\n"), msg.text, "\n"].join(""));
+  }
+
+  if (errors.length) {
+    process.exit(1);
+  }
+}
+
+const formatHost = {
+  getCurrentDirectory: () => ts__default["default"].sys.getCurrentDirectory(),
+  getNewLine: () => ts__default["default"].sys.newLine,
+  getCanonicalFileName: ts__default["default"].sys.useCaseSensitiveFileNames ? f => f : f => f.toLowerCase()
+};
+
+async function _buildTypes(options) {
+  const {
+    outDir,
+    tsconfig
+  } = options;
+
+  const compilerOptions = _objectSpread(_objectSpread({}, tsconfig.options), {}, {
+    declaration: true,
+    declarationDir: outDir,
+    emitDeclarationOnly: true,
+    noEmit: false,
+    outDir
+  });
+
+  const program = ts__default["default"].createProgram(tsconfig.fileNames, compilerOptions);
+  const emitResult = program.emit();
+  const allDiagnostics = ts__default["default"].getPreEmitDiagnostics(program).concat(emitResult.diagnostics);
+  allDiagnostics.forEach(diagnostic => {
+    if (diagnostic.file && diagnostic.start) {
+      const {
+        line,
+        character
+      } = ts__default["default"].getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+      const message = ts__default["default"].flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+      console.log("".concat(diagnostic.file.fileName, " ").concat(line + 1, ":").concat(character + 1, "\n").concat(message));
+    } else {
+      console.log(ts__default["default"].flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+    }
+  });
+
+  if (emitResult.emitSkipped) {
+    const errors = allDiagnostics.filter(diag => diag.category === ts__default["default"].DiagnosticCategory.Error);
+
+    if (errors.length) {
+      console.error(ts__default["default"].formatDiagnostics(errors, formatHost));
+      throw new Error("failed to compile");
+    }
+  }
+}
+
+class _DtsError extends Error {
+  constructor(message, messages) {
+    super(message);
+    this.messages = messages;
+  }
+
+}
+
+function _createApiExtractorConfig(options) {
+  const {
+    distPath,
+    exportPath,
+    filePath,
+    messages,
+    projectFolder,
+    mainEntryPointFilePath,
+    tsconfigPath
+  } = options;
+  return {
+    apiReport: {
+      enabled: false,
+      reportFileName: "<unscopedPackageName>.api.md"
+    },
+    compiler: {
+      tsconfigFilePath: tsconfigPath
+    },
+    docModel: {
+      enabled: false,
+      apiJsonFilePath: path__default["default"].resolve(distPath, "".concat(exportPath, ".api.json"))
+    },
+    dtsRollup: {
+      enabled: true,
+      untrimmedFilePath: path__default["default"].resolve(distPath, filePath)
+    },
+    tsdocMetadata: {
+      enabled: false
+    },
+    messages,
+    mainEntryPointFilePath,
+    projectFolder
+  };
+}
+
+async function _createTSDocConfig(opts) {
+  const {
+    customTags
+  } = opts;
+
+  if (customTags.length === 0) {
+    return void 0;
+  }
+
+  const tsDocBaseBuf = await fs.readFile(require.resolve("@microsoft/api-extractor/extends/tsdoc-base.json"));
+  const tsDocBaseConfig = jsoncParser.parse(tsDocBaseBuf.toString());
+  const tagDefinitions = (tsDocBaseConfig.tagDefinitions || []).concat(customTags.map(t => ({
+    tagName: "@".concat(t.name),
+    syntaxKind: t.syntaxKind,
+    allowMultiple: t.allowMultiple
+  })));
+
+  const supportForTags = _objectSpread({}, tsDocBaseConfig.supportForTags);
+
+  for (const customTag of customTags) {
+    supportForTags["@".concat(customTag.name)] = true;
+  }
+
+  return tsdocConfig.TSDocConfigFile.loadFromObject(_objectSpread(_objectSpread({}, tsDocBaseConfig), {}, {
+    noStandardTags: false,
+    tagDefinitions,
+    supportForTags
+  }));
+}
+
+const _LOG_LEVELS = {
+  error: "error",
+  info: "info",
+  off: "none",
+  warn: "warning"
+};
+
+async function _extractTypes(options) {
+  const {
+    distPath,
+    exportPath,
+    files,
+    filePath,
+    projectPath,
+    rules,
+    sourceTypesPath,
+    tsconfigPath
+  } = options;
+  const tsdocConfigFile = await _createTSDocConfig({
+    customTags: []
+  });
+
+  function _ruleToLogLevel(key, defaultLevel) {
+    const r = rules == null ? void 0 : rules[key];
+    return r ? _LOG_LEVELS[r] : defaultLevel || "warning";
+  }
+
+  const messagesConfig = {
+    compilerMessageReporting: {
+      default: {
+        logLevel: "warning"
+      }
+    },
+    extractorMessageReporting: {
+      default: {
+        logLevel: "warning",
+        addToApiReportFile: false
+      },
+      "ae-forgotten-export": {
+        logLevel: _ruleToLogLevel("ae-forgotten-export", "error"),
+        addToApiReportFile: false
+      },
+      "ae-incompatible-release-tags": {
+        logLevel: _ruleToLogLevel("ae-incompatible-release-tags", "error"),
+        addToApiReportFile: false
+      },
+      "ae-internal-missing-underscore": {
+        logLevel: _ruleToLogLevel("ae-internal-missing-underscore"),
+        addToApiReportFile: false
+      },
+      "ae-missing-release-tag": {
+        logLevel: _ruleToLogLevel("ae-missing-release-tag", "error"),
+        addToApiReportFile: false
+      },
+      "ae-wrong-input-file-type": {
+        logLevel: "none",
+        addToApiReportFile: false
+      }
+    },
+    tsdocMessageReporting: {
+      default: {
+        logLevel: "warning",
+        addToApiReportFile: false
+      },
+      "tsdoc-link-tag-unescaped-text": {
+        logLevel: _ruleToLogLevel("tsdoc-link-tag-unescaped-text", "warning"),
+        addToApiReportFile: false
+      },
+      "tsdoc-undefined-tag": {
+        logLevel: _ruleToLogLevel("tsdoc-undefined-tag", "error"),
+        addToApiReportFile: false
+      },
+      "tsdoc-unsupported-tag": {
+        logLevel: _ruleToLogLevel("tsdoc-unsupported-tag", "none"),
+        addToApiReportFile: false
+      }
+    }
+  };
+  const extractorConfig = apiExtractor.ExtractorConfig.prepare({
+    configObject: _createApiExtractorConfig({
+      distPath,
+      exportPath,
+      filePath,
+      messages: messagesConfig,
+      projectFolder: projectPath,
+      mainEntryPointFilePath: sourceTypesPath,
+      tsconfigPath
+    }),
+    configObjectFullPath: void 0,
+    tsdocConfigFile,
+    packageJsonFullPath: path__default["default"].resolve(projectPath, "package.json")
+  });
+  const messages = [];
+  const extractorResult = apiExtractor.Extractor.invoke(extractorConfig, {
+    localBuild: true,
+    showVerboseMessages: true,
+
+    messageCallback(message) {
+      messages.push(message);
+      message.handled = true;
+    }
+
+  });
+  const typesPath = path__default["default"].resolve(distPath, filePath);
+  const typesBuf = await fs__default["default"].readFile(typesPath);
+  const prettierConfig = await prettier__default["default"].resolveConfig(typesPath);
+  await mkdirp__default["default"](path__default["default"].dirname(typesPath));
+  await fs__default["default"].writeFile(typesPath, prettier__default["default"].format(typesBuf.toString(), _objectSpread(_objectSpread({}, prettierConfig), {}, {
+    filepath: typesPath
+  })));
+  files.push({
+    type: "types",
+    path: typesPath
+  });
+  return {
+    extractorResult,
+    messages
+  };
+}
+
+const rimraf = util.promisify(rimrafCallback__default["default"]);
+
+async function _doExtract(ctx, task) {
+  var _a;
+
+  const {
+    config,
+    cwd,
+    files,
+    ts
+  } = ctx;
+
+  if (!ts.config || !ts.configPath) {
+    return {
+      type: "dts",
+      messages: [],
+      results: []
+    };
+  }
+
+  const {
+    outDir,
+    rootDir = cwd
+  } = ts.config.options;
+
+  if (!outDir) {
+    throw new Error("tsconfig.json is missing `compilerOptions.outDir`");
+  }
+
+  const tmpPath = path__default["default"].resolve(outDir, "__tmp__");
+  await _buildTypes({
+    cwd,
+    outDir: tmpPath,
+    tsconfig: ts.config
+  });
+  const messages = [];
+  const results = [];
+
+  for (const entry of task.entries) {
+    const exportPath = entry.exportPath === "." ? "./index" : entry.exportPath;
+    const sourceTypesPath = path__default["default"].resolve(tmpPath, path__default["default"].relative(rootDir, path__default["default"].resolve(cwd, entry.sourcePath)).replace(/\.ts$/, ".d.ts"));
+    const targetPath = path__default["default"].resolve(cwd, entry.targetPath);
+    const result = await _extractTypes({
+      cwd,
+      exportPath,
+      files,
+      filePath: path__default["default"].relative(outDir, targetPath),
+      projectPath: cwd,
+      rules: (_a = config == null ? void 0 : config.extract) == null ? void 0 : _a.rules,
+      sourceTypesPath,
+      tsconfigPath: path__default["default"].resolve(cwd, ts.configPath || "tsconfig.json"),
+      distPath: outDir
+    });
+    messages.push(...result.messages);
+
+    if (result.messages.some(msg => msg.logLevel === "error")) {
+      await rimraf(tmpPath);
+      throw new _DtsError("encountered errors when extracting types", result.messages);
+    }
+
+    results.push({
+      sourcePath: path__default["default"].resolve(cwd, entry.sourcePath),
+      filePath: targetPath
+    });
+  }
+
+  await rimraf(tmpPath);
+  return {
+    type: "dts",
+    messages,
+    results
+  };
+}
+
+const _dtsTask = {
+  name: (_ctx, task) => ["build type definitions", ...task.entries.map(entry => "       ".concat(chalk__default["default"].blue(entry.importId), ": ").concat(entry.sourcePath, " -> ").concat(entry.targetPath))].join("\n"),
+  exec: (ctx, task) => {
+    return new rxjs.Observable(observer => {
+      _doExtract(ctx, task).then(result => {
+        observer.next(result);
+        observer.complete();
+      }).catch(err => {
+        observer.error(err);
+      });
+    });
+  },
+  complete: (ctx, _task, result) => {
+    _printExtractMessages(ctx, result.messages);
+  },
+  error: (ctx, _task, err) => {
+    const {
+      logger
+    } = ctx;
+
+    if (err instanceof _DtsError) {
+      _printExtractMessages(ctx, err.messages);
+    } else if (err instanceof Error) {
+      logger.error(err);
+    }
+  }
+};
+const _dtsWatchTask = {
+  name: (_ctx, task) => ["build type definitions", ...task.entries.map(entry => "       ".concat(chalk__default["default"].blue(entry.importId), ": ").concat(entry.sourcePath, " -> ").concat(entry.targetPath))].join("\n"),
+  exec: (ctx, task) => {
+    return new rxjs.Observable(observer => {
+      _doExtract(ctx, task).then(result => {
+        observer.next(result);
+        observer.complete();
+      }).catch(err => observer.error(err));
+    });
+  },
+  complete: (ctx, _task, result) => {
+    const {
+      logger
+    } = ctx;
+
+    _printExtractMessages(ctx, result.messages);
+
+    logger.warn("watching typescript definitions is currently not supported");
+    logger.log();
+  },
+  error: (ctx, _task, err) => {
+    const {
+      logger
+    } = ctx;
+
+    if (err instanceof _DtsError) {
+      _printExtractMessages(ctx, err.messages);
+    } else if (err instanceof Error) {
+      logger.error(err);
+    }
+  }
+};
+
+function _resolveRollupConfig(ctx, buildTask) {
+  var _ref, _ref3, _ref4, _ref5, _ref6, _ref7;
+
+  var _a, _b;
+
+  const {
+    format,
+    runtime,
+    target
+  } = buildTask;
+  const {
+    config,
+    cwd,
+    exports: _exports,
+    external,
+    distPath,
+    logger,
+    pkg,
+    ts
+  } = ctx;
+  const outputExt = _resolveBuildContext._MODULE_EXT[pkg.type][format];
+  const minify = (_ref = config == null ? void 0 : config.minify) !== null && _ref !== void 0 ? _ref : true;
+  const outDir = path__default["default"].relative(cwd, distPath);
+  const pathAliases = Object.fromEntries(Object.entries(((_a = ts.config) == null ? void 0 : _a.options.paths) || {}).map(_ref2 => {
+    let [key, val] = _ref2;
+
+    var _a2;
+
+    return [key, path__default["default"].resolve(cwd, ((_a2 = ts.config) == null ? void 0 : _a2.options.baseUrl) || ".", val[0])];
+  }));
+  const entries = buildTask.entries.map(entry => {
+    return _objectSpread(_objectSpread({}, entry), {}, {
+      name: path__default["default"].relative(outDir, entry.output).replace(/\.[^/.]+$/, "")
+    });
+  }, {});
+
+  const exportIds = _exports && Object.keys(_exports).map(exportPath => path__default["default"].join(pkg.name, exportPath));
+
+  const sourcePaths = _exports && Object.values(_exports).map(e => path__default["default"].resolve(cwd, e.source));
+
+  return {
+    inputOptions: {
+      context: cwd,
+      external: (id, importer) => {
+        if (exportIds == null ? void 0 : exportIds.includes(id)) {
+          return true;
+        }
+
+        if (importer && (id.startsWith(".") || id.startsWith("/"))) {
+          const idPath = path__default["default"].resolve(path__default["default"].dirname(importer), id);
+
+          if (sourcePaths == null ? void 0 : sourcePaths.includes(idPath)) {
+            logger.warn("detected self-referencing import \u2013 treating as external: ".concat(path__default["default"].relative(cwd, idPath)));
+            return true;
+          }
+        }
+
+        const idParts = id.split("/");
+        const name = idParts[0].startsWith("@") ? "".concat(idParts[0], "/").concat(idParts[1]) : idParts[0];
+
+        if (name && external.includes(name)) {
+          return true;
+        }
+
+        return false;
+      },
+      input: entries.reduce((acc, entry) => {
+        return _objectSpread(_objectSpread({}, acc), {}, {
+          [entry.name]: entry.source
+        });
+      }, {}),
+
+      onwarn(warning, rollupWarn) {
+        if (!warning.code || !["CIRCULAR_DEPENDENCY"].includes(warning.code)) {
+          rollupWarn(warning);
+        }
+      },
+
+      plugins: [replace__default["default"]({
+        preventAssignment: true,
+        values: _objectSpread({}, pkg.name === "@sanity/pkg-utils" ? {} : {
+          "process.env.PKG_FILE_PATH": arg => {
+            const sourcePath = "./" + path__default["default"].relative(cwd, arg);
+            const entry = entries.find(e => e.source === sourcePath);
+
+            if (!entry) {
+              throw new Error("could not find source entry: ".concat(sourcePath));
+            }
+
+            return JSON.stringify(path__default["default"].relative(cwd, path__default["default"].resolve(outDir, entry.name + outputExt)));
+          },
+          "process.env.PKG_FORMAT": JSON.stringify(format),
+          "process.env.PKG_RUNTIME": JSON.stringify(runtime),
+          "process.env.PKG_VERSION": JSON.stringify(process.env.PKG_VERSION || pkg.version)
+        })
+      }), alias__default["default"]({
+        entries: _objectSpread({}, pathAliases)
+      }), pluginNodeResolve.nodeResolve({
+        browser: runtime === "browser",
+        extensions: [".cjs", ".mjs", ".js", ".jsx", ".json", ".node"],
+        preferBuiltins: true
+      }), commonjs__default["default"]({
+        esmExternals: false,
+        extensions: [".js"]
+      }), json__default["default"](), esbuild__default["default"]({
+        jsx: (_ref3 = config == null ? void 0 : config.jsx) !== null && _ref3 !== void 0 ? _ref3 : "automatic",
+        jsxFactory: (_ref4 = config == null ? void 0 : config.jsxFactory) !== null && _ref4 !== void 0 ? _ref4 : "createElement",
+        jsxFragment: (_ref5 = config == null ? void 0 : config.jsxFragment) !== null && _ref5 !== void 0 ? _ref5 : "Fragment",
+        jsxImportSource: (_ref6 = config == null ? void 0 : config.jsxImportSource) !== null && _ref6 !== void 0 ? _ref6 : "react",
+        target,
+        tsconfig: ctx.ts.configPath || "tsconfig.json"
+      }), pluginBabel.getBabelOutputPlugin({
+        babelrc: false,
+        plugins: ["@babel/plugin-proposal-object-rest-spread"],
+        presets: [["@babel/preset-env", {
+          targets: pkg.browserslist || _resolveBuildContext._DEFAULTS.browserslist
+        }]]
+      }), minify && rollupPluginTerser.terser({
+        output: {
+          comments: (_node, comment) => {
+            const text = comment.value;
+            const type = comment.type;
+
+            if (type == "comment2") {
+              return /@preserve|@license|@cc_on/i.test(text);
+            }
+
+            return false;
+          }
+        }
+      }), ...(((_b = config == null ? void 0 : config.rollup) == null ? void 0 : _b.plugins) || [])].filter(Boolean),
+      treeshake: {
+        propertyReadSideEffects: false
+      }
+    },
+    outputOptions: {
+      chunkFileNames: () => "_chunks/[name]-[hash]".concat(outputExt),
+      dir: outDir,
+      entryFileNames: () => outputExt === ".esm.js" ? "[name].js" : "[name]".concat(outputExt),
+      format,
+      exports: "auto",
+      sourcemap: (_ref7 = config == null ? void 0 : config.sourcemap) !== null && _ref7 !== void 0 ? _ref7 : true
+    }
+  };
+}
+
+const _rollupTask = {
+  name: (ctx, task) => "build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk__default["default"].blue(path__default["default"].join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")),
+  exec: (ctx, task) => {
+    return new rxjs.Observable(observer => {
+      _execPromise(ctx, task).then(result => {
+        observer.next(result);
+        observer.complete();
+      }).catch(err => observer.error(err));
+    });
+  },
+  complete: () => {},
+  error: (_ctx, _task, err) => {
+    if (err instanceof Error) {
+      console.log(err);
+    }
+  }
+};
+
+async function _execPromise(ctx, task) {
+  const {
+    files,
+    distPath
+  } = ctx;
+  const outDir = path__default["default"].relative(ctx.cwd, distPath);
+
+  const {
+    inputOptions,
+    outputOptions
+  } = _resolveRollupConfig(ctx, task);
+
+  const bundle = await rollup.rollup(inputOptions);
+  const {
+    output
+  } = await bundle.generate(outputOptions);
+
+  for (const chunkOrAsset of output) {
+    if (chunkOrAsset.type === "asset") {
+      files.push({
+        type: "asset",
+        path: path__default["default"].resolve(outDir, chunkOrAsset.fileName)
+      });
+    } else {
+      files.push({
+        type: "chunk",
+        path: path__default["default"].resolve(outDir, chunkOrAsset.fileName)
+      });
+    }
+  }
+
+  await bundle.write(outputOptions);
+  await bundle.close();
+}
+
+const _rollupWatchTask = {
+  name: (ctx, task) => "build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk__default["default"].blue(path__default["default"].join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")),
+  exec: (ctx, task) => {
+    const {
+      inputOptions,
+      outputOptions
+    } = _resolveRollupConfig(ctx, task);
+
+    return new rxjs.Observable(observer => {
+      const watchOptions = _objectSpread(_objectSpread({}, inputOptions), {}, {
+        output: outputOptions
+      });
+
+      const watcher = rollup.watch(watchOptions);
+      watcher.on("event", event => {
+        observer.next(event);
+      });
+      return () => {
+        watcher.close();
+      };
+    });
+  },
+  complete: (ctx, task, event) => {
+    const {
+      logger
+    } = ctx;
+
+    if (event.code === "BUNDLE_END") {
+      logger.success("build javascript files (target ".concat(task.target.join(" + "), ", format ").concat(task.format, ")\n       ").concat(task.entries.map(e => "".concat(chalk__default["default"].blue(path__default["default"].join(ctx.pkg.name, e.path)), ": ").concat(e.source, " -> ").concat(e.output)).join("\n       ")));
+      logger.log("");
+      return;
+    }
+
+    if (event.code === "BUNDLE_START") {
+      return;
+    }
+
+    if (event.code === "END") {
+      return;
+    }
+
+    if (event.code === "ERROR") {
+      logger.error(event.code, event);
+      return;
+    }
+
+    if (event.code === "START") {
+      return;
+    }
+  },
+  error: (ctx, _task, err) => {
+    const {
+      logger
+    } = ctx;
+
+    if (err instanceof Error) {
+      logger.log(err);
+    }
+  }
+};
+const _buildTaskHandlers = {
+  "build:dts": _dtsTask,
+  "build:js": _rollupTask
+};
+const _watchTaskHandlers = {
+  "watch:dts": _dtsWatchTask,
+  "watch:js": _rollupWatchTask
+};
+exports._buildTaskHandlers = _buildTaskHandlers;
+exports._dtsTask = _dtsTask;
+exports._dtsWatchTask = _dtsWatchTask;
+exports._rollupTask = _rollupTask;
+exports._rollupWatchTask = _rollupWatchTask;
+exports._watchTaskHandlers = _watchTaskHandlers;
+//# sourceMappingURL=index-340fbb6a.js.map