@oclif/plugin-command-snapshot 4.0.15 → 4.0.16

package/lib/commands/snapshot/compare.js

@@ -1,12 +1,29 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const _ = require("lodash");
-const fs = require("fs");
-const os_1 = require("os");
-const snapshot_command_1 = require("../../snapshot-command");
-const chalk = require("chalk");
-class Compare extends snapshot_command_1.SnapshotCommand {
+import { Flags } from '@oclif/core';
+import chalk from 'chalk';
+import difference from 'lodash.difference';
+import * as fs from 'node:fs';
+import { EOL } from 'node:os';
+import SnapshotCommand from '../../snapshot-command.js';
+export default class Compare extends SnapshotCommand {
+    static flags = {
+        filepath: Flags.string({
+            default: './command-snapshot.json',
+            description: 'path of the generated snapshot file',
+        }),
+    };
+    get changed() {
+        return this.commands.map((command) => ({
+            alias: command.aliases.map((alias) => ({ name: alias })),
+            // we can assert as string because of the filter
+            chars: Object.values(command.flags)
+                .map((flag) => flag.char)
+                .filter((char) => typeof char === 'string')
+                .map((char) => ({ name: char })),
+            flags: Object.entries(command.flags).map((flagName) => ({ name: flagName[0] })),
+            name: command.id,
+            plugin: command.pluginName || '',
+        }));
+    }
     /**
      * Compare a snapshot with the current commands
      * @param {CommandChange[]} initialCommands Command list from the snapshot
@@ -17,7 +34,7 @@ class Compare extends snapshot_command_1.SnapshotCommand {
         const removedCommands = [];
         const diffCommands = [];
         for (const initialCommand of initialCommands) {
-            const updatedCommand = updatedCommands.find(updatedCommand => {
+            const updatedCommand = updatedCommands.find((updatedCommand) => {
                 // Protect against old snapshot files that don't have the plugin entry filled out.
                 const samePlugin = initialCommand.plugin ? initialCommand.plugin === updatedCommand.plugin : true;
                 return initialCommand.command === updatedCommand.name && samePlugin;
@@ -46,16 +63,16 @@ class Compare extends snapshot_command_1.SnapshotCommand {
                 removedCommands.push(initialCommand.command);
             }
         }
-        const initialCommandNames = initialCommands.map(initialCommand => initialCommand.command);
-        const updatedCommandNames = updatedCommands.map(updatedCommand => updatedCommand.name);
-        const addedCommands = _.difference(updatedCommandNames, initialCommandNames);
+        const initialCommandNames = initialCommands.map((initialCommand) => initialCommand.command);
+        const updatedCommandNames = updatedCommands.map((updatedCommand) => updatedCommand.name);
+        const addedCommands = difference(updatedCommandNames, initialCommandNames);
         if (removedCommands.length === 0 && addedCommands.length === 0 && diffCommands.length === 0) {
             this.log('No changes have been detected.');
             return {};
         }
         // Fail the process since there are changes to the snapshot file
         process.exitCode = 1;
-        this.log(`The following commands and flags have modified: (${chalk.green('+')} added, ${chalk.red('-')} removed)${os_1.EOL}`);
+        this.log(`The following commands and flags have modified: (${chalk.green('+')} added, ${chalk.red('-')} removed)${EOL}`);
         for (const command of removedCommands) {
             this.log(chalk.red(`\t-${command}`));
         }
@@ -64,7 +81,7 @@ class Compare extends snapshot_command_1.SnapshotCommand {
         }
         const removedProperties = [];
         const printCommandDiff = (properties, propertyName) => {
-            if (properties.some(prop => prop.added || prop.removed))
+            if (properties.some((prop) => prop.added || prop.removed))
                 this.log(`\t  ${propertyName}:`);
             for (const prop of properties) {
                 if (prop.added || prop.removed) {
@@ -81,23 +98,23 @@ class Compare extends snapshot_command_1.SnapshotCommand {
             printCommandDiff(command.chars, 'Short Flags');
             printCommandDiff(command.alias, 'Aliases');
         }
-        this.log(`${os_1.EOL}Command, flag, flag characters, or alias differences detected. If intended, please update the snapshot file and run again.`);
+        this.log(`${EOL}Command, flag, flag characters, or alias differences detected. If intended, please update the snapshot file and run again.`);
         // Check if existent commands, or properties (flags, aliases) have been deleted
         if (removedCommands.length > 0 || removedProperties.length > 0) {
-            this.log(chalk.red(`${os_1.EOL}Since there are deletions, a major version bump is required.`));
+            this.log(chalk.red(`${EOL}Since there are deletions, a major version bump is required.`));
         }
-        return { addedCommands, removedCommands, removedFlags: removedCommands, diffCommands };
+        return { addedCommands, diffCommands, removedCommands, removedFlags: removedCommands };
     }
     /**
-   * 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, updated) {
-        const updatedPropertyNames = updated.map(update => update.name);
-        const addedProperty = _.difference(updatedPropertyNames, initial);
-        const removedProperty = _.difference(initial, updatedPropertyNames);
+        const updatedPropertyNames = updated.map((update) => update.name);
+        const addedProperty = difference(updatedPropertyNames, initial);
+        const removedProperty = difference(initial, updatedPropertyNames);
         const changedProperty = [];
         for (const update of updated) {
             if (addedProperty.includes(update.name)) {
@@ -111,31 +128,12 @@ class Compare extends snapshot_command_1.SnapshotCommand {
             // so it shows removed.
             updated.push({ name: remove, removed: true });
         }
-        return { addedProperty, removedProperty, updated, changedProperty };
-    }
-    get changed() {
-        return this.commands.map(command => {
-            return {
-                name: command.id,
-                plugin: command.pluginName || '',
-                flags: Object.entries(command.flags).map(flagName => ({ name: flagName[0] })),
-                alias: command.aliases.map(alias => ({ name: alias })),
-                // we can assert as string because of the filter
-                chars: Object.values(command.flags).map(flag => flag.char).filter(char => typeof char === 'string').map(char => ({ name: char })),
-            };
-        });
+        return { addedProperty, changedProperty, removedProperty, updated };
     }
     async run() {
         const { flags } = await this.parse(Compare);
-        const oldCommands = JSON.parse(fs.readFileSync(flags.filepath).toString('utf8'));
+        const oldCommands = JSON.parse(fs.readFileSync(flags.filepath, 'utf8'));
         const newCommands = this.changed;
         return this.compareSnapshot(oldCommands, newCommands);
     }
 }
-exports.default = Compare;
-Compare.flags = {
-    filepath: core_1.Flags.string({
-        description: 'path of the generated snapshot file',
-        default: './command-snapshot.json',
-    }),
-};

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

@@ -1,8 +1,8 @@
-import { SnapshotCommand, SnapshotEntry } from '../../snapshot-command';
+import SnapshotCommand, { SnapshotEntry } from '../../snapshot-command.js';
 export type Snapshots = SnapshotEntry[];
 export default class Generate 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<Snapshots>;
 }

package/lib/commands/snapshot/generate.js

@@ -1,32 +1,34 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("@oclif/core");
-const fs = require("fs");
-const snapshot_command_1 = require("../../snapshot-command");
-class Generate extends snapshot_command_1.SnapshotCommand {
+import { Flags } from '@oclif/core';
+import SnapshotCommand from '../../snapshot-command.js';
+export default class Generate extends SnapshotCommand {
+    static flags = {
+        filepath: Flags.string({
+            default: './command-snapshot.json',
+            description: 'path to save the generated snapshot file; can use "{version}" to replace the current CLI/plugin version',
+        }),
+    };
     async run() {
         const numberOfSpaceChar = 4;
         const { flags } = await this.parse(Generate);
         const resultCommands = this.entries;
-        const duplicatedChar = resultCommands.find(command => command.flags.length > 1 && new Set(command.flagChars).size !== command.flagChars.length);
+        const duplicatedChar = resultCommands.find((command) => command.flags.length > 1 && new Set(command.flagChars).size !== command.flagChars.length);
         if (duplicatedChar) {
             throw new Error(`Command "${duplicatedChar.command}" has duplicate short-flag characters "${duplicatedChar.flagChars.filter((item, index) => duplicatedChar.flagChars.indexOf(item) !== index)}"`);
         }
-        const charConflictCommand = resultCommands.find(command => command.flags.length > 1 && new Set([...command.flags, ...command.flagChars, ...command.flagAliases]).size !== [...command.flags, ...command.flagChars, ...command.flagAliases].length);
+        const charConflictCommand = resultCommands.find((command) => command.flags.length > 1 &&
+            new Set([...command.flags, ...command.flagChars, ...command.flagAliases]).size !==
+                [...command.flags, ...command.flagChars, ...command.flagAliases].length);
         if (charConflictCommand) {
-            const conflictFlags = [...charConflictCommand.flags, ...charConflictCommand.flagChars, ...charConflictCommand.flagAliases].filter((item, index, array) => array.indexOf(item) !== index);
+            const conflictFlags = [
+                ...charConflictCommand.flags,
+                ...charConflictCommand.flagChars,
+                ...charConflictCommand.flagAliases,
+            ].filter((item, index, array) => array.indexOf(item) !== index);
             throw new Error(`Command "${charConflictCommand.command}" has conflicting flags "${conflictFlags}"`);
         }
         const filePath = flags.filepath.replace('{version}', this.config.version);
-        fs.writeFileSync(filePath, JSON.stringify(resultCommands, null, numberOfSpaceChar));
+        this.write(filePath, JSON.stringify(resultCommands, null, numberOfSpaceChar));
         this.log(`Generated snapshot file "${filePath}"`);
         return resultCommands;
     }
 }
-exports.default = Generate;
-Generate.flags = {
-    filepath: core_1.Flags.string({
-        description: 'path to save the generated snapshot file; can use "{version}" to replace the current CLI/plugin version',
-        default: './command-snapshot.json',
-    }),
-};

package/lib/index.js

@@ -1,3 +1 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = {};
+export default {};

package/lib/snapshot-command.d.ts

@@ -1,13 +1,14 @@
 import { Command } from '@oclif/core';
 export type SnapshotEntry = {
-    command: string;
-    plugin: string;
-    flags: string[];
     alias: string[];
-    flagChars: string[];
+    command: string;
     flagAliases: string[];
+    flagChars: string[];
+    flags: string[];
+    plugin: string;
 };
-export declare abstract class SnapshotCommand extends Command {
+export default abstract class SnapshotCommand extends Command {
     get commands(): Command.Loadable[];
     get entries(): SnapshotEntry[];
+    write(path: string, data: string): void;
 }

package/lib/snapshot-command.js

@@ -1,29 +1,33 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.SnapshotCommand = void 0;
-const core_1 = require("@oclif/core");
-const _ = require("lodash");
-class SnapshotCommand extends core_1.Command {
+import { Command } from '@oclif/core';
+import sortBy from 'lodash.sortby';
+import { writeFileSync } from 'node:fs';
+export default class SnapshotCommand extends Command {
     get commands() {
         const devPlugins = this.config.pjson.oclif.devPlugins ?? [];
         const commands = this.config.commands
             // Ignore dev plugins
-            .filter(command => !devPlugins.includes(command.pluginName ?? ''))
+            .filter((command) => !devPlugins.includes(command.pluginName ?? ''))
             // remove aliases that reference themselves
-            .filter(command => !command.aliases.includes(command.id));
-        return _.sortBy(commands, 'id');
+            .filter((command) => !command.aliases.includes(command.id));
+        return sortBy(commands, 'id');
     }
     get entries() {
-        return this.commands.map(command => {
-            return {
-                command: command.id,
-                plugin: command.pluginName,
-                flags: Object.keys(command.flags).sort(),
-                alias: command.aliases,
-                flagChars: Object.values(command.flags).map(flag => flag.char).filter(char => char).sort(),
-                flagAliases: Object.values(command.flags).flatMap(flag => flag.aliases).filter(alias => alias).sort(),
-            };
-        });
+        return this.commands.map((command) => ({
+            alias: command.aliases,
+            command: command.id,
+            flagAliases: Object.values(command.flags)
+                .flatMap((flag) => flag.aliases)
+                .filter(Boolean)
+                .sort(),
+            flagChars: Object.values(command.flags)
+                .map((flag) => flag.char)
+                .filter(Boolean)
+                .sort(),
+            flags: Object.keys(command.flags).sort(),
+            plugin: command.pluginName,
+        }));
+    }
+    write(path, data) {
+        writeFileSync(path, data);
     }
 }
-exports.SnapshotCommand = SnapshotCommand;

package/lib/util.js

@@ -1,24 +1,15 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getKeyNameFromFilename = exports.getSchemaFileName = void 0;
 /**
  * Get the file name for a given command ID replacing "-" with "__" and ":" with "-"
  * @param cmdId - command ID
  * @returns {string} - file name
  */
-const getSchemaFileName = (cmdId) => {
-    const baseName = cmdId.replace(/-/g, '__').replace(/:/g, '-');
+export const getSchemaFileName = (cmdId) => {
+    const baseName = cmdId.replaceAll('-', '__').replaceAll(':', '-');
     return `${baseName}.json`;
 };
-exports.getSchemaFileName = getSchemaFileName;
 /**
  * Get the command ID from a given file name replacing "-" with ":" and "__" with "-"
  * @param file - file name
  * @returns {string} - command ID
  */
-const getKeyNameFromFilename = (file) => {
-    return file.replace(/-/g, ':')
-        .replace(/__/g, '-')
-        .replace('.json', '');
-};
-exports.getKeyNameFromFilename = getKeyNameFromFilename;
+export const getKeyNameFromFilename = (file) => file.replaceAll('-', ':').replaceAll('__', '-').replace('.json', '');