TypeScript semver.lte函数代码示例

  return (tree: Tree, context: SchematicContext) => {
    const schematicsToRun: { name: string; version: string; }[] = [];

    // Create the collection for the package.
    const collection = context.engine.createCollection(options.collection);
    for (const name of collection.listSchematicNames()) {
      const schematic = collection.createSchematic(name, true);

      const description: JsonObject = schematic.description as JsonObject;

      if (typeof description['version'] == 'string') {
        let version = description['version'] as string;
        if (!version.match(/^\d{1,30}\.\d{1,30}\.\d{1,30}$/)) {
          version += '.0';
        }
        if (!version.match(/^\d{1,30}\.\d{1,30}\.\d{1,30}$/)) {
          version += '.0';
        }
        if (!semver.valid(version)) {
          throw new SchematicsException(
            `Invalid migration version: ${JSON.stringify(description['version'])}`,
          );
        }

        if (semver.gt(version, options.from) && semver.lte(version, options.to)) {
          schematicsToRun.push({ name, version });
        }
      }
    }

    schematicsToRun.sort((a, b) => {
      const cmp = semver.compare(a.version, b.version);

      // Revert to comparing the names of the collection if the versions are equal.
      return cmp == 0 ? a.name.localeCompare(b.name) : cmp;
    });

    if (schematicsToRun.length > 0) {
      const rules = schematicsToRun.map(x => externalSchematic(options.collection, x.name, {}));

      return chain(rules);
    }

    return tree;
  };

function _buildPackageInfo(
  tree: Tree,
  packages: Map<string, VersionRange>,
  allDependencies: Map<string, VersionRange>,
  npmPackageJson: NpmRepositoryPackageJson,
  logger: logging.LoggerApi,
): PackageInfo {
  const name = npmPackageJson.name;
  const packageJsonRange = allDependencies.get(name);
  if (!packageJsonRange) {
    throw new SchematicsException(
      `Package ${JSON.stringify(name)} was not found in package.json.`,
    );
  }

  // Find out the currently installed version. Either from the package.json or the node_modules/
  // TODO: figure out a way to read package-lock.json and/or yarn.lock.
  let installedVersion: string | undefined;
  const packageContent = tree.read(`/node_modules/${name}/package.json`);
  if (packageContent) {
    const content = JSON.parse(packageContent.toString()) as JsonSchemaForNpmPackageJsonFiles;
    installedVersion = content.version;
  }
  if (!installedVersion) {
    // Find the version from NPM that fits the range to max.
    installedVersion = semver.maxSatisfying(
      Object.keys(npmPackageJson.versions),
      packageJsonRange,
    );
  }

  const installedPackageJson = npmPackageJson.versions[installedVersion] || packageContent;
  if (!installedPackageJson) {
    throw new SchematicsException(
      `An unexpected error happened; package ${name} has no version ${installedVersion}.`,
    );
  }

  let targetVersion: VersionRange | undefined = packages.get(name);
  if (targetVersion) {
    if (npmPackageJson['dist-tags'][targetVersion]) {
      targetVersion = npmPackageJson['dist-tags'][targetVersion] as VersionRange;
    } else if (targetVersion == 'next') {
      targetVersion = npmPackageJson['dist-tags']['latest'] as VersionRange;
    } else {
      targetVersion = semver.maxSatisfying(
        Object.keys(npmPackageJson.versions),
        targetVersion,
      ) as VersionRange;
    }
  }

  if (targetVersion && semver.lte(targetVersion, installedVersion)) {
    logger.debug(`Package ${name} already satisfied by package.json (${packageJsonRange}).`);
    targetVersion = undefined;
  }

  const target: PackageVersionInfo | undefined = targetVersion
    ? {
      version: targetVersion,
      packageJson: npmPackageJson.versions[targetVersion],
      updateMetadata: _getUpdateMetadata(npmPackageJson.versions[targetVersion], logger),
    }
    : undefined;

  // Check if there's an installed version.
  return {
    name,
    npmPackageJson,
    installed: {
      version: installedVersion as VersionRange,
      packageJson: installedPackageJson,
      updateMetadata: _getUpdateMetadata(installedPackageJson, logger),
    },
    target,
    packageJsonRange,
  };
}

strn = semver.inc(str, "minor", loose);
strn = semver.inc(str, "preminor", loose);
strn = semver.inc(str, "patch", loose);
strn = semver.inc(str, "prepatch", loose);
strn = semver.inc(str, "prerelease", loose);
strn = semver.inc(str, "prerelease", loose, "alpha");
num = semver.major(str, loose);
num = semver.minor(str, loose);
num = semver.patch(str, loose);
strArr = semver.prerelease(str, loose);

// Comparison
bool = semver.gt(v1, v2, loose);
bool = semver.gte(v1, v2, loose);
bool = semver.lt(v1, v2, loose);
bool = semver.lte(v1, v2, loose);
bool = semver.eq(v1, v2, loose);
bool = semver.neq(v1, v2, loose);
bool = semver.cmp(v1, op, v2, loose);
comparatorResult = semver.compare(v1, v2, loose);
comparatorResult = semver.rcompare(v1, v2, loose);
comparatorResult = semver.compareIdentifiers(str, str);
comparatorResult = semver.rcompareIdentifiers(str, str);
versionsArr = semver.sort(['', new semver.SemVer('')]);
versionsArr = semver.rsort(['', new semver.SemVer('')]);
diff = semver.diff(v1, v2, loose);

// Ranges
str = semver.validRange(str, loose);
bool = semver.satisfies(version, str, loose);
str = semver.maxSatisfying(versions, str, loose);