npm-update-package 3.0.22 → 4.0.0-1

package/dist/{src/github → github}/pull-request/creator/createOutdatedPackagesTable.js

@@ -1,7 +1,4 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createOutdatedPackagesTable = void 0;
-const createOutdatedPackagesTable = (outdatedPackage) => {
+export const createOutdatedPackagesTable = (outdatedPackage) => {
     const packageName = outdatedPackage.name;
     const packageLink = `[${packageName}](https://www.npmjs.com/package/${packageName})`;
     const dependencyType = outdatedPackage.dependencyType;
@@ -14,4 +11,3 @@ const createOutdatedPackagesTable = (outdatedPackage) => {
 |---|---|---|---|---|
 |${packageLink}|${dependencyType}|${level}|${currentVersionLink}|${newVersionLink}|`;
 };
-exports.createOutdatedPackagesTable = createOutdatedPackagesTable;

package/dist/github/pull-request/finder/PullRequestFinder.js

@@ -0,0 +1,23 @@
+import { extractPullRequestMetadata } from '../metadata/extractPullRequestMetadata.js';
+import { isPullRequestByNpmUpdatePackage } from './isPullRequestByNpmUpdatePackage.js';
+export class PullRequestFinder {
+    pullRequests;
+    constructor(pullRequests) {
+        this.pullRequests = pullRequests;
+    }
+    findByPackageName(packageName) {
+        return this.pullRequests
+            .filter(pullRequest => isPullRequestByNpmUpdatePackage(pullRequest))
+            .filter(({ body }) => {
+            if (body === null) {
+                return false;
+            }
+            const metadata = extractPullRequestMetadata(body);
+            if (metadata === undefined) {
+                return false;
+            }
+            const { packages } = metadata;
+            return packages.some(({ name }) => name === packageName);
+        });
+    }
+}

package/dist/github/pull-request/finder/isPullRequestByNpmUpdatePackage.js

@@ -0,0 +1,3 @@
+export const isPullRequestByNpmUpdatePackage = (pullRequest) => {
+    return pullRequest.labels.some(({ name }) => name === 'npm-update-package');
+};

package/dist/github/pull-request/metadata/PullRequestMetadata.js

@@ -0,0 +1,12 @@
+import { array, literal, string, type, union } from 'io-ts';
+import { SemVerLevel } from '../../../semver/SemVerLevel.js';
+const PullRequestMetadata = type({
+    version: string,
+    packages: array(type({
+        name: string,
+        currentVersion: string,
+        newVersion: string,
+        level: union([literal(SemVerLevel.Major), literal(SemVerLevel.Minor), literal(SemVerLevel.Patch)])
+    }))
+});
+export const isPullRequestMetadata = PullRequestMetadata.is;

package/dist/github/pull-request/metadata/createPullRequestMetadata.js

@@ -0,0 +1,12 @@
+import * as app from '../../../app.js';
+export const createPullRequestMetadata = (outdatedPackages) => {
+    return {
+        version: app.version,
+        packages: outdatedPackages.map(({ name, currentVersion, newVersion, level }) => ({
+            name,
+            currentVersion: currentVersion.version,
+            newVersion: newVersion.version,
+            level
+        }))
+    };
+};

package/dist/{src/github → github}/pull-request/metadata/extractPullRequestMetadata.js

@@ -1,8 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.extractPullRequestMetadata = void 0;
-const PullRequestMetadata_1 = require("./PullRequestMetadata");
-const extractPullRequestMetadata = (pullRequestBody) => {
+import { isPullRequestMetadata } from './PullRequestMetadata.js';
+export const extractPullRequestMetadata = (pullRequestBody) => {
     const matched = pullRequestBody.match(/<div id="npm-update-package-metadata">\s*```json\s*([\S\s]+?)\s*```\s*<\/div>/);
     if (matched === null) {
         return undefined;
@@ -13,9 +10,8 @@ const extractPullRequestMetadata = (pullRequestBody) => {
         return undefined;
     }
     const metadata = JSON.parse(json);
-    if (!(0, PullRequestMetadata_1.isPullRequestMetadata)(metadata)) {
+    if (!isPullRequestMetadata(metadata)) {
         return undefined;
     }
     return metadata;
 };
-exports.extractPullRequestMetadata = extractPullRequestMetadata;

package/dist/github/releases/Release.js

@@ -0,0 +1 @@
+export {};

package/dist/{src/github → github}/releases/fetcher/ReleasesFetcher.js

@@ -1,14 +1,8 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ReleasesFetcher = void 0;
-const node_fetch_1 = __importDefault(require("node-fetch"));
-const semver_1 = require("semver");
-const util_1 = require("../../../util");
+import fetch from 'node-fetch';
+import { gte, lte, valid } from 'semver';
+import { sleep } from '../../../util/sleep.js';
 // TODO: Split into multiple classes and functions
-class ReleasesFetcher {
+export class ReleasesFetcher {
     options;
     packageManager;
     constructor({ options, packageManager }) {
@@ -29,7 +23,7 @@ class ReleasesFetcher {
     }
     async fetchReleaseByTag({ gitRepo, tag }) {
         const url = `${gitRepo.url.toString()}/releases/tag/${tag}`;
-        const resp = await (0, node_fetch_1.default)(url);
+        const resp = await fetch(url);
         if (resp.ok) {
             return {
                 tag,
@@ -41,7 +35,7 @@ class ReleasesFetcher {
         const releases = [];
         for (const [i, tag] of tags.entries()) {
             if (i > 0) {
-                await (0, util_1.sleep)(this.options.fetchSleepTime);
+                await sleep(this.options.fetchSleepTime);
             }
             const release = await this.fetchReleaseByTag({
                 gitRepo,
@@ -56,9 +50,8 @@ class ReleasesFetcher {
     async getVersions({ packageName, from, to }) {
         const versions = await this.packageManager.getVersions(packageName);
         // TODO: Move these to SemVer
-        return versions.filter(version => (0, semver_1.valid)(version))
-            .filter(version => (0, semver_1.gte)(version, from.version))
-            .filter(version => (0, semver_1.lte)(version, to.version));
+        return versions.filter(version => valid(version))
+            .filter(version => gte(version, from.version))
+            .filter(version => lte(version, to.version));
     }
 }
-exports.ReleasesFetcher = ReleasesFetcher;

package/dist/json/toJSON.js

@@ -0,0 +1,4 @@
+export const toJSON = (value, options) => {
+    const pretty = options?.pretty ?? false;
+    return pretty ? JSON.stringify(value, undefined, 2) : JSON.stringify(value);
+};

package/dist/logger/LogLevel.js

@@ -0,0 +1,12 @@
+export const LogLevel = {
+    Debug: 'debug',
+    Error: 'error',
+    Fatal: 'fatal',
+    Info: 'info',
+    Off: 'off',
+    Trace: 'trace',
+    Warn: 'warn'
+};
+const logLevels = Object.values(LogLevel);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+export const isLogLevel = (value) => logLevels.includes(value);

package/dist/logger/logger.js

@@ -0,0 +1,2 @@
+import log4js from 'log4js';
+export const logger = log4js.getLogger();

package/dist/main.js

@@ -0,0 +1,175 @@
+import { isLeft, isRight } from 'fp-ts/lib/Either.js';
+import { OutdatedPackagesProcessor } from './core/OutdatedPackagesProcessor.js';
+import { PackageUpdater } from './core/PackageUpdater.js';
+import { CommitMessageCreator } from './git/CommitMessageCreator.js';
+import { Git } from './git/Git.js';
+import { GitConfigInitializer } from './git/GitConfigInitializer.js';
+import { GitRepository } from './git/GitRepository.js';
+import { BranchFinder } from './github/branch/finder/BranchFinder.js';
+import { createGitHub } from './github/createGitHub.js';
+import { LabelCreator } from './github/label/creator/LabelCreator.js';
+import { PullRequestCloser } from './github/pull-request/closer/PullRequestCloser.js';
+import { PullRequestsCloser } from './github/pull-request/closer/PullRequestsCloser.js';
+import { AssigneesAdder } from './github/pull-request/creator/AssigneesAdder.js';
+import { GitHubUrlOptimizer } from './github/pull-request/creator/GitHubUrlOptimizer.js';
+import { LabelsAdder } from './github/pull-request/creator/LabelsAdder.js';
+import { PackageDiffsSectionCreator } from './github/pull-request/creator/PackageDiffsSectionCreator.js';
+import { PullRequestBodyCreator } from './github/pull-request/creator/PullRequestBodyCreator.js';
+import { PullRequestCreator } from './github/pull-request/creator/PullRequestCreator.js';
+import { PullRequestTitleCreator } from './github/pull-request/creator/PullRequestTitleCreator.js';
+import { ReleaseNotesSectionCreator } from './github/pull-request/creator/ReleaseNotesSectionCreator.js';
+import { ReviewersAdder } from './github/pull-request/creator/ReviewersAdder.js';
+import { PullRequestFinder } from './github/pull-request/finder/PullRequestFinder.js';
+import { ReleasesFetcher } from './github/releases/fetcher/ReleasesFetcher.js';
+import { logger } from './logger/logger.js';
+import { NpmCheckUpdates } from './npm-check-updates/NpmCheckUpdates.js';
+import { OutdatedPackageProcessorCreator } from './outdated-package-processor/OutdatedPackageProcessorCreator.js';
+import { PackageManagerCreator } from './package-manager/PackageManagerCreator.js';
+import { Terminal } from './terminal/Terminal.js';
+// TODO: Add test
+export const main = async (options) => {
+    logger.debug(`options=${JSON.stringify({
+        ...options,
+        githubToken: options.githubToken === '' ? '' : '***'
+    })}`);
+    const ncu = new NpmCheckUpdates(options);
+    const outdatedPackages = await ncu.check();
+    logger.debug(`outdatedPackages=${JSON.stringify(outdatedPackages)}`);
+    if (outdatedPackages.length === 0) {
+        logger.info('All packages are up-to-date.');
+        return;
+    }
+    logger.info(`There are ${outdatedPackages.length} outdated packages.`);
+    const terminal = new Terminal();
+    const git = new Git(terminal);
+    const remoteUrl = await git.getRemoteUrl();
+    const gitRepo = GitRepository.of(remoteUrl);
+    logger.debug(`gitRepo=${JSON.stringify(gitRepo)}`);
+    if (gitRepo === undefined) {
+        throw new Error(`Failed to parse remote url. URL=${remoteUrl}`);
+    }
+    const github = createGitHub({
+        host: gitRepo.url.host,
+        token: options.githubToken
+    });
+    const githubRepo = await github.fetchRepository({
+        owner: gitRepo.owner,
+        repo: gitRepo.name
+    });
+    logger.debug(`githubRepo=${JSON.stringify(githubRepo)}`);
+    const branches = await github.fetchBranches({
+        owner: gitRepo.owner,
+        repo: gitRepo.name
+    });
+    logger.debug(`branches=${JSON.stringify(branches)}`);
+    const pullRequests = await github.fetchPullRequests({
+        owner: gitRepo.owner,
+        repo: gitRepo.name
+    });
+    logger.debug(`pullRequests=${JSON.stringify(pullRequests)}`);
+    const labelCreator = new LabelCreator({
+        github,
+        gitRepo
+    });
+    await labelCreator.create({
+        name: 'npm-update-package',
+        description: 'Created by npm-update-package',
+        color: 'A00F21'
+    });
+    const branchFinder = new BranchFinder(branches);
+    const packageManagerCreator = new PackageManagerCreator(options);
+    const packageManager = await packageManagerCreator.create(terminal);
+    const pullRequestTitleCreator = new PullRequestTitleCreator(options.prTitle);
+    const releasesFetcher = new ReleasesFetcher({
+        options,
+        packageManager
+    });
+    const githubUrlOptimizer = new GitHubUrlOptimizer(options);
+    const packageDiffsSectionCreator = new PackageDiffsSectionCreator(githubUrlOptimizer);
+    const releaseNotesSectionCreator = new ReleaseNotesSectionCreator(githubUrlOptimizer);
+    const pullRequestBodyCreator = new PullRequestBodyCreator({
+        options,
+        releasesFetcher,
+        packageDiffsSectionCreator,
+        releaseNotesSectionCreator
+    });
+    const labelsAdder = new LabelsAdder({
+        options,
+        github,
+        gitRepo
+    });
+    const assigneesAdder = new AssigneesAdder({
+        github,
+        gitRepo
+    });
+    const reviewersAdder = new ReviewersAdder({
+        github,
+        gitRepo
+    });
+    const pullRequestCreator = new PullRequestCreator({
+        options,
+        github,
+        gitRepo,
+        githubRepo,
+        pullRequestTitleCreator,
+        pullRequestBodyCreator,
+        labelsAdder,
+        assigneesAdder,
+        reviewersAdder
+    });
+    const commitMessageCreator = new CommitMessageCreator(options.commitMessage);
+    const pullRequestFinder = new PullRequestFinder(pullRequests);
+    const pullRequestCloser = new PullRequestCloser(github);
+    const pullRequestsCloser = new PullRequestsCloser(pullRequestCloser);
+    const packageUpdater = new PackageUpdater({
+        packageManager,
+        ncu
+    });
+    const outdatedPackageProcessorCreator = new OutdatedPackageProcessorCreator(options);
+    const outdatedPackageProcessor = outdatedPackageProcessorCreator.create({
+        git,
+        packageManager,
+        pullRequestCreator,
+        branchFinder,
+        commitMessageCreator,
+        pullRequestFinder,
+        pullRequestsCloser,
+        packageUpdater
+    });
+    const gitConfigInitializer = new GitConfigInitializer({
+        options,
+        git
+    });
+    await gitConfigInitializer.initialize();
+    const outdatedPackagesProcessor = new OutdatedPackagesProcessor(outdatedPackageProcessor);
+    const results = await outdatedPackagesProcessor.process(outdatedPackages);
+    logger.debug(`results=${JSON.stringify(results)}`);
+    const succeededResults = results
+        // eslint-disable-next-line unicorn/no-array-callback-reference
+        .filter(isRight)
+        .map(({ right }) => right);
+    logger.debug(`succeededResults=${JSON.stringify(succeededResults)}`);
+    const createdPackages = succeededResults
+        .filter(({ created }) => created)
+        .map(({ outdatedPackage }) => outdatedPackage);
+    logger.debug(`createdPackages=${JSON.stringify(createdPackages)}`);
+    const skippedPackages = succeededResults
+        .filter(({ skipped }) => skipped)
+        .map(({ outdatedPackage }) => outdatedPackage);
+    logger.debug(`skippedPackages=${JSON.stringify(skippedPackages)}`);
+    const failedResults = results
+        // eslint-disable-next-line unicorn/no-array-callback-reference
+        .filter(isLeft)
+        .map(({ left }) => left);
+    logger.debug(`failedResults=${JSON.stringify(failedResults)}`);
+    const failedPackages = failedResults.map(({ outdatedPackage }) => outdatedPackage);
+    logger.debug(`failedPackages=${JSON.stringify(failedPackages)}`);
+    // TODO: Show as table
+    logger.info(`Processed ${succeededResults.length + failedPackages.length} packages:
+- ${createdPackages.length} packages: created (${createdPackages.map(({ name }) => name).join(',')})
+- ${skippedPackages.length} packages: skipped: (${skippedPackages.map(({ name }) => name).join(',')})
+- ${failedPackages.length} packages: failed: (${failedPackages.map(({ name }) => name).join(',')})`);
+    if (options.ignorePackages !== undefined) {
+        logger.info(`Ignored ${options.ignorePackages.length} packages: ${options.ignorePackages.join(',')}`);
+    }
+};

package/dist/npm-check-updates/Dependency.js

@@ -0,0 +1,10 @@
+export const Dependency = {
+    Bundle: 'bundle',
+    Dev: 'dev',
+    Optional: 'optional',
+    Peer: 'peer',
+    Prod: 'prod'
+};
+const values = Object.values(Dependency);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+export const isDependency = (value) => values.includes(value);

package/dist/{src/npm-check-updates → npm-check-updates}/NpmCheckUpdates.js

@@ -1,22 +1,21 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.NpmCheckUpdates = void 0;
-const npm_check_updates_1 = require("npm-check-updates");
-const type_guards_1 = require("type-guards");
-const logger_1 = require("../logger");
-const package_json_1 = require("../package-json");
-const semver_1 = require("../semver");
-const createDepOptionValue_1 = require("./createDepOptionValue");
-const NpmCheckUpdatesResult_1 = require("./NpmCheckUpdatesResult");
+import { run } from 'npm-check-updates';
+import { isNotUndefined } from 'type-guards';
+import { logger } from '../logger/logger.js';
+import { DependencyType } from '../package-json/DependencyType.js';
+import { readPackageJson } from '../package-json/readPackageJson.js';
+import { compareSemVers } from '../semver/compareSemVers.js';
+import { SemVer } from '../semver/SemVer.js';
+import { createDepOptionValue } from './createDepOptionValue.js';
+import { isNpmCheckUpdatesResult } from './NpmCheckUpdatesResult.js';
 // TODO: Add test
-class NpmCheckUpdates {
+export class NpmCheckUpdates {
     options;
     constructor(options) {
         this.options = options;
     }
     async check() {
-        const dep = (0, createDepOptionValue_1.createDepOptionValue)(this.options.dependencyTypes);
-        logger_1.logger.trace(`dep=${dep}`);
+        const dep = createDepOptionValue(this.options.dependencyTypes);
+        logger.trace(`dep=${dep}`);
         return await this.run({
             packageManager: this.options.packageManager,
             jsonUpgraded: true,
@@ -34,32 +33,32 @@ class NpmCheckUpdates {
     }
     async run(options) {
         // Read package.json before running npm-check-updates
-        const pkg = await (0, package_json_1.readPackageJson)('./package.json');
-        logger_1.logger.trace(`pkg=${JSON.stringify(pkg)}`);
+        const pkg = await readPackageJson('./package.json');
+        logger.trace(`pkg=${JSON.stringify(pkg)}`);
         // Run npm-check-updates
-        const result = await (0, npm_check_updates_1.run)(options);
-        logger_1.logger.trace(`result=${JSON.stringify(result)}`);
-        if (!(0, NpmCheckUpdatesResult_1.isNpmCheckUpdatesResult)(result)) {
+        const result = await run(options);
+        logger.trace(`result=${JSON.stringify(result)}`);
+        if (!isNpmCheckUpdatesResult(result)) {
             throw new Error(`npm-check-updates has outputted unexpected result. result=${JSON.stringify(result)}`);
         }
         const resultEntries = Object.entries(result);
-        logger_1.logger.trace(`resultEntries=${JSON.stringify(resultEntries)}`);
+        logger.trace(`resultEntries=${JSON.stringify(resultEntries)}`);
         const outdatedPackages = resultEntries
             .map(([name, newVersionString]) => {
             const currentVersionString = this.extractCurrentVersionString(pkg, name);
-            logger_1.logger.trace(`currentVersionString=${String(currentVersionString)}`);
+            logger.trace(`currentVersionString=${String(currentVersionString)}`);
             if (currentVersionString === undefined) {
                 return undefined;
             }
             const dependencyType = this.extractDependencyType(pkg, name);
-            logger_1.logger.trace(`dependencyType=${String(dependencyType)}`);
+            logger.trace(`dependencyType=${String(dependencyType)}`);
             if (dependencyType === undefined) {
                 return undefined;
             }
-            const currentVersion = semver_1.SemVer.of(currentVersionString);
-            const newVersion = semver_1.SemVer.of(newVersionString);
-            const level = (0, semver_1.compareSemVers)(currentVersion, newVersion);
-            logger_1.logger.trace(`level=${String(level)}`);
+            const currentVersion = SemVer.of(currentVersionString);
+            const newVersion = SemVer.of(newVersionString);
+            const level = compareSemVers(currentVersion, newVersion);
+            logger.trace(`level=${String(level)}`);
             if (level === undefined) {
                 return undefined;
             }
@@ -70,12 +69,12 @@ class NpmCheckUpdates {
                 level,
                 dependencyType
             };
-            logger_1.logger.trace(`outdatedPackage=${JSON.stringify(outdatedPackage)}`);
+            logger.trace(`outdatedPackage=${JSON.stringify(outdatedPackage)}`);
             return outdatedPackage;
         })
             // eslint-disable-next-line unicorn/no-array-callback-reference
-            .filter(type_guards_1.isNotUndefined);
-        logger_1.logger.trace(`outdatedPackages=${JSON.stringify(outdatedPackages)}`);
+            .filter(isNotUndefined);
+        logger.trace(`outdatedPackages=${JSON.stringify(outdatedPackages)}`);
         if (resultEntries.length !== outdatedPackages.length) {
             throw new Error(`Failed to running npm-check-updates. result=${JSON.stringify(result)}`);
         }
@@ -102,20 +101,19 @@ class NpmCheckUpdates {
     extractDependencyType(pkg, packageName) {
         const { dependencies, devDependencies, peerDependencies, bundledDependencies, optionalDependencies } = pkg;
         if (dependencies?.[packageName] !== undefined) {
-            return package_json_1.DependencyType.Dependencies;
+            return DependencyType.Dependencies;
         }
         else if (devDependencies?.[packageName] !== undefined) {
-            return package_json_1.DependencyType.DevDependencies;
+            return DependencyType.DevDependencies;
         }
         else if (peerDependencies?.[packageName] !== undefined) {
-            return package_json_1.DependencyType.PeerDependencies;
+            return DependencyType.PeerDependencies;
         }
         else if (bundledDependencies?.[packageName] !== undefined) {
-            return package_json_1.DependencyType.BundledDependencies;
+            return DependencyType.BundledDependencies;
         }
         else if (optionalDependencies?.[packageName] !== undefined) {
-            return package_json_1.DependencyType.OptionalDependencies;
+            return DependencyType.OptionalDependencies;
         }
     }
 }
-exports.NpmCheckUpdates = NpmCheckUpdates;

package/dist/npm-check-updates/NpmCheckUpdatesResult.js

@@ -0,0 +1,3 @@
+import { record, string } from 'io-ts';
+export const NpmCheckUpdatesResult = record(string, string);
+export const isNpmCheckUpdatesResult = NpmCheckUpdatesResult.is;

package/dist/npm-check-updates/createDepOptionValue.js

@@ -0,0 +1,7 @@
+import { toDependency } from './toDependency.js';
+// TODO: Add test
+export const createDepOptionValue = (dependencyTypes) => {
+    return dependencyTypes
+        .map((dependencyType) => toDependency(dependencyType))
+        .join(',');
+};

package/dist/npm-check-updates/toDependency.js

@@ -0,0 +1,17 @@
+import { DependencyType } from '../package-json/DependencyType.js';
+import { Dependency } from './Dependency.js';
+// TODO: Add test
+export const toDependency = (dependencyType) => {
+    switch (dependencyType) {
+        case DependencyType.Dependencies:
+            return Dependency.Prod;
+        case DependencyType.DevDependencies:
+            return Dependency.Dev;
+        case DependencyType.PeerDependencies:
+            return Dependency.Peer;
+        case DependencyType.BundledDependencies:
+            return Dependency.Bundle;
+        case DependencyType.OptionalDependencies:
+            return Dependency.Optional;
+    }
+};

package/dist/options/CLIOption.js

@@ -0,0 +1 @@
+export {};

package/dist/options/OptionType.js

@@ -0,0 +1,9 @@
+export const OptionType = {
+    Boolean: 'boolean',
+    Number: 'number',
+    String: 'string',
+    StringArray: 'string[]'
+};
+const optionTypes = Object.values(OptionType);
+// eslint-disable-next-line @typescript-eslint/no-unsafe-argument
+export const isOptionType = (value) => optionTypes.includes(value);

package/dist/options/Options.js

@@ -0,0 +1,53 @@
+import { array, boolean, intersection, literal, number, partial, string, type, union } from 'io-ts';
+import { LogLevel } from '../logger/LogLevel.js';
+import { OutdatedPullRequestStrategy } from '../outdated-package-processor/OutdatedPullRequestStrategy.js';
+import { DependencyType } from '../package-json/DependencyType.js';
+import { PackageManagerName } from '../package-manager/PackageManagerName.js';
+const Options = intersection([
+    type({
+        commitMessage: string,
+        dependencyTypes: array(union([
+            literal(DependencyType.Dependencies),
+            literal(DependencyType.DevDependencies),
+            literal(DependencyType.PeerDependencies),
+            literal(DependencyType.BundledDependencies),
+            literal(DependencyType.OptionalDependencies)
+        ])),
+        draftPr: boolean,
+        fetchReleaseNotes: boolean,
+        fetchSleepTime: number,
+        githubToken: string,
+        logLevel: union([
+            literal(LogLevel.Off),
+            literal(LogLevel.Fatal),
+            literal(LogLevel.Error),
+            literal(LogLevel.Warn),
+            literal(LogLevel.Info),
+            literal(LogLevel.Debug),
+            literal(LogLevel.Trace)
+        ]),
+        outdatedPrStrategy: union([
+            literal(OutdatedPullRequestStrategy.Create),
+            literal(OutdatedPullRequestStrategy.Recreate),
+            literal(OutdatedPullRequestStrategy.Skip)
+        ]),
+        prBodyGithubHost: string,
+        prTitle: string
+    }),
+    partial({
+        additionalLabels: array(string),
+        assignees: array(string),
+        assigneesSampleSize: number,
+        gitUserEmail: string,
+        gitUserName: string,
+        ignorePackages: array(string),
+        packageManager: union([
+            literal(PackageManagerName.Npm),
+            literal(PackageManagerName.Yarn)
+        ]),
+        prBodyNotes: string,
+        reviewers: array(string),
+        reviewersSampleSize: number
+    })
+]);
+export const isOptions = Options.is;