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

package/src/dotnet/MSBuildProject.ts

@@ -138,19 +138,6 @@ const msbuildEvaluationOutput: Type<{
 });
 
 export class MSBuildEvaluationOutput {
-  /**
-   * @param rawMSBuildEvaluation The output of a CLI MSBuild project evaluation.
-   * May be the UTF-8 string-encoded JSON or the object decoded from that JSON.
-   */
-  constructor(rawMSBuildEvaluation: Parameters<typeof JSON.parse>[0] | Parameters<typeof msbuildEvaluationOutput.from>[0]) {
-    /** `.assert` instead of `.from` to allow `unknown` JSON.parse return type */
-    const knownObject = msbuildEvaluationOutput.assert(typeof rawMSBuildEvaluation === 'string' ? JSON.parse(rawMSBuildEvaluation) : rawMSBuildEvaluation);
-
-    this.Properties = knownObject.Properties;
-    this.Items = knownObject.Items;
-    this.TargetResults = knownObject.TargetResults;
-  }
-
   /**
    * The specified properties and their values as evaluated by MSBuild Core.
    * `-getProperty:{propertyName,...}`
@@ -168,6 +155,19 @@ export class MSBuildEvaluationOutput {
    * `-getTargetResult:{targetName,...}`
    */
   TargetResults?: typeof msbuildEvaluationOutput.infer.TargetResults;
+
+  /**
+   * @param rawMSBuildEvaluation The output of a CLI MSBuild project evaluation.
+   * May be the UTF-8 string-encoded JSON or the object decoded from that JSON.
+   */
+  constructor(rawMSBuildEvaluation: Parameters<typeof JSON.parse>[0] | Parameters<typeof msbuildEvaluationOutput.from>[0]) {
+    /** `.assert` instead of `.from` to allow `unknown` JSON.parse return type */
+    const knownObject = msbuildEvaluationOutput.assert(typeof rawMSBuildEvaluation === 'string' ? JSON.parse(rawMSBuildEvaluation) : rawMSBuildEvaluation);
+
+    this.Properties = knownObject.Properties;
+    this.Items = knownObject.Items;
+    this.TargetResults = knownObject.TargetResults;
+  }
 }
 
 export const EvaluationOptions: Type<{
@@ -253,44 +253,6 @@ export class MSBuildProject {
     'RuntimeIdentifiers',
   ]);
 
-  /**
-   * Creates an instance of MSBuildProject.
-   * @param opts The order-independent arguments for this constructor.
-   * Properties may be added or moved around in this definition without
-   * breaking compatibility.
-   * @param opts.fullPath The full path of the MSBuild project's file. This
-   * should have a '.csproj', '.fsproj', or '.vbproj' file extension.
-   * @param opts.projTargets A list of MSBuild Targets supported by the project.
-   * @param opts.evaluation The output of an MSBuild project evaluation. This
-   * comprises MSBuild Properties, Items, and Target results.
-   */
-  public constructor(opts: {
-    fullPath: string;
-    projTargets: string[];
-    evaluation: MSBuildEvaluationOutput;
-  }) {
-    this.Items = opts.evaluation.Items ?? {};
-    this.Properties = new NugetProjectProperties(
-      opts.fullPath,
-      new CaseInsensitiveMap<string, string>(
-        Object.entries(opts.evaluation.Properties ?? {}),
-      ),
-    );
-    this.Targets = opts.projTargets;
-    this.TargetResults
-      = opts.evaluation.TargetResults === undefined
-        ? []
-        : [opts.evaluation.TargetResults];
-  }
-
-  readonly Items: Readonly<Required<MSBuildEvaluationOutput>['Items']>;
-  readonly Properties: Readonly<NugetProjectProperties>;
-  readonly Targets: readonly string[];
-  /**
-   * Allows appending subsequent target results.
-   */
-  readonly TargetResults: Required<MSBuildEvaluationOutput>['TargetResults'][];
-
   /**
    * @param projectPath The full path of the project file or its directory. A
    * relative path may be passed, but will resolve relative to the current
@@ -309,19 +271,19 @@ export class MSBuildProject {
    */
   static async GetTargets(
     projectPath: string,
+    // eslint-disable-next-line unicorn/consistent-boolean-name
     includeNonPublic = false,
   ): Promise<string[]> {
-    return execAsync(`dotnet msbuild ${projectPath} -targets`, true)
-      .then((v) => {
-        const targets = v.stdout
-          .split('\n')
-          .filter((v, index) => v !== '' && index !== 0)
-          .map(v => v.replaceAll('\r', ''))
-          .sort((a, b) => a.localeCompare(b));
-        return includeNonPublic
-          ? targets
-          : targets.filter(v => !v.startsWith('_'));
-      });
+    const stdPair = await execAsync(`dotnet msbuild ${projectPath} -targets`, true);
+
+    const targets = stdPair.stdout
+      .split('\n')
+      .filter((v, index) => v !== '' && index !== 0)
+      .map(v => v.replaceAll('\r', ''))
+      .sort((a, b) => a.localeCompare(b));
+    return includeNonPublic
+      ? targets
+      : targets.filter(v => !v.startsWith('_'));
   }
 
   /**
@@ -350,48 +312,51 @@ export class MSBuildProject {
     // reminder: args containing spaces and semi-colons MUST be quote-enclosed!
     options.FullName = MSBuildProjectProperties.GetFullPath(options.FullName);
     const _pairs = Object.entries(options.Property).filter(p => typeof p[1] === 'string');
-    const property
+    const string_property
       = _pairs.length === 0
         ? ''
         : `-p:"${_pairs.map(pair => pair[0] + '=' + pair[1]).join(';')}"`;
-    const target
+    const string_target
       = options.Targets.length === 0
         ? ''
         : `"-t:${options.Targets.join(';')}"`;
-    const getItem
+    const string_getItem
       = options.GetItem.length === 0
         ? ''
         : `-getItem:"${options.GetItem.join(',')}"`;
-    const getProperty
+    const string_getProperty
       = options.GetProperty.length === 0
         ? ''
         : `-getProperty:"${options.GetProperty.join(',')}"`;
-    const getTargetResult
+    const string_getTargetResult
       = options.GetTargetResult.length === 0
         ? ''
         : `-getTargetResult:"${options.GetTargetResult.join(',')}"`;
-    const cmdLine = [
+    const commandLine = [
       'dotnet',
       'msbuild',
       `"${options.FullName}"`,
       '-restore',
-      property,
-      target,
-      getItem,
-      getProperty,
-      getTargetResult,
+      string_property,
+      string_target,
+      string_getItem,
+      string_getProperty,
+      string_getTargetResult,
     ]
       .filter(v => v !== '')
       .join(' ');
-    let stdio: Awaited<ReturnType<typeof execAsync>> | undefined = undefined;
+    let stdio: Awaited<ReturnType<typeof execAsync>> | undefined;
     // may throw
     while (stdio === undefined) {
-      stdio = await setTimeout(
-        1000,
-        execAsync(cmdLine, true),
-      )
-        .then(async p => await p)
-        .catch<undefined>(catchEBUSY);
+      try {
+        stdio = await setTimeout(
+          1000,
+          execAsync(commandLine, true),
+        );
+      }
+      catch (error: unknown) {
+        catchEBUSY(error);
+      }
     }
 
     // todo: consider -getResultOutputFile:file
@@ -434,7 +399,7 @@ export class MSBuildProject {
 
     return new MSBuildProject({
       fullPath: options.FullName,
-      projTargets: await MSBuildProject.GetTargets(options.FullName),
+      projTargets: await this.GetTargets(options.FullName),
       evaluation,
     });
   }
@@ -453,12 +418,8 @@ export class MSBuildProject {
   public static async PackableProjectsToMSBuildProjects(
     projectsToPackAndPush: string[],
   ): Promise<Promise<MSBuildProject>[]> {
-    const dirEntriesPromise = toDirEntries(typeof projectsToPackAndPush === 'string' ? [projectsToPackAndPush] : projectsToPackAndPush);
-    const projectPromises: Promise<MSBuildProject>[] = await dirEntriesPromise
-      .then(
-        (direntArray: Dirent[]) =>
-          direntArray.map(element => convertDirentToMSBuildProject(element)),
-      );
+    const directoryEntriesPromise = await toDirectoryEntries(typeof projectsToPackAndPush === 'string' ? [projectsToPackAndPush] : projectsToPackAndPush);
+    const projectPromises: Promise<MSBuildProject>[] = directoryEntriesPromise.map(element => convertDirentToMSBuildProject(element));
     return projectPromises;
 
     /**
@@ -469,10 +430,10 @@ export class MSBuildProject {
      * https://github.com/dotnet/sdk/blob/497f334b2862bdf98b30c00ede2fd259ea5f624d/src/Cli/dotnet/Commands/New/MSBuildEvaluation/MSBuildEvaluationResult.cs#L19-L32.\
      * @returns An promised array of Dirent instances for discovered project files.
      */
-    async function toDirEntries(
+    async function toDirectoryEntries(
       projectsToPackAndPush: string[],
     ): Promise<Dirent[]> {
-      const dirEntries: (Dirent | Dirent[])[] = await Promise.all(
+      const directoryEntries: (Dirent | Dirent[])[] = await Promise.all(
         projectsToPackAndPush.map(async (proj) => {
           proj = await realpath(makeAbsolute(proj));
           const stats = await stat(proj);
@@ -489,10 +450,9 @@ export class MSBuildProject {
             );
             if (dirent)
               return dirent;
-            else
-              throw new Error(
-                `file "${proj}" not found. It may have been moved or deleted.`,
-              );
+            throw new Error(
+              `file "${proj}" not found. It may have been moved or deleted.`,
+            );
           }
           if (!stats.isDirectory())
             throw new Error(`"${proj}" is not a file or directory`);
@@ -505,7 +465,7 @@ export class MSBuildProject {
         }),
       );
 
-      return dirEntries.flat();
+      return directoryEntries.flat();
     }
 
     /**
@@ -519,19 +479,17 @@ export class MSBuildProject {
         ('path' in dirent ? dirent.path as string | undefined : undefined) ?? (dirent as unknown as Omit<typeof dirent, 'path'> & { parentPath: string }).parentPath,
         dirent.name,
       );
-      const projTargets: Promise<string[]> = MSBuildProject.GetTargets(fullPath);
-      const evalTargets = await projTargets.then(v =>
-        v.includes('Pack') ? ['Pack'] : [],
-      );
+      const projTargets: string[] = await MSBuildProject.GetTargets(fullPath);
+      const evalTargets: string[] = projTargets.includes('Pack') ? ['Pack'] : [];
       // this might be too long for a command line. What was it on Windows?
       // 2^15 (32,768) character limit for command lines?
-      const getProperties = NPPGetterNames.InstanceGettersRecursive;
+      const propertiesToEvaluate = NPPGetterNames.InstanceGettersRecursive;
 
       return await MSBuildProject.Evaluate(
         EvaluationOptions.from({
           FullName: fullPath,
           GetItem: [],
-          GetProperty: getProperties,
+          GetProperty: propertiesToEvaluate,
           GetTargetResult: [],
           Property: {},
           Targets: evalTargets,
@@ -544,7 +502,7 @@ export class MSBuildProject {
     const parsed = T_PseudoMSBPInstance.assert(JSON.parse(json));
 
     type.true.assert(
-      Reflect.setPrototypeOf(parsed, MSBuildProject.prototype),
+      Reflect.setPrototypeOf(parsed, this.prototype),
     );
     type.true.assert(
       Reflect.setPrototypeOf(parsed.Properties, NugetProjectProperties.prototype),
@@ -552,6 +510,45 @@ export class MSBuildProject {
     parsed.Properties = T_NPP.assert(parsed.Properties);
     return T_MSBuildProject.assert(parsed);
   }
+
+  readonly Items: Readonly<Required<MSBuildEvaluationOutput>['Items']>;
+  readonly Properties: Readonly<NugetProjectProperties>;
+  readonly Targets: readonly string[];
+  /**
+   * Allows appending subsequent target results.
+   */
+  readonly TargetResults: Required<MSBuildEvaluationOutput>['TargetResults'][];
+
+  /**
+   * Creates an instance of MSBuildProject.
+   * @param opts The order-independent arguments for this constructor.
+   * Properties may be added or moved around in this definition without
+   * breaking compatibility.
+   * @param opts.fullPath The full path of the MSBuild project's file. This
+   * should have a '.csproj', '.fsproj', or '.vbproj' file extension.
+   * @param opts.projTargets A list of MSBuild Targets supported by the project.
+   * @param opts.evaluation The output of an MSBuild project evaluation. This
+   * comprises MSBuild Properties, Items, and Target results.
+   */
+  // eslint-disable-next-line unicorn/name-replacements
+  public constructor(opts: {
+    fullPath: string;
+    projTargets: string[];
+    evaluation: MSBuildEvaluationOutput;
+  }) {
+    this.Items = opts.evaluation.Items ?? {};
+    this.Properties = new NugetProjectProperties(
+      opts.fullPath,
+      new CaseInsensitiveMap<string, string>(
+        Object.entries(opts.evaluation.Properties ?? {}),
+      ),
+    );
+    this.Targets = opts.projTargets;
+    this.TargetResults
+      = opts.evaluation.TargetResults === undefined
+        ? []
+        : [opts.evaluation.TargetResults];
+  }
 }
 
 const T_MSBuildProject = type.instanceOf(MSBuildProject);
@@ -679,12 +676,12 @@ export function catchEBUSY(error: unknown): undefined {
       // Normalize colon-like chars: '\uFF1A'.normalize('NFKC') === ':' === true;
       const normalizedStderr = error.stderr.normalize('NFKC');
       const patternEN = /The process cannot access the file '[^']+' because it is being used by another process\./gm;
-      const hasErrMsgPattern = patternEN.test(normalizedStderr);
+      const hasErrorMessagePattern = patternEN.test(normalizedStderr);
       const isCS2012 = /^CSC ?:.+CS2012:/gm.test(normalizedStderr);
       // generic error code; error message must be checked.
       const isAVLN9999 = /AVLN9999:/gm.test(normalizedStderr)
-        && hasErrMsgPattern;
-      if (isCS2012 || isAVLN9999 || hasErrMsgPattern)
+        && hasErrorMessagePattern;
+      if (isCS2012 || isAVLN9999 || hasErrorMessagePattern)
         // eslint-disable-next-line unicorn/no-useless-undefined
         return undefined; /* retry */
     }
@@ -750,7 +747,7 @@ export function catchCsc2012(error: unknown): undefined {
      *    > Learn about SDK resolution:
      *    > https://aka.ms/dotnet/sdk-not-found
      */
-    else throw error;
+    throw error;
   }
-  else throw new Error('unknown error', { cause: error });
+  throw new Error('unknown error', { cause: error });
 }

package/src/dotnet/MSBuildProjectProperties.ts

@@ -92,7 +92,7 @@ export class MSBuildProjectProperties {
       `arg 'properties' should be instanceof ${CaseInsensitiveMap.name}`,
     );
     strictEqual(
-      [...properties.keys()].every((v): v is string => typeof v === 'string'),
+      properties.keys().every((v): v is string => typeof v === 'string'),
       true,
       'all keys in arg \'properties\' should be strings',
     );

package/src/dotnet/NugetProjectProperties.ts

@@ -10,12 +10,12 @@ import {
   getPrototypesChainOf,
   listOwnGetters,
   type ClassLike,
-  type ProtoChainOfClass,
-  type WithProto,
+  type ProtoChainOfClass as PrototypeChainOfClass,
+  type WithProto as WithPrototype,
 } from '../utils/reflection.ts';
 import { MSBuildProjectProperties, type Class_MSBPP } from './MSBuildProjectProperties.ts';
 
-const Type_RepositoryType: type<'' | 'git' | 'tfs'> = type('""|"git"|"tfs"');
+const Type_RepoType: type<'' | 'git' | 'tfs'> = type('""|"git"|"tfs"');
 const Type_SymbolPackageFormat: type<'symbols.nupkg' | 'snupkg'> = type('"symbols.nupkg" | "snupkg"');
 
 /**
@@ -91,12 +91,6 @@ export class NugetProjectProperties extends MSBuildProjectProperties {
     // Pass the remainder to super
     super(msbuildProjectFullPath, properties);
 
-    /** convert values to strings */
-    for (const [value, key] of consumables.entries()) {
-      if (typeof value !== 'string')
-        consumables.set(key, String(value));
-    }
-
     const _getAndForget = (key: string) => NugetProjectProperties.getAndForget(consumables, key);
     let data;
     this._authors = _getAndForget('Authors');
@@ -140,7 +134,7 @@ export class NugetProjectProperties extends MSBuildProjectProperties {
     this._packageVersion = _getAndForget('PackageVersion');
     this._product = _getAndForget('Product');
     this._repositoryCommit = _getAndForget('RepositoryCommit');
-    if (Type_RepositoryType.allows(data = _getAndForget('RepositoryType')))
+    if (Type_RepoType.allows(data = _getAndForget('RepositoryType')))
       this._repositoryType = data;
     this._repositoryUrl = _getAndForget('RepositoryUrl');
     if (tBooleanString.allows(data = _getAndForget('SuppressDependenciesWhenPacking')))
@@ -405,7 +399,7 @@ export class NugetProjectProperties extends MSBuildProjectProperties {
    * Default: `''`
    * @example "git", "fts"
    */
-  get RepositoryType(): typeof Type_RepositoryType.inferOut {
+  get RepositoryType(): typeof Type_RepoType.inferOut {
     return this._repositoryType ??= '';
   }
 
@@ -569,28 +563,29 @@ export class NugetProjectProperties extends MSBuildProjectProperties {
 
 export type Class_NPP = ClassLike<
   typeof NugetProjectProperties
-  & WithProto<Class_MSBPP>
+  & WithPrototype<Class_MSBPP>
 >;
 
 // eslint-disable-next-line @typescript-eslint/no-extraneous-class
 export class NPPGetterNames {
-  private static _prototypeChain: ProtoChainOfClass<Class_NPP> | undefined;
-  private static get PrototypeChain(): [Class_NPP, Class_MSBPP] {
-    return this._prototypeChain ??= getPrototypesChainOf(NugetProjectProperties as Class_NPP, 'classes');
-  }
+  private static _prototypeChain: PrototypeChainOfClass<Class_NPP> | undefined;
 
   private static _instanceGetters: Exclude<keyof NugetProjectProperties, keyof MSBuildProjectProperties>[] | undefined;
   private static _instanceGettersRecursive: (keyof NugetProjectProperties)[] | undefined;
   private static _StaticGetters: never[] | undefined;
   private static _StaticGettersRecursive: (keyof typeof NugetProjectProperties)[] | undefined;
 
+  private static get PrototypeChain(): [Class_NPP, Class_MSBPP] {
+    return this._prototypeChain ??= getPrototypesChainOf(NugetProjectProperties as Class_NPP, 'classes');
+  }
+
   public static get InstanceGetters(): Exclude<keyof NugetProjectProperties, keyof MSBuildProjectProperties>[] {
     return this._instanceGetters ??= listOwnGetters(NugetProjectProperties as Class_NPP, 'Instance');
   }
 
   public static get InstanceGettersRecursive(): (keyof NugetProjectProperties)[] {
     return this._instanceGettersRecursive ??= this.PrototypeChain.flatMap(
-      proto => listOwnGetters<typeof proto, 'Instance'>(proto, 'Instance'),
+      prototype => listOwnGetters<typeof prototype, 'Instance'>(prototype, 'Instance'),
     );
   }
 
@@ -600,7 +595,7 @@ export class NPPGetterNames {
 
   public static get StaticGettersRecursive(): ('prototype' | 'GetFullPath')[] {
     return this._StaticGettersRecursive ??= this.PrototypeChain.flatMap(
-      proto => listOwnGetters(proto, 'Static'),
+      prototype => listOwnGetters(prototype, 'Static'),
     );
   }
 }