To automatically run laravel pint in VS Code when saving PHP files, follow these steps:

1. Install the `emeraldwalk` ["Run on Save"](https://marketplace.visualstudio.com/items?itemName=emeraldwalk.RunOnSave) extension from the VS Code Extensions Marketplace.

2. In your `settings.json` file, Configure the "Run on Save" extension to run the pint command every time you save a PHP file :
   
```json
   "emeraldwalk.runonsave": {
	  "commands": [
		{
		  "match": "\\.php$",
		  "cmd": "${workspaceFolder}/vendor/bin/pint ${file}"
		}
	  ]
	}
```

3. Open a PHP file in your Laravel project, make a change, and save it (`Ctrl+S`).

4. Witness the `php artisan pint` command's output in the terminal at the bottom of the VS Code window.

Run Laravel Pint on Save with VS Code

In this quick tutorial, we'll show you how to list the recent GitHub branches in your terminal using a simple command, and how to create an alias for that command to save time and streamline your workflow.

### Listing Recent GitHub Branches

To list the 20 most recent branches in your local repository, enter the following command in your terminal:

```console
git for-each-ref --count=20 --sort=-committerdate refs/heads/ --format='%(refname:short)'
```
*This command will display the 20 most recent branches, sorted by the commit date in descending order.*


### Creating an Alias for the Command

To make the process even more efficient, you can create an alias for the command. Add the following line to your `.bashrc`, `.zshrc`, or other relevant shell configuration file:

```console
alias rb="git for-each-ref --count=20 --sort=-committerdate refs/heads/ --format='%(refname:short)'"
```

After saving the changes to the configuration file, restart your terminal or run source ~/.bashrc, from now on you should be able to list your recent branches using the alias `rb`

List Recent GitHub Branches in Terminal

When working with React components, it's important to define the props a component can accept. However, defining every single prop for a component can become tedious and result in a lot of boilerplate code.

One way to reduce the amount of code needed to define props is to inherit props from the HTML element inside the component. For example, instead of defining all the props for a `<button>` element, you can inherit the props from the HTML element and only define the "custom" ones.

Let's take a look at an example component:

```typescript
interface Props {
  onClick: () => void;
  customProp: boolean;
}

function SomeButton({ customProp = false, onClick }: Props): JSX.Element {
  if (customProp) {
    // do something
  }

  return <button onClick={onClick} />;
}
```

In this example, the `SomeButton` component has two props: `onClick` and `customProp`. If we want to add a className prop to the button, we can't do so because we did not define it in the Props interface.

```typescript
// this is not valid because we don't have a `className` prop
<SomeButton customProp onClick={doSomething} className="p-3" />
```

To solve this problem, we can define the props by extending `React.ButtonHTMLAttributes<HTMLButtonElement>`. This means that we can add any prop that a regular button accepts.

```typescript
interface Props extends React.ButtonHTMLAttributes<HTMLButtonElement> {
  customProp?: boolean;
}

function SomeButton({ customProp = false, ...props }: Props): JSX.Element {
  if (customProp) {
    // do something
  }

  return <button {...props} />;
}
```

With this updated implementation of `SomeButton`, we can now add the `className` prop, along with any other prop that a regular button accepts.

```typescript
// this works
<SomeButton customProp onClick={doSomething} className="p-3" {...anyOtherProp} />
```

This technique can be applied to any HTML element that a component is based on. For example, if the component is based on a `<div>` element, we can inherit props from `React.HTMLAttributes<HTMLDivElement>` instead.

```typescript
interface Props extends React.HTMLAttributes<HTMLDivElement> {
  customProp?: boolean;
}
```

By inheriting props from the HTML element inside a component, we can reduce the amount of boilerplate code needed to define props, while still allowing us to add any prop that the HTML element accepts.

Latest Posts

Run Laravel Pint on Save with VS Code

List Recent GitHub Branches in Terminal

Efficient Prop Declarations in React Components