@oclif/plugin-command-snapshot 6.0.0 → 6.0.2

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

@@ -1,8 +1,8 @@
-import { Operation } from 'just-diff';
+import { type Operation } from 'just-diff';
 import SnapshotCommand from '../../snapshot-command.js';
 export type SchemaComparison = Array<{
     op: Operation;
-    path: (number | string)[];
+    path: Array<number | string>;
     value: unknown;
 }>;
 export default class SchemaCompare extends SnapshotCommand {

package/lib/commands/schema/compare.js

@@ -61,22 +61,22 @@ export default class SchemaCompare extends SnapshotCommand {
             const objPath = change.path.join('.');
             const existing = get(existingSchema, objPath);
             const latest = get(latestSchema, objPath);
-            const [commandId] = objPath.split('.definitions');
+            const [commandId] = objPath.split('.definitions', 1);
             const readablePath = objPath.replace(`${commandId}.`, '');
             if (!humanReadableChanges[commandId]) {
                 humanReadableChanges[commandId] = [];
             }
-            const lastElementIsNum = isNumber(lastPathElement);
-            const basePath = lastElementIsNum ? readablePath.replace(`.${lastPathElement}`, '') : readablePath;
+            const isLastElementNum = isNumber(lastPathElement);
+            const basePath = isLastElementNum ? readablePath.replace(`.${lastPathElement}`, '') : readablePath;
             switch (change.op) {
                 case 'add': {
-                    humanReadableChanges[commandId].push(lastElementIsNum
+                    humanReadableChanges[commandId].push(isLastElementNum
                         ? `Array item at ${underline(basePath)} was ${cyan('added')} to latest schema`
                         : `${underline(readablePath)} was ${cyan('added')} to latest schema`);
                     break;
                 }
                 case 'remove': {
-                    humanReadableChanges[commandId].push(lastElementIsNum
+                    humanReadableChanges[commandId].push(isLastElementNum
                         ? `Array item at ${underline(basePath)} was ${cyan('not found')} in latest schema`
                         : `${underline(readablePath)} was ${cyan('not found')} in latest schema`);
                     break;
@@ -111,8 +111,8 @@ export default class SchemaCompare extends SnapshotCommand {
     }
     readExistingSchema(filePath) {
         const contents = fs.readdirSync(filePath);
-        const folderIsVersioned = contents.every((c) => semver.valid(c));
-        const schemasDir = folderIsVersioned ? path.join(filePath, semver.rsort(contents)[0] || '') : filePath;
+        const isFolderVersioned = contents.every((c) => semver.valid(c));
+        const schemasDir = isFolderVersioned ? path.join(filePath, semver.rsort(contents)[0] || '') : filePath;
         const schemaFiles = getAllFiles(schemasDir, '.json');
         let schemas = {
             commands: {},

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

@@ -1,8 +1,6 @@
-import { Schema } from 'ts-json-schema-generator';
+import { type Schema } from 'ts-json-schema-generator';
 import SnapshotCommand from '../../snapshot-command.js';
-export type SchemasMap = {
-    [key: string]: Schema;
-};
+export type SchemasMap = Record<string, Schema>;
 export type Schemas = {
     commands: SchemasMap;
     hooks: SchemasMap;
@@ -15,11 +13,11 @@ type SchemaGenerateOptions = {
     ignoreVoid?: boolean;
 };
 export declare class SchemaGenerator {
-    private base;
+    private readonly base;
     private classToId;
-    private commandGlobs;
-    private commandsDir;
-    private ignoreVoid;
+    private readonly commandGlobs;
+    private readonly commandsDir;
+    private readonly ignoreVoid;
     constructor(options: SchemaGenerateOptions);
     generate(): Promise<Schemas>;
     private determineCommandId;

package/lib/commands/schema/generate.js

@@ -144,28 +144,28 @@ export class SchemaGenerator {
         const contents = fs.readFileSync(file, 'utf8');
         const [returnType] = returnTypeRegex.exec(contents) || [];
         if (!returnType || returnType === 'void') {
-            return { hookId: null, returnType: null };
+            return { hookId: undefined, returnType: undefined };
         }
         const hooks = this.base.config.pjson.oclif?.hooks ?? {};
         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 currentFileName = path.basename(file).split('.')[0];
+            const hookFileNames = hookFiles.map((f) => path.basename(f).split('.', 1)[0]);
+            const currentFileName = path.basename(file).split('.', 1)[0];
             return hookFileNames.includes(currentFileName);
         });
         if (!hookId) {
-            return { hookId: null, returnType: null };
+            return { hookId: undefined, returnType: undefined };
         }
         this.validateReturnType(returnType, hookId);
         return { hookId, returnType };
     }
     validateReturnType(returnType, commandId) {
         const notAllowed = this.ignoreVoid ? ['any', 'unknown'] : ['any', 'unknown', 'void'];
-        const vagueTypes = ['JsonMap', 'JsonCollection', 'AnyJson'];
         if (notAllowed.includes(returnType)) {
             throw new Error(`${returnType} (from ${commandId}) is not allowed. Please use a more specific type.`);
         }
-        else if (vagueTypes.includes(returnType)) {
+        const vagueTypes = ['JsonMap', 'JsonCollection', 'AnyJson'];
+        if (vagueTypes.includes(returnType)) {
             throw new Error(`${returnType} (from ${commandId}) is too vague. Please use a more specific type.`);
         }
     }

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

@@ -1,9 +1,9 @@
-import SnapshotCommand, { SnapshotEntry } from '../../snapshot-command.js';
-interface Change {
+import SnapshotCommand, { type SnapshotEntry } from '../../snapshot-command.js';
+type Change = {
     added?: boolean;
     name: string;
     removed?: boolean;
-}
+};
 type CommandChange = Change & {
     alias: Change[];
     chars: Change[];

package/lib/commands/snapshot/compare.js

@@ -36,26 +36,26 @@ export default class Compare extends SnapshotCommand {
         for (const initialCommand of initialCommands) {
             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;
+                const isSamePlugin = initialCommand.plugin ? initialCommand.plugin === updatedCommand.plugin : true;
+                return initialCommand.command === updatedCommand.name && isSamePlugin;
             });
             if (updatedCommand) {
                 const changedFlags = this.diffCommandProperty(initialCommand.flags, updatedCommand.flags).changedProperty;
                 const changedAlias = this.diffCommandProperty(initialCommand.alias, updatedCommand.alias).changedProperty;
                 const changedChars = this.diffCommandProperty(initialCommand.flagChars, updatedCommand.chars).changedProperty;
-                const flagsChanged = changedFlags.length > 0;
-                const aliasChanged = changedAlias.length > 0;
-                const charsChanged = changedChars.length > 0;
-                if (aliasChanged) {
+                const isFlagsChanged = changedFlags.length > 0;
+                const isAliasChanged = changedAlias.length > 0;
+                const isCharsChanged = changedChars.length > 0;
+                if (isAliasChanged) {
                     updatedCommand.alias = changedAlias;
                 }
-                if (charsChanged) {
+                if (isCharsChanged) {
                     updatedCommand.chars = changedChars;
                 }
-                if (flagsChanged) {
+                if (isFlagsChanged) {
                     updatedCommand.flags = changedFlags;
                 }
-                if (flagsChanged || aliasChanged || charsChanged) {
+                if (isFlagsChanged || isAliasChanged || isCharsChanged) {
                     diffCommands.push(updatedCommand);
                 }
             }
@@ -117,10 +117,11 @@ export default class Compare extends SnapshotCommand {
         const removedProperty = difference(initial, updatedPropertyNames);
         const changedProperty = [];
         for (const update of updated) {
-            if (addedProperty.includes(update.name)) {
-                update.added = true;
-                changedProperty.push(update);
+            if (!addedProperty.includes(update.name)) {
+                continue;
             }
+            update.added = true;
+            changedProperty.push(update);
         }
         for (const remove of removedProperty) {
             changedProperty.push({ name: remove, removed: true });

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

@@ -1,4 +1,4 @@
-import SnapshotCommand, { SnapshotEntry } from '../../snapshot-command.js';
+import SnapshotCommand, { type SnapshotEntry } from '../../snapshot-command.js';
 export type Snapshots = SnapshotEntry[];
 export default class Generate extends SnapshotCommand {
     static flags: {

package/oclif.manifest.json

@@ -145,5 +145,5 @@
       ]
     }
   },
-  "version": "6.0.0"
+  "version": "6.0.2"
 }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@oclif/plugin-command-snapshot",
   "description": "generates and compares OCLIF plugins snapshot files",
-  "version": "6.0.0",
+  "version": "6.0.2",
   "author": "Salesforce",
   "bugs": "https://github.com/oclif/plugin-command-snapshot/issues",
   "bin": {