When the decoration is applied to a tab, the width is (generally) 4x wider than it should be since the width is based on the character width.

$model = new Model();
$model->bar = 'baz';
$otherModel->foobar = $model;

Bad

$model     = new Model();
$model     ->bar    = 'baz';
$otherModel->foobar = $model;

Good

$model = new Model();
$model->bar         = 'baz';
$otherModel->foobar = $model;

It may be desirable to align -> but i suspect only if the preceding expression is the same

The alignment is automatically triggered every time when a file is first opened.
I hope that add an option to turn off the automatic behavior.

I really like the concept and see massive potential but it needs some usability improvements. The core idea of the extension is text visualization, not a text editing, and to get rid of hard coded text alignment which is counter-productive. It should be some automatic intelligence for displaying text which does not modify the stored byte representation and does not mess with the version control system.

I am not expecting this to be implemented in near future but for anyone interested in futuristic features, I write this list:

• context/language awareness, at least an optional black- or whitelist of languages or a filename pattern
• cursor movement/selection based on screen coordinates and not (column, row) so that it freely moves through stretched spaces
  • not even clear if vscode is able to do that at the moment, given that this is quite elaborate to provide and untypical for text editors
  • the width of characters may be split appropriately by typing a new character at a position in between the stretched area
• automatically adapt alignment of the currently connected group of lines when typing
• consecutive lines grouped by indentation level and separated by lines without alignment. All lines within such a group are aligned to each other. Groups can be nested inside other groups and receive their own independent alignement but parent groups may continue after the child group.
  • slightly related, split off a subset of lines into a nested group, if those lines cause alignment of other lines which exceeds a configured maximum width
• allow pattern specifications for where alignment is allowed and which characters may be stretched, ideally language-sensitive
• stretched characters may be filled with spaces in copied text (and replaced by stretched characters when pasting it)
• allow partner definitions of a symbol S which whitelists all symbols S' that S can be aligned to

There are technically two ways to implement character stretches (without thinking of current technology's constraints):

1. transient spaces. These only exist in RAM or other volatile memory but are discarded whenever text is saved to non-volatile memory). The reason being that there are two interface points: one which automatically inserts transient spaces when reading data, one which doesn't. The first is for visual applications, the 2nd one for background applications where visually related information is just noise. Transient spaces would be the clean solution. The only difficult part is for OS maintainers to have a clear algorithm for inserting transient spaces during read operations.
2. virtual coordinates. An overlay coordinate system in the text field for the cursor. These coordinates are purely based on visualization, not on actual character-based coordinates. I think, this is much harder to deal with for text editors because there are so many coordinate transformations involved all the time. It may create compatibility issues with other text fields/editors which implement the alignment differently or not at all.

    /**
     * does this / that
     */

Bad

/ and * are aligning

     /*          *
     * does this / that
     */

Good

Unchanged

    /**
     * does this / that
     */

For now at least, if it ends up using info from the current language server it might be a different story.

microsoft/vscode#120251

For now I think it would be enough to only consider operators that are surrounded on both sides by whitespace.

Why does alignment only initiate when cursor is in specific window?

Is it possible that when the cursor has been in the specific window, the alignment will be permanent or that the alignment will pushed to all windows and keep it that way?

Maybe it's useful to have an option which restricts stretched characters to certain given characters with certain given preceding or following characters.

Example: it could be that only whitespace characters are regarded for stretching and maybe only those which immediately precede an operator (which is the default).

"align-spaces.stretch-text" : [" ", "\t"]
"align-spaces.when-before": ["//", "/*"]
"align-spaces.when-after": [",", ";", ":"]

I think, it also would be useful to ask in the VSCode community if it is possible to allow the cursor being maneuvred based on the screen coordinates (visualization) and not based on character column start/end.

Love this tool! Trying it out with Azure Bicep. Works better than anything else out there, but a few edge cases that could be even better. Going to see what I can do.

Case 1

Raw

@description('VNET resource group name.')
param vnetResourceGroupName string
param vnetName string = 'HXVNET'
param p4SubnetName string = 'PublicSubnet0'
param p4NicName string = 'hxnic'
@description('Name of the public IP to assign for NIC')
param p4PublicIPName string = 'hxcorepip'

Current

Preferred

@description('VNET resource group name.')
param vnetResourceGroupName string
param vnetName              string = 'HXVNET'
param p4SubnetName          string = 'PublicSubnet0'
param p4NicName             string = 'hxnic'
@description('Name of the public IP to assign for NIC')
param p4PublicIPName        string = 'hxcorepip'

Case 2

Input

var p4CmdToRun = 'sudo /usr/local/bin/signal.sh >> /var/log/userdata.log 2>&1'
var vnetID = resourceId(vnetResourceGroupName, 'Microsoft.Network/virtualNetworks', vnetName)
var imageReferenceSource = {...
}
var planReferenceSource = {...
}

Current

Preferred

var p4CmdToRu            = 'sudo /usr/local/bin/signal.sh >> /var/log/userdata.log 2>&1'
var vnetID               = resourceId(vnetResourceGroupName, 'Microsoft.Network/virtualNetworks', vnetName)
var imageReferenceSource = {...
}
var planReferenceSource  = {...
}

Case 3

Raw

resource p4PublicIPName_resource 'Microsoft.Network/publicIPAddresses@2020-08-01' = {...
}

resource p4NicName_resource 'Microsoft.Network/networkInterfaces@2020-08-01' = {...
}

Current

Prefered

resource p4PublicIPName_resource 'Microsoft.Network/publicIPAddresses@2020-08-01' = {...
}

resource p4NicName_resource      'Microsoft.Network/networkInterfaces@2020-08-01' = {...
}

I have a lot of extensions installed so I can't be sure, but I did some tests and it seems that having this extension enabled causes delays when typing on every keypress. More investigation is required, but disabling automatic alignment does seem to help.

Add commands to enable or disable the decorators

I think only the first = or : alignment is enough for each line

For example, the alignment of arrows or other operators will cause too many meaningless whitespace, because if variable names are very long, the whitespace will increase exponentially,there are many such examples.

In short, one is enough.

// expected
const f1      = (x) => x + 1
const f111111 = (x, y, z) => x + y + z

```javascript
// now
const f1      = (x)       => x + 1
const f111111 = (x, y, z) => x + y + z

VSCode reports that this extension is throwing uncaught errors (though I haven't noticed any functional problems). It's maybe to do with opening tabs that don't have normal text content.

If the last character in a line is a comma, don't align it with others as it makes selecting a line by mouse difficult

Many formatters have their own alignment

Example:

type T struct {
	A   int
	AAA int
}

// '.' is real space
// ' ' is fake space

// '…' some real spaces with reduced width
// (cool way if it's possible to set width less than 1)

// raw
var _ = T{
	A:...100000000,
	AAA:.1000,
}

// current
var _ = T{
	A  :...100000000,
	AAA:.1000,
}

// reduced spaces (best way)
var _ = T{
	A  :…100000000,
	AAA:.1000,
}

// if … not supported (still much better than current)
var _ = T{
	A  :...100000000,
	AAA:.  1000,
}

// // same for spaces before ':'

This thing exists and may have useful algo's we can use in this extension. License permitting, we may be able to copy / port some nice stuff.

https://github.com/cpmcgrath/codealignment

When working out how to align two things, if the number of leading tabs is different the width of the offset required is miscalculated.

Also, if two lines have different indentation they should probably not be grouped.

The list of operators that it looks for to align is very naive at the moment.

I'd like to align <> with = in SQL, and < and > should probably be added along with the <= and >= operators, but doing so would almost definitely interfere with xml-type languages.

Comments tend to contain text, text contains commas, commas in text don't need to be aligned.

@param and @return could be aligned, but multiline types would have to be considered.

/**
 * does some things, and some other things, and some more things
 * @param {{ foo: string; foobar: string; }} foo
 * @param {string} bar this, and that, are parameters
 * @param {Record<string, number>} baz
 */
function foo(foo, bar, baz) {}

Currently the comma in the first line things, will align with the comma in the doc for the bar parameter, which is bad.

Ideally, bar and baz should align after the type definitions, the comment and the @foo parameter should be ignored.

Add a config to define which languages should this extension be active on.

It was a great plugin, but I felt a little dizzy, like I was typing into a shaking computer.
So that I couldn't focus on the line I was editing.
I recommend adding an option to align document by a command/shortcut, rather than keystroke typing.

const foo = bar
    ? foobarbaz.foo === foobarbaz.bar
    : foobar !== bar

Current Behaviour

const foo             = bar
    ? foobarbaz.foo === foobarbaz.bar
    : foobar !=       = bar

Expected

const foo = bar
    ? foobarbaz.foo === foobarbaz.bar
    : foobar        !== bar

See also #4