@fc3/mmcadi 0.1.0

package/src/server/result-serializer/block/audio.ts

@@ -0,0 +1,33 @@
+import BlockResultSerializer from 'server/result-serializer/block';
+import AudioBlock from 'type/block/audio';
+
+class AudioBlockResultSerializer extends BlockResultSerializer<AudioBlock> {
+	public serializeContent(): string {
+		if (!this.canRead()) {
+			return this.serializePermissionDenied();
+		}
+
+		const {files} = this.getResult();
+
+		if (files === undefined) {
+			return this.wrapSection(`
+				<em>(no audio files specified)</em>
+			`);
+		}
+
+		const serialized_files = files.map((file) => {
+			const {filename} = file;
+			const url = `/public/${filename}`;
+
+			return `
+				<audio controls src="${url}">
+			`;
+		});
+
+		return this.wrapSection(`
+			${serialized_files.join('\n')}
+		`);
+	}
+}
+
+export default AudioBlockResultSerializer;

package/src/server/result-serializer/block/background.ts

@@ -0,0 +1,20 @@
+import BlockResultSerializer from 'server/result-serializer/block';
+import BackgroundBlock from 'type/block/background';
+import getHexForColor from 'server/utility/get-hex-for-color';
+
+class BackgroundBlockResultSerializer extends BlockResultSerializer<BackgroundBlock> {
+	public serializeContent(): string {
+		const {color} = this.getResult();
+		const hex = getHexForColor(color);
+
+		return this.wrapSection(`
+			<style>
+				main {
+					background: ${hex} !important;
+				}
+			</style>
+		`);
+	}
+}
+
+export default BackgroundBlockResultSerializer;

package/src/server/result-serializer/block/calendar.ts

@@ -0,0 +1,148 @@
+import dateToKey from 'server/utility/date-to-key';
+import Emoji from 'enum/emoji';
+import BlockResultSerializer from 'server/result-serializer/block';
+import getEndOfWeek from 'server/utility/get-end-of-week';
+import dateOccursBefore from 'server/utility/date-occurs-before';
+import getShortOrdinal from 'server/utility/get-short-ordinal';
+import dateToPath from 'server/utility/date-to-path';
+import getOrdinalLabelForWeek from 'server/utility/get-ordinal-label-for-week';
+import weekToPath from 'server/utility/week-to-path';
+import createToastPath from 'server/utility/create-toast-path';
+import Color from 'enum/color';
+import datesAreEqual from 'server/utility/dates-are-equal';
+import getWeekdayName from 'server/utility/get-weekday-name';
+import addDays from 'server/utility/add-days';
+import Block from 'type/block';
+import getMonthName from 'server/utility/get-month-name';
+import createDate from 'server/utility/create-date';
+import dateToLabel from 'server/utility/date-to-label';
+import subtractDays from 'server/utility/subtract-days';
+
+class CalendarBlockResultSerializer extends BlockResultSerializer<Block> {
+	public serializeContent(): string {
+		const target_date = this.getTargetDate();
+		const month_name = getMonthName(target_date);
+		const day_index = target_date.getUTCDate();
+		const year = target_date.getUTCFullYear();
+		const day_ordinal = getShortOrdinal(day_index);
+
+		const weekday_name = getWeekdayName(target_date);
+		const previous_date = subtractDays(target_date, 1);
+		const previous_path = dateToPath(previous_date);
+		const previous_label = dateToLabel(previous_date);
+		const next_date = addDays(target_date, 1);
+		const next_path = dateToPath(next_date);
+		const next_label = dateToLabel(next_date);
+		const predominant_week = getEndOfWeek(target_date);
+		const week_label = getOrdinalLabelForWeek(predominant_week);
+		const week_path = weekToPath(predominant_week);
+		const today = createDate();
+		const today_key = dateToKey(today);
+		const base_path = dateToPath(today);
+		const day_is_today = datesAreEqual(target_date, today);
+		const today_emoji = Emoji.SUNSHINE;
+
+		const multiline_date = `
+			${weekday_name}
+			<br />
+			${month_name} ${day_ordinal}
+			<br />
+			${year}
+		`;
+
+		const current_day_markup = !day_is_today ? `<h2>${multiline_date}</h2>` : `
+			<h2 class="nowrap">
+				${today_emoji} today ${today_emoji}
+			</h2>
+
+			<em>${multiline_date}</em>
+		`;
+
+		const toast_message = `${Emoji.SUNSHINE} today ${Emoji.SUNSHINE}`;
+
+		const today_path = createToastPath(`${base_path}?highlight_date=${today_key}`, {
+			message: toast_message,
+			color: Color.YELLOW
+		});
+
+		const today_before_day = dateOccursBefore(today, target_date);
+		const toast_prefix = today_before_day ? Emoji.LEFT_ARROW_UNICODE : '';
+		const toast_suffix = today_before_day ? '' : Emoji.RIGHT_ARROW_UNICODE;
+
+		const other_day_markup = day_is_today ? '' : `
+			<table class="fixed mt-8">
+				<tbody>
+					<tr>
+						<td>
+							<a class="biglink" href="${today_path}">
+								${toast_prefix}
+								go to ${toast_message}
+								${toast_suffix}
+							</a>
+						</td>
+					</tr>
+				</tbody>
+			</table>
+		`;
+
+		const full_previous_path = (() => {
+			if (datesAreEqual(today, previous_date)) {
+				return createToastPath(previous_path, {
+					message: toast_message,
+					color: Color.YELLOW
+				});
+			} else {
+				return previous_path;
+			}
+		})();
+
+		const full_next_path = (() => {
+			if (datesAreEqual(today, next_date)) {
+				return createToastPath(next_path, {
+					message: toast_message,
+					color: Color.YELLOW
+				});
+			} else {
+				return next_path;
+			}
+		})();
+
+		const primary_section_markup = this.wrapSection(`
+			<a class="biglink mb-8" href="${week_path}">
+				${Emoji.UP_ARROW_UNICODE} ${week_label} ${Emoji.UP_ARROW_UNICODE}
+			</a>
+
+			<table class="fixed">
+				<tr>
+					<td class="biglink-container">
+						<a class="biglink stretch" href="${full_previous_path}">
+							${Emoji.LEFT_ARROW_UNICODE} ${previous_label}
+						</a>
+					</td>
+					<td>
+						${current_day_markup}
+					</td>
+					<td class="biglink-container">
+						<a class="biglink stretch" href="${full_next_path}">
+							${next_label} ${Emoji.RIGHT_ARROW_UNICODE}
+						</a>
+					</td>
+				</tr>
+			</table>
+
+			${other_day_markup}
+		`);
+
+		return `
+			${primary_section_markup}
+		`;
+	}
+
+	private getTargetDate(): Date {
+		const date = createDate();
+
+		return date;
+	}
+}
+
+export default CalendarBlockResultSerializer;

package/src/server/result-serializer/block/directory.ts

@@ -0,0 +1,57 @@
+import Path from 'path';
+
+import BlockResultSerializer from 'server/result-serializer/block';
+import Emoji from 'enum/emoji';
+import DirectoryItemType from 'enum/directory-item-type';
+import DirectoryBlock, {DirectoryItem} from 'type/block/directory';
+
+class DirectoryBlockResultSerializer extends BlockResultSerializer<DirectoryBlock> {
+	public serializeContent(): string {
+		const block = this.getResult();
+		const {items, path} = block;
+
+		if (items === undefined || !Array.isArray(items)) {
+			return this.printWarning(`
+				Got invalid config for directory block (no items specified):
+				${JSON.stringify(block)}
+			`);
+		}
+
+		const serialized_items = items.map((directory_item) => {
+			return this.serializeDirectoryItem(directory_item);
+		});
+
+		return this.wrapSection(`
+			<h4>contents of <em>${path}</em>:</h4>
+			<ul>
+				${serialized_items.join('\n')}
+			</ul>
+		`);
+	}
+
+	private serializeDirectoryItem(directory_item: DirectoryItem): string {
+		const {filename, item_type} = directory_item;
+		const {page_path} = this.getMetadata();
+		const path = Path.resolve(page_path, filename);
+
+		const emoji = (() => {
+			switch (item_type) {
+				case DirectoryItemType.DIRECTORY:
+					return Emoji.FOLDER;
+				case DirectoryItemType.GENERIC_FILE:
+				default:
+					return Emoji.FILE;
+			}
+		})();
+
+		return `
+			<li class="mt-8">
+				<a class="biglink yellow align-left" href="${path}">
+					${emoji} ${filename}
+				</a>
+			</li>
+		`;
+	}
+}
+
+export default DirectoryBlockResultSerializer;

package/src/server/result-serializer/block/ephemeral.ts

@@ -0,0 +1,14 @@
+import BlockResultSerializer from 'server/result-serializer/block';
+import EphemeralBlock from 'type/block/ephemeral';
+
+class EphemeralBlockResultSerializer extends BlockResultSerializer<EphemeralBlock> {
+	public serializeContent(): string {
+		const {label} = this.getResult();
+
+		return this.wrapSection(`
+			<span class="ephemeral">${label}</span>
+		`);
+	}
+}
+
+export default EphemeralBlockResultSerializer;

package/src/server/result-serializer/block/folder.ts

@@ -0,0 +1,106 @@
+import getElementIdForBlock from 'server/utility/get-element-id-for-block';
+import BlockResultSerializer from 'server/result-serializer/block';
+import Color from 'enum/color';
+import FolderBlock from 'type/block/folder';
+import Emoji from 'enum/emoji';
+import getPathForFolderBlock from 'server/utility/get-path-for-folder-block';
+
+class FolderBlockResultSerializer extends BlockResultSerializer<FolderBlock> {
+	public serializeContent(): string {
+		const block_id = this.getBlockId();
+		const title = this.getBlockTitle();
+		const color = this.getColor();
+		const subtitle = this.serializeSubtitle();
+		const emoji = this.getEmoji();
+		const path = this.getBlockPath();
+
+		return this.wrapSection(`
+			<a data-role="block_activation" class="biglink ${color} wrap" href="${path}">
+				<table>
+					<tr>
+						<td class="p-8" style="width:15%">
+							<h1 class="m-0">${emoji}</h1>
+						</td>
+						<td class="p-8 align-left">
+							<h4 id="${block_id}-title-target">${title}</h4>
+							${subtitle}
+						</td>
+						<td class="p-8" style="width:15%">
+							${Emoji.RIGHT_ARROW_UNICODE}
+						</td>
+					</tr>
+				</table>
+			</a>
+		`);
+	}
+
+	private getBlockId(): string {
+		const block = this.getResult();
+		const metadata = this.getMetadata();
+
+		return getElementIdForBlock(block, metadata);
+	}
+
+	private getBlockTitle(): string {
+		const {title} = this.getResult();
+
+		return title || '<em>no text supplied</em>';
+	}
+
+	private getColor(): Color {
+		const {color} = this.getResult();
+
+		return color;
+	}
+
+	private getEmoji(): Emoji {
+		if (!this.canRead()) {
+			return Emoji.LOCKED;
+		}
+
+		const {emoji} = this.getResult();
+
+		return emoji;
+	}
+
+	private serializeSubtitle(): string {
+		const block = this.getResult();
+		const subtitle = this.getSubtitle();
+		const metadata = this.getMetadata();
+		const path = this.getBlockPath();
+		const block_id = getElementIdForBlock(block, metadata);
+		const has_subtitle = subtitle !== '';
+
+		const path_visibility_class = has_subtitle ? 'hidden': '';
+		const subtitle_visibility_class = has_subtitle ? '' : 'hidden';
+
+		return `
+			<code id="${block_id}-path-target" class="${path_visibility_class} text-smaller three-quarter-opacity">${path}</code>
+			<h5 class="${subtitle_visibility_class} three-quarter-opacity m-0 mt-4" id="${block_id}-subtitle-target">
+				${subtitle}
+			</h5>
+		`;
+	}
+
+	private getSubtitle(): string {
+		if (!this.canRead()) {
+			return this.getPermissionDeniedMessage();
+		}
+
+		const {subtitle} = this.getResult();
+
+		return subtitle;
+	}
+
+	private getBlockPath(): string {
+		const block = this.getResult();
+		const {page_path} = this.getMetadata();
+
+		return getPathForFolderBlock({
+			block,
+			base_path: page_path
+		});
+	}
+}
+
+export default FolderBlockResultSerializer;

package/src/server/result-serializer/block/header.ts

@@ -0,0 +1,31 @@
+import BlockResultSerializer from 'server/result-serializer/block';
+import HeaderBlock from 'type/block/header';
+import HeaderSize from 'enum/header-size';
+
+class HeaderBlockResultSerializer extends BlockResultSerializer<HeaderBlock> {
+	public serializeContent(): string {
+		if (!this.canRead()) {
+			return this.serializePermissionDenied();
+		}
+
+		const {title, size} = this.getResult();
+
+		const tag = (() => {
+			switch (size) {
+				case HeaderSize.SMALL:
+					return 'h3';
+				case HeaderSize.MEDIUM:
+					return 'h2';
+				case HeaderSize.LARGE:
+				default:
+					return 'h1';
+			}
+		})();
+
+		return this.wrapSection(`
+			<${tag}>${title}</${tag}>
+		`);
+	}
+}
+
+export default HeaderBlockResultSerializer;

package/src/server/result-serializer/block/image.ts

@@ -0,0 +1,46 @@
+import Path from 'path';
+
+import BlockResultSerializer from 'server/result-serializer/block';
+import ImageBlock from 'type/block/image';
+import getElementIdForBlock from 'server/utility/get-element-id-for-block';
+
+class ImageBlockResultSerializer extends BlockResultSerializer<ImageBlock> {
+	public serializeContent(): string {
+		if (!this.canRead()) {
+			return this.serializePermissionDenied();
+		}
+
+		const page_path = this.getPagePath();
+		const block = this.getResult();
+		const {files} = block;
+		const metadata = this.getMetadata();
+		const block_id = getElementIdForBlock(block, metadata);
+
+		if (files === undefined || files.length === 0) {
+			return this.wrapSection(`
+				<div id="${block_id}-image-container">
+					<em>(no image specified)</em>
+				</div>
+			`);
+		}
+
+		const serialized_files = files.map((file) => {
+			const {filename} = file;
+			const file_path = Path.resolve(page_path, `./${filename}`);
+
+			return `
+				<a data-role="block_activation" href="${file_path}">
+					<img class="thumbnail" src="${file_path}" />
+				</a>
+			`;
+		});
+
+		return this.wrapSection(`
+			<div id="${block_id}-image-container">
+				${serialized_files.join('\n')}
+			</div>
+		`);
+	}
+}
+
+export default ImageBlockResultSerializer;

package/src/server/result-serializer/block/link.ts

@@ -0,0 +1,40 @@
+import BlockResultSerializer from 'server/result-serializer/block';
+import Color from 'enum/color';
+import LinkBlock from 'type/block/link';
+
+class LinkBlockResultSerializer extends BlockResultSerializer<LinkBlock> {
+	public serializeContent(): string {
+		const block = this.getResult();
+		const {label, href, color} = block;
+		const all_colors = Object.values(Color);
+
+		if (typeof label !== 'string') {
+			return this.printWarning(`
+				Got invalid config for link block (no label content):
+				${JSON.stringify(block)}
+			`);
+		}
+
+		if (typeof href !== 'string') {
+			return this.printWarning(`
+				Got invalid config for link block (no href content):
+				${JSON.stringify(block)}
+			`);
+		}
+
+		if (!all_colors.includes(color)) {
+			return this.printWarning(`
+				Got invalid config for link block (unsupported color):
+				${JSON.stringify(block)}
+			`);
+		}
+
+		return this.wrapSection(`
+			<a class="biglink ${color} p-16" href="${href}">
+				${label}
+			</a>
+		`);
+	}
+}
+
+export default LinkBlockResultSerializer;

package/src/server/result-serializer/block/list.ts

@@ -0,0 +1,140 @@
+import {InvariantViolation} from 'lib/errors';
+
+import BlockResultSerializer from 'server/result-serializer/block';
+import ListBlock from 'type/block/list';
+import FieldDefinition from 'type/field-definition';
+import FieldType from 'enum/field-type';
+import Resource from 'type/resource';
+import Price from 'type/price';
+import FieldValue from 'type/field-value';
+import dateToLabel from 'server/utility/date-to-label';
+
+class ListBlockResultSerializer extends BlockResultSerializer<ListBlock> {
+	public serializeContent(): string {
+		const block = this.getResult();
+		const {fields, items} = block;
+
+		if (!Array.isArray(fields)) {
+			return this.printWarning(`
+				Got invalid config for list block (no fields defined):
+				${JSON.stringify(block)}
+			`);
+		}
+
+		if (!Array.isArray(items)) {
+			return this.printWarning(`
+				Got invalid config for list block (no items defined):
+				${JSON.stringify(block)}
+			`);
+		}
+
+		const serialized_headers = this.serializeHeaders(fields);
+		const serialized_items = this.serializeItems(fields, items);
+
+		return this.wrapSection(`
+			<table class="resource-list align-left">
+				<thead>
+					<tr>
+						${serialized_headers}
+					</tr>
+				</thead>
+				<tbody>
+					${serialized_items}
+				</tbody>
+			</table>
+		`);
+	}
+
+	private serializeHeaders(fields: FieldDefinition[]): string {
+		const keys = fields.map((field) => {
+			return field.key;
+		});
+
+		const serialized_cells = keys.map((key) => {
+			return `
+				<th>
+					<a class="biglink blue align-left" href="?sort_by=${key}">${key}</a>
+				</th>
+			`;
+		});
+
+		return serialized_cells.join('\n');
+	}
+
+	private serializeItems(fields: FieldDefinition[], items: Resource[]): string {
+		const serialized_items = items.map((item) => {
+			const serialized_cells = fields.map((field) => {
+				const {key} = field;
+				const value = item[key];
+
+				if (value === undefined) {
+					throw new InvariantViolation(`
+						Tried to read value for key "${key}", but it was not set
+					`);
+				}
+
+				const serialized_value = this.serializeValue(field, value);
+
+				return `
+					<td>${serialized_value}</td>
+				`;
+			});
+
+			return `
+				<tr>
+					${serialized_cells.join('\n')}
+				</tr>
+			`;
+		});
+
+		return serialized_items.join('\n');
+	}
+
+	private serializeValue(field: FieldDefinition, value: FieldValue): string {
+		const {field_type} = field;
+
+		switch (field_type) {
+			case FieldType.TEXT:
+				return this.serializeTextValue(field, value as string);
+
+			case FieldType.PRICE:
+				return this.serializePriceValue(field, value as Price);
+
+			case FieldType.DATE:
+				return this.serializeDateValue(field, value as number);
+
+			case FieldType.ENUM:
+				return this.serializeEnumValue(field, value as string);
+
+			default:
+				throw new InvariantViolation(`Unsupported field type: ${field_type}`);
+		}
+	}
+
+	private serializeTextValue(field: FieldDefinition, value: string): string {
+		return value;
+	}
+
+	private serializePriceValue(field: FieldDefinition, price: Price): string {
+		const {amount, currency_code} = price;
+
+		return `
+			$${amount} ${currency_code}
+		`;
+	}
+
+	private serializeDateValue(field: FieldDefinition, timestamp: number): string {
+		const date = new Date(timestamp);
+		const label = dateToLabel(date);
+
+		return `
+			${label}
+		`;
+	}
+
+	private serializeEnumValue(field: FieldDefinition, value: string): string {
+		return value;
+	}
+}
+
+export default ListBlockResultSerializer;