Remove unused libs

08324ba8014fae1188b96ba7484c42a95b47e9d0

Cohee <18619528+Cohee1207@users.noreply.github.com>

Parents: e9a002bc2b78ed700f3f4069febf20d0c064a6fe
2 files changed, +0 -411Showing whitespace changes
public/lib/droll.js+0 -108
@@ -1,108 +0,0 @@
1// Borrowed from the Droll library by thebinarypenguin
2// https://github.com/thebinarypenguin/droll
3// Licensed under MIT license
4var droll = {};
5
6// Define a "class" to represent a formula
7function DrollFormula() {
8 this.numDice = 0;
9 this.numSides = 0;
10 this.modifier = 0;
11
12 this.minResult = 0;
13 this.maxResult = 0;
14 this.avgResult = 0;
15}
16
17// Define a "class" to represent the results of the roll
18function DrollResult() {
19 this.rolls = [];
20 this.modifier = 0;
21 this.total = 0;
22}
23
24/**
25 * Returns a string representation of the roll result
26 */
27DrollResult.prototype.toString = function () {
28 if (this.rolls.length === 1 && this.modifier === 0) {
29 return this.rolls[0] + '';
30 }
31
32 if (this.rolls.length > 1 && this.modifier === 0) {
33 return this.rolls.join(' + ') + ' = ' + this.total;
34 }
35
36 if (this.rolls.length === 1 && this.modifier > 0) {
37 return this.rolls[0] + ' + ' + this.modifier + ' = ' + this.total;
38 }
39
40 if (this.rolls.length > 1 && this.modifier > 0) {
41 return this.rolls.join(' + ') + ' + ' + this.modifier + ' = ' + this.total;
42 }
43
44 if (this.rolls.length === 1 && this.modifier < 0) {
45 return this.rolls[0] + ' - ' + Math.abs(this.modifier) + ' = ' + this.total;
46 }
47
48 if (this.rolls.length > 1 && this.modifier < 0) {
49 return this.rolls.join(' + ') + ' - ' + Math.abs(this.modifier) + ' = ' + this.total;
50 }
51};
52
53/**
54 * Parse the formula into its component pieces.
55 * Returns a DrollFormula object on success or false on failure.
56 */
57droll.parse = function (formula) {
58 var pieces = null;
59 var result = new DrollFormula();
60
61 pieces = formula.match(/^([1-9]\d*)?d([1-9]\d*)([+-]\d+)?$/i);
62 if (!pieces) { return false; }
63
64 result.numDice = (pieces[1] - 0) || 1;
65 result.numSides = (pieces[2] - 0);
66 result.modifier = (pieces[3] - 0) || 0;
67
68 result.minResult = (result.numDice * 1) + result.modifier;
69 result.maxResult = (result.numDice * result.numSides) + result.modifier;
70 result.avgResult = (result.maxResult + result.minResult) / 2;
71
72 return result;
73};
74
75/**
76 * Test the validity of the formula.
77 * Returns true on success or false on failure.
78 */
79droll.validate = function (formula) {
80 return (droll.parse(formula)) ? true : false;
81};
82
83/**
84 * Roll the dice defined by the formula.
85 * Returns a DrollResult object on success or false on failure.
86 */
87droll.roll = function (formula) {
88 var pieces = null;
89 var result = new DrollResult();
90
91 pieces = droll.parse(formula);
92 if (!pieces) { return false; }
93
94 for (var a = 0; a < pieces.numDice; a++) {
95 result.rolls[a] = (1 + Math.floor(Math.random() * pieces.numSides));
96 }
97
98 result.modifier = pieces.modifier;
99
100 for (var b = 0; b < result.rolls.length; b++) {
101 result.total += result.rolls[b];
102 }
103 result.total += result.modifier;
104
105 return result;
106};
107
108// END OF DROLL CODE
public/lib/uniqolor.js+0 -303
@@ -1,303 +0,0 @@
1const SATURATION_BOUND = [0, 100];
2const LIGHTNESS_BOUND = [0, 100];
3
4const pad2 = str => `${str.length === 1 ? '0' : ''}${str}`;
5
6const clamp = (num, min, max) => Math.max(Math.min(num, max), min);
7
8const random = (min, max) => Math.floor(Math.random() * ((max - min) + 1)) + min;
9
10const randomExclude = (min, max, exclude) => {
11 const r = random(min, max);
12
13 for (let i = 0; i < exclude?.length; i++) {
14 const value = exclude[i];
15
16 if (value?.length === 2 && r >= value[0] && r <= value[1]) {
17 return randomExclude(min, max, exclude);
18 }
19 }
20
21 return r;
22};
23
24/**
25 * Generate hashCode
26 * @param {string} str
27 * @return {number}
28 */
29const hashCode = str => {
30 const len = str.length;
31 let hash = 0;
32
33 for (let i = 0; i < len; i++) {
34 hash = ((hash << 5) - hash) + str.charCodeAt(i);
35 hash &= hash; // Convert to 32bit integer
36 }
37
38 return hash;
39};
40
41/**
42* Clamps `num` within the inclusive `range` bounds
43* @param {number} num
44* @param {number|Array} range
45* @return {number}
46*/
47const boundHashCode = (num, range) => {
48 if (typeof range === 'number') {
49 return range;
50 }
51
52 return (num % Math.abs(range[1] - range[0])) + range[0];
53};
54
55/**
56 * Sanitizing the `range`
57 * @param {number|Array} range
58 * @param {Array} bound
59 * @return {number|Array}
60 */
61const sanitizeRange = (range, bound) => {
62 if (typeof range === 'number') {
63 return clamp(Math.abs(range), ...bound);
64 }
65
66 if (range.length === 1 || range[0] === range[1]) {
67 return clamp(Math.abs(range[0]), ...bound);
68 }
69
70 return [
71 Math.abs(clamp(range[0], ...bound)),
72 clamp(Math.abs(range[1]), ...bound),
73 ];
74};
75
76/**
77 * @param {number} p
78 * @param {number} q
79 * @param {number} t
80 * @return {number}
81 */
82const hueToRgb = (p, q, t) => {
83 if (t < 0) {
84 t += 1;
85 } else if (t > 1) {
86 t -= 1;
87 }
88
89 if (t < 1 / 6) {
90 return p + ((q - p) * 6 * t);
91 }
92
93 if (t < 1 / 2) {
94 return q;
95 }
96
97 if (t < 2 / 3) {
98 return p + ((q - p) * ((2 / 3) - t) * 6);
99 }
100
101 return p;
102};
103
104/**
105 * Converts an HSL color to RGB
106 * @param {number} h Hue
107 * @param {number} s Saturation
108 * @param {number} l Lightness
109 * @return {Array}
110 */
111const hslToRgb = (h, s, l) => {
112 let r;
113 let g;
114 let b;
115
116 h /= 360;
117 s /= 100;
118 l /= 100;
119
120 if (s === 0) {
121 // achromatic
122 r = g = b = l;
123 } else {
124 const q = l < 0.5
125 ? l * (1 + s)
126 : (l + s) - (l * s);
127 const p = (2 * l) - q;
128
129 r = hueToRgb(p, q, h + (1 / 3));
130 g = hueToRgb(p, q, h);
131 b = hueToRgb(p, q, h - (1 / 3));
132 }
133
134 return [
135 Math.round(r * 255),
136 Math.round(g * 255),
137 Math.round(b * 255),
138 ];
139};
140
141/**
142 * Determines whether the RGB color is light or not
143 * http://www.w3.org/TR/AERT#color-contrast
144 * @param {number} r Red
145 * @param {number} g Green
146 * @param {number} b Blue
147 * @param {number} differencePoint
148 * @return {boolean}
149 */
150const rgbIsLight = (r, g, b, differencePoint) => ((r * 299) + (g * 587) + (b * 114)) / 1000 >= differencePoint; // eslint-disable-line max-len
151
152/**
153 * Converts an HSL color to string format
154 * @param {number} h Hue
155 * @param {number} s Saturation
156 * @param {number} l Lightness
157 * @return {string}
158 */
159const hslToString = (h, s, l) => `hsl(${h}, ${s}%, ${l}%)`;
160
161/**
162 * Converts RGB color to string format
163 * @param {number} r Red
164 * @param {number} g Green
165 * @param {number} b Blue
166 * @param {string} format Color format
167 * @return {string}
168 */
169const rgbFormat = (r, g, b, format) => {
170 switch (format) {
171 case 'rgb':
172 return `rgb(${r}, ${g}, ${b})`;
173 case 'hex':
174 default:
175 return `#${pad2(r.toString(16))}${pad2(g.toString(16))}${pad2(b.toString(16))}`;
176 }
177};
178
179/**
180 * Generate unique color from `value`
181 * @param {string|number} value
182 * @param {Object} [options={}]
183 * @param {string} [options.format='hex']
184 * The color format, it can be one of `hex`, `rgb` or `hsl`
185 * @param {number|Array} [options.saturation=[50, 55]]
186 * Determines the color saturation, it can be a number or a range between 0 and 100
187 * @param {number|Array} [options.lightness=[50, 60]]
188 * Determines the color lightness, it can be a number or a range between 0 and 100
189 * @param {number} [options.differencePoint=130]
190 * Determines the color brightness difference point. We use it to obtain the `isLight` value
191 * in the output, it can be a number between 0 and 255
192 * @return {Object}
193 * @example
194 *
195 * ```js
196 * uniqolor('Hello world!')
197 * // { color: "#5cc653", isLight: true }
198 *
199 * uniqolor('Hello world!', { format: 'rgb' })
200 * // { color: "rgb(92, 198, 83)", isLight: true }
201 *
202 * uniqolor('Hello world!', {
203 * saturation: 30,
204 * lightness: [70, 80],
205 * })
206 * // { color: "#afd2ac", isLight: true }
207 *
208 * uniqolor('Hello world!', {
209 * saturation: 30,
210 * lightness: [70, 80],
211 * differencePoint: 200,
212 * })
213 * // { color: "#afd2ac", isLight: false }
214 * ```
215 */
216const uniqolor = (value, {
217 format = 'hex',
218 saturation = [50, 55],
219 lightness = [50, 60],
220 differencePoint = 130,
221} = {}) => {
222 const hash = Math.abs(hashCode(String(value)));
223 const h = boundHashCode(hash, [0, 360]);
224 const s = boundHashCode(hash, sanitizeRange(saturation, SATURATION_BOUND));
225 const l = boundHashCode(hash, sanitizeRange(lightness, LIGHTNESS_BOUND));
226 const [r, g, b] = hslToRgb(h, s, l);
227
228 return {
229 color: format === 'hsl'
230 ? hslToString(h, s, l)
231 : rgbFormat(r, g, b, format),
232 isLight: rgbIsLight(r, g, b, differencePoint),
233 };
234};
235
236/**
237 * Generate random color
238 * @param {Object} [options={}]
239 * @param {string} [options.format='hex']
240 * The color format, it can be one of `hex`, `rgb` or `hsl`
241 * @param {number|Array} [options.saturation=[50, 55]]
242 * Determines the color saturation, it can be a number or a range between 0 and 100
243 * @param {number|Array} [options.lightness=[50, 60]]
244 * Determines the color lightness, it can be a number or a range between 0 and 100
245 * @param {number} [options.differencePoint=130]
246 * Determines the color brightness difference point. We use it to obtain the `isLight` value
247 * in the output, it can be a number between 0 and 255
248 * @param {Array} [options.excludeHue]
249 * Exclude certain hue ranges. For example to exclude red color range: `[[0, 20], [325, 359]]`
250 * @return {Object}
251 * @example
252 *
253 * ```js
254 * // Generate random color
255 * uniqolor.random()
256 * // { color: "#644cc8", isLight: false }
257 *
258 * // Generate a random color with HSL format
259 * uniqolor.random({ format: 'hsl' })
260 * // { color: "hsl(89, 55%, 60%)", isLight: true }
261 *
262 * // Generate a random color in specific saturation and lightness
263 * uniqolor.random({
264 * saturation: 80,
265 * lightness: [70, 80],
266 * })
267 * // { color: "#c7b9da", isLight: true }
268 *
269 * // Generate a random color but exclude red color range
270 * uniqolor.random({
271 * excludeHue: [[0, 20], [325, 359]],
272 * })
273 * // {color: '#53caab', isLight: true}
274 * ```
275 */
276uniqolor.random = ({
277 format = 'hex',
278 saturation = [50, 55],
279 lightness = [50, 60],
280 differencePoint = 130,
281 excludeHue,
282} = {}) => {
283 saturation = sanitizeRange(saturation, SATURATION_BOUND);
284 lightness = sanitizeRange(lightness, LIGHTNESS_BOUND);
285
286 const h = excludeHue ? randomExclude(0, 359, excludeHue) : random(0, 359);
287 const s = typeof saturation === 'number'
288 ? saturation
289 : random(...saturation);
290 const l = typeof lightness === 'number'
291 ? lightness
292 : random(...lightness);
293 const [r, g, b] = hslToRgb(h, s, l);
294
295 return {
296 color: format === 'hsl'
297 ? hslToString(h, s, l)
298 : rgbFormat(r, g, b, format),
299 isLight: rgbIsLight(r, g, b, differencePoint),
300 };
301};
302
303export default uniqolor;