@blocklet/cli 1.16.33 → 1.16.34-beta-20241120-080738-bbbe036c

package/lib/commands/blocklet/bundle/bundle.js

@@ -0,0 +1,184 @@
+const os = require('os');
+const path = require('path');
+const packList = require('npm-packlist');
+const chalk = require('chalk');
+const uniq = require('lodash/uniq');
+const pick = require('lodash/pick');
+const merge = require('lodash/merge');
+const cloneDeep = require('lodash/cloneDeep');
+const fs = require('fs-extra');
+const fg = require('fast-glob');
+const isGlob = require('is-glob');
+const { list: metaFiles, select: getMetaFile, update: updateMetaFile } = require('@blocklet/meta/lib/file');
+const {
+  BLOCKLET_BUNDLE_FOLDER,
+  BLOCKLET_ENTRY_FILE,
+  BLOCKLET_BUNDLE_FILE,
+  BLOCKLET_OPEN_API_FILE,
+  BLOCKLET_OPEN_API_FILE_JSON,
+  BLOCKLET_OPEN_COMPONENT_FILE,
+  BLOCKLET_OPEN_COMPONENT_FILE_JSON,
+  BLOCKLET_RESOURCE_DIR,
+} = require('@blocklet/constant');
+const formatBackSlash = require('@abtnode/util/lib/format-back-slash');
+const { getGitHash, printInfo } = require('../../../util');
+const SimpleBundler = require('./bundlers/simple');
+const { parseExternalDependencies } = require('./parse-external-dependencies');
+
+const createBlockletEntry = (blockletDir, entryFile) => {
+  const packageFile = path.join(blockletDir, 'package.json');
+  const hasPackageFile = fs.existsSync(packageFile);
+  const tempEntryFile = formatBackSlash(`./${path.normalize(entryFile)}`);
+  if (hasPackageFile) {
+    const packageJson = JSON.parse(fs.readFileSync(packageFile).toString());
+    if (packageJson.type === 'module') {
+      return `import '${tempEntryFile}';${os.EOL}`;
+    }
+  }
+
+  return `require('${tempEntryFile}');${os.EOL}`;
+};
+
+const PACKAGE_JSON_KEYS = [
+  'name',
+  'version',
+  'type',
+  'description',
+  'keywords',
+  'author',
+  'repository',
+  'bugs',
+  'publishConfig',
+];
+
+const createBlockletBundle = async ({
+  blockletDir,
+  meta,
+  updates = {},
+  inMonoRepo = false,
+  withChangeLog = true,
+  externals = [],
+  externalManager = 'npm',
+}) => {
+  // 新增 meta.files 支持 glob 后，需要将 glob 匹配的文件也进行复制放入 bundle 中
+  const metaFileList = meta.files || [];
+  const distDir = path.join(blockletDir, BLOCKLET_BUNDLE_FOLDER);
+
+  let files = [
+    `!${path.dirname(BLOCKLET_BUNDLE_FOLDER)}`,
+    ...metaFiles,
+    BLOCKLET_BUNDLE_FILE,
+    BLOCKLET_ENTRY_FILE,
+    BLOCKLET_OPEN_API_FILE,
+    BLOCKLET_OPEN_API_FILE_JSON,
+    BLOCKLET_OPEN_COMPONENT_FILE,
+    BLOCKLET_OPEN_COMPONENT_FILE_JSON,
+    BLOCKLET_RESOURCE_DIR,
+    'LICENSE',
+    meta.group === 'static' ? meta.main : '',
+    ...metaFileList,
+  ].filter(Boolean);
+
+  // #5823, always include the entire main folder for dapps
+  if (meta.group === 'dapp') {
+    const mainPath = path.join(blockletDir, meta.main);
+    const hasMainFile = fs.statSync(mainPath).isFile();
+    if (hasMainFile) {
+      if (path.dirname(mainPath) !== blockletDir) {
+        files.unshift(path.dirname(meta.main));
+      }
+    }
+  }
+
+  files = uniq(files);
+
+  if (!fs.existsSync(distDir)) {
+    fs.mkdirSync(distDir);
+  }
+
+  // https://docs.npmjs.com/cli/v9/configuring-npm/package-json#files
+  const selected = await packList({ package: { files } }, { path: blockletDir });
+  selected.forEach((fileName) => {
+    const source = path.join(blockletDir, fileName);
+    const target = path.join(distDir, fileName);
+    if (fs.existsSync(source) && !fs.existsSync(target)) {
+      fs.copySync(source, target);
+    }
+  });
+
+  await new SimpleBundler({ blockletDir, inMonoRepo, withChangeLog, meta }).bundle();
+
+  // Update blocklet meta file in the bundle
+  try {
+    updates.gitHash = getGitHash(blockletDir);
+  } catch (err) {
+    // Do nothing
+  }
+
+  const metaToUpdate = getMetaFile(path.join(distDir));
+  const rawMeta = cloneDeep(meta);
+  updateMetaFile(metaToUpdate, Object.assign(rawMeta, updates));
+
+  // Rewrite the package.json file if exist
+  const packageFile = path.join(blockletDir, 'package.json');
+  const hasPackageFile = fs.existsSync(packageFile);
+  if (hasPackageFile) {
+    const json = JSON.parse(fs.readFileSync(packageFile).toString());
+    const result = parseExternalDependencies({
+      externals,
+      externalManager,
+      distDir,
+      persist: false,
+    });
+    fs.writeFileSync(
+      path.join(distDir, 'package.json'),
+      JSON.stringify(merge(pick(json, PACKAGE_JSON_KEYS), result), null, 2)
+    );
+  }
+};
+
+/**
+ * 获取所有 extraFiles，理论上所有 .js 都需要查出来，才能进一步去找到依赖
+ * @param {Object} meta blocklet meta
+ * @returns Array
+ */
+const getExtraFiles = (blockletDir, meta) => {
+  const { files = [], scripts = {} } = meta;
+  const fileList = [];
+  for (const file of files) {
+    if (isGlob(file)) {
+      const entries = fg.sync(file, { cwd: blockletDir, absolute: false });
+      fileList.push(...entries);
+    } else {
+      const filePath = path.join(blockletDir, file);
+      const fileStat = fs.lstatSync(filePath);
+      if (fileStat.isFile() && path.extname(filePath) === '.js') {
+        fileList.push(file);
+      }
+    }
+  }
+
+  Object.entries(scripts).forEach(([key, script]) => {
+    if (key.startsWith('pre') || key.startsWith('post')) {
+      [script]
+        .concat(script.split(' ').filter(Boolean))
+        .filter((x) => path.extname(x) === '.js')
+        .forEach((x) => {
+          const filePath = path.join(blockletDir, x);
+          if (fs.existsSync(filePath) && fs.lstatSync(filePath).isFile()) {
+            printInfo(`Extra script file detected for bundling ${chalk.cyan(x)}`);
+            fileList.push(x);
+          }
+        });
+    }
+  });
+
+  // add migration scripts
+  const migrationScripts = fg.sync('migration/*.js', { cwd: blockletDir, absolute: false });
+  fileList.push(...migrationScripts);
+  migrationScripts.forEach((x) => printInfo(`Extra migration file detected for bundling ${chalk.cyan(x)}`));
+
+  return uniq([...fileList]).filter((x) => x !== BLOCKLET_ENTRY_FILE);
+};
+
+module.exports = { createBlockletBundle, createBlockletEntry, getExtraFiles };

package/lib/commands/blocklet/bundle/bundlers/blocklet.js

@@ -0,0 +1,138 @@
+const chalk = require('chalk');
+const fg = require('fast-glob');
+const isEmpty = require('lodash/isEmpty');
+const { printError, printWarning, print } = require('../../../../util');
+const MarkdownBundler = require('./markdown');
+
+class BlockletMdBundler extends MarkdownBundler {
+  static BLOCKLET_MD_REGEX = /blocklet\.[\S]*md$/i;
+
+  /**
+   * Creates an instance of BlockletMdBundler.
+   * @param {{
+   *  blockletDir: string,
+   *  blockletMdFileName: string, // 约定: blocklet.md的文件名是小写的
+   *  backupMdFileNames?: string[];
+   *  required?: boolean = false;
+   *  duplicateMdFileName?: string;
+   * }} { blockletDir, backupMdFileNames, backupMdFileName, required, duplicateMdFileName }
+   * @memberof BlockletMdBundler
+   */
+  constructor({ blockletDir, blockletMdFileName, backupMdFileNames, required = false, duplicateMdFileName }) {
+    super({ blockletDir });
+    this.blockletMdFileName = blockletMdFileName;
+    this.backupMdFileNames = backupMdFileNames;
+    this.required = required;
+    this.duplicateMdFileName = duplicateMdFileName;
+    this.fastGlobOptions = {
+      cwd: this.blockletDir,
+      deep: 1,
+      caseSensitiveMatch: false,
+      onlyFiles: true,
+      absolute: true,
+    };
+  }
+
+  /**
+   *
+   *
+   * @return {string[]} blocklet.md absolute paths
+   * @memberof BlockletMdBundler
+   */
+  async _find() {
+    const found = fg.sync(this.blockletMdFileName, this.fastGlobOptions);
+
+    if (found.length === 0 && !isEmpty(this.backupMdFileNames)) {
+      const foundByBackupMdFileName = await this._findByBackupFileNames();
+      if (foundByBackupMdFileName.length === 1) {
+        return foundByBackupMdFileName;
+      }
+    }
+
+    if (found.length === 0 && this.required) {
+      printError(`File ${chalk.red(this.blockletMdFileName)} must exist in ${chalk.cyan(this.blockletDir)}`);
+      process.exit(1);
+    }
+
+    if (found.length > 1) {
+      printError(
+        `Only one ${chalk.red(this.blockletMdFileName)}(not case sensitive) can exist in ${chalk.cyan(
+          this.blockletDir
+        )}`
+      );
+      process.exit(1);
+    }
+
+    if (this.duplicateMdFileName) {
+      await this.warnDuplicateMdFileName();
+    }
+
+    return found;
+  }
+
+  _findByBackupFileNames() {
+    for (const backupMdFileName of this.backupMdFileNames) {
+      // 我们先来找找备份文件
+      const foundByBackupMdFileName = fg.sync(backupMdFileName, this.fastGlobOptions);
+
+      if (foundByBackupMdFileName.length === 1) {
+        // 找到了1个备份的文件
+        return foundByBackupMdFileName;
+      }
+
+      if (foundByBackupMdFileName.length > 1) {
+        // 备份文件太多了,我不知道选哪个好
+        printError(
+          `Only one ${chalk.red(backupMdFileName)}(not case sensitive) can exist in ${chalk.cyan(this.blockletDir)}`
+        );
+        process.exit(1);
+      }
+    }
+
+    if (this.required) {
+      // 连备份文件也没找到,但是文件还是必要的,不能没有啊,故中断当前任务
+      printError(
+        `Either ${chalk.red(this.blockletMdFileName)} or ${this.backupMdFileNames
+          .map((backupMdFileName) => chalk.red(backupMdFileName))
+          .join(',')} should exist in ${chalk.cyan(this.blockletDir)}`
+      );
+      process.exit(1);
+    }
+
+    return [];
+  }
+
+  warnDuplicateMdFileName() {
+    const foundByDuplicateMdFileName = fg.sync(this.duplicateMdFileName, this.fastGlobOptions);
+
+    if (foundByDuplicateMdFileName.length) {
+      // 我是故意这么换行的,不然warning信息和其他信息会显示在同一行,不太美观
+      print();
+      printWarning(
+        `File ${chalk.cyan(this.blockletMdFileName)} is currently in use, file ${chalk.yellow(
+          this.duplicateMdFileName
+        )} is ignored`
+      );
+    }
+  }
+
+  bundle() {
+    return super.bundle();
+  }
+
+  /**
+   *
+   *
+   * @param {string} dest
+   * @param {string | NodeJS.ArrayBufferView} data
+   * @memberof BlockletMdBundler
+   */
+  async writeFile(dest, data) {
+    await super.writeFile(
+      dest.replace(BlockletMdBundler.BLOCKLET_MD_REGEX, this.blockletMdFileName.toLowerCase()),
+      data
+    );
+  }
+}
+
+module.exports = BlockletMdBundler;

package/lib/commands/blocklet/bundle/bundlers/changelog.js

@@ -0,0 +1,100 @@
+const path = require('path');
+const fromMarkdown = require('mdast-util-from-markdown');
+const detectWorkspace = require('@abtnode/util/lib/detect-workspace');
+const fs = require('fs-extra');
+const { BLOCKLET_BUNDLE_FOLDER } = require('@blocklet/constant');
+const fg = require('fast-glob');
+const chalk = require('chalk');
+const { printError } = require('../../../../util');
+
+class ChangelogBundler {
+  constructor({ blockletDir, inMonoRepo }) {
+    this.blockletDir = blockletDir;
+    this.inMonoRepo = inMonoRepo;
+    this.bundlerDir = path.join(this.blockletDir, BLOCKLET_BUNDLE_FOLDER);
+    this.changelogFileName = 'CHANGELOG.md';
+  }
+
+  /**
+   *
+   *
+   * @return {string | null} changelog.md absolute path
+   * @memberof ChangelogBundler
+   */
+  _find() {
+    const found = fg.sync(this.changelogFileName, {
+      cwd: this.blockletDir,
+      deep: 1,
+      caseSensitiveMatch: false,
+      onlyFiles: true,
+      absolute: true,
+    });
+
+    if (found.length === 1) {
+      return found[0];
+    }
+
+    if (found.length > 1) {
+      printError(
+        `Only one ${chalk.red(this.changelogFileName)}(not case sensitive) can exist in ${chalk.cyan(this.blockletDir)}`
+      );
+      process.exit(1);
+    }
+
+    if (this.inMonoRepo) {
+      const workspace = detectWorkspace(this.blockletDir);
+      if (workspace) {
+        const foundByMonoRepo = fg.sync(this.changelogFileName, {
+          cwd: workspace.dir,
+          deep: 1,
+          caseSensitiveMatch: false,
+          onlyFiles: true,
+          absolute: true,
+        });
+
+        if (foundByMonoRepo.length === 1) {
+          return foundByMonoRepo[0];
+        }
+
+        if (foundByMonoRepo.length > 1) {
+          printError(
+            `Only one ${chalk.red(this.changelogFileName)}(not case sensitive) can exist in ${chalk.cyan(
+              workspace.dir
+            )}`
+          );
+          process.exit(1);
+        }
+      }
+    }
+
+    return null;
+  }
+
+  async _bundle(changelogAbsolutePath) {
+    if (changelogAbsolutePath && fs.existsSync(changelogAbsolutePath)) {
+      await fs.copy(changelogAbsolutePath, path.join(this.bundlerDir, this.changelogFileName));
+    }
+  }
+
+  _validate(changelogAbsolutePath) {
+    if (changelogAbsolutePath && fs.existsSync(changelogAbsolutePath)) {
+      const ast = fromMarkdown(fs.readFileSync(changelogAbsolutePath));
+      const children = ast?.children || [];
+      children.forEach((element) => {
+        if (element.type === 'heading' && element.depth !== 2) {
+          const line = element.position?.start.line || 0;
+          printError(`Only H2 headings should be used in ${chalk.cyan(changelogAbsolutePath)} at line ${line}`);
+          process.exit(1);
+        }
+      });
+    }
+  }
+
+  async bundle() {
+    const changelogAbsolutePath = await this._find();
+    this._validate(changelogAbsolutePath);
+    await this._bundle(changelogAbsolutePath);
+  }
+}
+
+module.exports = ChangelogBundler;

package/lib/commands/blocklet/bundle/bundlers/logo.js

@@ -0,0 +1,56 @@
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { BLOCKLET_BUNDLE_FOLDER } = require('@blocklet/constant');
+const { validateLogo } = require('@blocklet/images');
+const { print, printError, printInfo, printWarning } = require('../../../../util');
+
+class LogoBundler {
+  static minSide = 256;
+
+  /**
+   * Creates an instance of LogBundler.
+   * @param {{
+   *  blockletDir: string,
+   *  minSide: number = LogoBundler.minSide,
+   *  logoFileName: string,
+   *  maxFileSize: string = "100KB",
+   * }} { widthPx, heightPx, logoFileName }
+   * @see https://looka.com/blog/logo-size-guidelines/
+   * @memberof LogBundler
+   */
+  constructor({ blockletDir = '', minSide = LogoBundler.minSide, logoFileName = '', maxFileSize = 1024 }) {
+    this.blockletDir = blockletDir;
+    this.logoFileName = logoFileName;
+    this.minSide = minSide;
+    this.maxFileSize = maxFileSize;
+
+    this.sourceLogoPath = path.join(blockletDir, logoFileName);
+    this.targetLogoPath = path.join(blockletDir, BLOCKLET_BUNDLE_FOLDER, logoFileName);
+  }
+
+  _verify() {
+    const errorMessages = validateLogo(this.logoFileName, {
+      extractedFilepath: this.blockletDir,
+      width: this.minSide,
+      maxSize: this.maxFileSize,
+    });
+    if (errorMessages.length) {
+      print('');
+      printWarning('Blocklet bundle failed! Please check the following errors about logo:');
+      errorMessages.forEach((errorMessage) => printError(errorMessage));
+      printInfo(
+        `You can run the command "${chalk.cyan('blocklet dev studio')}" to help you generate more standard images.`
+      );
+      print('');
+      process.exit(1);
+    }
+  }
+
+  async bundle() {
+    this._verify();
+    await fs.copy(this.sourceLogoPath, this.targetLogoPath);
+  }
+}
+
+module.exports = LogoBundler;