@oclif/plugin-command-snapshot 4.0.14 → 4.0.16-dev.1

package/README.md

@@ -1,5 +1,4 @@
-@oclif/plugin-command-snapshot
-========
+# @oclif/plugin-command-snapshot
 
 Generates and compares OCLIF plugins snapshot files
 
@@ -9,12 +8,14 @@ Generates and compares OCLIF plugins snapshot files
 [![License](https://img.shields.io/npm/l/@oclif/plugin-command-snapshot.svg)](https://github.com/nramyasri-sf/@oclif/plugin-command-snapshot/blob/main/package.json)
 
 <!-- toc -->
+* [@oclif/plugin-command-snapshot](#oclifplugin-command-snapshot)
 * [Usage](#usage)
 * [generates a snapshot file that has a list or commands and flags in the current CLI or plugin](#generates-a-snapshot-file-that-has-a-list-or-commands-and-flags-in-the-current-cli-or-plugin)
 * [compare the current CLI or plugin commands and flags with a snapshot file to identify changes](#compare-the-current-cli-or-plugin-commands-and-flags-with-a-snapshot-file-to-identify-changes)
 <!-- tocstop -->
 
 # Usage
+
 This plugin is used to take snapshot of commands and flags in OCLIF plugins. These snapshots can be used to enforce a deprecation policy or to keep track of changes.
 
 To include it in your plugin, add it to the `devPlugins` section in your package.json.
@@ -32,12 +33,12 @@ Use the `snapshot:generate` command in your development process.
 
 ```sh-session
 # generates a snapshot file that has a list or commands and flags in the current CLI or plugin
-$ ./bin/run snapshot:generate
+$ ./bin/run.js snapshot:generate
 ```
 
 Use the `snapshot:compare` command in your continuos integration. This command will fail if changes are detected. The snapshot file should be updated and committed to the repository when legitimate changes are made.
 
 ```sh-session
 # compare the current CLI or plugin commands and flags with a snapshot file to identify changes
-$ ./bin/run snapshot:compare
+$ ./bin/run.js snapshot:compare
 ```

package/lib/commands/schema/compare.d.ts

@@ -1,15 +1,15 @@
 import { Operation } from 'just-diff';
-import { SnapshotCommand } from '../../snapshot-command';
+import SnapshotCommand from '../../snapshot-command.js';
 export type SchemaComparison = Array<{
     op: Operation;
-    path: (string | number)[];
-    value: any;
+    path: (number | string)[];
+    value: unknown;
 }>;
 export default class SchemaCompare extends SnapshotCommand {
     static flags: {
-        filepath: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        filepath: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
     run(): Promise<SchemaComparison>;
-    private readExistingSchema;
     private generateLatestSchema;
+    private readExistingSchema;
 }

package/lib/commands/schema/compare.js

@@ -1,23 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const path = require("path");
-const fs = require("fs");
-const semver = require("semver");
-const lodash_1 = require("lodash");
-const just_diff_1 = require("just-diff");
-const core_1 = require("@oclif/core");
-const snapshot_command_1 = require("../../snapshot-command");
-const generate_1 = require("./generate");
-const chalk_1 = require("chalk");
-const util_1 = require("../../util");
+import { Flags, toConfiguredId } from '@oclif/core';
+import chalk from 'chalk';
+import { diff } from 'just-diff';
+import get from 'lodash.get';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as semver from 'semver';
+import SnapshotCommand from '../../snapshot-command.js';
+import { getKeyNameFromFilename } from '../../util.js';
+import { SchemaGenerator, getAllFiles } from './generate.js';
 function isNumber(n) {
     return Number.isInteger(Number(n));
 }
 function isMeaningless(n) {
+    if (!n)
+        return true;
     const meaninglessKeys = ['$comment', '__computed'];
     return meaninglessKeys.includes(n);
 }
-class SchemaCompare extends snapshot_command_1.SnapshotCommand {
+export default class SchemaCompare extends SnapshotCommand {
+    static flags = {
+        filepath: Flags.string({
+            default: './schemas',
+            description: 'path of the generated snapshot file',
+        }),
+    };
     async run() {
         const { flags } = await this.parse(SchemaCompare);
         try {
@@ -28,18 +34,18 @@ class SchemaCompare extends snapshot_command_1.SnapshotCommand {
             return [];
         }
         const existingSchema = this.readExistingSchema(flags.filepath);
-        const latestSchema = (await this.generateLatestSchema());
+        const latestSchema = await this.generateLatestSchema();
         this.debug('existingSchema', existingSchema);
         this.debug('latestSchema', latestSchema);
-        const changes = (0, just_diff_1.diff)(latestSchema, existingSchema);
+        const changes = diff(latestSchema, existingSchema);
         const humanReadableChanges = {};
         for (const change of changes) {
-            const lastPathElement = change.path[change.path.length - 1];
+            const lastPathElement = change.path.at(-1);
             if (isMeaningless(lastPathElement))
                 continue;
             const objPath = change.path.join('.');
-            const existing = (0, lodash_1.get)(existingSchema, objPath);
-            const latest = (0, lodash_1.get)(latestSchema, objPath);
+            const existing = get(existingSchema, objPath);
+            const latest = get(latestSchema, objPath);
             const [commandId] = objPath.split('.definitions');
             const readablePath = objPath.replace(`${commandId}.`, '');
             if (!humanReadableChanges[commandId]) {
@@ -48,21 +54,25 @@ class SchemaCompare extends snapshot_command_1.SnapshotCommand {
             const lastElementIsNum = isNumber(lastPathElement);
             const basePath = lastElementIsNum ? readablePath.replace(`.${lastPathElement}`, '') : readablePath;
             switch (change.op) {
-                case 'replace':
-                    humanReadableChanges[commandId].push(`${(0, chalk_1.underline)(readablePath)} was changed from ${(0, chalk_1.cyan)(existing)} to ${(0, chalk_1.cyan)(latest)}`);
+                case 'replace': {
+                    humanReadableChanges[commandId].push(`${chalk.underline(readablePath)} was changed from ${chalk.cyan(existing)} to ${chalk.cyan(latest)}`);
                     break;
-                case 'add':
-                    humanReadableChanges[commandId].push(lastElementIsNum ?
-                        `Array item at ${(0, chalk_1.underline)(basePath)} was ${(0, chalk_1.cyan)('added')} to latest schema` :
-                        `${(0, chalk_1.underline)(readablePath)} was ${(0, chalk_1.cyan)('added')} to latest schema`);
+                }
+                case 'add': {
+                    humanReadableChanges[commandId].push(lastElementIsNum
+                        ? `Array item at ${chalk.underline(basePath)} was ${chalk.cyan('added')} to latest schema`
+                        : `${chalk.underline(readablePath)} was ${chalk.cyan('added')} to latest schema`);
                     break;
-                case 'remove':
-                    humanReadableChanges[commandId].push(lastElementIsNum ?
-                        `Array item at ${(0, chalk_1.underline)(basePath)} was ${(0, chalk_1.cyan)('not found')} in latest schema` :
-                        `${(0, chalk_1.underline)(readablePath)} was ${(0, chalk_1.cyan)('not found')} in latest schema`);
+                }
+                case 'remove': {
+                    humanReadableChanges[commandId].push(lastElementIsNum
+                        ? `Array item at ${chalk.underline(basePath)} was ${chalk.cyan('not found')} in latest schema`
+                        : `${chalk.underline(readablePath)} was ${chalk.cyan('not found')} in latest schema`);
                     break;
-                default:
+                }
+                default: {
                     break;
+                }
             }
         }
         if (Object.keys(humanReadableChanges).length === 0) {
@@ -70,25 +80,29 @@ class SchemaCompare extends snapshot_command_1.SnapshotCommand {
             return [];
         }
         this.log();
-        this.log((0, chalk_1.bold)((0, chalk_1.red)('Found the following schema changes:')));
+        this.log(chalk.bold.red('Found the following schema changes:'));
         for (const [commandId, changes] of Object.entries(humanReadableChanges)) {
             this.log();
-            this.log((0, chalk_1.bold)(commandId));
+            this.log(chalk.bold(commandId));
             for (const change of changes) {
                 this.log(`  - ${change}`);
             }
         }
         this.log();
         const bin = process.platform === 'win32' ? 'bin\\dev.cmd' : 'bin/dev';
-        this.log('If intended, please update the schema file(s) and run again:', (0, chalk_1.bold)(`${bin} ${(0, core_1.toConfiguredId)('schema:generate', this.config)}`));
+        this.log('If intended, please update the schema file(s) and run again:', chalk.bold(`${bin} ${toConfiguredId('schema:generate', this.config)}`));
         process.exitCode = 1;
         return changes;
     }
+    async generateLatestSchema() {
+        const generator = new SchemaGenerator(this);
+        return generator.generate();
+    }
     readExistingSchema(filePath) {
         const contents = fs.readdirSync(filePath);
-        const folderIsVersioned = contents.every(c => semver.valid(c));
+        const folderIsVersioned = contents.every((c) => semver.valid(c));
         const schemasDir = folderIsVersioned ? path.join(filePath, semver.rsort(contents)[0] || '') : filePath;
-        const schemaFiles = (0, generate_1.getAllFiles)(schemasDir, '.json');
+        const schemaFiles = getAllFiles(schemasDir, '.json');
         let schemas = {
             commands: {},
             hooks: {},
@@ -99,7 +113,7 @@ class SchemaCompare extends snapshot_command_1.SnapshotCommand {
         else {
             for (const file of schemaFiles) {
                 const schema = JSON.parse(fs.readFileSync(file).toString('utf8'));
-                const key = path.basename((0, util_1.getKeyNameFromFilename)(file));
+                const key = path.basename(getKeyNameFromFilename(file));
                 if (file.split(path.sep).includes('hooks')) {
                     schemas.hooks[key] = schema;
                 }
@@ -110,15 +124,4 @@ class SchemaCompare extends snapshot_command_1.SnapshotCommand {
         }
         return schemas;
     }
-    async generateLatestSchema() {
-        const generator = new generate_1.SchemaGenerator(this);
-        return generator.generate();
-    }
 }
-exports.default = SchemaCompare;
-SchemaCompare.flags = {
-    filepath: core_1.Flags.string({
-        description: 'path of the generated snapshot file',
-        default: './schemas',
-    }),
-};

package/lib/commands/schema/generate.d.ts

@@ -1,5 +1,5 @@
 import { Schema } from 'ts-json-schema-generator';
-import { SnapshotCommand } from '../../snapshot-command';
+import SnapshotCommand from '../../snapshot-command.js';
 export type SchemasMap = {
     [key: string]: Schema;
 };
@@ -15,9 +15,11 @@ export declare class SchemaGenerator {
     private classToId;
     constructor(base: SnapshotCommand, ignoreVoid?: boolean);
     generate(): Promise<Schemas>;
+    private determineCommandId;
     private generateSchema;
     private getAllCmdFiles;
     private getAllHookFiles;
+    private getDirs;
     /**
      * Use regex to find the typescript type being returned by the command's
      * `run` method.
@@ -32,14 +34,12 @@ export declare class SchemaGenerator {
      */
     private parseHookFile;
     private validateReturnType;
-    private determineCommandId;
-    private getDirs;
 }
 export default class SchemaGenerate extends SnapshotCommand {
     static flags: {
-        filepath: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
-        singlefile: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
-        ignorevoid: import("@oclif/core/lib/interfaces").BooleanFlag<boolean>;
+        filepath: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
+        ignorevoid: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
+        singlefile: import("@oclif/core/lib/interfaces/parser.js").BooleanFlag<boolean>;
     };
     run(): Promise<GenerateResponse>;
 }

package/lib/commands/schema/generate.js

@@ -1,14 +1,11 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SchemaGenerator = exports.getAllFiles = void 0;
-const path = require("path");
-const fs = require("fs");
-const core_1 = require("@oclif/core");
-const ts_json_schema_generator_1 = require("ts-json-schema-generator");
-const snapshot_command_1 = require("../../snapshot-command");
-const chalk_1 = require("chalk");
-const util_1 = require("../../util");
-function getAllFiles(dirPath, ext, allFiles = []) {
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { createGenerator } from 'ts-json-schema-generator';
+import SnapshotCommand from '../../snapshot-command.js';
+import { getSchemaFileName } from '../../util.js';
+export function getAllFiles(dirPath, ext, allFiles = []) {
     let files = [];
     try {
         files = fs.readdirSync(dirPath);
@@ -25,12 +22,14 @@ function getAllFiles(dirPath, ext, allFiles = []) {
     }
     return allFiles;
 }
-exports.getAllFiles = getAllFiles;
-class SchemaGenerator {
+export class SchemaGenerator {
+    base;
+    ignoreVoid;
+    classToId = {};
+    // eslint-disable-next-line no-useless-constructor
     constructor(base, ignoreVoid = true) {
         this.base = base;
         this.ignoreVoid = ignoreVoid;
-        this.classToId = {};
     }
     async generate() {
         for (const cmd of this.base.commands) {
@@ -40,32 +39,45 @@ class SchemaGenerator {
         }
         const cmdSchemas = {};
         for (const file of this.getAllCmdFiles()) {
-            const { returnType, commandId } = this.parseCmdFile(file);
+            const { commandId, returnType } = this.parseCmdFile(file);
             if (this.ignoreVoid && returnType === 'void')
                 continue;
             cmdSchemas[commandId] = this.generateSchema(returnType, file);
         }
         const hookSchemas = {};
         for (const file of this.getAllHookFiles()) {
-            const { returnType, hookId } = this.parseHookFile(file);
+            const { hookId, returnType } = this.parseHookFile(file);
             if (returnType && hookId) {
                 hookSchemas[hookId] = this.generateSchema(returnType, file);
             }
         }
         return { commands: cmdSchemas, hooks: hookSchemas };
     }
+    determineCommandId(contents) {
+        for (const [className, cmdId] of Object.entries(this.classToId)) {
+            const regex = new RegExp(` class ${className} `, 'g');
+            if (regex.test(contents)) {
+                return cmdId;
+            }
+        }
+    }
     generateSchema(returnType, file) {
         try {
             const config = {
                 path: file,
-                type: returnType,
                 skipTypeCheck: true,
+                type: returnType,
             };
-            return (0, ts_json_schema_generator_1.createGenerator)(config).createSchema(config.type);
+            return createGenerator(config).createSchema(config.type);
         }
         catch (error) {
-            const error_ = error.message.toLowerCase().includes('no root type') ? new Error(`Schema generator could not find the ${(0, chalk_1.red)(returnType)} type. Please make sure that ${(0, chalk_1.red)(returnType)} is exported.`) : error;
-            throw error_;
+            if (error instanceof Error) {
+                const error_ = error.message.toLowerCase().includes('no root type')
+                    ? new Error(`Schema generator could not find the ${chalk.red(returnType)} type. Please make sure that ${chalk.red(returnType)} is exported.`)
+                    : error;
+                throw error_;
+            }
+            throw error;
         }
     }
     getAllCmdFiles() {
@@ -74,11 +86,27 @@ class SchemaGenerator {
     }
     getAllHookFiles() {
         // eslint-disable-next-line unicorn/no-array-reduce
-        const hookFiles = Object.values(this.base.config.pjson.oclif?.hooks ?? {}).reduce((x, y) => {
-            return Array.isArray(y) ? [...x, ...y] : [...x, y];
-        }, []);
-        const { rootDir, outDir } = this.getDirs();
-        return hookFiles.map(h => `${path.resolve(h)}.ts`.replace(outDir, rootDir));
+        const hookFiles = Object.values(this.base.config.pjson.oclif?.hooks ?? {}).reduce((x, y) => (Array.isArray(y) ? [...x, ...y] : [...x, y]), []);
+        const { outDir, rootDir } = this.getDirs();
+        return hookFiles.map((h) => `${path.resolve(h)}.ts`.replace(outDir, rootDir));
+    }
+    getDirs() {
+        const dirs = {
+            outDir: path.join(this.base.config.root, 'lib'),
+            rootDir: path.join(this.base.config.root, 'src'),
+        };
+        try {
+            const tsConfig = JSON.parse(fs.readFileSync(path.join(this.base.config.root, 'tsconfig.json'), 'utf8'));
+            if (tsConfig.compilerOptions.rootDir) {
+                dirs.rootDir = path.join(this.base.config.root, tsConfig.compilerOptions.rootDir);
+            }
+            if (tsConfig.compilerOptions.outDir) {
+                dirs.outDir = path.join(this.base.config.root, tsConfig.compilerOptions.outDir);
+            }
+            return dirs;
+        }
+        catch { }
+        return dirs;
     }
     /**
      * Use regex to find the typescript type being returned by the command's
@@ -98,7 +126,7 @@ class SchemaGenerator {
             throw new Error(`No commandId found for file ${file}`);
         }
         this.validateReturnType(returnType, commandId);
-        return { returnType, commandId };
+        return { commandId, returnType };
     }
     /**
      * Use regex to find the typescript type being returned by the hook
@@ -110,20 +138,20 @@ class SchemaGenerator {
         const contents = fs.readFileSync(file, 'utf8');
         const [returnType] = returnTypeRegex.exec(contents) || [];
         if (!returnType || returnType === 'void') {
-            return { returnType: null, hookId: null };
+            return { hookId: null, returnType: null };
         }
         const hooks = this.base.config.pjson.oclif?.hooks ?? {};
-        const hookId = Object.keys(hooks).find(key => {
+        const hookId = Object.keys(hooks).find((key) => {
             const hookFiles = (Array.isArray(hooks[key]) ? hooks[key] : [hooks[key]]);
-            const hookFileNames = hookFiles.map(f => path.basename(f).split('.')[0]);
+            const hookFileNames = hookFiles.map((f) => path.basename(f).split('.')[0]);
             const currentFileName = path.basename(file).split('.')[0];
             return hookFileNames.includes(currentFileName);
         });
         if (!hookId) {
-            return { returnType: null, hookId: null };
+            return { hookId: null, returnType: null };
         }
         this.validateReturnType(returnType, hookId);
-        return { returnType, hookId };
+        return { hookId, returnType };
     }
     validateReturnType(returnType, commandId) {
         const notAllowed = this.ignoreVoid ? ['any', 'unknown'] : ['any', 'unknown', 'void'];
@@ -135,35 +163,22 @@ class SchemaGenerator {
             throw new Error(`${returnType} (from ${commandId}) is too vague. Please use a more specific type.`);
         }
     }
-    determineCommandId(contents) {
-        for (const [className, cmdId] of Object.entries(this.classToId)) {
-            const regex = new RegExp(` class ${className} `, 'g');
-            if (regex.test(contents)) {
-                return cmdId;
-            }
-        }
-    }
-    getDirs() {
-        const dirs = {
-            rootDir: path.join(this.base.config.root, 'src'),
-            outDir: path.join(this.base.config.root, 'lib'),
-        };
-        try {
-            const tsConfig = JSON.parse(fs.readFileSync(path.join(this.base.config.root, 'tsconfig.json'), 'utf-8'));
-            if (tsConfig.compilerOptions.rootDir) {
-                dirs.rootDir = path.join(this.base.config.root, tsConfig.compilerOptions.rootDir);
-            }
-            if (tsConfig.compilerOptions.outDir) {
-                dirs.outDir = path.join(this.base.config.root, tsConfig.compilerOptions.outDir);
-            }
-            return dirs;
-        }
-        catch { }
-        return dirs;
-    }
 }
-exports.SchemaGenerator = SchemaGenerator;
-class SchemaGenerate extends snapshot_command_1.SnapshotCommand {
+export default class SchemaGenerate extends SnapshotCommand {
+    static flags = {
+        filepath: Flags.string({
+            default: './schemas',
+            description: 'directory to save the generated schema files; can use "{version}" to insert the current CLI/plugin version',
+        }),
+        ignorevoid: Flags.boolean({
+            default: true,
+            description: 'ignore commands that return void',
+        }),
+        singlefile: Flags.boolean({
+            default: false,
+            description: 'put generated schema into a single file',
+        }),
+    };
     async run() {
         const { flags } = await this.parse(SchemaGenerate);
         const generator = new SchemaGenerator(this, flags.ignorevoid);
@@ -173,15 +188,15 @@ class SchemaGenerate extends snapshot_command_1.SnapshotCommand {
         const files = [];
         if (flags.singlefile) {
             const filePath = path.join(directory, 'schema.json');
-            fs.writeFileSync(filePath, JSON.stringify(schemas, null, 2));
+            this.write(filePath, JSON.stringify(schemas, null, 2));
             this.log(`Generated JSON schema file "${filePath}"`);
             files.push(filePath);
         }
         else {
             for (const [cmdId, schema] of Object.entries(schemas.commands)) {
-                const fileName = (0, util_1.getSchemaFileName)(cmdId);
+                const fileName = getSchemaFileName(cmdId);
                 const filePath = path.join(directory, fileName);
-                fs.writeFileSync(filePath, JSON.stringify(schema, null, 2));
+                this.write(filePath, JSON.stringify(schema, null, 2));
                 this.log(`Generated JSON schema file "${filePath}"`);
                 files.push(filePath);
             }
@@ -189,9 +204,9 @@ class SchemaGenerate extends snapshot_command_1.SnapshotCommand {
                 const hooksDir = path.join(directory, 'hooks');
                 fs.mkdirSync(hooksDir, { recursive: true });
                 for (const [hookId, schema] of Object.entries(schemas.hooks)) {
-                    const fileName = (0, util_1.getSchemaFileName)(hookId);
+                    const fileName = getSchemaFileName(hookId);
                     const filePath = path.join(hooksDir, fileName);
-                    fs.writeFileSync(filePath, JSON.stringify(schema, null, 2));
+                    this.write(filePath, JSON.stringify(schema, null, 2));
                     this.log(`Generated JSON schema file "${filePath}"`);
                     files.push(filePath);
                 }
@@ -200,18 +215,3 @@ class SchemaGenerate extends snapshot_command_1.SnapshotCommand {
         return files;
     }
 }
-exports.default = SchemaGenerate;
-SchemaGenerate.flags = {
-    filepath: core_1.Flags.string({
-        description: 'directory to save the generated schema files; can use "{version}" to insert the current CLI/plugin version',
-        default: './schemas',
-    }),
-    singlefile: core_1.Flags.boolean({
-        description: 'put generated schema into a single file',
-        default: false,
-    }),
-    ignorevoid: core_1.Flags.boolean({
-        description: 'ignore commands that return void',
-        default: true,
-    }),
-};

package/lib/commands/snapshot/compare.d.ts

@@ -1,25 +1,26 @@
-import { SnapshotCommand, SnapshotEntry } from '../../snapshot-command';
+import SnapshotCommand, { SnapshotEntry } from '../../snapshot-command.js';
 interface Change {
+    added?: boolean;
     name: string;
     removed?: boolean;
-    added?: boolean;
 }
 type CommandChange = {
-    plugin: string;
+    alias: Change[];
     chars: Change[];
     flags: Change[];
-    alias: Change[];
+    plugin: string;
 } & Change;
 export type CompareResponse = {
     addedCommands?: string[];
+    diffCommands?: CommandChange[];
     removedCommands?: string[];
     removedFlags?: string[];
-    diffCommands?: CommandChange[];
 };
 export default class Compare extends SnapshotCommand {
     static flags: {
-        filepath: import("@oclif/core/lib/interfaces").OptionFlag<string, import("@oclif/core/lib/interfaces/parser").CustomOptions>;
+        filepath: import("@oclif/core/lib/interfaces/parser.js").OptionFlag<string, import("@oclif/core/lib/interfaces/parser.js").CustomOptions>;
     };
+    get changed(): CommandChange[];
     /**
      * Compare a snapshot with the current commands
      * @param {CommandChange[]} initialCommands Command list from the snapshot
@@ -28,18 +29,17 @@ export default class Compare extends SnapshotCommand {
      */
     compareSnapshot(initialCommands: SnapshotEntry[], updatedCommands: CommandChange[]): Promise<CompareResponse>;
     /**
-   * compares two command's properties to each other
-   * @return a list of added, removed, updated, and changed properties
-   * @param initial initial command property to compare against
-   * @param updated generated command property to compare with
-   */
+     * compares two command's properties to each other
+     * @return a list of added, removed, updated, and changed properties
+     * @param initial initial command property to compare against
+     * @param updated generated command property to compare with
+     */
     diffCommandProperty(initial: string[], updated: Change[]): {
         addedProperty: string[];
+        changedProperty: Change[];
         removedProperty: string[];
         updated: Change[];
-        changedProperty: Change[];
     };
-    get changed(): CommandChange[];
     run(): Promise<CompareResponse>;
 }
 export {};