powershell | technologies behind PowerShell evolve , so will the PnP | Command Line Interface library

As we can see from the comment section of the question, the solution was:

• Go into Tools -> Get Tools and Features
• download the .Net desktop development

As Maybemonday described in his/her comment, functions can be created afterwards.

There is a conflict in the casing

C:\Users\Ruben|desktop\reactapp\test.... whereas the nodemodules is looking for C:\Users\Ruben|Desktop\Reactapp\test....

This is a windows specific problem, and previously react would have run the app regardless of this difference. Not anymore it seems.

The solution I used was to locate the folder and open with code; that ensures that the path matches directly with what is stored in node modules

This section discusses the specific statements from your sample functions.
See the bottom section for background information.

• $n = 1 and $n++ are assignments and therefore do not produce output.
• $n is an expression whose value is output
• $null - ditto, but even though it is output, it doesn't display by default
• ($n++) - due to enclosure in (...) - turns the assignment into an expression and therefore does output the assigned value (too).
  • However, because you've used the post-increment form of the assignment, it is the old value that is output, not the now incremented value; to increment first (pre-increment) and then output, use (++$n)
• [System.Console]::WriteLine("Hello") prints directly to the console, which bypasses PowerShell's system of output streams.
  • This means you cannot capture or redirect such output from inside PowerShell (see the next section).

^{Tip of the hat to iRon for his help.}

PowerShell, following the model of traditional shells, is organized around streams - see the conceptual about_Redirection help topic for an overview of all 6 streams that PowerShell supports.^[1]

That is, any statement - and therefore potentially multiple ones - in a script or function can write to any of the output streams.

The primary output stream, meant to convey data, is the success output stream (whose number is 1), and only it is sent through the pipeline by default, and therefore by default only it is captured in a variable, suppressed, or redirected to a file.

There are two ways to write to the success output stream, i.e. to produce data output:

• Explicitly, with a Write-Output call - although that is rarely needed.

• Typically implicitly, by neither capturing, suppressing, nor redirecting output produced by a statement.

  • In other words: Output from any command (e.g., Get-ChildItem *.txt) or expression (e.g, 1 + 2 or (42).ToString('x')) is sent to the success output stream by default.

  • Unlike in traditional programming languages, return is not needed to produce output - in fact, its primary purpose is to exit the enclosing scope independently of any output the scope produces, though as a syntactic convenience you can combine the two aspects:

    • return is in effect the same as the following two statements, the first of which (potentially) produces output, the second of which exits the scope: ; return

  • This implicit output behavior is convenient and and allows for concise, expressive code, but can also be a pitfall: it is easy to accidentally produce output - typically from a .NET method whose return value isn't needed (see this question for an example).

    • iRon's GitHub feature request #15781 discusses one potential way to remedy this problem: introduction of an opt-in strict mode that only permits using explicit output statements (Write-Output, return) in order to produce output.

    • This answer shows troubleshooting techniques you can use with the currently available features.

As for assignments - e.g. $n = 1; $n += 1; ++$n; $n--:

• By default they do not produce output.
  • A hybrid case is the chaining form of a multi-assignment, e.g. $a = $b = 1, which assigns 1 to both variables: statement-internally the assignment value is passed through, but the statement as a whole has no output.
• However, as an opt-in you can make them pass the value(s) being assigned through via (...), the grouping operator; e.g. ($n = 1) both assigns 1 to variable $n and outputs 1, which allows it to participate in larger expressions, such as ($n = 1) -gt 0
  • Note that the related $(...) (subexpression operator) and @(...) (array-subexpression operator) do not have that effect - they wrap one or more entire statement(s), without affecting the enclosed statements' intrinsic output behavior; e.g. $($n = 1) does not produce output, because $n = 1 by itself doesn't produce output; however, $(($n = 1)) does, because ($n = 1) by itself does.

As for output enumeration behavior:

• By default, PowerShell enumerates collections that are being output, in the spirit of streaming output: That is, it sends a collection's elements to the pipeline, one by one.

• In the rare event that you do need to output a collection as a whole - which in general should be avoided, so as not to confound other commands participating in a pipeline, which usually do expect object-by-object input - you have two options:

  • , $collection (sic; uses an aux. one-element wrapper array)
  • More explicitly, but less efficiently: Write-Output -NoEnumerate $collection
  • See this answer for more information.

As for outputting $null:

• $null is output to the pipeline, but by default doesn't show.

  • $null by itself produces no visible output,

  • but the following returns $true, demonstrating that the value was sent:

There is an update to mini-css-extract-plugin in version 2.5.0. I temporarily fixed it by adding in package.json:

Environment.GetCommandLineArgs() always has process file name as the first element. You should start from index 1.

In my search for an answer to a similar problem (IInputStream Interface) I came upon this Reddit thread that gets the content of IBuffer as follows:

You need to capture the output and check it for the failure, or rather, check for success and fail if it doesn't.

This comes indeed from the GCM used by Git.
You can either downgrade to Git 2.32, or wait for the recently released Git-Credential-Manager-Core v2.0.603, which does remove those messages.

Said release is not yet packaged with the latest Git for Windows, like the recent 2.34.0, but expect it in 2.34.1.

A set GCM_PROVIDER=generic could help too.

Update Nov. 25th, 2021: Git for Windows 2.34.1 has been released, and it does include Git Credential Manager Core v2.0.605.12951.

That GCM 2.0.605 includes "Remove noisy messages during auto-detection" (#492, #494).

Turns out that Windows 10 Update Assistant incorrectly reported it upgraded my OS to 21H2 on my laptop. Checking Windows version by running winver reports that my OS is still 21H1. Of course CUDA in WSL2 will not work in Windows 10 without 21H2.

After successfully installing 21H2 I can confirm CUDA works with WSL2 even for laptops with Optimus NVIDIA cards.