@modern-js/app-tools 2.53.0 → 2.53.1-alpha.1

package/dist/js/modern/analyze/index.js

@@ -0,0 +1,148 @@
+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; }
+
+import * as path from 'path';
+import { createAsyncWaterfall } from '@modern-js/plugin';
+import { createDebugger, fs, isApiOnly } from '@modern-js/utils';
+import { cloneDeep } from '@modern-js/utils/lodash';
+import { isRouteComponentFile } from "./utils";
+const debug = createDebugger('plugin-analyze');
+export const modifyEntryImports = createAsyncWaterfall();
+export const modifyEntryExport = createAsyncWaterfall();
+export const addRuntimeExports = createAsyncWaterfall();
+export const modifyEntryRuntimePlugins = createAsyncWaterfall();
+export const modifyEntryRenderFunction = createAsyncWaterfall();
+export const modifyAsyncEntry = createAsyncWaterfall();
+export const modifyFileSystemRoutes = createAsyncWaterfall();
+export const modifyServerRoutes = createAsyncWaterfall();
+export const htmlPartials = createAsyncWaterfall();
+export const beforeGenerateRoutes = createAsyncWaterfall();
+export const addDefineTypes = createAsyncWaterfall();
+export default (() => ({
+  name: '@modern-js/plugin-analyze',
+  registerHook: {
+    modifyAsyncEntry,
+    modifyEntryImports,
+    modifyEntryExport,
+    modifyEntryRuntimePlugins,
+    modifyEntryRenderFunction,
+    modifyFileSystemRoutes,
+    modifyServerRoutes,
+    htmlPartials,
+    addRuntimeExports,
+    beforeGenerateRoutes,
+    addDefineTypes
+  },
+  setup: api => {
+    let pagesDir = [];
+    let originEntrypoints = [];
+    return {
+      async prepare() {
+        var _resolvedConfig$sourc;
+
+        const appContext = api.useAppContext();
+        const resolvedConfig = api.useResolvedConfigContext();
+        const hookRunners = api.useHookRunners();
+
+        try {
+          fs.emptydirSync(appContext.internalDirectory);
+        } catch (_unused) {// FIXME:
+        }
+
+        const apiOnly = await isApiOnly(appContext.appDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig$sourc = resolvedConfig.source) === null || _resolvedConfig$sourc === void 0 ? void 0 : _resolvedConfig$sourc.entriesDir);
+        await hookRunners.addRuntimeExports();
+
+        if (apiOnly) {
+          const {
+            routes
+          } = await hookRunners.modifyServerRoutes({
+            routes: []
+          });
+          debug(`server routes: %o`, routes);
+          api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+            apiOnly,
+            serverRoutes: routes
+          }));
+          return;
+        }
+
+        const [{
+          getBundleEntry
+        }, {
+          getServerRoutes
+        }, {
+          generateCode
+        }, {
+          getHtmlTemplate
+        }] = await Promise.all([import("./getBundleEntry"), import("./getServerRoutes"), import("./generateCode"), import("./getHtmlTemplate")]);
+        const entrypoints = getBundleEntry(appContext, resolvedConfig);
+        const defaultChecked = entrypoints.map(point => point.entryName);
+        debug(`entrypoints: %o`, entrypoints);
+        const initialRoutes = getServerRoutes(entrypoints, {
+          appContext,
+          config: resolvedConfig
+        });
+        const {
+          routes
+        } = await hookRunners.modifyServerRoutes({
+          routes: initialRoutes
+        });
+        debug(`server routes: %o`, routes);
+        api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+          entrypoints,
+          serverRoutes: routes
+        }));
+        pagesDir = entrypoints.map(point => point.entry);
+        originEntrypoints = cloneDeep(entrypoints);
+        await generateCode(appContext, resolvedConfig, entrypoints, api);
+        const htmlTemplates = await getHtmlTemplate(entrypoints, api, {
+          appContext,
+          config: resolvedConfig
+        });
+        debug(`html templates: %o`, htmlTemplates);
+        await hookRunners.addDefineTypes();
+        debug(`add Define Types`);
+        api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+          entrypoints,
+          checkedEntries: defaultChecked,
+          apiOnly,
+          serverRoutes: routes,
+          htmlTemplates
+        }));
+      },
+
+      watchFiles() {
+        return pagesDir;
+      },
+
+      async fileChange(e) {
+        const appContext = api.useAppContext();
+        const {
+          appDirectory
+        } = appContext;
+        const {
+          filename,
+          eventType
+        } = e;
+
+        const isPageFile = name => pagesDir.some(pageDir => name.includes(pageDir));
+
+        const absoluteFilePath = path.resolve(appDirectory, filename);
+        const isRouteComponent = isPageFile(absoluteFilePath) && isRouteComponentFile(absoluteFilePath);
+
+        if (isRouteComponent && (eventType === 'add' || eventType === 'unlink')) {
+          const resolvedConfig = api.useResolvedConfigContext();
+          const {
+            generateCode
+          } = await import("./generateCode");
+          const entrypoints = cloneDeep(originEntrypoints);
+          generateCode(appContext, resolvedConfig, entrypoints, api);
+        }
+      }
+
+    };
+  }
+}));

package/dist/js/modern/analyze/isDefaultExportFunction.js

@@ -0,0 +1,32 @@
+import fs from 'fs';
+import { parse } from '@babel/parser';
+import traverse from '@babel/traverse';
+import * as t from '@babel/types';
+
+const isFunction = node => t.isFunctionDeclaration(node) || t.isFunctionExpression(node) || t.isArrowFunctionExpression(node);
+
+export const isDefaultExportFunction = file => {
+  if (!file || !fs.existsSync(file)) {
+    return false;
+  }
+
+  const ast = parse(fs.readFileSync(file, 'utf8'), {
+    sourceType: 'unambiguous',
+    plugins: ['jsx', 'typescript', 'classProperties', 'dynamicImport', 'exportDefaultFrom', 'exportNamespaceFrom', 'decorators-legacy', 'functionBind', 'classPrivateMethods', ['pipelineOperator', {
+      proposal: 'minimal'
+    }], 'optionalChaining', 'optionalCatchBinding', 'objectRestSpread', 'numericSeparator']
+  });
+  let isExportFunction = false;
+  traverse(ast, {
+    ExportDefaultDeclaration: path => {
+      const {
+        declaration
+      } = path.node;
+
+      if (isFunction(declaration)) {
+        isExportFunction = true;
+      }
+    }
+  });
+  return isExportFunction;
+};

package/dist/js/modern/analyze/makeLegalIdentifier.js

@@ -0,0 +1,16 @@
+/**
+ * modified from https://github.com/rollup/plugins/blob/master/packages/pluginutils
+ * license at https://github.com/rollup/plugins/blob/master/LICENSE
+ */
+const reservedWords = 'break case class catch const continue debugger default delete do else export extends finally for function if import in instanceof let new return super switch this throw try typeof var void while with yield enum await implements package protected static interface private public';
+const builtins = 'arguments Infinity NaN undefined null true false eval uneval isFinite isNaN parseFloat parseInt decodeURI decodeURIComponent encodeURI encodeURIComponent escape unescape Object Function Boolean Symbol Error EvalError InternalError RangeError ReferenceError SyntaxError TypeError URIError Number Math Date String RegExp Array Int8Array Uint8Array Uint8ClampedArray Int16Array Uint16Array Int32Array Uint32Array Float32Array Float64Array Map Set WeakMap WeakSet SIMD ArrayBuffer DataView JSON Promise Generator GeneratorFunction Reflect Proxy Intl';
+const forbidList = new Set(`${reservedWords} ${builtins}`.split(' '));
+export function makeLegalIdentifier(str) {
+  const identifier = str.replace(/-(\w)/g, (_, letter) => letter.toUpperCase()).replace(/[^$_a-zA-Z0-9]/g, '_');
+
+  if (/\d/.test(identifier[0]) || forbidList.has(identifier)) {
+    return `_${identifier}`;
+  }
+
+  return identifier || '_';
+}

package/dist/js/modern/analyze/templates.js

@@ -0,0 +1,88 @@
+export const index = ({
+  mountId,
+  imports,
+  renderFunction,
+  exportStatement
+}) => `
+const IS_BROWSER = typeof window !== 'undefined' && window.name !== 'nodejs';
+const IS_REACT18 = process.env.IS_REACT18 === 'true';
+const MOUNT_ID = '${mountId}';
+
+${imports}
+
+let AppWrapper = null;
+
+let root = null;
+
+function render() {
+  ${renderFunction}
+}
+
+AppWrapper = render();
+
+${exportStatement};
+`;
+export const renderFunction = ({
+  plugins,
+  customBootstrap,
+  fileSystemRoutes
+}) => `
+  AppWrapper = createApp({
+    plugins: [
+     ${plugins.map(({
+  name,
+  options,
+  args
+}) => `${name}({...${options}, ...App?.config?.${args || name}}),`).join('\n')}
+    ]
+  })(${fileSystemRoutes ? '' : `App`})
+
+  if (IS_BROWSER) {
+    ${customBootstrap ? `customBootstrap(AppWrapper);` : `bootstrap(AppWrapper, MOUNT_ID, root, ReactDOM);`}
+  }
+
+  return AppWrapper
+`;
+export const html = partials => `
+<!DOCTYPE html>
+<html>
+<head>
+  <%= meta %>
+  <title><%= title %></title>
+
+  ${partials.top.join('\n')}
+
+  <script>
+    window.__assetPrefix__ = '<%= assetPrefix %>';
+  </script>
+  ${partials.head.join('\n')}
+
+  <!--<?- chunksMap.css ?>-->
+</head>
+
+<body>
+  <noscript>
+    We're sorry but react app doesn't work properly without JavaScript enabled. Please enable it to continue.
+  </noscript>
+  <div id="<%= mountId %>"><!--<?- html ?>--></div>
+  ${partials.body.join('\n')}
+  <!--<?- chunksMap.js ?>-->
+  <!--<?- SSRDataScript ?>-->
+  <!--<?- bottomTemplate ?>-->
+</body>
+
+</html>
+`;
+export const fileSystemRoutes = ({
+  routes
+}) => `
+import loadable from '@modern-js/runtime/loadable';
+
+${routes.map(({
+  component,
+  _component
+}) => `const ${component} = loadable(() => import('${_component}'));`).join('\n\n')}
+
+
+export const routes = ${JSON.stringify(routes, null, 2).replace(/"component"\s*:\s*"(\S+)"/g, '"component": $1')}
+`;

package/dist/js/modern/analyze/utils.js

@@ -0,0 +1,92 @@
+import fs from 'fs';
+import path from 'path';
+import { isReact18, normalizeToPosixPath } from '@modern-js/utils';
+import { FILE_SYSTEM_ROUTES_FILE_NAME } from "./constants";
+export const walkDirectory = dir => fs.readdirSync(dir).reduce((previous, filename) => {
+  const filePath = path.join(dir, filename);
+
+  if (fs.statSync(filePath).isDirectory()) {
+    return [...previous, ...walkDirectory(filePath)];
+  } else {
+    return [...previous, filePath];
+  }
+}, []);
+export const getDefaultImports = ({
+  entrypoint,
+  srcDirectory,
+  internalSrcAlias,
+  internalDirAlias,
+  internalDirectory
+}) => {
+  const {
+    entryName,
+    fileSystemRoutes,
+    customBootstrap,
+    entry
+  } = entrypoint;
+  const imports = [{
+    specifiers: [{
+      local: 'React'
+    }],
+    value: 'react'
+  }, {
+    specifiers: [{
+      local: 'ReactDOM'
+    }],
+    value: isReact18(path.join(internalDirectory, '../../')) ? 'react-dom/client' : 'react-dom'
+  }, {
+    specifiers: [{
+      imported: 'createApp'
+    }, {
+      imported: 'bootstrap'
+    }],
+    value: '@modern-js/runtime'
+  }, customBootstrap && {
+    specifiers: [{
+      local: 'customBootstrap'
+    }],
+    value: normalizeToPosixPath(customBootstrap.replace(srcDirectory, internalSrcAlias))
+  }].filter(Boolean);
+
+  if (fileSystemRoutes) {
+    const route = {
+      specifiers: [{
+        imported: 'routes'
+      }],
+      value: normalizeToPosixPath(`${internalDirAlias}/${entryName}/${FILE_SYSTEM_ROUTES_FILE_NAME}`)
+    };
+
+    if (fileSystemRoutes.globalApp) {
+      imports.push({
+        specifiers: [{
+          local: 'App'
+        }],
+        value: normalizeToPosixPath(fileSystemRoutes.globalApp.replace(srcDirectory, internalSrcAlias))
+      });
+    } else {
+      route.initialize = 'const App = false;';
+    }
+
+    imports.push(route);
+  } else {
+    imports.push({
+      specifiers: [{
+        local: 'App'
+      }],
+      value: normalizeToPosixPath(entry.replace(srcDirectory, internalSrcAlias))
+    });
+  }
+
+  return imports;
+};
+export const isRouteComponentFile = filePath => {
+  if (/\.(d|test|spec|e2e)\.(js|jsx|ts|tsx)$/.test(filePath)) {
+    return false;
+  }
+
+  if (['.js', '.jsx', '.ts', '.tsx'].includes(path.extname(filePath))) {
+    return true;
+  }
+
+  return false;
+};

package/dist/js/modern/commands/build.js

@@ -0,0 +1,154 @@
+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; }
+
+import { webpack, getWebpackConfig, WebpackConfigTarget } from '@modern-js/webpack';
+import { ResolvedConfigContext } from '@modern-js/core';
+import { formatWebpackMessages, measureFileSizesBeforeBuild, printFileSizesAfterBuild, printBuildError, logger, isUseSSRBundle, emptyDir } from '@modern-js/utils';
+import { generateRoutes } from "../utils/routes";
+import { buildServerConfig, emitResolvedConfig } from "../utils/config";
+// These sizes are pretty large. We'll warn for bundles exceeding them.
+const WARN_AFTER_BUNDLE_GZIP_SIZE = 512 * 1024;
+const WARN_AFTER_CHUNK_GZIP_SIZE = 1024 * 1024;
+export const build = async (api, options) => {
+  let resolvedConfig = api.useResolvedConfigContext();
+  const appContext = api.useAppContext();
+  const hookRunners = api.useHookRunners();
+  const {
+    apiOnly
+  } = appContext;
+
+  if (apiOnly) {
+    const {
+      appDirectory,
+      distDirectory,
+      serverConfigFile
+    } = appContext;
+    await emptyDir(distDirectory);
+    await hookRunners.beforeBuild({
+      webpackConfigs: []
+    });
+    await buildServerConfig({
+      appDirectory,
+      distDirectory,
+      configFile: serverConfigFile
+    });
+    await generateRoutes(appContext);
+    await hookRunners.afterBuild();
+    return;
+  }
+
+  const webpackBuild = async (webpackConfig, type) => {
+    const compiler = webpack(webpackConfig);
+    return new Promise((resolve, reject) => {
+      let label = process.env.NODE_ENV || '';
+
+      if (type && type !== 'legacy') {
+        label += ` ${type}`;
+      }
+
+      logger.info(`Creating a ${label} build...`);
+      compiler.run((err, stats) => {
+        let messages;
+
+        if (!err) {
+          messages = formatWebpackMessages(stats.toJson({
+            all: false,
+            warnings: true,
+            errors: true
+          }));
+
+          if (messages.errors.length === 0) {
+            logger.info(`File sizes after ${label} build:\n`);
+            printFileSizesAfterBuild(stats, previousFileSizes, distDirectory, WARN_AFTER_BUNDLE_GZIP_SIZE, WARN_AFTER_CHUNK_GZIP_SIZE);
+            logger.log();
+          }
+        } // When using run or watch, call close and wait for it to finish before calling run or watch again.
+        // Concurrent compilations will corrupt the output files.
+
+
+        compiler.close(closeErr => {
+          if (closeErr) {
+            logger.error(closeErr);
+          }
+
+          if (err) {
+            reject(err);
+          } else {
+            if (messages.errors.length) {
+              reject(new Error(messages.errors.join('\n\n')));
+              return;
+            }
+
+            resolve({
+              warnings: messages.warnings
+            });
+          }
+        });
+      });
+    });
+  };
+
+  resolvedConfig = _objectSpread(_objectSpread({}, resolvedConfig), {}, {
+    cliOptions: options
+  });
+  ResolvedConfigContext.set(resolvedConfig);
+  const {
+    distDirectory,
+    appDirectory,
+    serverConfigFile
+  } = appContext;
+  const previousFileSizes = await measureFileSizesBeforeBuild(distDirectory);
+  await emptyDir(distDirectory);
+  await buildServerConfig({
+    appDirectory,
+    distDirectory,
+    configFile: serverConfigFile
+  });
+  const buildConfigs = [];
+  buildConfigs.push({
+    type: 'legacy',
+    config: getWebpackConfig(WebpackConfigTarget.CLIENT, appContext, resolvedConfig)
+  });
+
+  if (resolvedConfig.output.enableModernMode) {
+    buildConfigs.push({
+      type: 'modern',
+      config: getWebpackConfig(WebpackConfigTarget.MODERN, appContext, resolvedConfig)
+    });
+  }
+
+  if (isUseSSRBundle(resolvedConfig)) {
+    buildConfigs.push({
+      type: 'ssr',
+      config: getWebpackConfig(WebpackConfigTarget.NODE, appContext, resolvedConfig)
+    });
+  }
+
+  await hookRunners.beforeBuild({
+    webpackConfigs: buildConfigs.map(({
+      config
+    }) => config)
+  });
+
+  for (const buildConfig of buildConfigs) {
+    const {
+      type: buildType,
+      config
+    } = buildConfig;
+
+    try {
+      await webpackBuild(config, buildType);
+    } catch (error) {
+      printBuildError(error); // eslint-disable-next-line no-process-exit
+
+      process.exit(1);
+    }
+  }
+
+  await generateRoutes(appContext);
+  await hookRunners.afterBuild();
+  await emitResolvedConfig(appDirectory, resolvedConfig);
+};

package/dist/js/modern/commands/deploy.js

@@ -0,0 +1,5 @@
+export const deploy = async (api, options) => {
+  const hookRunners = api.useHookRunners();
+  await hookRunners.beforeDeploy(options);
+  await hookRunners.afterDeploy(options);
+};

package/dist/js/modern/commands/dev.js

@@ -0,0 +1,95 @@
+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; }
+
+import { fs, logger, chalk, isSSR } from '@modern-js/utils';
+import { ResolvedConfigContext } from '@modern-js/core';
+import { createCompiler } from "../utils/createCompiler";
+import { createServer } from "../utils/createServer";
+import { generateRoutes } from "../utils/routes";
+import { printInstructions } from "../utils/printInstructions";
+import { getSpecifiedEntries } from "../utils/getSpecifiedEntries";
+import { buildServerConfig } from "../utils/config";
+export const dev = async (api, options) => {
+  let userConfig = api.useResolvedConfigContext();
+  const appContext = api.useAppContext();
+  const hookRunners = api.useHookRunners();
+  userConfig = _objectSpread(_objectSpread({}, userConfig), {}, {
+    cliOptions: options
+  });
+  ResolvedConfigContext.set(userConfig);
+  const {
+    appDirectory,
+    distDirectory,
+    port,
+    apiOnly,
+    entrypoints,
+    serverConfigFile
+  } = appContext;
+  const checkedEntries = await getSpecifiedEntries(options.entry || false, entrypoints);
+  api.setAppContext(_objectSpread(_objectSpread({}, appContext), {}, {
+    checkedEntries
+  }));
+  appContext.checkedEntries = checkedEntries;
+  fs.emptyDirSync(distDirectory);
+  await buildServerConfig({
+    appDirectory,
+    distDirectory,
+    configFile: serverConfigFile,
+    options: {
+      esbuildOptions: {
+        watch: true
+      }
+    }
+  });
+  await hookRunners.beforeDev();
+  let compiler = null;
+
+  if (!apiOnly) {
+    const {
+      getWebpackConfig,
+      WebpackConfigTarget
+    } = await import('@modern-js/webpack');
+    const webpackConfigs = [isSSR(userConfig) && getWebpackConfig(WebpackConfigTarget.NODE, appContext, userConfig), getWebpackConfig(WebpackConfigTarget.CLIENT, appContext, userConfig)].filter(Boolean);
+    compiler = await createCompiler({
+      api,
+      webpackConfigs,
+      userConfig,
+      appContext
+    });
+  }
+
+  await generateRoutes(appContext);
+  const app = await createServer({
+    dev: _objectSpread(_objectSpread({}, {
+      client: {
+        port: port.toString()
+      },
+      devMiddleware: {
+        writeToDisk: file => !file.includes('.hot-update.')
+      },
+      hot: true,
+      liveReload: true,
+      port,
+      https: userConfig.dev.https
+    }), userConfig.tools.devServer),
+    compiler,
+    pwd: appDirectory,
+    config: userConfig,
+    serverConfigFile,
+    plugins: appContext.plugins.filter(p => p.server).map(p => p.server)
+  });
+  app.listen(port, async err => {
+    if (err) {
+      throw err;
+    }
+
+    if (apiOnly) {
+      return printInstructions(hookRunners, appContext, userConfig);
+    }
+
+    return logger.log(chalk.cyan(`Starting the development server...`));
+  });
+};

package/dist/js/modern/commands/index.js

@@ -0,0 +1,3 @@
+export * from "./dev";
+export * from "./build";
+export * from "./start";