@halospv3/hce.shared-config 3.5.3-develop.2 → 3.6.0

package/src/dotnet/helpers.ts

@@ -7,7 +7,7 @@ import { MSBuildProjectProperties as MSBPP } from './MSBuildProjectProperties.ts
 import { NugetRegistryInfo } from './NugetRegistryInfo.ts';
 import type { Default } from 'arktype/internal/attributes.ts';
 
-const ourDefaultPubDir = path.join('.', 'publish') as `.${'/' | '\\'}publish`;
+const ourDefaultPubDirectory = path.join('.', 'publish') as `.${'/' | '\\'}publish`;
 
 /**
  * Build a prepareCmd string from .NET projects.\
@@ -26,31 +26,30 @@ const ourDefaultPubDir = path.join('.', 'publish') as `.${'/' | '\\'}publish`;
  * of the `--output` argument will be set to {@link ourDefaultPubDir} if `undefined`.
  * @returns A single string of CLI commands joined by ' && '
  */
+// eslint-disable-next-line unicorn/name-replacements
 export async function configurePrepareCmd(
   projectsToPublish: string[] | MSBuildProject[],
   projectsToPackAndPush?: string[] | NugetRegistryInfo[],
+  // eslint-disable-next-line unicorn/name-replacements
   dotnetNugetSignOpts?: typeof DotnetNugetSignOptions.inferIn,
 ): Promise<string> {
-  const evaluatedProjects: MSBuildProject[] = [];
+  const evaluatedProjects: MSBuildProject[] = projectsToPublish.filter(p => p instanceof MSBuildProject);
 
-  // append evaluated projects
-  for (const p of projectsToPublish.filter(p => p instanceof MSBuildProject)) {
-    evaluatedProjects.push(p);
-  }
   if (projectsToPackAndPush) {
-    for (const p of projectsToPackAndPush.filter(p => p instanceof NugetRegistryInfo)) {
-      evaluatedProjects.push(p.project);
+    for (const project of projectsToPackAndPush) {
+      if (project instanceof NugetRegistryInfo)
+        evaluatedProjects.push(project.project);
     }
   }
 
-  const dotnetPublishCmd: string = await formatDotnetPublish(projectsToPublish);
-  const dotnetPackCmd: string | undefined = await formatDotnetPack(projectsToPackAndPush ?? []);
-  const dotnetNugetSignCmd: string | undefined = formatDotnetNugetSign(dotnetNugetSignOpts);
+  const dotnetPublishCommand: string = await formatDotnetPublish(projectsToPublish);
+  const dotnetPackCommand: string | undefined = await formatDotnetPack(projectsToPackAndPush ?? []);
+  const dotnetNugetSignCommand: string | undefined = formatDotnetNugetSign(dotnetNugetSignOpts);
 
   return [
-    dotnetPublishCmd,
-    dotnetPackCmd,
-    dotnetNugetSignCmd,
+    dotnetPublishCommand,
+    dotnetPackCommand,
+    dotnetNugetSignCommand,
     // remove no-op commands
   ]
     .filter(v => v !== undefined)
@@ -162,7 +161,7 @@ export async function configurePrepareCmd(
      * // return array as success-chained CLI commands.
      * return publishCmdArray.join(' && ');
      */
-    function getPublishArgsPermutations(proj: MSBuildProject):
+    function getPublishArgumentsPermutations(proj: MSBuildProject):
       ([`"${typeof proj.Properties.MSBuildProjectFullPath}" -t:PublishAll -p:Configuration=Release`])
       | ([`"${typeof proj.Properties.MSBuildProjectFullPath}"`])
       | (`"${typeof proj.Properties.MSBuildProjectFullPath}" --runtime ${string} --framework ${string}`)[]
@@ -212,8 +211,8 @@ export async function configurePrepareCmd(
       }
 
       /** prepend each set of args with the project's path */
-      return tfmRidPermutations.map(permArgs =>
-        `"${proj.Properties.MSBuildProjectFullPath}" ${permArgs}`,
+      return tfmRidPermutations.map(permArguments =>
+        `"${proj.Properties.MSBuildProjectFullPath}" ${permArguments}`,
       ) as `"${typeof proj.Properties.MSBuildProjectFullPath}" --runtime ${string} --framework ${string}`[]
       | `"${typeof proj.Properties.MSBuildProjectFullPath}" --runtime ${string}`[]
       | `"${typeof proj.Properties.MSBuildProjectFullPath}" --framework ${string}`[];
@@ -222,13 +221,13 @@ export async function configurePrepareCmd(
 
     const publishCmds: (`dotnet publish "${string}"` | `dotnet publish "${string}" ${string}` | `dotnet msbuild "${string}" -t:PublishAll -p:Configuration=Release`)[] = [];
     /** convert {@link evaluatedPublishProjects} to sets of space-separated CLI args. */
-    const argsSets = evaluatedPublishProjects.map(
-      proj => getPublishArgsPermutations(proj),
+    const argumentsSets = evaluatedPublishProjects.map(
+      proj => getPublishArgumentsPermutations(proj),
     );
-    for (const args of argsSets) {
-      if (typeof args === 'string')
+    for (const arguments_ of argumentsSets) {
+      if (typeof arguments_ === 'string')
         throw new Error(`\`args\` should not be a string!`);
-      for (const permutation of args) {
+      for (const permutation of arguments_) {
         if (typeof permutation === 'string' && permutation.length === 1)
           throw new Error('Something has gone terribly wrong. A `dotnet publish` argument set was split to single characters!');
         if (/".+" -t:PublishAll -p:Configuration=Release/.test(permutation))
@@ -258,27 +257,27 @@ export async function configurePrepareCmd(
   ): Promise<string | undefined> {
     if (projectsToPackAndPush.length === 0)
       return undefined;
-    return await Promise.all(
+    const nriArray = await Promise.all(
       projectsToPackAndPush.map(async (proj) => {
         if (proj instanceof NugetRegistryInfo)
           return proj;
 
-        const msbpArr: MSBuildProject[] = await Promise.all(await MSBuildProject.PackableProjectsToMSBuildProjects([proj]));
-        if (msbpArr.length === 0 || msbpArr[0] === undefined) {
+        const msbpArray: MSBuildProject[] = await Promise.all(await MSBuildProject.PackableProjectsToMSBuildProjects([proj]));
+        if (msbpArray.length === 0 || msbpArray[0] === undefined) {
           throw new Error('This should be impossible!');
         }
-        const msbp: MSBuildProject = msbpArr[0];
+        const msbp: MSBuildProject = msbpArray[0];
 
         evaluatedProjects.push(msbp);
 
         return new NugetRegistryInfo({ project: msbp });
       }),
-    ).then((nriArray: NugetRegistryInfo[]): string => {
-      return nriArray
-        .map((nri: NugetRegistryInfo): string =>
-          nri.GetPackCommand(NugetRegistryInfo.PackPackagesOptionsType.from({})),
-        ).join(' && ');
-    });
+    );
+
+    return nriArray
+      .map((nri: NugetRegistryInfo): string =>
+        nri.GetPackCommand(NugetRegistryInfo.PackPackagesOptionsType.from({})),
+      ).join(' && ');
   }
 }
 
@@ -323,48 +322,49 @@ export function configureDotnetNugetPush(
  * @returns `dotnet nuget sign {...}`
  */
 function formatDotnetNugetSign(
+  // eslint-disable-next-line unicorn/name-replacements
   opts: typeof DotnetNugetSignOptions.inferIn | undefined,
 ): string | undefined {
   if (opts === undefined)
     return undefined;
 
-  const validOpts = DotnetNugetSignOptions.from(opts);
-  const args: ['--timestamper', typeof validOpts.timestamper, '-o', string, ...string[]] = [
-    '--timestamper', validOpts.timestamper,
-    '-o', validOpts.output ?? ourDefaultPubDir,
+  const validOptions = DotnetNugetSignOptions.from(opts);
+  const arguments_: ['--timestamper', typeof validOptions.timestamper, '-o', string, ...string[]] = [
+    '--timestamper', validOptions.timestamper,
+    '-o', validOptions.output ?? ourDefaultPubDirectory,
   ];
-  if (validOpts.certificatePassword)
-    args.push('---certificate-password', validOpts.certificatePassword);
-  if (validOpts.hashAlgorithm)
-    args.push('--hash-algorithm', validOpts.hashAlgorithm);
-  if (validOpts.overwrite)
-    args.push('--overwrite');
-  if (validOpts.timestampHashAlgorithm)
-    args.push('--timestamp-hash-algorithm', validOpts.timestampHashAlgorithm);
-  if (validOpts.verbosity)
-    args.push('-v', validOpts.verbosity);
-
-  if ('certificatePath' in validOpts)
-    args.push('--certificate-path', validOpts.certificatePath);
-  else if ('certificateStoreName' in validOpts) {
+  if (validOptions.certificatePassword)
+    arguments_.push('---certificate-password', validOptions.certificatePassword);
+  if (validOptions.hashAlgorithm)
+    arguments_.push('--hash-algorithm', validOptions.hashAlgorithm);
+  if (validOptions.overwrite)
+    arguments_.push('--overwrite');
+  if (validOptions.timestampHashAlgorithm)
+    arguments_.push('--timestamp-hash-algorithm', validOptions.timestampHashAlgorithm);
+  if (validOptions.verbosity)
+    arguments_.push('-v', validOptions.verbosity);
+
+  if ('certificatePath' in validOptions)
+    arguments_.push('--certificate-path', validOptions.certificatePath);
+  else if ('certificateStoreName' in validOptions) {
     SetSubjectNameOrFingerprint();
-    args.push('--certificate-store-name', validOpts.certificateStoreName);
+    arguments_.push('--certificate-store-name', validOptions.certificateStoreName);
   }
-  else if ('certificateStoreLocation' in validOpts) {
+  else if ('certificateStoreLocation' in validOptions) {
     SetSubjectNameOrFingerprint();
-    args.push('--certificate-store-location', validOpts.certificateStoreLocation);
+    arguments_.push('--certificate-store-location', validOptions.certificateStoreLocation);
   }
   else throw new Error('No code signing certificate was specified!');
 
-  return `dotnet nuget sign ${args.join(' ')} `;
+  return `dotnet nuget sign ${arguments_.join(' ')} `;
 
   // eslint-disable-next-line jsdoc/require-jsdoc
   function SetSubjectNameOrFingerprint() {
-    if ('certificateSubjectName' in validOpts)
-      args.push('--certificate-subject-name', validOpts.certificateSubjectName);
+    if ('certificateSubjectName' in validOptions)
+      arguments_.push('--certificate-subject-name', validOptions.certificateSubjectName);
 
-    else if ('certificateFingerprint' in validOpts)
-      args.push('--certificate-fingerprint', validOpts.certificateFingerprint);
+    else if ('certificateFingerprint' in validOptions)
+      arguments_.push('--certificate-fingerprint', validOptions.certificateFingerprint);
     else throw new Error('If certificateStoreName or certificateStoreLocation is set, either certificateSubjectName or certificateFingerprint must also be set!');
   }
 }

package/src/insertPlugins.ts

@@ -73,8 +73,8 @@ export function insertPlugin(
   const indexOfLastAfter = afterPluginsIDs
     .filter(v => pluginIDs.includes(v))
     .map(v => pluginIDs.indexOf(v))
-    .sort()
-    .find((_v, i, obj) => i === obj.length - 1);
+    .sort((a, b) => a - b)
+    .find((_v, index, object) => index === object.length - 1);
   if (undefined === indexOfLastAfter)
     throw new ReferenceError(
       'An attempt to get the last element of an array returned undefined.',
@@ -83,7 +83,7 @@ export function insertPlugin(
   const indicesOfBefore = beforePluginsIDs
     .filter(v => pluginIDs.includes(v))
     .map(v => pluginIDs.indexOf(v))
-    .sort();
+    .sort((a, b) => a - b);
 
   // This for-of collects *all* sorting errors. The resulting AggregateError
   // notifies the API user of *all* errors in the order rather than just the

package/src/semantic-release__github.d.ts

@@ -1,3 +1,4 @@
+/* eslint-disable unicorn/name-replacements */
 declare module '@semantic-release/github' {
   /**
    * @see https://github.com/semantic-release/github#configuration

package/src/semanticReleaseConfigDotnet.ts

@@ -22,8 +22,8 @@ import type { Options } from 'semantic-release';
 import type { Options as SRExecOptions } from '@semantic-release/exec';
 import * as console from 'node:console';
 import debug from './debug.ts';
-import { configureDotnetNugetPush, configurePrepareCmd } from './dotnet/helpers.ts';
-import { getEnvVarValue } from './utils/env.ts';
+import { configureDotnetNugetPush, configurePrepareCmd as configurePrepareCommand } from './dotnet/helpers.ts';
+import { getEnvVarValue as getEnvironmentVariableValue } from './utils/env.ts';
 import { baseConfig } from './semanticReleaseConfig.ts';
 import { NugetRegistryInfo } from './dotnet/NugetRegistryInfo.ts';
 import { MSBuildProject } from './dotnet/MSBuildProject.ts';
@@ -80,7 +80,7 @@ export class SemanticReleaseConfigDotnet {
 
     this._projectsToPublish = projectsToPublish;
     if (this._projectsToPublish.length === 0) {
-      const p = getEnvVarValue('PROJECTS_TO_PUBLISH')?.split(';');
+      const p = getEnvironmentVariableValue('PROJECTS_TO_PUBLISH')?.split(';');
       if (p && p.length > 0) {
         this._projectsToPublish = p;
       }
@@ -91,7 +91,7 @@ export class SemanticReleaseConfigDotnet {
 
     this._projectsToPackAndPush = projectsToPackAndPush;
     if (this._projectsToPackAndPush.length === 0) {
-      const p = getEnvVarValue('PROJECTS_TO_PACK_AND_PUSH')?.split(';');
+      const p = getEnvironmentVariableValue('PROJECTS_TO_PACK_AND_PUSH')?.split(';');
       if (p && p.length > 0) {
         this._projectsToPackAndPush = p;
       }
@@ -149,15 +149,15 @@ export class SemanticReleaseConfigDotnet {
 Unable to find\`['@semantic-release/exec', unknown]\` in plugins array!
 Appending it to the end of the array...This may cause an unexpected order of operations!`;
       console.warn(message);
-      srExecIndex = this.options.plugins.push(['@semantic-release/exec', {}]) - 1;
+      this.options.plugins.push(['@semantic-release/exec', {}]);
+      srExecIndex = this.options.plugins.length - 1;
     }
 
     const plugin = this.options.plugins[srExecIndex] as ['@semantic-release/exec', SRExecOptions];
     const execOptions: SRExecOptions = plugin[1];
 
     // ensure all packable projects are evaluated
-    // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-    this._projectsToPackAndPush = await Promise.all(
+    const projectPromiseArrayArray = await Promise.all(
       this._projectsToPackAndPush.map(async (project) => {
         if (typeof project === 'string') {
           const packableProjects = await Promise.all(
@@ -172,28 +172,26 @@ Appending it to the end of the array...This may cause an unexpected order of ope
           // if the user doesn't want a defaulted NRI, they should pass their own NRI (or derived) instance.
           return packableProjects.map(project => new NugetRegistryInfo({ project }));
         }
-        else return [project];
+        return [project];
       }),
-    ).then(p => p.flat()) as NugetRegistryInfo[];
+    );
+    this._projectsToPackAndPush = projectPromiseArrayArray.flat();
 
-    // todo: double-check token-testing commands. Are they formatted prepended correctly?
-    const verifyConditionsCmdAppendix = await Promise.all(
+    const _pushDummyCommands = await Promise.all(
       this._projectsToPackAndPush
-        .map(async project =>
-          await project.PackDummyPackage({})
-            .then(() =>
-              project.GetPushDummyCommand({}),
-            ),
-        ),
-    ).then(cmds =>
-      cmds.join(' && '),
+        .map(async (project) => {
+          await project.PackDummyPackage({});
+          return project.GetPushDummyCommand({});
+        }),
     );
+    const verifyConditionsCommandAppendix = _pushDummyCommands.join(' && ');
+
     execOptions.verifyConditionsCmd
       = execOptions.verifyConditionsCmd && execOptions.verifyConditionsCmd.trim().length > 0
-        ? `${execOptions.verifyConditionsCmd} && ${verifyConditionsCmdAppendix}`
-        : verifyConditionsCmdAppendix;
+        ? `${execOptions.verifyConditionsCmd} && ${verifyConditionsCommandAppendix}`
+        : verifyConditionsCommandAppendix;
 
-    const verifyReleaseCmdAppendix
+    const verifyReleaseCommandAppendix
       = this.ProjectsToPackAndPush
         .filter(project =>
           typeof project !== 'string',
@@ -202,10 +200,10 @@ Appending it to the end of the array...This may cause an unexpected order of ope
         ).join(' && ');
     execOptions.verifyReleaseCmd
       = execOptions.verifyReleaseCmd && execOptions.verifyReleaseCmd.trim().length > 0
-        ? `${execOptions.verifyReleaseCmd} && ${verifyReleaseCmdAppendix}`
-        : verifyConditionsCmdAppendix;
+        ? `${execOptions.verifyReleaseCmd} && ${verifyReleaseCommandAppendix}`
+        : verifyConditionsCommandAppendix;
 
-    const prepareCmdAppendix = await configurePrepareCmd(
+    const prepareCommandAppendix = await configurePrepareCommand(
       this._projectsToPublish,
       this._projectsToPackAndPush,
     );
@@ -213,19 +211,19 @@ Appending it to the end of the array...This may cause an unexpected order of ope
     // 'ZipPublishDir' zips each publish folder to ./publish/*.zip
     execOptions.prepareCmd
       = execOptions.prepareCmd && execOptions.prepareCmd.trim().length > 0
-        ? `${execOptions.prepareCmd} && ${prepareCmdAppendix}`
-        : prepareCmdAppendix;
+        ? `${execOptions.prepareCmd} && ${prepareCommandAppendix}`
+        : prepareCommandAppendix;
 
     // FINISHED execOptions.prepareCmd
     // STARTING execOptions.publishCmd
     if (this._projectsToPackAndPush.length > 0) {
-      const publishCmdAppendix: string = configureDotnetNugetPush(
+      const publishCommandAppendix: string = configureDotnetNugetPush(
         this._projectsToPackAndPush,
       );
       execOptions.publishCmd
         = execOptions.publishCmd && execOptions.publishCmd.trim().length > 0
-          ? `${execOptions.publishCmd} && ${publishCmdAppendix}`
-          : publishCmdAppendix;
+          ? `${execOptions.publishCmd} && ${publishCommandAppendix}`
+          : publishCommandAppendix;
     }
 
     // FINISHED execOptions.publishCmd
@@ -254,8 +252,8 @@ Appending it to the end of the array...This may cause an unexpected order of ope
     const indexOfLastPreceding: number | undefined = insertAfterPluginIDs
       .filter(v => pluginIDs.includes(v))
       .map(v => pluginIDs.indexOf(v))
-      .sort()
-      .find((_v, i, obj) => i === obj.length - 1);
+      .sort((a, b) => a - b)
+      .find((_v, index, object) => index === object.length - 1);
     if (!indexOfLastPreceding)
       throw new ReferenceError(
         'An attempt to get the last element of indexOfLastAfter returned undefined.',
@@ -264,23 +262,24 @@ Appending it to the end of the array...This may cause an unexpected order of ope
     const indicesOfBefore: number[] = insertBeforePluginsIDs
       .filter(v => pluginIDs.includes(v))
       .map(v => pluginIDs.indexOf(v))
-      .sort();
+      .sort((a, b) => a - b);
 
     for (const index of indicesOfBefore) {
-      if (index <= indexOfLastPreceding) {
-        const formattedInsertIds: string
-          = '[' + insertPluginIDs.map(v => `"${v}"`).join(', ') + ']';
-        const formattedAfterIds: string
-          = '[' + insertAfterPluginIDs.map(v => `"${v}"`).join(', ') + ']';
-        const formattedBeforeIds: string
-          = '[' + insertBeforePluginsIDs.map(v => `"${v}"`).join(', ') + ']';
-        errors.push(
-          new Error(
-            `insertPlugin was instructed to insert ${formattedInsertIds} after ${formattedAfterIds} and before ${formattedBeforeIds}, `
-            + `but ${JSON.stringify(pluginIDs[indexOfLastPreceding])} is ordered after ${JSON.stringify(pluginIDs[index])}!`,
-          ),
-        );
-      }
+      if (index > indexOfLastPreceding)
+        continue;
+
+      const formattedInsertIds: string
+        = '[' + insertPluginIDs.map(v => `"${v}"`).join(', ') + ']';
+      const formattedAfterIds: string
+        = '[' + insertAfterPluginIDs.map(v => `"${v}"`).join(', ') + ']';
+      const formattedBeforeIds: string
+        = '[' + insertBeforePluginsIDs.map(v => `"${v}"`).join(', ') + ']';
+      errors.push(
+        new Error(
+          `insertPlugin was instructed to insert ${formattedInsertIds} after ${formattedAfterIds} and before ${formattedBeforeIds}, `
+          + `but ${JSON.stringify(pluginIDs[indexOfLastPreceding])} is ordered after ${JSON.stringify(pluginIDs[index])}!`,
+        ),
+      );
     }
 
     if (errors.length > 0)
@@ -310,6 +309,7 @@ Appending it to the end of the array...This may cause an unexpected order of ope
     );
     const nupkgPaths = await Promise.all(
       regInfos.map(nri =>
+        // eslint-disable-next-line unicorn/prefer-await
         nri.PackDummyPackage({}).then((nupkgs) => {
           // this is a full file path.
           const mainNupkg = nupkgs.find(nupkg =>
@@ -376,7 +376,7 @@ export async function getConfig(
   const errors: Error[] = [];
 
   if (projectsToPublish.length === 0) {
-    const _ = getEnvVarValue('PROJECTS_TO_PUBLISH');
+    const _ = getEnvironmentVariableValue('PROJECTS_TO_PUBLISH');
     if (_ === undefined)
       errors.push(
         new Error(
@@ -387,7 +387,7 @@ export async function getConfig(
   }
 
   if (!projectsToPackAndPush) {
-    const _ = getEnvVarValue('PROJECTS_TO_PACK_AND_PUSH');
+    const _ = getEnvironmentVariableValue('PROJECTS_TO_PACK_AND_PUSH');
     if (_ === undefined)
       errors.push(
         new Error(
@@ -398,11 +398,9 @@ export async function getConfig(
   }
 
   if (errors.length > 0) {
-    throw new Error(
-      [
-        'getConfig cannot continue. One or more errors occurred.',
-        ...errors.map(v => v.stack),
-      ].join('\n'),
+    throw new AggregateError(
+      errors,
+      'getConfig cannot continue. One or more errors occurred.',
     );
   }
 

package/src/setupGitPluginSpec.ts

@@ -40,36 +40,35 @@ function gitAssetsToStringArray(
     return [assets] as string[];
   if (typeof assets.path === 'string')
     return [assets.path];
-  else
-    throw new TypeError('assets is not typeof GitOptions[\'assets\'!');
+  throw new TypeError('assets is not typeof GitOptions[\'assets\'!');
 }
 
 /**
  * Sanitize a {@link GitOptions} object so its {@link GitOptions#assets} property is either `false` or a `string[]`.
- * @param opts A {@link GitOptions} object.
+ * @param options A {@link GitOptions} object.
  * @returns A {@link GitOptions} object whose {@link GitOptions#assets} is `string[] | false`.
  */
-function sanitizeGitOptions(opts: GitOptions): Omit<GitOptions, 'assets'> & { assets: string[] | false } {
-  return { ...opts, assets: opts.assets === false ? opts.assets : gitAssetsToStringArray(opts.assets) };
+function sanitizeGitOptions(options: GitOptions): Omit<GitOptions, 'assets'> & { assets: string[] | false } {
+  return { ...options, assets: options.assets === false ? options.assets : gitAssetsToStringArray(options.assets) };
 }
 
 /**
- *Determine if {@link opts} is a {@link GitOptions} object.
- * @param opts Anything.
- * @returns `true` if {@link opts} is a {@link GitOptions} object. Else, `false`.
+ *Determine if {@link options} is a {@link GitOptions} object.
+ * @param options Anything.
+ * @returns `true` if {@link options} is a {@link GitOptions} object. Else, `false`.
  */
-function isGitOptions(opts: unknown): opts is GitOptions {
+function isGitOptions(options: unknown): options is GitOptions {
   let isOptions = false;
 
-  if (typeof opts !== 'object' || opts == undefined)
+  if (typeof options !== 'object' || options == undefined)
     return isOptions;
-  if ('assets' in opts) {
-    isOptions = Array.isArray(opts.assets)
-      ? opts.assets.every(unk => isGitAsset(unk))
-      : isGitAsset(opts.assets);
+  if ('assets' in options) {
+    isOptions = Array.isArray(options.assets)
+      ? options.assets.every(unk => isGitAsset(unk))
+      : isGitAsset(options.assets);
   }
-  if ('message' in opts)
-    isOptions = typeof opts.message === 'string';
+  if ('message' in options)
+    isOptions = typeof options.message === 'string';
   return isOptions;
 }
 
@@ -112,7 +111,7 @@ export function setupGitPluginSpec(plugins: PluginSpecTuple[]): PluginSpecTuple[
    */
   // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
   const firstGitPlugin = plugins[firstGitPluginIndex]!;
-  const firstGitOpts: ReturnType<typeof sanitizeGitOptions> = isGitOptions(firstGitPlugin[1])
+  const firstGitOptions: ReturnType<typeof sanitizeGitOptions> = isGitOptions(firstGitPlugin[1])
     ? sanitizeGitOptions(firstGitPlugin[1])
     : DefaultOptions;
 
@@ -130,23 +129,23 @@ export function setupGitPluginSpec(plugins: PluginSpecTuple[]): PluginSpecTuple[
 
     /** if another Git PluginSpec is discovered, copy its options to the first Git PluginSpec and return undefined. */
     if (hasGitOptions(current)) {
-      const currentGitOpts = sanitizeGitOptions(current[1]);
+      const currentGitOptions = sanitizeGitOptions(current[1]);
 
-      if (currentGitOpts.assets === false) {
-        firstGitOpts.assets = false;
+      if (currentGitOptions.assets === false) {
+        firstGitOptions.assets = false;
       }
       else {
-        const assets: string[] = gitAssetsToStringArray(currentGitOpts.assets);
-        if (Array.isArray(firstGitOpts.assets)) {
-          firstGitOpts.assets.push(...assets);
+        const assets: string[] = gitAssetsToStringArray(currentGitOptions.assets);
+        if (Array.isArray(firstGitOptions.assets)) {
+          firstGitOptions.assets.push(...assets);
         }
         else {
-          firstGitOpts.assets = assets;
+          firstGitOptions.assets = assets;
         }
       }
 
-      if (typeof currentGitOpts.message === 'string')
-        firstGitOpts.message = currentGitOpts.message;
+      if (typeof currentGitOptions.message === 'string')
+        firstGitOptions.message = currentGitOptions.message;
     }
     return undefined;
   }).filter(pluginSpec => pluginSpec !== undefined);

package/src/utils/env.ts

@@ -1,3 +1,4 @@
+/* eslint-disable unicorn/name-replacements */
 import dotenvx, {
   type DotenvConfigOptions,
   type GetOptions,

package/src/utils/execAsync.ts

@@ -9,19 +9,22 @@ import { isError } from './isError.ts';
  * A `promisify(exec)` wrapper to optionally assign the child process's STDERR as the {@link Error.prototype.cause}.
  * @see {@link promisify}, {@link exec}
  * @param command The command to run, with space-separated arguments.
- * @param [setStderrAsCause=false] If true and the child process's stderr is available, the thrown Error's {@link Error.prototype.cause} is assigned the stderr string.
+ * @param [shouldSetStderrAsCause=false] If true and the child process's stderr is available, the thrown Error's {@link Error.prototype.cause} is assigned the stderr string.
  * @returns A promise of the child process's STDOUT and STDERR streams as strings
  * @throws {Error | ChildProcessSpawnException}
  */
-export async function execAsync(command: string, setStderrAsCause = false): Promise<{
+export async function execAsync(command: string, shouldSetStderrAsCause = false): Promise<{
   stdout: string;
   stderr: string;
 }> {
-  return await promisify(exec)(command).catch((error: unknown): never => {
+  try {
+    return await promisify(exec)(command);
+  }
+  catch (error: unknown) {
     if (!isError(error))
-      throw new Error(JSON.stringify(error));
+      throw new Error(JSON.stringify(error), { cause: error });
 
-    if (setStderrAsCause && 'stderr' in error && typeof error.stderr === 'string' && error.stderr !== '')
+    if (shouldSetStderrAsCause && 'stderr' in error && typeof error.stderr === 'string' && error.stderr !== '')
       error.cause ??= error.stderr;
 
     if ('stdout' in error && typeof error.stdout === 'string') {
@@ -36,7 +39,7 @@ export async function execAsync(command: string, setStderrAsCause = false): Prom
     }
 
     throw new ChildProcessSpawnException(error.message, error);
-  });
+  }
 }
 
 const T_ExecException: Type<{
@@ -65,6 +68,13 @@ const T_ExecException: Type<{
 type _ExecException = typeof T_ExecException.inferOut;
 
 export class ChildProcessSpawnException extends Error implements _ExecException {
+  cmd: typeof T_ExecException.inferOut.cmd;
+  code: typeof T_ExecException.inferOut.code;
+  killed: typeof T_ExecException.inferOut.killed;
+  signal: typeof T_ExecException.inferOut.signal;
+  stderr: typeof T_ExecException.inferOut.stderr;
+  stdout: typeof T_ExecException.inferOut.stdout;
+
   constructor(
     message: Parameters<typeof Error>[0],
     options: typeof T_ExecException.inferIn,
@@ -78,11 +88,4 @@ export class ChildProcessSpawnException extends Error implements _ExecException
     this.stderr = options.stderr;
     this.stdout = options.stdout;
   }
-
-  cmd: typeof T_ExecException.inferOut.cmd;
-  code: typeof T_ExecException.inferOut.code;
-  killed: typeof T_ExecException.inferOut.killed;
-  signal: typeof T_ExecException.inferOut.signal;
-  stderr: typeof T_ExecException.inferOut.stderr;
-  stdout: typeof T_ExecException.inferOut.stdout;
 }

package/src/utils/reflection/FunctionLike.d.ts

@@ -1,3 +1,4 @@
+/* eslint-disable unicorn/name-replacements */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /**
  * A generic alternative to the boxing {@link Function} type. Based on the

package/src/utils/reflection/InstancePropertyDescriptorMap.d.ts

@@ -1,10 +1,10 @@
 import type { PropertyDescriptorMap } from './PropertyDescriptorMap.d.ts';
 import type {
-  BaseClassProto,
+  BaseClassProto as BaseClassPrototype,
   ConstructorConstraint,
   InstanceTypeOrSelf,
   SuperClassLike,
-  WithProto,
+  WithProto as WithPrototype,
 } from './inheritance.ts';
 
 /**
@@ -26,7 +26,7 @@ import type {
  * @since 3.0.0
  */
 export type InstancePropertyDescriptorMap<
-  Class extends ConstructorConstraint<Class> & WithProto<SuperClassLike | BaseClassProto>,
-> = Class['__proto__'] extends BaseClassProto
+  Class extends ConstructorConstraint<Class> & WithPrototype<SuperClassLike | BaseClassPrototype>,
+> = Class['__proto__'] extends BaseClassPrototype
   ? PropertyDescriptorMap<InstanceType<Class>>
   : PropertyDescriptorMap<InstanceType<Class>, InstanceTypeOrSelf<Class['__proto__']>>;