@fc3/mmcadi 0.1.0

package/src/server/utility/get-random-emoji-for-date.ts

@@ -0,0 +1,109 @@
+import Emoji from 'enum/emoji';
+import {InvariantViolation} from 'lib/errors';
+import {randomElement} from 'lib/random';
+
+enum Season {
+	SPRING = 'spring',
+	SUMMER = 'summer',
+	AUTUMN = 'autumn',
+	WINTER = 'winter'
+}
+
+enum Month {
+	JANUARY,
+	FEBRUARY,
+	MARCH,
+	APRIL,
+	MAY,
+	JUNE,
+	JULY,
+	AUGUST,
+	SEPTEMBER,
+	OCTOBER,
+	NOVEMBER,
+	DECEMBER
+}
+
+const SEASONAL_EMOJI: Record<Season, Emoji[]> = {
+	[Season.WINTER]: [
+    Emoji.SNOWMAN,
+    Emoji.SNOWFLAKE,
+    Emoji.SNOW_CLOUD,
+    Emoji.SCARF,
+    Emoji.GLOVES,
+    Emoji.CANDLE,
+    Emoji.CHRISTMAS_TREE,
+    Emoji.SOCKS,
+    Emoji.COLD_FACE,
+  ],
+  [Season.SPRING]: [
+    Emoji.SEEDLING,
+    Emoji.TULIP,
+    Emoji.BEE,
+    Emoji.HATCHING_CHICK,
+    Emoji.NEST_WITH_EGGS,
+    Emoji.BLOSSOM,
+    Emoji.UMBRELLA,
+    Emoji.RAINBOW,
+    Emoji.PICNIC_BASKET,
+  ],
+  [Season.SUMMER]: [
+    Emoji.SUN_WITH_FACE,
+    Emoji.BEACH_UMBRELLA,
+    Emoji.WATERMELON,
+    Emoji.SUNGLASSES,
+    Emoji.ICE_CREAM,
+    Emoji.SUNFLOWER,
+    Emoji.CAMPING,
+    Emoji.JUICE_BOX,
+    Emoji.PARASOL,
+  ],
+  [Season.AUTUMN]: [
+    Emoji.MAPLE_LEAF,
+    Emoji.FALLEN_LEAF,
+    Emoji.TURKEY,
+    Emoji.JACK_O_LANTERN,
+    Emoji.PIE,
+    Emoji.LOG,
+    Emoji.SPIDER_WEB,
+    Emoji.BACKPACK,
+    Emoji.CHESTNUT,
+  ]
+};
+
+function getSeasonForDate(date: Date): Season {
+  const month = date.getUTCMonth();
+
+	switch (month) {
+		case Month.DECEMBER:
+		case Month.JANUARY:
+		case Month.FEBRUARY:
+			return Season.WINTER;
+		case Month.MARCH:
+		case Month.APRIL:
+		case Month.MAY:
+			return Season.SPRING;
+		case Month.JUNE:
+		case Month.JULY:
+		case Month.AUGUST:
+			return Season.SUMMER;
+		case Month.SEPTEMBER:
+		case Month.OCTOBER:
+		case Month.NOVEMBER:
+			return Season.AUTUMN;
+		default:
+			throw new InvariantViolation(`Invalid month: ${month}`);
+	}
+}
+
+function getRandomEmojiForSeason(season: Season): Emoji {
+	const subset = SEASONAL_EMOJI[season];
+
+	return randomElement(subset) as Emoji;
+}
+
+function getRandomEmojiForDate(date: Date): Emoji {
+	return getRandomEmojiForSeason(getSeasonForDate(date));
+}
+
+export default getRandomEmojiForDate;

package/src/server/utility/get-short-label-for-date.ts

@@ -0,0 +1,11 @@
+import getShortMonthName from 'server/utility/get-short-month-name';
+
+function getShortLabelForDate(date: Date): string {
+	const month = getShortMonthName(date);
+	const day = date.getUTCDate();
+	const year = date.getUTCFullYear();
+
+	return `${month} ${day} ${year} `;
+}
+
+export default getShortLabelForDate;

package/src/server/utility/get-short-month-name.ts

@@ -0,0 +1,9 @@
+import getMonthName from 'server/utility/get-month-name';
+
+function getShortMonthName(date: Date): string {
+	const month_name = getMonthName(date);
+
+	return month_name.slice(0, 3);
+}
+
+export default getShortMonthName;

package/src/server/utility/get-short-ordinal.ts

@@ -0,0 +1,26 @@
+function getOrdinalSuffix(index: number): string {
+	if (index > 10 && index < 20) {
+		return 'th';
+	}
+
+	const modulus = index % 10;
+
+	switch (modulus) {
+		case 1:
+			return 'st';
+		case 2:
+			return 'nd';
+		case 3:
+			return 'rd';
+		default:
+			return 'th';
+	}
+}
+
+function getShortOrdinal(index: number): string {
+	const suffix = getOrdinalSuffix(index);
+
+	return `${index}${suffix}`;
+}
+
+export default getShortOrdinal;

package/src/server/utility/get-siblings-and-index-for-index-path.ts

@@ -0,0 +1,67 @@
+import {InvalidError} from 'lib/errors';
+import {getLastValue} from 'lib/array';
+
+import Page from 'type/page';
+import Block from 'type/block';
+import parseIndexPath from 'server/utility/parse-index-path';
+
+type SiblingsAndIndex = {
+	siblings: Block[];
+	index: number;
+};
+
+function getSiblingsAndIndexForIndexPath(page: Page, index_path: string): SiblingsAndIndex {
+	const parsed_path = parseIndexPath(index_path);
+	const first_index = parsed_path[0];
+
+	if (parsed_path.length === 1) {
+		return {
+			siblings: page.blocks,
+			index: first_index
+		};
+	}
+
+	let current = page.blocks[first_index];
+
+	if (!current) {
+		throw new InvalidError(`Invalid index path segment: ${first_index}`);
+	}
+
+	let i = 1;
+
+	while (i < parsed_path.length - 1) {
+		const segment = parsed_path[i++];
+		const children = current.children;
+
+		if (children === undefined) {
+			throw new InvalidError(`Path segment ${i} has no children`);
+		}
+
+		current = children[segment];
+
+		if (!current) {
+			throw new InvalidError(`
+				Invalid index path segment at depth ${i}: ${segment}
+			`);
+		}
+	}
+
+	const siblings = current.children;
+
+	if (siblings === undefined) {
+		throw new InvalidError('Final ancestor has no children');
+	}
+
+	const index = getLastValue(parsed_path);
+
+	if (index === undefined) {
+		throw new InvalidError('Parsed path had no final part');
+	}
+
+	return {
+		siblings,
+		index
+	};
+}
+
+export default getSiblingsAndIndexForIndexPath;

package/src/server/utility/get-start-of-month.ts

@@ -0,0 +1,11 @@
+import createDate from 'server/utility/create-date';
+
+function getStartOfMonth(date: Date): Date {
+	const new_date = createDate(date);
+
+	new_date.setUTCDate(1);
+
+	return new_date;
+}
+
+export default getStartOfMonth;

package/src/server/utility/get-start-of-week.ts

@@ -0,0 +1,12 @@
+import createDate from 'server/utility/create-date';
+
+function getStartOfWeek(date: Date): Date {
+	const new_date = createDate(date);
+	const current_day = new_date.getUTCDay();
+
+	new_date.setUTCDate(new_date.getUTCDate() - current_day);
+
+	return new_date;
+}
+
+export default getStartOfWeek;

package/src/server/utility/get-start-of-year.ts

@@ -0,0 +1,12 @@
+import createDate from 'server/utility/create-date';
+
+function getStartOfYear(date: Date): Date {
+	const new_date = createDate(date);
+
+	new_date.setUTCMonth(0);
+	new_date.setUTCDate(1);
+
+	return new_date;
+}
+
+export default getStartOfYear;

package/src/server/utility/get-weekday-name.ts

@@ -0,0 +1,24 @@
+import {InvariantViolation} from 'lib/errors';
+
+const WEEKDAY_NAMES = [
+	'sunday',
+	'monday',
+	'tuesday',
+	'wednesday',
+	'thursday',
+	'friday',
+	'saturday'
+];
+
+function getWeekdayName(date: Date): string {
+	const weekday_index = date.getUTCDay();
+	const weekday_name = WEEKDAY_NAMES[weekday_index];
+
+	if (weekday_name === undefined) {
+		throw new InvariantViolation(`Invalid weekday index: ${weekday_index}`);
+	}
+
+	return weekday_name;
+}
+
+export default getWeekdayName;

package/src/server/utility/increment-date.ts

@@ -0,0 +1,15 @@
+import createDate from 'server/utility/create-date';
+
+function incrementDate(date: Date, days?: number): Date {
+	if (days === undefined) {
+		days = 1;
+	}
+
+	const new_date = createDate(date);
+
+	new_date.setUTCDate(date.getUTCDate() + days);
+
+	return new_date;
+}
+
+export default incrementDate;

package/src/server/utility/is-index-path.ts

@@ -0,0 +1,5 @@
+function isIndexPath(path: string): boolean {
+	return path === '/' || path === '/index';
+}
+
+export default isIndexPath;

package/src/server/utility/key-to-date.ts

@@ -0,0 +1,25 @@
+import {InvalidError} from 'lib/errors';
+
+import createDate from 'server/utility/create-date';
+
+const DATE_REGEX = /^\/day\/([0-9]+)-([0-9]+)-([0-9]+)$/;
+
+function keyToDate(key: string): Date {
+	const match = key.match(DATE_REGEX);
+
+	if (!match) {
+		throw new InvalidError(`Key did not include a valid date: ${key}`);
+	}
+
+	const month = parseInt(match[1]) - 1;
+	const day = parseInt(match[2]);
+	const year = parseInt(match[3]);
+
+	if (isNaN(month) || isNaN(day) || isNaN(year)) {
+		throw new InvalidError(`The specified date components are not valid: ${key}`);
+	}
+
+	return createDate(year, month, day);
+}
+
+export default keyToDate;

package/src/server/utility/month-has-week-containing-date.ts

@@ -0,0 +1,13 @@
+import getStartOfWeek from 'server/utility/get-start-of-week';
+import getEndOfWeek from 'server/utility/get-end-of-week';
+import getEndOfMonth from 'server/utility/get-end-of-month';
+import datesAreInOrder from 'server/utility/dates-are-in-order';
+
+function monthHasWeekContainingDate(month: Date, date: Date): boolean {
+	const first_week_start = getStartOfWeek(month);
+	const final_week_end = getEndOfWeek(getEndOfMonth(month));
+
+	return datesAreInOrder(first_week_start, date, final_week_end);
+}
+
+export default monthHasWeekContainingDate;

package/src/server/utility/month-to-date.ts

@@ -0,0 +1,28 @@
+import {InvalidError} from 'lib/errors';
+
+import MonthNames from 'constant/month-names';
+import Month from 'type/month';
+
+const month_segment = MonthNames.join('|');
+const MONTH_REGEX = new RegExp(`^(${month_segment})\-([0-9][0-9][0-9][0-9])$`);
+
+function monthToDate(month: Month): Date {
+	const {key} = month;
+	const match = key.match(MONTH_REGEX);
+
+	if (!match) {
+		throw new InvalidError(`Invalid month: ${key}`);
+	}
+
+	const month_name = match[1];
+	const month_index = MonthNames.indexOf(month_name) + 1;
+	const year = parseInt(match[2]);
+
+	if (isNaN(year) || isNaN(month_index)) {
+		throw new InvalidError(`Invalid month components: ${key}`);
+	}
+
+	return new Date(`${year}-${month_index}-01`);
+}
+
+export default monthToDate;

package/src/server/utility/month-to-path.ts

@@ -0,0 +1,10 @@
+import getMonthName from 'server/utility/get-month-name';
+
+function monthToPath(date: Date): string {
+	const month_name = getMonthName(date);
+	const year = date.getUTCFullYear();
+
+	return `/month/${month_name}-${year}`;
+}
+
+export default monthToPath;

package/src/server/utility/months-are-equal.ts

@@ -0,0 +1,8 @@
+import getStartOfMonth from 'server/utility/get-start-of-month';
+import datesAreEqual from 'server/utility/dates-are-equal';
+
+function monthsAreEqual(a: Date, b: Date): boolean {
+	return datesAreEqual(getStartOfMonth(a), getStartOfMonth(b));
+}
+
+export default monthsAreEqual;

package/src/server/utility/parse-index-path.ts

@@ -0,0 +1,23 @@
+import {InvariantViolation} from 'lib/errors';
+
+function parseIndexPath(index_path: string): number[] {
+	if (index_path === undefined) {
+		throw new InvariantViolation(`Undefined index path`);
+	}
+
+	if (index_path.trim() === '') {
+		throw new InvariantViolation(`Invalid index path: ${index_path}`);
+	}
+
+	return index_path.split('.').map((part) => {
+		const parsed_part = parseInt(part);
+
+		if (isNaN(parsed_part)) {
+			throw new InvariantViolation(`Invalid index path: ${index_path}`);
+		}
+
+		return parsed_part;
+	});
+}
+
+export default parseIndexPath;

package/src/server/utility/path-is-date.ts

@@ -0,0 +1,13 @@
+import validatePath from 'server/utility/validate-path';
+
+const DateRegex = /^\/(year|month|week|day)\/([0-9]+)-([0-9]+)-([0-9]+)$/;
+
+export {DateRegex};
+
+function pathIsDate(path: string): boolean {
+	validatePath(path);
+
+	return DateRegex.test(path);
+}
+
+export default pathIsDate;

package/src/server/utility/path-to-date.ts

@@ -0,0 +1,24 @@
+import {InvalidError} from 'lib/errors';
+
+import {DateRegex} from 'server/utility/path-is-date';
+import createDate from 'server/utility/create-date';
+
+function pathToDate(key: string): Date {
+	const match = key.match(DateRegex);
+
+	if (!match) {
+		throw new InvalidError(`Key did not include a valid date: ${key}`);
+	}
+
+	const month = parseInt(match[2]) - 1;
+	const day = parseInt(match[3]);
+	const year = parseInt(match[4]);
+
+	if (isNaN(month) || isNaN(day) || isNaN(year)) {
+		throw new InvalidError(`Key did not include a valid date: ${key}`);
+	}
+
+	return createDate(year, month, day);
+}
+
+export default pathToDate;

package/src/server/utility/subtract-days.ts

@@ -0,0 +1,7 @@
+import addDays from 'server/utility/add-days';
+
+function subtractDays(old_date: Date, days: number): Date {
+	return addDays(old_date, days * -1);
+}
+
+export default subtractDays;

package/src/server/utility/validate-month.ts

@@ -0,0 +1,10 @@
+import Month from 'type/month';
+import monthToDate from 'server/utility/month-to-date';
+
+function validateMonth(month: Month): Month {
+	monthToDate(month);
+
+	return month;
+}
+
+export default validateMonth;

package/src/server/utility/validate-page.ts

@@ -0,0 +1,46 @@
+import {InvariantViolation} from 'lib/errors';
+
+import Page from 'type/page';
+import Block from 'type/block';
+
+interface PageWithPossibleTitle extends Page {
+	readonly title?: string;
+}
+
+function validateBlock(block: Block, page_path: string, index: number): void {
+	if (typeof block !== 'object') {
+		throw new InvariantViolation(`
+			Invalid block in page ${page_path} at index ${index}: not a block object
+		`);
+	}
+
+	if (typeof block.created_at !== 'number') {
+		throw new InvariantViolation(`
+			Block in page ${page_path} at index ${index} did not have a valid created_at
+		`);
+	}
+}
+
+function validatePage(page: Page): void {
+	const {path} = page;
+
+	if (path === undefined) {
+		throw new InvariantViolation(`
+			Page had no path: ${JSON.stringify(page)}
+		`);
+	}
+
+	const coerced_page = page as PageWithPossibleTitle;
+
+	if (coerced_page.title !== undefined) {
+		throw new InvariantViolation(`
+			Page had a title: ${JSON.stringify(page)}
+		`);
+	}
+
+	coerced_page.blocks.forEach((block, index) => {
+		validateBlock(block, path, index);
+	});
+}
+
+export default validatePage;

package/src/server/utility/validate-path.ts

@@ -0,0 +1,9 @@
+import {InvalidError} from 'lib/errors';
+
+function validatePath(path: string): void {
+	if (!path.startsWith('/')) {
+		throw new InvalidError(`Invalid path: ${path}`);
+	}
+}
+
+export default validatePath;

package/src/server/utility/validate-url.ts

@@ -0,0 +1,12 @@
+import {InvalidError} from 'lib/errors';
+
+function validateUrl(url: string): void {
+	try {
+		new URL(url);
+	} catch (error) {
+		console.trace();
+		throw new InvalidError(`Invalid url: ${url}`);
+	}
+}
+
+export default validateUrl;

package/src/server/utility/week-greater-than.ts

@@ -0,0 +1,10 @@
+import getStartOfWeek from 'server/utility/get-start-of-week';
+
+function weekGreaterThan(date: Date, target: Date): boolean {
+	const truncated_date = getStartOfWeek(date);
+	const truncated_target = getStartOfWeek(target);
+
+	return truncated_date > truncated_target;
+}
+
+export default weekGreaterThan;

package/src/server/utility/week-to-date.ts

@@ -0,0 +1,8 @@
+import Week from 'type/week';
+import dayToDate from 'server/utility/day-to-date';
+
+function weekToDate(week: Week): Date {
+	return dayToDate(week);
+}
+
+export default weekToDate;

package/src/server/utility/week-to-path.ts

@@ -0,0 +1,12 @@
+import getMonthName from 'server/utility/get-month-name';
+import getPaddedDate from 'server/utility/get-padded-date';
+
+function weekToPath(week: Date): string {
+	const month_name = getMonthName(week);
+	const day = getPaddedDate(week);
+	const year = week.getUTCFullYear();
+
+	return `/week/${month_name}-${day}-${year}`;
+}
+
+export default weekToPath;

package/src/server/utility/weeks-are-equal.ts

@@ -0,0 +1,8 @@
+import datesAreEqual from 'server/utility/dates-are-equal';
+import getStartOfWeek from 'server/utility/get-start-of-week';
+
+function weeksAreEqual(a: Date, b: Date): boolean {
+	return datesAreEqual(getStartOfWeek(a), getStartOfWeek(b));
+}
+
+export default weeksAreEqual;

package/src/server/utility/year-to-date.ts

@@ -0,0 +1,26 @@
+import {InvalidError} from 'lib/errors';
+
+import Year from 'type/year';
+
+const YEAR_REGEX = new RegExp(`^([0-9][0-9][0-9][0-9])$`);
+
+function yearToDate(year: Year): Date {
+	const {key} = year;
+	const match = key.match(YEAR_REGEX);
+
+	if (!match) {
+		throw new InvalidError(`Invalid year: ${key}`);
+	}
+
+	const numeric_year = parseInt(match[1]);
+
+	if (isNaN(numeric_year)) {
+		throw new InvalidError(`Invalid year: ${key}`);
+	}
+
+	const date_string = `${numeric_year}-01-01`;
+
+	return new Date(date_string);
+}
+
+export default yearToDate;

package/src/server/utility/year-to-path.ts

@@ -0,0 +1,7 @@
+function yearToPath(date: Date): string {
+	const year = date.getUTCFullYear();
+
+	return `/year/${year}`;
+}
+
+export default yearToPath;

package/src/server/utility/years-are-equal.ts

@@ -0,0 +1,8 @@
+import datesAreEqual from 'server/utility/dates-are-equal';
+import getStartOfYear from 'server/utility/get-start-of-year';
+
+function yearsAreEqual(a: Date, b: Date): boolean {
+	return datesAreEqual(getStartOfYear(a), getStartOfYear(b));
+}
+
+export default yearsAreEqual;