FilesExpand file tree

main

/

release-notes-utils.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

108 lines (96 loc) · 3.27 KB

main

/

release-notes-utils.js

Copy path

Top

File metadata and controls

• Code
• Blame

108 lines (96 loc) · 3.27 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

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

import semver from 'semver'

import renderContent from './render-content/index.js'

/**

* Turn { [key]: { notes, intro, date } }

* into [{ version, notes, intro, date }]

*/

export function sortPatchKeys(release, version, options = {}) {

const keys = Object.keys(release)

.map((key) => {

const keyWithDots = key.replace(/-/g, '.')

return {

version: `${version}.${keyWithDots}`,

patchVersion: keyWithDots,

downloadVersion: `${version}.${keyWithDots.replace(/\.rc\d*$/, '')}`,

release: version, // TODO this naming :/ we are not currently using this value, but we may want to.

...release[key],

}

})

// Filter out any deprecated patches

.filter((key) => !key.deprecated)

// Versions with numbered releases like GHES 2.22, 3.0, etc. need additional semver sorting;

// Versions with date releases need to be sorted by date.

return options.semverSort

? semverSort(keys)

: keys.sort((a, b) => new Date(b.date) - new Date(a.date))

}

export function semverSort(keys) {

return keys.sort((a, b) => {

let aTemp = a.version

let bTemp = b.version

// There's an RC version here, so doing regular semver

// comparisons won't work. So, we'll convert the incompatible version

// strings to real semver strings, then compare.

const [aBase, aRc] = a.version.split('.rc')

if (aRc) aTemp = `${aBase}-rc.${aRc}`

const [bBase, bRc] = b.version.split('.rc')

if (bRc) bTemp = `${bBase}-rc.${bRc}`

if (semver.gt(aTemp, bTemp)) return -1

if (semver.lt(aTemp, bTemp)) return 1

return 0

})

}

/**

* Render each note in the given patch, by looping through the

* sections and rendering either `note` or `note.notes` in the

* case of a sub-section

*/

export async function renderPatchNotes(patch, ctx) {

// Run the notes through the markdown rendering pipeline

for (const key in patch.sections) {

await Promise.all(

patch.sections[key].map(async (noteOrHeading, index) => {

patch.sections[key][index] =

typeof noteOrHeading === 'string'

? await renderContent(noteOrHeading, ctx)

: {

...noteOrHeading,

notes: await Promise.all(

noteOrHeading.notes.map((note) => renderContent(note, ctx))

),

}

})

)

}

// Also render the patch's intro

if (patch.intro) {

patch.intro = await renderContent(patch.intro, ctx)

}

return patch

}

export function sortReleasesByDate(releaseNotes) {

return Object.keys(releaseNotes)

.map((release) => {

const [year, month] = release.split('-')

return {

name: release,

date: new Date(`20${year}`, month - 1, '1'),

}

})

.sort((releaseEntry1, releaseEntry2) => releaseEntry2.date - releaseEntry1.date)

.map((releaseEntry) => releaseEntry.name)

}

export function getAllReleases(releases, releaseNotesPerPlan, hasNumberedReleases) {

return releases.map((version) => {

const release = releaseNotesPerPlan[version.replace(/\./g, '-')]

if (!release) return { version }

const patches = sortPatchKeys(release, version, { semverSort: hasNumberedReleases })

return { version, patches }

})

}

export default {

sortReleasesByDate,

sortPatchKeys,

renderPatchNotes,

getAllReleases,

}