TypeScript license-checker.init函数代码示例

export default function (_options: {}, logger: logging.Logger) {
  checker.init({ start: path.join(__dirname, '..') }, (err: Error, json: JsonObject) => {
    if (err) {
      logger.fatal(`Something happened:\n${err.message}`);
    } else {
      logger.info(`Testing ${Object.keys(json).length} packages.\n`);

      // Packages with bad licenses are those that neither pass SPDX nor are ignored.
      const badLicensePackages = Object.keys(json)
      .map(key => ({
          id: key,
          licenses: ([] as string[])
            // tslint:disable-next-line:non-null-operator
            .concat((json[key] ! as JsonObject).licenses as string[])
            // `*` is used when the license is guessed.
            .map(x => x.replace(/\*$/, ''))
            .map(x => x in licenseReplacements ? licenseReplacements[x] : x),
      }))
      .filter(pkg => !passesSpdx(pkg.licenses, licensesWhitelist))
      .filter(pkg => !ignoredPackages.find(ignored => ignored === pkg.id));

      // Report packages with bad licenses
      if (badLicensePackages.length > 0) {
        logger.error('Invalid package licences found:');
        badLicensePackages.forEach(pkg => {
          logger.error(`${pkg.id}: ${JSON.stringify(pkg.licenses)}`);
        });
        logger.fatal(`\n${badLicensePackages.length} total packages with invalid licenses.`);
      } else {
        logger.info('All package licenses are valid.');
      }
    }
  });

// Check if a license is accepted by an array of accepted licenses
  function passesSpdx(licenses: string[], accepted: string[]) {
    return accepted.some(l => {
      try {
        return spdxSatisfies(licenses.join(' AND '), l);
      } catch (_) {
        return false;
      }
    });
  }
}

  return new Promise(resolve => {
    checker.init({ start: path.join(__dirname, '..') }, (err: Error, json: JsonObject) => {
      if (err) {
        logger.fatal(`Something happened:\n${err.message}`);
        resolve(1);
      } else {
        logger.info(`Testing ${Object.keys(json).length} packages.\n`);

        // Packages with bad licenses are those that neither pass SPDX nor are ignored.
        const badLicensePackages = Object.keys(json)
          .map(key => ({
            id: key,
            licenses: ([] as string[])
              // tslint:disable-next-line:non-null-operator
              .concat((json[key] ! as JsonObject).licenses as string[])
              // `*` is used when the license is guessed.
              .map(x => x.replace(/\*$/, ''))
              .map(x => x in licenseReplacements ? licenseReplacements[x] : x),
          }))
          .filter(pkg => !_passesSpdx(pkg.licenses, licensesWhitelist))
          .filter(pkg => !ignoredPackages.find(ignored => ignored === pkg.id));

        // Report packages with bad licenses
        if (badLicensePackages.length > 0) {
          logger.error('Invalid package licences found:');
          badLicensePackages.forEach(pkg => {
            logger.error(`${pkg.id}: ${JSON.stringify(pkg.licenses)}`);
          });
          logger.fatal(`\n${badLicensePackages.length} total packages with invalid licenses.`);
          resolve(2);
        } else {
          logger.info('All package licenses are valid.');
          resolve(0);
        }
      }
    });
  });

import * as checker from "license-checker";

checker.init(
    {
        start: "/path/to/start/looking",
        production: true,
        customPath: {
            licenseText: ""
        }
    },
    (err: Error, json: checker.ModuleInfos): void => {
        if (err) {
            throw err;
        } else {
            const licenses = Object.keys(json).reduce(
                (memo, key) => {
                    const license = json[key];
                    const { name, version, repository, licenseText } = license;
                    if (licenseText == null) {
                        return memo;
                    }
                    memo.push(license);
                    return memo;
                },
                [] as checker.ModuleInfo[]
            );
        }
    }
);

checker.init(
    {
        start: "/path/to/start/looking",
        production: true,
        customPath: {
            licenseText: ""
        },
        json: false,
        csv: false,
        csvComponentPrefix: "prefixColumn",
        out: "/write/to/specific/file",
        failOn: "impermissible;licenses",
        onlyAllow: "permissible;licenses",
        packages: "packages;to;check",
        excludePackages: "packages;to;exclude",
        excludePrivatePackages: false,
        direct: false
    },
    (err: Error, json: checker.ModuleInfos): void => {
        if (err) {
            throw err;
        } else {
            const licenses = Object.keys(json).reduce(
                (memo, key) => {
                    const license = json[key];
                    const { name, version, repository, licenseText } = license;
                    if (licenseText == null) {
                        return memo;
                    }
                    memo.push(license);
                    return memo;
                },
                [] as checker.ModuleInfo[]
            );
        }
    }
);

// From README.md:

import * as checker from 'license-checker';

checker.init({
    start: '/path/to/start/looking'
}, (err: Error, json: checker.ModuleInfos): void => {
    if (err) {
        // Handle error
    } else {
        // The sorted json data
    }
});