cli/ts/mod_format/format.packagejson.ts

import * as plugins from './mod.plugins.js';
import * as paths from '../paths.js';
import * as gulpFunction from '@push.rocks/gulp-function';
import { Project } from '../classes.project.js';

import { logger } from '../gitzone.logging.js';

/**
 * ensures a certain dependency
 */
const ensureDependency = async (
  packageJsonObjectArg: any,
  position: 'dep' | 'devDep' | 'everywhere',
  constraint: 'exclude' | 'include' | 'latest',
  dependencyArg: string,
) => {
  const [packageName, version] = dependencyArg.includes('@')
    ? dependencyArg.split('@').filter(Boolean)
    : [dependencyArg, 'latest'];

  const targetSections: string[] = [];

  switch (position) {
    case 'dep':
      targetSections.push('dependencies');
      break;
    case 'devDep':
      targetSections.push('devDependencies');
      break;
    case 'everywhere':
      targetSections.push('dependencies', 'devDependencies');
      break;
  }

  for (const section of targetSections) {
    if (!packageJsonObjectArg[section]) {
      packageJsonObjectArg[section] = {};
    }

    switch (constraint) {
      case 'exclude':
        delete packageJsonObjectArg[section][packageName];
        break;
      case 'include':
        if (!packageJsonObjectArg[section][packageName]) {
          packageJsonObjectArg[section][packageName] =
            version === 'latest' ? '^1.0.0' : version;
        }
        break;
      case 'latest':
        // Fetch latest version from npm
        try {
          const registry = new plugins.smartnpm.NpmRegistry();
          const packageInfo = await registry.getPackageInfo(packageName);
          const latestVersion = packageInfo['dist-tags'].latest;
          packageJsonObjectArg[section][packageName] = `^${latestVersion}`;
        } catch (error) {
          logger.log(
            'warn',
            `Could not fetch latest version for ${packageName}, using existing or default`,
          );
          if (!packageJsonObjectArg[section][packageName]) {
            packageJsonObjectArg[section][packageName] =
              version === 'latest' ? '^1.0.0' : version;
          }
        }
        break;
    }
  }
};

export const run = async (projectArg: Project) => {
  const formatStreamWrapper = new plugins.smartstream.StreamWrapper([
    plugins.smartgulp.src([`package.json`]),
    gulpFunction.forEach(async (fileArg: plugins.smartfile.SmartFile) => {
      const npmextraConfig = new plugins.npmextra.Npmextra(paths.cwd);
      const gitzoneData: any = npmextraConfig.dataFor('gitzone', {});
      const fileString = fileArg.contents.toString();
      const packageJson = JSON.parse(fileString);

      // metadata
      packageJson.repository = {
        type: 'git',
        url: `https://${gitzoneData.module.githost}/${gitzoneData.module.gitscope}/${gitzoneData.module.gitrepo}.git`,
      };
      ((packageJson.bugs = {
        url: `https://${gitzoneData.module.githost}/${gitzoneData.module.gitscope}/${gitzoneData.module.gitrepo}/issues`,
      }),
        (packageJson.homepage = `https://${gitzoneData.module.githost}/${gitzoneData.module.gitscope}/${gitzoneData.module.gitrepo}#readme`));

      // Check for module type
      if (!packageJson.type) {
        logger.log('info', `setting packageJson.type to "module"`);
        packageJson.type = 'module';
      }

      // Check for private or public
      if (packageJson.private !== undefined) {
        logger.log(
          'info',
          'Success -> found private/public info in package.json!',
        );
      } else {
        logger.log(
          'error',
          'found no private boolean! Setting it to private for now!',
        );
        packageJson.private = true;
      }

      // Check for license
      if (packageJson.license) {
        logger.log('info', 'Success -> found license in package.json!');
      } else {
        logger.log(
          'error',
          'found no license! Setting it to UNLICENSED for now!',
        );
        packageJson.license = 'UNLICENSED';
      }

      // Check for build script
      if (packageJson.scripts.build) {
        logger.log('info', 'Success -> found build script in package.json!');
      } else {
        logger.log(
          'error',
          'found no build script! Putting a placeholder there for now!',
        );
        packageJson.scripts.build = `echo "Not needed for now"`;
      }

      // Check for buildDocs script
      if (!packageJson.scripts.buildDocs) {
        logger.log(
          'info',
          'found no buildDocs script! Putting tsdoc script there now.',
        );
        packageJson.scripts.buildDocs = `tsdoc`;
      }

      // check for files
      packageJson.files = [
        'ts/**/*',
        'ts_web/**/*',
        'dist/**/*',
        'dist_*/**/*',
        'dist_ts/**/*',
        'dist_ts_web/**/*',
        'assets/**/*',
        'cli.js',
        'npmextra.json',
        'readme.md',
      ];

      // check for dependencies
      await ensureDependency(
        packageJson,
        'devDep',
        'latest',
        '@push.rocks/tapbundle',
      );
      await ensureDependency(
        packageJson,
        'devDep',
        'latest',
        '@git.zone/tstest',
      );
      await ensureDependency(
        packageJson,
        'devDep',
        'latest',
        '@git.zone/tsbuild',
      );

      // set overrides
      const overrides = plugins.smartfile.fs.toObjectSync(
        plugins.path.join(paths.assetsDir, 'overrides.json'),
      );
      packageJson.pnpm = packageJson.pnpm || {};
      packageJson.pnpm.overrides = overrides;

      // exclude
      // TODO

      fileArg.setContentsFromString(JSON.stringify(packageJson, null, 2));
    }),
    plugins.smartgulp.replace(),
  ]);
  await formatStreamWrapper.run().catch((error) => {
    console.log(error);
  });
};