FilesExpand file tree

master

/

index.js

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

107 lines (90 loc) · 2.72 KB

master

/

index.js

Copy path

Top

File metadata and controls

• Code
• Blame

107 lines (90 loc) · 2.72 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

/* global document */

const minCharacterLength = 4;

// http://stackoverflow.com/questions/39776819/function-to-normalize-any-number-from-0-1

function normalize(min, max) {

const delta = max - min;

return value => {

return Number.parseFloat(((value - min) / delta).toFixed(2));

};

}

function cleanText(text) {

return text.replaceAll(/[^A-Za-z]/, " ").trim();

}

function extractWords(text) {

return text

.split(" ")

.filter(string => string.length >= minCharacterLength)

.map(word => word.toLowerCase())

.sort();

}

function getWordFrequency(words) {

return words.reduce((map, current) => {

const frequency = map.get(current) ? map.get(current) + 1 : 1;

return map.set(current, frequency);

}, new Map());

}

function getNormalisedWordFrequency(wordFrequenciesMap) {

const wordFrequencies = [...wordFrequenciesMap];

const frequencyData = wordFrequencies.map(([, frequency]) => frequency);

const maxFrequency = Math.max(...frequencyData);

return wordFrequencies.reduce((map, [word, frequency]) => {

const normalizedFrequency =

frequency > 1 ? normalize(0, maxFrequency)(frequency) : 0;

return map.set(word, normalizedFrequency);

}, new Map());

}

function createTagCloudTemplate(wordFrequencies) {

const container = [...wordFrequencies].reduce((map, [word, frequency]) => {

const wordItem = document.createElement("li");

wordItem.textContent = word;

wordItem.style.color = `rgba(0, 48, 225, ${frequency + 0.2})`;

wordItem.style.fontSize = `${1 + frequency * 2}em`;

map.append(wordItem);

return map;

}, document.createElement("ul"));

container.classList.add("bookmarklet-tag-cloud");

return container;

}

function getTagCloudStyles() {

const tagCloudStyles = `

.bookmarklet-tag-cloud {

list-style-type: none !important;

display: flex;

flex-wrap: wrap;

font-size: 20px;

background: white;

position: fixed;

top: 0;

left: 0;

width: 80vw;

max-height: 70vh;

overflow: scroll;

margin: 30px;

padding: 20px;

z-index: 99;

box-shadow: 0 0 8px 6px rgba(88, 84, 84, 0.59);

font-family: Verdana;

}

.bookmarklet-tag-cloud li {

margin: 2px 8px;

list-style-type: none !important;

align-self: center;

font-size: 0.9em;

}

`;

const style = document.createElement("style");

style.type = "text/css";

style.append(document.createTextNode(tagCloudStyles));

return style;

}

function init() {

const text = cleanText(document.body.textContent);

const words = extractWords(text);

const wordFrequency = getWordFrequency(words);

const normalisedWordFrequency = getNormalisedWordFrequency(wordFrequency);

const template = createTagCloudTemplate(normalisedWordFrequency);

const styles = getTagCloudStyles();

document.body.append(styles);

document.body.append(template);

}

init();