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

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

@@ -0,0 +1,88 @@
+/* eslint-disable no-await-in-loop */
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { BLOCKLET_BUNDLE_FOLDER, BLOCKLET_ENTRY_FILE } = require('@blocklet/constant');
+const parseBlockletMeta = require('@blocklet/meta/lib/parse');
+
+const { print, printSuccess } = require('../../../../util');
+const { wrapSpinner } = require('../../../../ui');
+const pack = require('../pack');
+const { createBlockletBundle, createBlockletEntry, getExtraFiles } = require('../bundle');
+const { logTar, getContents } = require('../../../../util/blocklet/tar');
+const { bundleMergeExtra } = require('./bundle-merge-extra');
+const { defaultExternals } = require('./default-external');
+
+exports.run = async ({
+  meta,
+  blockletDir,
+  createRelease = false,
+  inMonoRepo = false,
+  withChangeLog = true,
+  sourceMap,
+  nosourcesSourceMap,
+  externalManager,
+  minify,
+  externals: inputExternals = [],
+}) => {
+  const externals = Array.from(new Set([...defaultExternals, ...inputExternals]));
+
+  // eslint-disable-next-line no-param-reassign
+  meta = meta || parseBlockletMeta(blockletDir);
+
+  const buildOutputDir = path.join(blockletDir, BLOCKLET_BUNDLE_FOLDER);
+
+  if (fs.existsSync(buildOutputDir)) {
+    fs.removeSync(buildOutputDir);
+  }
+  fs.mkdirSync(buildOutputDir, { recursive: true });
+
+  await wrapSpinner(`Creating blocklet bundle in ${chalk.cyan(BLOCKLET_BUNDLE_FOLDER)}...`, async () => {
+    if (meta.main && meta.main !== BLOCKLET_ENTRY_FILE) {
+      fs.writeFileSync(path.join(buildOutputDir, BLOCKLET_ENTRY_FILE), createBlockletEntry(blockletDir, meta.main));
+    }
+
+    await createBlockletBundle({
+      blockletDir,
+      meta,
+      updates: meta.group === 'dapp' ? { main: BLOCKLET_ENTRY_FILE } : {},
+      inMonoRepo,
+      withChangeLog,
+    });
+  });
+
+  await wrapSpinner(`Bundle single file in ${chalk.cyan(BLOCKLET_BUNDLE_FOLDER)}...`, async () => {
+    fs.rmSync(path.dirname(path.join(buildOutputDir, meta.main)), { force: true, recursive: true });
+    const extraFiles = getExtraFiles(blockletDir, meta).filter((file) => file.endsWith('.js') || file.endsWith('.ts'));
+
+    // clean history builded files
+    for (const file of extraFiles) {
+      fs.rmSync(path.dirname(path.join(buildOutputDir, file)), { force: true, recursive: true });
+    }
+
+    await bundleMergeExtra({
+      extraFiles,
+      srcPath: blockletDir,
+      distDir: buildOutputDir,
+      sourceMap,
+      nosourcesSourceMap,
+      enterFile: meta.main || BLOCKLET_ENTRY_FILE,
+      externalManager,
+      externals,
+      minify,
+    });
+  });
+
+  // print total stats
+  printSuccess(`Blocklet ${chalk.cyan(`${meta.name}@${meta.version}`)} was successfully bundled!`);
+
+  if (createRelease) {
+    print('');
+    // eslint-disable-next-line no-shadow
+    const { tarball, meta } = await pack(blockletDir);
+    const pkgContents = await getContents(meta, tarball);
+    logTar(pkgContents);
+  }
+
+  process.exit(0);
+};

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

@@ -0,0 +1,139 @@
+const path = require('path');
+const chalk = require('chalk');
+const formatError = require('@abtnode/util/lib/format-error');
+const parseBlockletMeta = require('@blocklet/meta/lib/parse');
+const hasReservedKey = require('@blocklet/meta/lib/has-reserved-key');
+const zipBundle = require('./zip');
+const simpleBundle = require('./simple');
+const compactBundle = require('./compact');
+const {
+  printError,
+  printInfo,
+  printSuccess,
+  wrapDefaultStoreUrl,
+  checkEntryFileForStaticBlocklet,
+} = require('../../../util');
+const { checkCircularDependencies } = require('../../../util/blocklet/meta');
+
+const getMode = (meta, { useZip, useSimple, useCompact } = {}) => {
+  if (useCompact) {
+    return 'compact';
+  }
+
+  if (useSimple) {
+    return 'simple';
+  }
+
+  let mode = 'simple';
+  if (meta.group === 'static' || useZip) {
+    mode = 'zip';
+  }
+
+  if (meta.group === 'gateway') {
+    mode = 'simple';
+  }
+
+  if (!meta.group) {
+    mode = 'zip';
+  }
+
+  return mode;
+};
+
+exports.getMode = getMode;
+
+exports.run = async ({
+  zip: useZip = false,
+  simple: useSimple = false,
+  changelog: withChangeLog = true,
+  createRelease = false,
+  monorepo: inMonoRepo = false,
+  compact: useCompact = false,
+  sourceMap = false,
+  nosourcesSourceMap = false,
+  external = [],
+  externalManager = 'npm',
+  storeUrl,
+  minify = true,
+}) => {
+  const defaultStoreUrl = storeUrl || process.env.COMPONENT_STORE_URL;
+  const blockletDir = process.cwd();
+  let meta = {};
+
+  try {
+    meta = parseBlockletMeta(blockletDir, {
+      ensureFiles: true,
+      schemaOptions: {
+        stripUnknown: false,
+      },
+      defaultStoreUrl: defaultStoreUrl ? wrapDefaultStoreUrl(defaultStoreUrl) : null,
+    });
+    printSuccess(`Parsing blocklet meta from: ${chalk.cyan(blockletDir)}`);
+  } catch (err) {
+    if (process.env.DEBUG) {
+      console.error(err);
+    }
+    printError(`Blocklet bundle failed from ${chalk.cyan(blockletDir)}`);
+    printError(`Abort due to error: ${chalk.red(formatError(err))}`);
+    printInfo(`Please check your ${chalk.cyan(path.join(blockletDir, 'blocklet.yml'))}`);
+    printInfo(`See ${chalk.cyan('https://developer.blocklet.io/docs/reference/blocklet-spec')}`);
+    process.exit(1);
+  }
+
+  if (hasReservedKey(meta.environments)) {
+    printError('Blocklet key of environments can not start with `ABT_NODE_` or `BLOCKLET_`');
+    process.exit(1);
+  }
+
+  if (meta.group === 'static') {
+    try {
+      checkEntryFileForStaticBlocklet(meta, blockletDir);
+    } catch (error) {
+      printError(error.message);
+      process.exit(1);
+    }
+  }
+
+  // Try parse components to avoid circular dependencies
+  await checkCircularDependencies(meta);
+
+  const mode = getMode(meta, { useZip, useSimple, useCompact });
+
+  printInfo(`Bundling in ${chalk.cyan(mode)} mode for blocklet ${chalk.cyan(meta.name)}...`);
+
+  let externals = [];
+  if (external) {
+    externals = Array.isArray(external) ? external : [external];
+    externals = externals.reduce((acc, cur) => {
+      if (cur.indexOf(',') > -1) {
+        acc.push(...cur.split(','));
+      } else {
+        acc.push(cur);
+      }
+      return acc;
+    }, []);
+  }
+
+  if (mode === 'compact') {
+    await compactBundle.run({
+      meta,
+      blockletDir,
+      createRelease,
+      inMonoRepo,
+      withChangeLog,
+      sourceMap,
+      nosourcesSourceMap,
+      externals,
+      externalManager,
+      minify,
+    });
+  } else if (mode === 'zip') {
+    await zipBundle.run({ meta, blockletDir, createRelease, inMonoRepo, withChangeLog, externals, externalManager });
+  } else if (mode === 'simple') {
+    await simpleBundle.run({ meta, blockletDir, createRelease, inMonoRepo, withChangeLog, externals, externalManager });
+  } else {
+    // should not reach here
+    printError(`Unsupported bundle mode ${mode}`);
+    process.exit(1);
+  }
+};

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

@@ -0,0 +1,8 @@
+const path = require('path');
+const { createRelease } = require('@abtnode/util/lib/create-blocklet-release');
+
+const { printError, printInfo } = require('../../../util');
+
+const pack = (dir) => createRelease(path.join(dir, '.blocklet'), { printError, printInfo });
+
+module.exports = pack;

package/lib/commands/blocklet/bundle/parse-external-dependencies.js

@@ -0,0 +1,97 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+const repoPrefixes = [
+  'http:',
+  'https:',
+  'github:',
+  'git+',
+  'file:',
+  'ssh:',
+  'git@',
+  'bitbucket:',
+  'gitlab:',
+  'hg+',
+  'svn+',
+  'bzr+',
+];
+
+// eslint-disable-next-line consistent-return
+function parseExternalDependencies({ externals = [], distDir, externalManager, persist = true }) {
+  if (['npm', 'pnpm', 'yarn'].includes(externalManager) === false) {
+    throw new Error(`Unsupported external manager: ${externalManager}`);
+  }
+
+  if (externals.length === 0) {
+    return { dependencies: {}, externalManager, blockletExternalDependencies: [] };
+  }
+
+  const packageJsonPath = 'package.json';
+  const dependencies = {};
+
+  const manifest = fs.readJSONSync(packageJsonPath);
+  if (externals.find((x) => x === '*')) {
+    return {
+      dependencies: manifest.dependencies,
+      externalManager,
+      blockletExternalDependencies: Object.keys(manifest.dependencies),
+    };
+  }
+
+  externals.forEach((external) => {
+    const version =
+      manifest.dependencies?.[external] ||
+      manifest.devDependencies?.[external] ||
+      manifest.peerDependencies?.[external] ||
+      manifest.optionalDependencies?.[external];
+    if (version && repoPrefixes.some((prefix) => version.startsWith(prefix))) {
+      dependencies[external] = version;
+      return;
+    }
+    for (let i = 0; i < 9; i++) {
+      const upDir = Array(i).fill('..');
+      const tmp = path.resolve(...upDir, 'node_modules', external, 'package.json');
+      if (fs.existsSync(tmp)) {
+        const packageJson = fs.readJSONSync(tmp);
+        dependencies[external] = packageJson.version;
+        break;
+      }
+    }
+  });
+
+  if (Object.keys(dependencies).length === 0) {
+    return { dependencies: {}, externalManager, blockletExternalDependencies: [] };
+  }
+
+  if (persist === false) {
+    return { dependencies, externalManager, blockletExternalDependencies: Object.keys(dependencies) };
+  }
+
+  let packageJson = {};
+  if (fs.existsSync(packageJsonPath)) {
+    packageJson = fs.readJSONSync(packageJsonPath);
+    delete packageJson.devDependencies;
+    delete packageJson.peerDependencies;
+    delete packageJson.optionalDependencies;
+    delete packageJson.bundledDependencies;
+    delete packageJson.scripts;
+  }
+
+  fs.writeFileSync(
+    path.resolve(distDir, 'package.json'),
+    JSON.stringify(
+      {
+        ...packageJson,
+        dependencies,
+        externalManager,
+        blockletExternalDependencies: Object.keys(dependencies),
+      },
+      null,
+      2
+    )
+  );
+}
+
+module.exports = {
+  parseExternalDependencies,
+};

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

@@ -0,0 +1,62 @@
+/* eslint-disable no-await-in-loop */
+const fs = require('fs-extra');
+const path = require('path');
+const chalk = require('chalk');
+const { BLOCKLET_BUNDLE_FOLDER, BLOCKLET_ENTRY_FILE } = require('@blocklet/constant');
+const parseBlockletMeta = require('@blocklet/meta/lib/parse');
+
+const { print, printSuccess } = require('../../../../util');
+const { wrapSpinner } = require('../../../../ui');
+const pack = require('../pack');
+const { createBlockletBundle, createBlockletEntry } = require('../bundle');
+const { logTar, getContents } = require('../../../../util/blocklet/tar');
+
+exports.run = async ({
+  meta,
+  blockletDir,
+  createRelease = false,
+  inMonoRepo = false,
+  withChangeLog = true,
+  externals = [],
+  externalManager = 'npm',
+}) => {
+  // eslint-disable-next-line no-param-reassign
+  meta = meta || parseBlockletMeta(blockletDir);
+
+  const distDir = path.join(blockletDir, BLOCKLET_BUNDLE_FOLDER);
+
+  if (fs.existsSync(distDir)) {
+    fs.removeSync(distDir);
+  } else {
+    fs.mkdirSync(distDir, { recursive: true });
+  }
+
+  await wrapSpinner(`Creating blocklet bundle in ${chalk.cyan(BLOCKLET_BUNDLE_FOLDER)}...`, async () => {
+    if (meta.main && meta.main !== BLOCKLET_ENTRY_FILE) {
+      fs.writeFileSync(path.join(distDir, BLOCKLET_ENTRY_FILE), createBlockletEntry(blockletDir, meta.main));
+    }
+
+    await createBlockletBundle({
+      blockletDir,
+      meta,
+      updates: meta.group === 'dapp' ? { main: BLOCKLET_ENTRY_FILE } : {},
+      inMonoRepo,
+      withChangeLog,
+      externals,
+      externalManager,
+    });
+  });
+
+  // print total stats
+  printSuccess(`Blocklet ${chalk.cyan(`${meta.name}@${meta.version}`)} was successfully bundled!`);
+
+  if (createRelease) {
+    print('');
+    // eslint-disable-next-line no-shadow
+    const { tarball, meta } = await pack(blockletDir);
+    const pkgContents = await getContents(meta, tarball);
+    logTar(pkgContents);
+  }
+
+  process.exit(0);
+};

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

@@ -0,0 +1,35 @@
+/* eslint-disable func-names */
+const { createWriteStream } = require('fs');
+
+const archiver = require('archiver');
+const endOfStream = require('end-of-stream');
+const { promisify } = require('util');
+
+const pEndOfStream = promisify(endOfStream);
+
+// Start zipping files
+const startZip = function (destPath) {
+  const output = createWriteStream(destPath);
+  const archive = archiver('zip', { level: 9 });
+  archive.pipe(output);
+  return { archive, output };
+};
+
+// Add new file to zip
+const addZipFile = function (archive, file, name, stat) {
+  // Ensure sha256 stability regardless of mtime
+  archive.file(file, { name, mode: stat.mode, date: new Date(0), stats: stat });
+};
+
+// Add new file content to zip
+const addZipContent = function (archive, content, name) {
+  archive.append(content, { name, date: new Date(0) });
+};
+
+// End zipping files
+const endZip = async function (archive, output) {
+  archive.finalize();
+  await pEndOfStream(output);
+};
+
+module.exports = { startZip, addZipFile, addZipContent, endZip };