make-mp-data 1.1.18 → 1.2.0

package/tests/unit.test.js

@@ -7,6 +7,7 @@ const { timeSoup } = generate;
 require('dotenv').config();
 
 
+
 describe('timeSoup', () => {
 	test('always positive dates', () => {
 		const dates = [];
@@ -21,3 +22,157 @@ describe('timeSoup', () => {
 
 	});
 });
+
+
+
+const { applySkew, boxMullerRandom, choose, date, dates, day, exhaust, generateEmoji, getUniqueKeys, integer, makeHashTags, makeProducts, mapToRange, person, pick, range, weighList, weightedRange } = require('../utils');
+
+describe('utils', () => {
+
+	test('pick: works', () => {
+		const array = [1, 2, 3];
+		const item = pick(array);
+		expect(array).toContain(item);
+	});
+
+	test('pick: null', () => {
+		expect(pick(123)).toBe(123);
+	});
+
+
+
+	test('integer: diff', () => {
+		const min = 5;
+		const max = 10;
+		const result = integer(min, max);
+		expect(result).toBeGreaterThanOrEqual(min);
+		expect(result).toBeLessThanOrEqual(max);
+	});
+
+	test('integer: same', () => {
+		expect(integer(7, 7)).toBe(7);
+	});
+
+
+
+	test('hashtags', () => {
+		const hashtags = makeHashTags();
+		expect(hashtags).toBeInstanceOf(Array);
+		expect(hashtags).not.toHaveLength(0);
+		hashtags.forEach(tag => {
+			expect(tag).toMatch(/^#/);
+		});
+	});
+
+
+
+	test('person: fields', () => {
+		const generatedPerson = person();
+		expect(generatedPerson).toHaveProperty('$name');
+		expect(generatedPerson).toHaveProperty('$email');
+		expect(generatedPerson).toHaveProperty('$avatar');
+		expect(generatedPerson).toHaveProperty('anonymousIds');
+		expect(generatedPerson.anonymousIds).toBeInstanceOf(Array);
+	});
+
+
+	test('date: past date', () => {
+		const pastDate = date(10, true, 'YYYY-MM-DD')();
+		expect(dayjs(pastDate, 'YYYY-MM-DD').isValid()).toBeTruthy();
+		expect(dayjs(pastDate).isBefore(dayjs())).toBeTruthy();
+	});
+
+	test('date: future date', () => {
+		const futureDate = date(10, false, 'YYYY-MM-DD')();
+		expect(dayjs(futureDate, 'YYYY-MM-DD').isValid()).toBeTruthy();
+		expect(dayjs(futureDate).isAfter(dayjs())).toBeTruthy();
+	});
+
+	test('dates: returns pairs of dates', () => {
+		const datePairs = dates(10, 3, 'YYYY-MM-DD');
+		expect(datePairs).toBeInstanceOf(Array);
+		expect(datePairs).toHaveLength(3);
+		datePairs.forEach(pair => {
+			expect(pair).toHaveLength(2);
+		});
+	});
+
+	test('choose: choose from array', () => {
+		const options = ['apple', 'banana', 'cherry'];
+		const choice = choose(options);
+		expect(options).toContain(choice);
+	});
+
+	test('choose: execute function', () => {
+		const result = choose(() => 'test');
+		expect(result).toBe('test');
+	});
+
+	test('exhaust: exhaust array elements', () => {
+		const arr = [1, 2, 3];
+		const exhaustFn = exhaust([...arr]);
+		expect(exhaustFn()).toBe(1);
+		expect(exhaustFn()).toBe(2);
+		expect(exhaustFn()).toBe(3);
+		expect(exhaustFn()).toBeUndefined();
+	});
+
+	test('generateEmoji: returns string of emojis', () => {
+		const emojis = generateEmoji(5)();
+		expect(typeof emojis).toBe('string');
+		expect(emojis.split(', ').length).toBeLessThanOrEqual(5);
+	});
+
+	test('getUniqueKeys: find unique keys', () => {
+		const objects = [{ a: 1, b: 2 }, { a: 3, c: 4 }, { a: 5, b: 6 }];
+		const uniqueKeys = getUniqueKeys(objects);
+		expect(uniqueKeys).toEqual(expect.arrayContaining(['a', 'b', 'c']));
+	});
+
+
+	test('date: generates a valid date', () => {
+		const result = date();
+		expect(dayjs(result()).isValid()).toBe(true);
+	});
+
+	test('dates: generates an array of date pairs', () => {
+		const result = dates();
+		expect(result).toBeInstanceOf(Array);
+		expect(result.length).toBe(5); // Assuming default numPairs is 5
+		result.forEach(pair => {
+			expect(pair).toBeInstanceOf(Array);
+			expect(pair.length).toBe(2);
+			expect(dayjs(pair[0]()).isValid()).toBe(true);
+			expect(dayjs(pair[1]()).isValid()).toBe(true);
+		});
+	});
+
+	test('day: generates a day within range', () => {
+		const start = '2020-01-01';
+		const end = '2020-01-30';
+		const result = day(start, end);
+		const dayResult = result(0, 9);
+		expect(dayjs(dayResult.day).isAfter(dayjs(dayResult.start))).toBe(true);
+		expect(dayjs(dayResult.day).isBefore(dayjs(dayResult.end))).toBe(true);
+	});
+
+	test('exhaust: sequentially removes items from array', () => {
+		const arr = [1, 2, 3];
+		const next = exhaust(arr);
+		expect(next()).toBe(1);
+		expect(next()).toBe(2);
+		expect(next()).toBe(3);
+		expect(next()).toBe(undefined); // or whatever your implementation does after array is exhausted
+	});
+
+	test('generateEmoji: generates correct format and length', () => {
+		const result = generateEmoji();
+		const emojis = result();
+		expect(typeof emojis).toBe('string');
+		const emojiArray = emojis.split(', ');
+		expect(emojiArray.length).toBeLessThanOrEqual(10); // Assuming max default is 10
+		
+	});
+
+
+});

package/timesoup.js

@@ -0,0 +1,92 @@
+const Chance = require("chance");
+const chance = new Chance();
+const dayjs = require("dayjs");
+const utc = require("dayjs/plugin/utc");
+dayjs.extend(utc);
+const { integer } = require('./utils');
+const NOW = dayjs().unix();
+
+const PEAK_DAYS = [
+	dayjs().subtract(2, "day").unix(),
+	dayjs().subtract(3, "day").unix(),
+	dayjs().subtract(5, "day").unix(),
+	dayjs().subtract(7, "day").unix(),
+	dayjs().subtract(11, "day").unix(),
+	dayjs().subtract(13, "day").unix(),
+	dayjs().subtract(17, "day").unix(),
+	dayjs().subtract(19, "day").unix(),
+	dayjs().subtract(23, "day").unix(),
+	dayjs().subtract(29, "day").unix(),
+];
+
+
+/**
+ * essentially, a timestamp generator with a twist
+ * @param {number} earliestTime - The earliest timestamp in Unix format.
+ * @param {number} latestTime - The latest timestamp in Unix format.
+ * @param {Array} peakDays - Array of Unix timestamps representing the start of peak days.
+ * @returns {number} - The generated event timestamp in Unix format.
+ */
+function AKsTimeSoup(earliestTime, latestTime = NOW, peakDays = PEAK_DAYS) {
+	let chosenTime;
+	let eventTime;
+	let validTime = false;
+
+	if (typeof earliestTime !== "number") {
+		if (parseInt(earliestTime) > 0) earliestTime = parseInt(earliestTime);
+		if (dayjs(earliestTime).isValid()) earliestTime = dayjs(earliestTime).unix();
+	}
+
+	while (!validTime) {
+
+		// Define business hours
+		const peakStartHour = 4; // 4 AM
+		const peakEndHour = 23; // 11 PM
+		const likelihoodOfPeakDay = chance.integer({ min: integer(5, 42), max: integer(43, 69) }); // Randomize likelihood with CHAOS!~~
+
+		// Select a day, with a preference for peak days
+		let selectedDay;
+		if (chance.bool({ likelihood: likelihoodOfPeakDay })) { // Randomized likelihood to pick a peak day
+			selectedDay = peakDays.length > 0 ? chance.pickone(peakDays) : integer(earliestTime, latestTime);
+		} else {
+			// Introduce minor peaks by allowing some events to still occur during business hours
+			selectedDay = chance.bool({ likelihood: integer(1, 42) })
+				? chance.pickone(peakDays)
+				: integer(earliestTime, latestTime);
+		}
+
+		// Normalize selectedDay to the start of the day
+		selectedDay = dayjs.unix(selectedDay).startOf('day').unix();
+
+		// Generate a random time within business hours with a higher concentration in the middle of the period
+		const businessStart = dayjs.unix(selectedDay).hour(peakStartHour).minute(0).second(0).unix();
+		const businessEnd = dayjs.unix(selectedDay).hour(peakEndHour).minute(0).second(0).unix();
+
+		if (selectedDay === peakDays[0]) {
+			// Use a skewed distribution for peak days
+			eventTime = chance.normal({ mean: (businessEnd + businessStart) / integer(1, 4), dev: (businessEnd - businessStart) / integer(2, 8) });
+		} else {
+			// For non-peak days, use a uniform distribution to add noise
+			eventTime = integer(integer(businessStart, businessEnd), integer(businessStart, businessEnd));
+		}
+
+		// usually, ensure the event time is within business hours
+		if (chance.bool({ likelihood: 42 })) eventTime = Math.min(Math.max(eventTime, businessStart), businessEnd);
+
+		if (eventTime > 0) validTime = true;
+		const parsedTime = dayjs.unix(eventTime).toISOString();
+		if (!parsedTime.startsWith('20')) validTime = false;
+
+	}
+	chosenTime = dayjs.unix(eventTime).toISOString();
+
+	//should never get here
+	if (eventTime < 0) debugger;
+	if (!chosenTime.startsWith('20')) debugger;
+
+
+	return chosenTime;
+}
+
+
+module.exports = AKsTimeSoup;

package/utils.js

@@ -7,18 +7,27 @@ const dayjs = require('dayjs');
 const utc = require('dayjs/plugin/utc');
 dayjs.extend(utc);
 
-function pick() {
-	try {
-		const choice = chance.pickone(this);
-		return choice;
-	}
-	catch (e) {
-		return null;
+function pick(items) {
+	if (!Array.isArray(items)) {
+		if (typeof items === 'function') {
+			const selection = items();
+			if (Array.isArray(selection)) {
+				return chance.pickone(selection);
+			}
+			else {
+				return selection;
+			}
+		}
+		return items;
+
 	}
-}
+	return chance.pickone(items);
+};
 
 function date(inTheLast = 30, isPast = true, format = 'YYYY-MM-DD') {
 	const now = dayjs.utc();
+	// dates must be in the the last 10 years
+	if (Math.abs(inTheLast) > 365 * 10) inTheLast = chance.integer({ min: 1, max: 180 });
 	return function () {
 		try {
 			const when = chance.integer({ min: 0, max: Math.abs(inTheLast) });
@@ -43,7 +52,7 @@ function date(inTheLast = 30, isPast = true, format = 'YYYY-MM-DD') {
 			if (!format) return now?.toISOString();
 		}
 	};
-}
+};
 
 function dates(inTheLast = 30, numPairs = 5, format = 'YYYY-MM-DD') {
 	const pairs = [];
@@ -52,7 +61,7 @@ function dates(inTheLast = 30, numPairs = 5, format = 'YYYY-MM-DD') {
 	}
 	return pairs;
 
-}
+};
 
 function day(start, end) {
 	const format = 'YYYY-MM-DD';
@@ -69,7 +78,7 @@ function day(start, end) {
 		};
 	};
 
-}
+};
 
 function choose(value) {
 	if (typeof value === 'function') {
@@ -80,13 +89,13 @@ function choose(value) {
 	}
 
 	return value;
-}
+};
 
 function exhaust(arr) {
 	return function () {
 		return arr.shift();
 	};
-}
+};
 
 
 function integer(min, max) {
@@ -109,7 +118,7 @@ function integer(min, max) {
 	}
 
 	return 0;
-}
+};
 
 function makeHashTags() {
 	const popularHashtags = [
@@ -133,7 +142,7 @@ function makeHashTags() {
 		hashtags.push(chance.pickone(popularHashtags));
 	}
 	return hashtags;
-}
+};
 
 function makeProducts() {
 	let categories = ["Device Accessories", "eBooks", "Automotive", "Baby Products", "Beauty", "Books", "Camera & Photo", "Cell Phones & Accessories", "Collectible Coins", "Consumer Electronics", "Entertainment Collectibles", "Fine Art", "Grocery & Gourmet Food", "Health & Personal Care", "Home & Garden", "Independent Design", "Industrial & Scientific", "Accessories", "Major Appliances", "Music", "Musical Instruments", "Office Products", "Outdoors", "Personal Computers", "Pet Supplies", "Software", "Sports", "Sports Collectibles", "Tools & Home Improvement", "Toys & Games", "Video, DVD & Blu-ray", "Video Games", "Watches"];
@@ -167,7 +176,7 @@ function makeProducts() {
 	}
 
 	return data;
-}
+};
 
 // Box-Muller transform to generate standard normally distributed values
 function boxMullerRandom() {
@@ -175,7 +184,7 @@ function boxMullerRandom() {
 	while (u === 0) u = Math.random();
 	while (v === 0) v = Math.random();
 	return Math.sqrt(-2.0 * Math.log(u)) * Math.cos(2.0 * Math.PI * v);
-}
+};
 
 // Apply skewness to the value
 function applySkew(value, skew) {
@@ -183,12 +192,12 @@ function applySkew(value, skew) {
 	// Adjust the value based on skew
 	let sign = value < 0 ? -1 : 1;
 	return sign * Math.pow(Math.abs(value), skew);
-}
+};
 
 // Map standard normal value to our range
 function mapToRange(value, mean, sd) {
 	return Math.round(value * sd + mean);
-}
+};
 
 function weightedRange(min, max, size = 100, skew = 1) {
 	const mean = (max + min) / 2;
@@ -209,54 +218,12 @@ function weightedRange(min, max, size = 100, skew = 1) {
 	}
 
 	return array;
-}
+};
 
 function progress(thing, p) {
 	readline.cursorTo(process.stdout, 0);
 	process.stdout.write(`${thing} processed ... ${comma(p)}`);
-}
-
-function person(bornDaysAgo = 30) {
-	//names and photos
-	const gender = chance.pickone(['male', 'female']);
-	const first = chance.first({ gender });
-	const last = chance.last();
-	const $name = `${first} ${last}`;
-	const $email = `${first[0]}.${last}@${chance.domain()}.com`;
-	const avatarPrefix = `https://randomuser.me/api/portraits`;
-	const randomAvatarNumber = chance.integer({
-		min: 1,
-		max: 99
-	});
-	const avPath = gender === 'male' ? `/men/${randomAvatarNumber}.jpg` : `/women/${randomAvatarNumber}.jpg`;
-	const $avatar = avatarPrefix + avPath;
-	const $created = date(bornDaysAgo, true, null)();
-
-	//anon Ids
-	const anonymousIds = [];
-	const clusterSize = integer(2, 10);
-	for (let i = 0; i < clusterSize; i++) {
-		anonymousIds.push(uid(42));
-	}
-
-	//session Ids
-	const sessionIds = [];
-	const sessionSize = integer(5, 30);
-	for (let i = 0; i < sessionSize; i++) {
-		sessionIds.push([uid(5), uid(5), uid(5), uid(5)].join("-"));
-	}
-
-
-
-	return {
-		$name,
-		$email,
-		$avatar,
-		$created,
-		anonymousIds,
-		sessionIds
-	};
-}
+};
 
 function range(a, b, step = 1) {
 	step = !step ? 1 : step;
@@ -276,7 +243,7 @@ function openFinder(path, callback) {
 		p.kill();
 		return callback(err);
 	});
-}
+};
 
 function getUniqueKeys(data) {
 	const keysSet = new Set();
@@ -284,7 +251,7 @@ function getUniqueKeys(data) {
 		Object.keys(item).forEach(key => keysSet.add(key));
 	});
 	return Array.from(keysSet);
-}
+};
 
 //makes a random-sized array of emojis
 function generateEmoji(max = 10, array = false) {
@@ -299,92 +266,98 @@ function generateEmoji(max = 10, array = false) {
 		if (!array) return arr.join(', ');
 		return "🤷";
 	};
-}
+};
 
-function generateName() {
-	var adjs = [
-		"autumn", "hidden", "bitter", "misty", "silent", "empty", "dry", "dark",
-		"summer", "icy", "delicate", "quiet", "white", "cool", "spring", "winter",
-		"patient", "twilight", "dawn", "crimson", "wispy", "weathered", "blue",
-		"billowing", "broken", "cold", "damp", "falling", "frosty", "green",
-		"long", "late", "lingering", "bold", "little", "morning", "muddy", "old",
-		"red", "rough", "still", "small", "sparkling", "throbbing", "shy",
-		"wandering", "withered", "wild", "black", "young", "holy", "solitary",
-		"fragrant", "aged", "snowy", "proud", "floral", "restless", "divine",
-		"polished", "ancient", "purple", "lively", "nameless", "gentle", "gleaming", "furious", "luminous", "obscure", "poised", "shimmering", "swirling",
-		"sombre", "steamy", "whispering", "jagged", "melodic", "moonlit", "starry", "forgotten",
-		"peaceful", "restive", "rustling", "sacred", "ancient", "haunting", "solitary", "mysterious",
-		"silver", "dusky", "earthy", "golden", "hallowed", "misty", "roaring", "serene", "vibrant",
-		"stalwart", "whimsical", "timid", "tranquil", "vast", "youthful", "zephyr", "raging",
-		"sapphire", "turbulent", "whirling", "sleepy", "ethereal", "tender", "unseen", "wistful"
-	];
 
-	var nouns = [
-		"waterfall", "river", "breeze", "moon", "rain", "wind", "sea", "morning",
-		"snow", "lake", "sunset", "pine", "shadow", "leaf", "dawn", "glitter",
-		"forest", "hill", "cloud", "meadow", "sun", "glade", "bird", "brook",
-		"butterfly", "bush", "dew", "dust", "field", "fire", "flower", "firefly",
-		"feather", "grass", "haze", "mountain", "night", "pond", "darkness",
-		"snowflake", "silence", "sound", "sky", "shape", "surf", "thunder",
-		"violet", "water", "wildflower", "wave", "water", "resonance", "sun",
-		"wood", "dream", "cherry", "tree", "fog", "frost", "voice", "paper",
-		"frog", "smoke", "star", "glow", "wave", "riverbed", "cliff", "deluge", "prairie", "creek", "ocean",
-		"peak", "valley", "starlight", "quartz", "woodland", "marsh", "earth", "canopy",
-		"petal", "stone", "orb", "gale", "bay", "canyon", "watercourse", "vista", "raindrop",
-		"boulder", "grove", "plateau", "sand", "mist", "tide", "blossom", "leaf", "flame",
-		"shade", "coil", "grotto", "pinnacle", "scallop", "serenity", "abyss", "skyline",
-		"drift", "echo", "nebula", "horizon", "crest", "wreath", "twilight", "balm", "glimmer"
-	];
+function person(bornDaysAgo = 30) {
+	//names and photos
+	const gender = chance.pickone(['male', 'female']);
+	const first = chance.first({ gender });
+	const last = chance.last();
+	const $name = `${first} ${last}`;
+	const $email = `${first[0]}.${last}@${chance.domain()}.com`;
+	const avatarPrefix = `https://randomuser.me/api/portraits`;
+	const randomAvatarNumber = chance.integer({
+		min: 1,
+		max: 99
+	});
+	const avPath = gender === 'male' ? `/men/${randomAvatarNumber}.jpg` : `/women/${randomAvatarNumber}.jpg`;
+	const $avatar = avatarPrefix + avPath;
+	const $created = date(bornDaysAgo, true, null)();
 
-	var verbs = [
-		"dancing", "whispering", "flowing", "shimmering", "swirling", "echoing", "sparkling", "glistening",
-		"cascading", "drifting", "glowing", "rippling", "quivering", "singing", "twinkling", "radiating",
-		"enveloping", "enchanting", "captivating", "embracing", "embracing", "illuminating", "pulsating", "gliding",
-		"soaring", "wandering", "meandering", "dazzling", "cuddling", "embracing", "caressing", "twisting",
-		"twirling", "tumbling", "surging", "glimmering", "gushing", "splashing", "rolling", "splintering",
-		"splintering", "crescendoing", "whirling", "bursting", "shining", "gushing", "emerging", "revealing",
-		"emerging", "unfolding", "unveiling", "emerging", "surrounding", "unveiling", "materializing", "revealing"
-	];
+	//anon Ids
+	const anonymousIds = [];
+	const clusterSize = integer(2, 10);
+	for (let i = 0; i < clusterSize; i++) {
+		anonymousIds.push(uid(42));
+	}
 
-	var adverbs = [
-		"gracefully", "softly", "smoothly", "gently", "tenderly", "quietly", "serenely", "peacefully",
-		"delicately", "effortlessly", "subtly", "tranquilly", "majestically", "silently", "calmly", "harmoniously",
-		"elegantly", "luminously", "ethereally", "mysteriously", "sublimely", "radiantly", "dreamily", "ethereally",
-		"mesmerizingly", "hypnotically", "mystically", "enigmatically", "spellbindingly", "enchantingly", "fascinatingly",
-		"bewitchingly", "captivatingly", "entrancingly", "alluringly", "rapturously", "seductively", "charismatically",
-		"seductively", "envelopingly", "ensnaringly", "entrancingly", "intoxicatingly", "irresistibly", "transcendentally",
-		"envelopingly", "rapturously", "intimately", "intensely", "tangibly", "vividly", "intensely", "deeply"
-	];
+	//session Ids
+	const sessionIds = [];
+	const sessionSize = integer(5, 30);
+	for (let i = 0; i < sessionSize; i++) {
+		sessionIds.push([uid(5), uid(5), uid(5), uid(5)].join("-"));
+	}
 
 
-	// ? http://stackoverflow.com/a/17516862/103058
-	var adj = adjs[Math.floor(Math.random() * adjs.length)];
-	var noun = nouns[Math.floor(Math.random() * nouns.length)];
-	var verb = verbs[Math.floor(Math.random() * verbs.length)];
-	var adverb = adverbs[Math.floor(Math.random() * adverbs.length)];
+
+	return {
+		$name,
+		$email,
+		$avatar,
+		$created,
+		anonymousIds,
+		sessionIds
+	};
+};
 
 
-	return adj + '-' + noun + '-' + verb + '-' + adverb;
+function weighList(items, mostChosenIndex) {
+	if (mostChosenIndex > items.length) mostChosenIndex = items.length;
+	return function () {
+		const weighted = [];
+		for (let i = 0; i < 10; i++) {
+			if (chance.bool({ likelihood: integer(10, 35) })) {
+				if (chance.bool({ likelihood: 50 })) {
+					weighted.push(items[mostChosenIndex]);
+				}
+				else {
+					const rand = chance.d10();
+					const addOrSubtract = chance.bool({ likelihood: 50 }) ? -rand : rand;
+					let newIndex = mostChosenIndex + addOrSubtract;
+					if (newIndex < 0) newIndex = 0;
+					if (newIndex > items.length) newIndex = items.length;
+					weighted.push(items[newIndex]);
+				}
+			}
+			else {
+				weighted.push(chance.pickone(items));
+			}
+		}
+		return weighted;
 
+	};
 }
 
 module.exports = {
-	weightedRange,
 	pick,
+	date,
+	dates,
 	day,
+	choose,
+	exhaust,
 	integer,
+	makeHashTags,
 	makeProducts,
-	date,
+	boxMullerRandom,
+	applySkew,
+	mapToRange,
+	weightedRange,
 	progress,
-	person,
-	choose,
 	range,
-	exhaust,
 	openFinder,
-	applySkew,
-	boxMullerRandom,
-	generateEmoji,
 	getUniqueKeys,
-	makeHashTags,
-	generateName,
+	generateEmoji,
+	person,
+	weighList
 };