NodeApi.Generator.targets

<Project>
  <PropertyGroup>
    <GenerateNodeApiTypeDefinitions Condition=" '$(GenerateNodeApiTypeDefinitions)' == '' ">true</GenerateNodeApiTypeDefinitions>
    <NodeApiTypeDefinitionsFileName Condition=" '$(NodeApiTypeDefinitionsFileName)' == '' ">$(TargetName).d.ts</NodeApiTypeDefinitionsFileName>

    <NodeApiGeneratorAssemblyName>Microsoft.JavaScript.NodeApi.Generator</NodeApiGeneratorAssemblyName>
    <NodeApiGeneratorDirectory>$(MSBuildThisFileDirectory)../lib/net8.0/</NodeApiGeneratorDirectory>
    <NodeApiGeneratorNet4xDirectory>$(MSBuildThisFileDirectory)../lib/net472/</NodeApiGeneratorNet4xDirectory>
    <NodeApiGeneratorNetStandardDirectory>$(MSBuildThisFileDirectory)../lib/netstandard2.0/</NodeApiGeneratorNetStandardDirectory>

    <!--
      With .NET Framework 4.x, invoke the generator executable; otherwise use the dotnet CLI (which will check the runtimeconfig.json).
      The TS generator tool selection is based on the current project target framework, NOT the current MSBuild .NET version.
    -->
    <NodeApiGeneratorCommand Condition=" $(TargetFramework.StartsWith('net4')) ">&quot;$(NodeApiGeneratorNet4xDirectory)$(NodeApiGeneratorAssemblyName).exe&quot;</NodeApiGeneratorCommand>
    <NodeApiGeneratorCommand Condition=" !$(TargetFramework.StartsWith('net4')) ">dotnet &quot;$(NodeApiGeneratorDirectory)$(NodeApiGeneratorAssemblyName).dll&quot;</NodeApiGeneratorCommand>

    <!-- Try to infer the module type from package.json in the project directory. Otherwise default to generating both module types.-->
    <NodeApiPackageJson Condition=" '$(NodeApiPackageJson)' == '' ">$(ProjectDir)package.json</NodeApiPackageJson>
    <NodeApiJSModuleType Condition=" '$(NodeApiJSModuleType)' == '' AND Exists('$(NodeApiPackageJson)') ">&quot;$(NodeApiPackageJson)&quot;</NodeApiJSModuleType>
    <NodeApiJSModuleType Condition=" '$(NodeApiJSModuleType)' == '' ">commonjs,esm</NodeApiJSModuleType>

    <NodeApiTargetFramework Condition=" '$(NodeApiTargetFramework)' == '' ">$(TargetFramework)</NodeApiTargetFramework>

    <NodeApiTypeDefinitionsGeneratorOptions>--module $(NodeApiJSModuleType) --framework $(NodeApiTargetFramework) $(NodeApiTypedefsGeneratorOptions)</NodeApiTypeDefinitionsGeneratorOptions>
  </PropertyGroup>

  <!--
    Resolves NodeApi source-generator (analyzer) assemblies.
    The recommended practice is to build analyzers targeting only .NET Standard 2.0, and place them in a special "analyzers" directory
    in the package where they are found automatically. But this package contains separate targets for .NET Standard 2.0, .NET Framework 4.x,
    and .NET 6.0 (and later) in the "lib" directory. This task chooses the correct target based on the currnet MSBuild process's .NET version
    (NOT the current target framework), and adds the assemblies to the Analyzer item group.
  -->
  <Target Name="ResolveNodeApiAnalyzer" AfterTargets="ResolvePackageDependenciesForBuild">
    <ItemGroup>
      <Analyzer Condition=" $([System.Environment]::Version.Major) &gt; 4 " Include="$(NodeApiGeneratorDirectory)*.dll" />
      <Analyzer Condition=" $([System.Environment]::Version.Major) &lt;= 4 " Include="$(NodeApiGeneratorNetStandardDirectory)*.dll" />
    </ItemGroup>
  </Target>

  <Target Name="ConfigureNodeApiTypeDefinitions"
    Condition=" '$(GenerateNodeApiTypeDefinitions)' == 'true' "
    BeforeTargets="BeforeBuild"
  >
    <!-- When the project does not have any source files, copy all reference assemblies to output and generate typedefs for them. -->
    <PropertyGroup Condition=" '@(Compile)' == '' ">
        <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
        <CopyBuildOutputToOutputDirectory>false</CopyBuildOutputToOutputDirectory>
        <CopyOutputSymbolsToOutputDirectory>false</CopyOutputSymbolsToOutputDirectory>
        <GenerateNodeApiTypeDefinitionsForReferences Condition=" '$(GenerateNodeApiTypeDefinitionsForReferences)' == '' ">true</GenerateNodeApiTypeDefinitionsForReferences>
    </PropertyGroup>
  </Target>

  <!--
    Generates TS type definitions for a Node API module project.
   -->
  <Target Name="GenerateNodeApiTypeDefinitions"
    AfterTargets="Build"
    Inputs="$(TargetPath)"
    Outputs="$(TargetDir)$(NodeApiTypeDefinitionsFileName)"
    Condition=" '$(GenerateNodeApiTypeDefinitions)' == 'true' AND Exists('$(TargetPath)') "
  >
    <PropertyGroup>
      <NodeApiGeneratorResponseFile>$(IntermediateOutputPath)$(NodeApiGeneratorAssemblyName).rsp</NodeApiGeneratorResponseFile>
      <_NodeApiGeneratorTargetingPacks>@(TargetingPack, '%3B')</_NodeApiGeneratorTargetingPacks>
      <_NodeApiGeneratorAssemblyReferences>@(ReferencePathWithRefAssemblies, '%3B')</_NodeApiGeneratorAssemblyReferences>
    </PropertyGroup>

    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="--assembly &quot;$(TargetPath)&quot;" Overwrite="true" />
    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="--packs &quot;$(_NodeApiGeneratorTargetingPacks)&quot;" />
    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="--reference &quot;$(_NodeApiGeneratorAssemblyReferences)&quot;" />
    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="--typedefs &quot;$(TargetDir)$(NodeApiTypeDefinitionsFileName)&quot;" />
    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="--exclude &quot;$(NodeApiExcludeFromMetadata.Replace(';', '%3B'))&quot;" Condition=" '$(NodeApiExcludeFromMetadata)' != '' " />
    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="$(NodeApiTypeDefinitionsGeneratorOptions)" />

    <!-- Run the generator using args from the response file. Note the '@' indicates the response file NOT an MSBuild item-list. -->
    <Exec Command="$(NodeApiGeneratorCommand) &quot;@$(NodeApiGeneratorResponseFile)&quot;"
      ConsoleToMSBuild="true" />
  </Target>

  <!--
   Publishes TS type definitions for a Node API module project.
   -->
  <Target Name="PublishNodeApiTypeDefinitions"
    AfterTargets="Publish"
    Inputs="$(TargetDir)$(NodeApiTypeDefinitionsFileName)"
    Outputs="$(PublishDir)$(NodeApiTypeDefinitionsFileName)"
    Condition=" '$(GenerateNodeApiTypeDefinitions)' == 'true' AND Exists('$(TargetDir)$(NodeApiTypeDefinitionsFileName)') "
  >
    <Copy SourceFiles="$(TargetDir)$(NodeApiTypeDefinitionsFileName)" DestinationFolder="$(PublishDir)" />
    <Copy SourceFiles="$(TargetDir)$(TargetName).js" DestinationFolder="$(PublishDir)" Condition="Exists('$(TargetDir)$(TargetName).js')" />
    <Copy SourceFiles="$(TargetDir)$(TargetName).cjs" DestinationFolder="$(PublishDir)" Condition="Exists('$(TargetDir)$(TargetName).cjs')" />
    <Copy SourceFiles="$(TargetDir)$(TargetName).mjs" DestinationFolder="$(PublishDir)" Condition="Exists('$(TargetDir)$(TargetName).mjs')" />
  </Target>

  <Target Name="CleanNodeApiTypeDefinitions" AfterTargets="CoreClean">
    <Delete Files="$(TargetDir)$(NodeApiTypeDefinitionsFileName)" />
    <Delete Files="$(PublishDir)$(NodeApiTypeDefinitionsFileName)" />
  </Target>

  <!--
    Supports building a project that does not compile any code, but only collects and outputs
    a set of package references in the output directory for use by a JavaScript project.
   -->
  <Target Name="ResolveNodeApiReferenceAssemblies"
      Condition=" '$(GenerateNodeApiTypeDefinitionsForReferences)' == 'true' "
      AfterTargets="ResolvePackageAssets">
    <ItemGroup>
      <!-- TODO: Should resource assemblies be copied? They might be needed at runtime. -->
      <ResourceCopyLocalItems Remove="@(ResourceCopyLocalItems)" />

      <!-- Do not copy the generator assembly because it is not needed at runtime. -->
      <!-- (Code analysis assemblies are used by the generator.) -->
      <RuntimeCopyLocalItems Remove="@(RuntimeCopyLocalItems)"
        Condition=" '%(Filename)' == 'Microsoft.JavaScript.NodeApi.Generator' " />
      <RuntimeCopyLocalItems Remove="@(RuntimeCopyLocalItems)"
        Condition=" '%(Filename)' == 'Microsoft.CodeAnalysis' " />
      <RuntimeCopyLocalItems Remove="@(RuntimeCopyLocalItems)"
        Condition=" '%(Filename)' == 'Microsoft.CodeAnalysis.CSharp' " />

      <!-- Generate type definitions for assemblies from package references. -->
      <NodeApiReferenceAssemblies Include="@(RuntimeCopyLocalItems)" />
    </ItemGroup>
  </Target>
  <Target Name="ResolveNodeApiProjectReferenceAssemblies"
      Condition=" '$(GenerateNodeApiTypeDefinitionsForReferences)' == 'true' "
      BeforeTargets="GenerateNodeApiReferenceTypeDefinitions"
      DependsOnTargets="GenerateBuildDependencyFile">
    <ItemGroup>
      <!-- Generate type definitions for assemblies from project references. -->
      <NodeApiReferenceAssemblies Include="@(UserRuntimeAssembly)" />
    </ItemGroup>
  </Target>

  <!--
    Generates TS type definitions for all referenced assemblies in the output directory.
   -->
  <Target Name="GenerateNodeApiReferenceTypeDefinitions"
    AfterTargets="Build"
    Inputs="@(NodeApiReferenceAssemblies)"
    Outputs="@(NodeApiReferenceAssemblies->'$(TargetDir)%(Filename).d.ts')"
    Condition=" '$(GenerateNodeApiTypeDefinitions)' == 'true' AND '$(Compile)' == '' "
  >
    <ItemGroup Condition="$(TargetFramework.StartsWith('net4'))">
      <NodeApiSystemReferenceAssembly Include="mscorlib" />
      <NodeApiSystemReferenceAssembly Include="System" />
    </ItemGroup>
    <ItemGroup Condition="! $(TargetFramework.StartsWith('net4'))">
      <NodeApiSystemReferenceAssembly Include="System.Runtime" />
      <NodeApiSystemReferenceAssembly Include="System.Console" />
    </ItemGroup>
    <ItemGroup>
      <!-- This does not use @(NodeApiReferenceAssemblies), like the target Inputs, to avoid excluding items that are up-to-date. -->
      <_NodeApiAllReferenceAssemblies Include="@(UserRuntimeAssembly)" />
      <_NodeApiAllReferenceAssemblies Include="@(RuntimeCopyLocalItems)" />
      <_NodeApiAllReferenceAssemblies Include="@(NodeApiSystemReferenceAssembly)" />

      <_NodeApiAllTypeDefs Include="@(UserRuntimeAssembly->'$(TargetDir)%(Filename).d.ts')" />
      <_NodeApiAllTypeDefs Include="@(RuntimeCopyLocalItems->'$(TargetDir)%(Filename).d.ts')" />
      <_NodeApiAllTypeDefs Include="@(NodeApiSystemReferenceAssembly->'$(TargetDir)%(Identity).d.ts')" />
    </ItemGroup>

    <PropertyGroup>
      <NodeApiGeneratorResponseFile>$(IntermediateOutputPath)$(NodeApiGeneratorAssemblyName).rsp</NodeApiGeneratorResponseFile>
      <_NodeApiGeneratorTargetingPacks>@(TargetingPack, '%3B')</_NodeApiGeneratorTargetingPacks>
      <_NodeApiGeneratorAssemblyReferences>@(_NodeApiAllReferenceAssemblies, '%3B')</_NodeApiGeneratorAssemblyReferences>
      <_NodeApiGeneratorTypeDefs>@(_NodeApiAllTypeDefs, '%3B')</_NodeApiGeneratorTypeDefs>
    </PropertyGroup>

    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="--assemblies &quot;$(_NodeApiGeneratorAssemblyReferences)&quot;" Overwrite="true" />
    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="--packs &quot;$(_NodeApiGeneratorTargetingPacks)&quot;" />
    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="--typedefs &quot;$(_NodeApiGeneratorTypeDefs)&quot;" />
    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="--nowarn" Condition=" '$(NodeApiTypeDefinitionsEnableWarnings)' != 'true' " />
    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="--exclude &quot;$(NodeApiExcludeFromMetadata.Replace(';', '%3B'))&quot;" Condition=" '$(NodeApiExcludeFromMetadata)' != '' " />
    <WriteLinesToFile File="$(NodeApiGeneratorResponseFile)" Lines="$(NodeApiTypeDefinitionsGeneratorOptions)" />

    <!-- Run the generator using args from the response file. Note the '@' indicates the response file NOT an MSBuild item-list. -->
    <Exec Command="$(NodeApiGeneratorCommand) &quot;@$(NodeApiGeneratorResponseFile)&quot;"
      ConsoleToMSBuild="true" />
  </Target>

</Project>