k6-studio/src/codegen/browser/formatting/spacing.ts at feaac8402bbc6f75d960f9047dbb0485f5826493 · grafana/k6-studio · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
import type { TSESTree as ts } from '@typescript-eslint/types'

export function trimBefore(
  newLine: ts.NewLine | undefined
): ts.NewLine | undefined {
  if (newLine === undefined) {
    return undefined
  }

  return {
    ...newLine,
    before: newLine.before === true ? false : newLine.before,
  }
}

export function trimAfter(
  newLine: ts.NewLine | undefined
): ts.NewLine | undefined {
  if (newLine === undefined) {
    return undefined
  }

  return {
    ...newLine,
    after: newLine.after === true ? false : newLine.after,
  }
}

export function mergeNewLine(
  target: ts.NewLine | undefined,
  newLine: ts.NewLine
): ts.NewLine {
  if (target === undefined) {
    return newLine
  }

  const before =
    newLine.before !== undefined
      ? target.before === 'never'
        ? 'never'
        : newLine.before
      : target.before

  const after =
    newLine.after !== undefined
      ? target.after === 'never'
        ? 'never'
        : newLine.after
      : target.after

  return { before, after }
}

export function spaceBetween<T extends ts.Node>(nodes: T[]) {
  return nodes.map((node, index) => {
    const nextNode = nodes[index + 1]

    if (nextNode === undefined || nextNode.newLine?.before === 'never') {
      return node
    }

    return { ...node, newLine: mergeNewLine(node.newLine, { after: true }) }
  })
}

export function spaceAfter<T extends ts.Node>(nodes: T[]): T[] {
  const last = nodes[nodes.length - 1]

  if (last === undefined) {
    return []
  }

  return [
    ...nodes.slice(0, -1),
    { ...last, newLine: mergeNewLine(last.newLine, { after: true }) },
  ]
}

export function spaceAround<T extends ts.Node>([first, ...rest]: T[]): T[] {
  if (first === undefined) {
    return []
  }

  const last = rest[rest.length - 1]

  if (last === undefined || last === first) {
    return [{ ...first, newLine: 'both' }]
  }

  const middle = rest.slice(0, -1)

  return [
    { ...first, newLine: mergeNewLine(first.newLine, { before: true }) },
    ...middle,
    { ...last, newLine: mergeNewLine(last.newLine, { after: true }) },
  ]
}

export function spaceBefore<T extends ts.Node>([first, ...rest]: T[]): T[] {
  if (first === undefined) {
    return []
  }

  return [
    { ...first, newLine: mergeNewLine(first.newLine, { before: true }) },
    ...rest,
  ]
}

export function trimSpacing<T extends ts.Node>([first, ...rest]: T[]): T[] {
  if (first === undefined) {
    return []
  }

  const last = rest[rest.length - 1]

  if (last === undefined) {
    return [{ ...first, newLine: undefined }]
  }

  return [
    { ...first, newLine: trimBefore(first.newLine) },
    ...rest.slice(0, -1),
    { ...last, newLine: trimAfter(last.newLine) },
  ]
}