@modern-js/plugin-docsite 0.0.0-bundle-deps-202110123508

package/dist/js/modern/features/utils/generate-files.js

@@ -0,0 +1,197 @@
+import _difference from "lodash/difference";
+import _template from "lodash/template";
+import _union from "lodash/union";
+import _camelCase from "lodash/camelCase";
+import _startCase from "lodash/startCase";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (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 = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { _defineProperty(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { 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 path from 'path';
+import { logger, fs } from '@modern-js/utils';
+import matter from 'gray-matter';
+import GithubSlugger from 'github-slugger';
+import sortPaths from 'sort-paths';
+import visit from 'unist-util-visit';
+import toString from 'mdast-util-to-string';
+import u from 'unist-builder';
+import mdx from '@mdx-js/mdx';
+import babelParser from '@modern-js/deps/compiled/babel/parser';
+import { DOCS_RENDER_PATH, MDX_DEFAULT_RENDERER, UTILS_STATIC } from "../constant";
+
+const loadTemplate = async (file, customPath = false) => {
+  let result = '';
+
+  if (customPath) {
+    result = await fs.readFile(file, 'utf-8');
+  } else {
+    result = await fs.readFile(path.join(UTILS_STATIC, file), 'utf-8');
+  }
+
+  return _template(result, {
+    interpolate: /<%=([\s\S]+?)%>/g
+  });
+};
+
+// eslint-disable-next-line max-statements
+async function handleFile(appDirectory, tmpDir, file, images) {
+  const moduleName = file.replace(/\.(md|mdx)$/, '');
+  const content = await fs.readFile(path.resolve(appDirectory, 'docs', file));
+  const parsed = matter(content);
+
+  if (!parsed.data.title) {
+    parsed.data.title = _startCase(_camelCase(path.basename(moduleName)));
+  }
+
+  const slugger = new GithubSlugger();
+  slugger.reset();
+  const babelOptions = {
+    allowUndeclaredExports: true,
+    sourceType: 'module'
+  };
+  const imported = [];
+  const exported = [];
+  const toc = [];
+
+  const modifier = () => tree => {
+    visit(tree, 'import', node => {
+      const parsedNode = babelParser.parse(node.value, babelOptions);
+      const nodes = parsedNode.program.body;
+      nodes.forEach(n => {
+        if (n.type === 'ImportDeclaration') {
+          n.specifiers.forEach(sp => {
+            imported.push({
+              id: sp.local.name,
+              node
+            });
+          });
+        }
+      });
+    });
+    visit(tree, 'export', node => {
+      const parsedNode = babelParser.parse(node.value, babelOptions);
+      const nodes = parsedNode.program.body;
+      nodes.forEach(n => {
+        if (n.type === 'ExportNamedDeclaration') {
+          n.specifiers.forEach(sp => {
+            exported.push({
+              id: sp.exported.name,
+              node
+            });
+          });
+        }
+      });
+    });
+
+    const extraImported = _difference(imported.map(n => n.id), exported.map(n => n.id)); // we have to put the export statement with the import,
+    // otherwise the mdx's babel transformer cannot found
+    // the corresponding imports
+
+
+    extraImported.forEach(id => {
+      const {
+        node
+      } = imported.find(n => n.id === id);
+      node.value += `\nexport { ${id} };`;
+    });
+    visit(tree, 'heading', node => {
+      if (node.depth === 2) {
+        const slug = slugger.slug(toString(node));
+        node.data = {
+          hProperties: {
+            id: slug
+          }
+        };
+        toc.push({
+          slug,
+          text: toString(node)
+        });
+      }
+    });
+    visit(tree, 'root', node => {
+      (node.children || []).unshift(u('heading', {
+        depth: 1,
+        children: [u('text', {
+          value: parsed.data.title
+        })]
+      }));
+    });
+    visit(tree, 'image', node => {
+      const {
+        url
+      } = node;
+
+      if (!url.startsWith('http')) {
+        const fullPath = path.resolve(path.dirname(path.resolve(appDirectory, 'docs', file)), url);
+        const relativePath = path.relative(path.resolve(appDirectory, 'assets'), fullPath);
+
+        if (relativePath.startsWith('..')) {
+          logger.warn(`${url} referenced in ${file} is not under the "assets" folder`);
+        } else {
+          images.push(relativePath);
+          node.url = `/${path.relative(path.dirname(path.resolve(appDirectory, 'docs', file)), path.resolve(appDirectory, 'docs/assets', relativePath))}`;
+        }
+      }
+    });
+  };
+
+  const transpiled = await mdx(parsed.content, {
+    remarkPlugins: [modifier]
+  });
+
+  const totalExported = _union(imported.map(n => n.id), exported.map(n => n.id));
+
+  const outputFile = path.resolve(tmpDir, `${moduleName}/mdx.jsx`);
+  await fs.outputFile(outputFile, MDX_DEFAULT_RENDERER + transpiled, {
+    encoding: 'utf8'
+  });
+  const pageFile = path.resolve(tmpDir, `${moduleName}/index.jsx`);
+  const pageTemplate = await loadTemplate('docs-page.jsx.tpl');
+  const pageContent = pageTemplate({
+    moduleName,
+    toc: JSON.stringify(toc),
+    relRoot: path.relative(path.dirname(outputFile), tmpDir),
+    imports: totalExported.length ? `import { ${totalExported.join(', ')} } from './mdx';` : '',
+    imported: totalExported.join(',')
+  });
+  await fs.outputFile(pageFile, pageContent, {
+    encoding: 'utf8'
+  });
+  return _objectSpread(_objectSpread({}, parsed.data), {}, {
+    moduleName,
+    pageFile
+  });
+}
+
+export async function generateFiles(appDirectory, tmpDir, files, isDev) {
+  await fs.remove(tmpDir);
+  await fs.ensureDir(tmpDir);
+  const images = [];
+  const meta = await Promise.all(files.map(file => handleFile(appDirectory, tmpDir, file, images)));
+  const sorted = sortPaths(meta, e => e.moduleName.endsWith('index') ? e.moduleName.replace(/index$/, '') : `${e.moduleName}/`, '/');
+  const routesTemplate = await loadTemplate('DocsRoutes.jsx.tpl');
+  await fs.outputFile(path.resolve(tmpDir, 'DocsRoutes.jsx'), routesTemplate({
+    meta: sorted
+  }));
+  const pkgInfo = await fs.readJson(path.resolve(appDirectory, 'package.json'));
+  const entryTemplate = await loadTemplate('docs-entry.jsx.tpl');
+  await fs.outputFile(path.resolve(tmpDir, 'docs-entry.jsx'), entryTemplate({
+    basename: isDev ? '/' : `${DOCS_RENDER_PATH}/${pkgInfo.name}/${pkgInfo.version}`
+  }));
+  await Promise.all(['DocsNav.jsx.tpl', 'DocsToc.jsx.tpl', 'docs.css'].map(async file => fs.copyFile(path.resolve(UTILS_STATIC, file), path.resolve(tmpDir, file.replace('.tpl', '')))));
+  await fs.outputJson(path.resolve(tmpDir, 'meta.json'), sorted.map(({
+    title,
+    moduleName
+  }) => ({
+    title,
+    moduleName
+  })), {
+    spaces: 2
+  });
+  await fs.ensureDir(path.resolve(appDirectory, 'dist/docs/assets'));
+  await Promise.all(Array.from(new Set(images)).map(file => fs.copyFile(path.resolve(appDirectory, 'assets', file), path.resolve(appDirectory, 'dist/docs/assets', file))));
+  return sorted;
+}

package/dist/js/modern/features/utils/valid.js

@@ -0,0 +1,17 @@
+import path from 'path';
+import * as glob from 'glob';
+import { chalk, fs } from '@modern-js/utils';
+export const valid = ({
+  appDirectory,
+  docsDir
+}) => {
+  const docsAbsPath = path.join(appDirectory, docsDir);
+  const files = glob.sync(`${docsAbsPath}/**/*.{md,mdx}`);
+
+  if (!fs.existsSync(docsAbsPath) || files.length <= 0) {
+    console.info(chalk.yellow('No docs found, create directory "./docs" and add md(x) files'));
+    return false;
+  }
+
+  return true;
+};

package/dist/js/modern/features/utils/webpack.js

@@ -0,0 +1,63 @@
+import path from 'path';
+import { fs } from '@modern-js/utils';
+import HtmlWebpackPlugin from '@modern-js/deps/compiled/html-webpack-plugin';
+import webpack from '@modern-js/deps/compiled/webpack';
+import { getWebpackConfig, WebpackConfigTarget } from '@modern-js/webpack';
+import { UTILS_STATIC } from "../constant";
+export function generatorWebpackConfig(appDirectory, tmpDir, isDev) {
+  const originConfig = getWebpackConfig(WebpackConfigTarget.CLIENT);
+  const plugins = (originConfig.plugins || []).filter(p => p.constructor !== webpack.HotModuleReplacementPlugin);
+  const config = {
+    mode: isDev ? 'development' : 'production',
+    context: tmpDir,
+    entry: {
+      index: path.resolve(tmpDir, 'docs-entry.jsx')
+    },
+    output: {
+      path: path.resolve(appDirectory, 'dist/docs')
+    },
+    resolve: originConfig.resolve || {
+      alias: {}
+    },
+    module: originConfig.module,
+    plugins: [...plugins, new HtmlWebpackPlugin({
+      templateContent: fs.readFileSync(path.resolve(UTILS_STATIC, 'index.html.ejs'), 'utf8')
+    })]
+  };
+  config.resolve.modules = [...(config.resolve.modules || []), path.join(__dirname, '../../../../../', 'node_modules')];
+  config.resolve.alias['@assets'] = path.resolve(appDirectory, 'assets');
+  config.resolve.alias['@styles'] = path.resolve(appDirectory, 'styles'); // fix this since react-live relies on core-js@2
+
+  config.resolve.alias[`${path.dirname(require.resolve('core-js'))}/fn`] = 'core-js/es';
+  const pkgJSON = JSON.parse(fs.readFileSync(path.join(appDirectory, 'package.json'), 'utf-8'));
+
+  if (pkgJSON.dependencies.react || pkgJSON.devDependencies.react) {
+    config.resolve.alias.react = path.resolve('node_modules/react');
+  } else {
+    config.resolve.alias.react = path.resolve(__dirname, '../../../../../', 'node_modules', 'react');
+  }
+
+  if (pkgJSON.dependencies['react-dom'] || pkgJSON.devDependencies['react-dom']) {
+    config.resolve.alias['react-dom'] = path.resolve('node_modules/react-dom');
+  } else {
+    config.resolve.alias['react-dom'] = path.resolve(__dirname, '../../../../../', 'node_modules', 'react-dom');
+  }
+
+  config.resolve.fallback = {
+    path: require.resolve('path-browserify')
+  };
+  return config;
+}
+export async function runWebpack(config) {
+  await new Promise((resolve, reject) => {
+    webpack(config).run((err, stats) => {
+      if (err) {
+        reject(err);
+      } else if (stats !== null && stats !== void 0 && stats.hasErrors()) {
+        reject(stats === null || stats === void 0 ? void 0 : stats.compilation.errors);
+      } else {
+        resolve(stats);
+      }
+    });
+  });
+}

package/dist/js/modern/index.js

@@ -0,0 +1,49 @@
+import { Import } from '@modern-js/utils';
+const core = Import.lazy('@modern-js/core', require);
+const features = Import.lazy('./features', require);
+export default core.createPlugin(() => ({
+  commands({
+    program
+  }) {
+    const {
+      appDirectory
+    } = core.useAppContext();
+    const devCommand = program.commandsMap.get('dev');
+
+    if (devCommand) {
+      devCommand.command('docs').action(async () => {
+        await features.buildDocs({
+          appDirectory,
+          isDev: true
+        });
+      });
+    }
+  },
+
+  // module-tools menu mode
+  moduleToolsMenu() {
+    const {
+      appDirectory
+    } = core.useAppContext();
+    return {
+      name: 'Docsite 调试',
+      value: 'docsite',
+      runTask: async () => features.buildDocs({
+        appDirectory,
+        isDev: true
+      })
+    };
+  },
+
+  platformBuild() {
+    return {
+      name: 'docsite',
+      title: 'Run Docsite log',
+      taskPath: require.resolve("./build-task"),
+      params: []
+    };
+  }
+
+}), {
+  name: '@modern-js/plugin-docsite'
+});

package/dist/js/node/build-task.js

@@ -0,0 +1,33 @@
+"use strict";
+
+var _utils = require("@modern-js/utils");
+
+const core = _utils.Import.lazy('@modern-js/core', require);
+
+const features = _utils.Import.lazy('./features', require);
+
+const taskMain = async ({
+  appContext
+}) => {
+  const {
+    appDirectory
+  } = appContext;
+  await features.buildDocs({
+    appDirectory
+  });
+};
+
+(async () => {
+  const {
+    appContext
+  } = await core.cli.init();
+  await core.manager.run(async () => {
+    try {
+      await taskMain({
+        appContext
+      });
+    } catch (e) {
+      console.error(e.message);
+    }
+  });
+})();

package/dist/js/node/features/build.js

@@ -0,0 +1,31 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.build = build;
+
+var _utils = require("@modern-js/utils");
+
+const wp = _utils.Import.lazy('./utils/webpack', require);
+
+const gen = _utils.Import.lazy('./utils/generate-files', require); // eslint-disable-next-line max-params
+
+
+async function build(appDirectory, tmpDir, files, webpackConfig, isDev) {
+  const meta = await gen.generateFiles(appDirectory, tmpDir, files, isDev);
+
+  try {
+    await wp.runWebpack(webpackConfig);
+
+    _utils.logger.log(_utils.chalk.green('build docs successful'));
+
+    return meta;
+  } catch (err) {
+    _utils.logger.error('failed to build docs');
+
+    _utils.logger.error(err);
+
+    return null;
+  }
+}

package/dist/js/node/features/constant.js

@@ -0,0 +1,21 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UTILS_STATIC = exports.MDX_DEFAULT_RENDERER = exports.DOCS_RENDER_PATH = void 0;
+
+var _path = _interopRequireDefault(require("path"));
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const UTILS_STATIC = _path.default.join(__dirname, '../../static');
+
+exports.UTILS_STATIC = UTILS_STATIC;
+const DOCS_RENDER_PATH = '/api/v1/docs/render';
+exports.DOCS_RENDER_PATH = DOCS_RENDER_PATH;
+const MDX_DEFAULT_RENDERER = `
+import React from 'react'
+import { mdx } from '@mdx-js/react'
+`;
+exports.MDX_DEFAULT_RENDERER = MDX_DEFAULT_RENDERER;

package/dist/js/node/features/dev.js

@@ -0,0 +1,39 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.dev = dev;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+var _webpack = _interopRequireDefault(require("@modern-js/deps/compiled/webpack"));
+
+var _webpackDevServer = _interopRequireDefault(require("webpack-dev-server"));
+
+var _chokidar = require("./utils/chokidar");
+
+var _generateFiles = require("./utils/generate-files");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+// eslint-disable-next-line max-params
+async function dev(appDirectory, tmpDir, files, webpackConfig, isDev, port) {
+  await (0, _generateFiles.generateFiles)(appDirectory, tmpDir, files, isDev);
+  const compiler = (0, _webpack.default)(webpackConfig);
+  const server = new _webpackDevServer.default({
+    host: '0.0.0.0',
+    port,
+    historyApiFallback: true,
+    static: {
+      directory: _path.default.resolve(appDirectory, 'assets'),
+      publicPath: '/assets'
+    }
+  }, compiler);
+  server.startCallback(() => {
+    _utils.logger.info(`Starting server on http://localhost:${port}`);
+  });
+  (0, _chokidar.chokidarFile)(appDirectory, tmpDir, isDev);
+}

package/dist/js/node/features/index.js

@@ -0,0 +1,68 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.buildDocs = buildDocs;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+var _valid = require("./utils/valid");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+const buildFeat = _utils.Import.lazy('./build', require);
+
+const devFeat = _utils.Import.lazy('./dev', require);
+
+const wp = _utils.Import.lazy('./utils/webpack', require);
+
+const glob = _utils.Import.lazy('glob', require);
+
+const DEFAULT_PORT = 5000;
+
+async function buildDocs({
+  appDirectory,
+  isDev = false,
+  port = DEFAULT_PORT
+}) {
+  if (!(0, _valid.valid)({
+    appDirectory,
+    docsDir: 'docs'
+  })) {
+    return;
+  }
+
+  const docsDir = _path.default.resolve(appDirectory, 'docs');
+
+  if (!_utils.fs.pathExistsSync(docsDir)) {
+    return;
+  }
+
+  const files = glob.sync('**/*.{md,mdx}', {
+    cwd: docsDir,
+    ignore: '**/_*'
+  });
+
+  if (files.length === 0) {
+    _utils.logger.warn('not find md(x) files');
+
+    return;
+  }
+
+  const tmpDir = _path.default.join(appDirectory, './node_modules/.modern-js/docs');
+
+  _utils.fs.ensureDirSync(tmpDir);
+
+  const finalWebpackConfig = wp.generatorWebpackConfig(appDirectory, tmpDir, isDev);
+
+  if (!isDev) {
+    _utils.logger.info('build docs');
+
+    await buildFeat.build(appDirectory, tmpDir, files, finalWebpackConfig, false);
+  } else {
+    await devFeat.dev(appDirectory, tmpDir, files, finalWebpackConfig, true, port);
+  }
+}

package/dist/js/node/features/utils/chokidar.js

@@ -0,0 +1,55 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.chokidarFile = chokidarFile;
+
+var _path = _interopRequireDefault(require("path"));
+
+var _utils = require("@modern-js/utils");
+
+var _chokidar = _interopRequireDefault(require("chokidar"));
+
+var _glob = _interopRequireDefault(require("glob"));
+
+var _generateFiles = require("./generate-files");
+
+function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
+
+function chokidarFile(appDirectory, tmpDir, isDev) {
+  let dirty = false;
+  let building = false;
+
+  _chokidar.default.watch('docs/**/*.{md,mdx}', {
+    cwd: appDirectory,
+    ignoreInitial: true
+  }).on('all', async () => {
+    if (building) {
+      dirty = true;
+    } else {
+      building = true;
+      dirty = false;
+
+      _utils.logger.info('changed, collect and rebuild docs');
+
+      const files = _glob.default.sync('**/*.{md,mdx}', {
+        cwd: _path.default.resolve(appDirectory, 'docs'),
+        ignore: '**/_*'
+      });
+
+      if (files.length) {
+        await (0, _generateFiles.generateFiles)(appDirectory, tmpDir, files, isDev);
+
+        _utils.logger.info('built');
+      } // eslint-disable-next-line require-atomic-updates
+
+
+      building = false;
+
+      if (dirty) {
+        await (0, _generateFiles.generateFiles)(appDirectory, tmpDir, files, isDev);
+      }
+    }
+  });
+}