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
127
128
129
130
131
132
133
|
'use strict'
const { flattenGrouplike, isGroup } = require('./playlist-utils')
function shuffleGroups(grouplike) {
if (isGroup(grouplike) && grouplike.items.every(isGroup)) {
const items = shuffleArray(grouplike.items.map(shuffleGroups))
return Object.assign({}, grouplike, {items})
} else {
return grouplike
}
}
function makePicker(grouplike, sort, loop) {
// Options to take into consideration:
// - How should the top-level be sorted?
// (e.g. "order", "shuffle", "shuffle-groups")
// - How should looping be handled?
// (e.g. "loop", "no-loop")
// - Also keep in mind aliases for all of the above.
// (e.g. "ordered", "shuffled", "noloop")
//
// What about a shuffle-mode that should simply pick a random track every
// time?
//
// What about a shuffle-mode that re-shuffles the list every time a loop
// happens?
//
// Both of those options could probably be handled via the 'loop' option.
const topLevel = {items: []}
let generateTopLevel = () => {
if (sort === 'order' || sort === 'ordered') {
topLevel.items = flattenGrouplike(grouplike).items
}
if (sort === 'shuffle' || sort === 'shuffled') {
topLevel.items = shuffleArray(flattenGrouplike(grouplike).items)
}
if (sort === 'shuffle-groups' || sort === 'shuffled-groups') {
topLevel.items = flattenGrouplike(shuffleGroups(grouplike)).items
}
}
generateTopLevel()
let index = 0
return function() {
if (index === topLevel.items.length) {
if (loop === 'loop-same-order' || loop === 'loop') {
index = 0
}
if (loop === 'loop-regenerate') {
generateTopLevel()
index = 0
}
if (loop === 'no-loop' || loop === 'no') {
// Returning null means the picker is done picking.
// (In theory, we could use an ES2015 generator intead, but this works
// well enough.)
return null
}
}
if (index > topLevel.items.length) {
throw new Error(
"Picker index is greater than total item count?" +
`(${index} > ${topLevel.items.length}`
)
}
if (index < topLevel.items.length) {
// Pick-random is a special exception - in this case we don't actually
// care about the value of the index variable; instead we just pick a
// random track from the generated top level.
//
// Loop=pick-random is different from sort=shuffle. Sort=shuffle always
// ensures the same song doesn't play twice in a single shuffle. It's
// like how when you shuffle a deck of cards, you'll still never pick
// the same card twice, until you go all the way through the deck and
// re-shuffle the deck!
//
// Loop=pick-random instead picks a random track every time the picker
// is called. It's more like you reshuffle the complete deck every time
// you pick something.
//
// Now, how should pick-random work when dealing with groups, such as
// when using sort=shuffle-groups? (If I can't find a solution, I'd say
// that's alright.)
if (loop === 'pick-random') {
const pickedIndex = Math.floor(Math.random() * topLevel.items.length)
return topLevel.items[pickedIndex]
}
// If we're using any other mode, we just want to get the current item
// in the playlist, and increment the index variable by one (note i++
// and not ++i; i++ increments AFTER getting i so it gets us the range
// 0..length-1, whereas ++i increments BEFORE, which gets us the range
// 1..length.
return topLevel.items[index++]
}
}
}
function shuffleArray(array) {
// Shuffles the items in an array. Super-interesting post on how it works:
// https://bost.ocks.org/mike/shuffle/
const workingArray = array.slice(0)
let m = array.length
while (m) {
let i = Math.floor(Math.random() * m)
m--
// Stupid lol; avoids the need of a temporary variable!
Object.assign(workingArray, {
[m]: workingArray[i],
[i]: workingArray[m]
})
}
return workingArray
}
module.exports = makePicker
|
